@sunbird-cb/utils-v2 0.0.1

package/lib/services/content-strip-multiple.model.d.ts

@@ -0,0 +1,79 @@
+import { NSSearch } from './widget-search.model';
+import { NsContent } from './widget-content.model';
+import { NsCardContent } from './card-content.model';
+import { NsWidgetResolver } from './widget-resolver.model';
+export declare namespace NsContentStripMultiple {
+    interface IContentStripMultiple {
+        errorWidget?: NsWidgetResolver.IRenderConfigWithAnyData;
+        loader?: boolean;
+        noDataWidget?: NsWidgetResolver.IRenderConfigWithAnyData;
+        strips: IContentStripUnit[];
+        isChannelStrip?: boolean;
+    }
+    interface IContentStripUnit {
+        key: string;
+        title: string;
+        name?: string;
+        mode?: 'accordion';
+        info?: IStripInfo;
+        preWidgets?: NsWidgetResolver.IRenderConfigWithAnyData[];
+        postWidgets?: NsWidgetResolver.IRenderConfigWithAnyData[];
+        stripConfig?: IStripConfig;
+        canHideStrip?: boolean;
+        filters?: any[];
+        selectAll?: boolean | null;
+        request?: {
+            search?: NSSearch.ISearchRequest;
+            searchV6?: NSSearch.ISearchV6Request;
+            searchRegionRecommendation?: NSSearch.ISearchOrgRegionRecommendationRequest;
+            api?: IStripRequestApi;
+            ids?: string[];
+        };
+        searchV6Type?: 'KB' | 'Collections' | 'searchQuery' | null;
+        stripBackground?: string;
+        noDataWidget?: NsWidgetResolver.IRenderConfigWithAnyData;
+        loader?: boolean;
+        errorWidget?: NsWidgetResolver.IRenderConfigWithAnyData;
+        refreshEvent?: Record<'eventType' | 'from', string>;
+        fetchLikes?: boolean;
+    }
+    interface IStripRequestApi {
+        path: string;
+        queryParams?: {
+            pageNo?: number;
+            pageSize?: number;
+            pageState?: string;
+            sourceFields?: string;
+        };
+    }
+    interface IStripInfo {
+        mode: 'below' | 'popup' | 'modal';
+        visibilityMode?: 'hidden' | 'visible';
+        icon: {
+            icon: string;
+            scale: number;
+            style?: any;
+        };
+        widget: NsWidgetResolver.IRenderConfigWithAnyData;
+    }
+    interface IStripConfig {
+        cardSubType: NsCardContent.TCardSubType;
+        postCardForSearch?: boolean;
+        intranetMode?: 'greyOut' | 'hide';
+        deletedMode?: 'greyOut' | 'hide';
+        contentTags?: IContentTags;
+    }
+    interface IContentTags {
+        daysSpan?: number;
+        excludeContentType?: NsContent.EContentTypes[];
+        excludeMimeType?: string[];
+        tag: string;
+        criteriaField: string;
+    }
+    interface IContentStripResponseApi {
+        contents: NsContent.IContent[];
+        hasMore?: boolean;
+        pageState?: string;
+        totalHits?: number;
+    }
+}

package/lib/services/event.model.d.ts

@@ -0,0 +1,205 @@
+export declare namespace WsEvents {
+    interface IWsEventsFromWidget {
+        type: 'widget';
+        widgetType: string;
+        widgetSubType: string;
+    }
+    interface IWsEventsFromPage {
+        type: 'page';
+        pageUrl: string;
+        pageType: string;
+    }
+    enum WsEventType {
+        Action = "Action",
+        Telemetry = "Telemetry",
+        PageNavigation = "PageNavigation",
+        AccessRestrictedContentAccessed = "AccessRestrictedContentAccessed",
+        PageSlow = "PageSlow",
+        ErrorOccurred = "ErrorOccurred",
+        WidgetResolveError = "WidgetResolveError"
+    }
+    enum WsEventLogLevel {
+        Warn = "Warn",
+        Error = "Error",
+        Info = "Info",
+        Log = "Log",
+        Trace = "Trace"
+    }
+    enum WsAuditTypes {
+        Created = "Created",
+        Updated = "Updated",
+        Deleted = "Deleted"
+    }
+    enum WsTimeSpentType {
+        Page = "Page",
+        Player = "Player"
+    }
+    enum WsTimeSpentMode {
+        Play = "Play",
+        View = "View"
+    }
+    enum externalTelemetrypdata {
+        RBCP = "rbcp-web-ui"
+    }
+    interface IWsEvents<T> {
+        eventType: WsEventType;
+        eventLogLevel: WsEventLogLevel;
+        from: IWsEventsFromWidget | IWsEventsFromPage | string;
+        to: string;
+        data: T;
+        passThroughData?: any;
+        pageContext?: any;
+    }
+    enum EnumTelemetrySubType {
+        Init = "Init",
+        Interact = "Interact",
+        Loaded = "Loaded",
+        Unloaded = "Unloaded",
+        StateChange = "StateChange",
+        HeartBeat = "HeartBeat",
+        Search = "Search",
+        Feedback = "Feedback",
+        Impression = "Impression",
+        Chatbot = "Chatbot",
+        GetStarted = "Get Started",
+        PlatformRating = "PlatformRating"
+    }
+    interface ITelemetryPageContext {
+        pageId?: string;
+        module?: string;
+        pageIdExt?: string;
+    }
+    interface ITelemetryEdata {
+        type: string;
+        subType?: string;
+        id?: string;
+        pageid?: string;
+    }
+    interface ITelemetryTabData {
+        label: string;
+        index: number;
+    }
+    interface IWsEventTelemetry {
+        eventSubType: EnumTelemetrySubType;
+        pageContext?: ITelemetryPageContext;
+    }
+    enum EnumTelemetryPdfActivity {
+        PAGE_CHANGED = "PAGE_CHANGED",
+        FULLSCREEN_ACTIVATED = "FULLSCREEN_ACTIVATED",
+        FULLSCREEN_DEACTIVATED = "FULLSCREEN_DEACTIVATED",
+        ZOOM_CHANGE = "ZOOM_CHANGE",
+        NONE = "NONE"
+    }
+    interface IWsEventTelemetryPdfData extends IWsEventTelemetry {
+        activityType: EnumTelemetryPdfActivity;
+        currentPage: number;
+        totalPage: number;
+        activityStartedAt: Date | null;
+        object: any;
+    }
+    interface IWsEventTelemetrySurveyData extends IWsEventTelemetry {
+        object: any;
+    }
+    type WsEventTelemetryPDF = IWsEvents<IWsEventTelemetryPdfData>;
+    type WsEventTelemetrySurvey = IWsEvents<IWsEventTelemetrySurveyData>;
+    interface IWsEventTelemetryInteract extends IWsEventTelemetry {
+        edata: ITelemetryEdata;
+        object: any;
+        pageContext?: ITelemetryPageContext;
+    }
+    interface IWsEventTelemetryFeedback extends IWsEventTelemetry {
+        edata: ITelemetryEdata;
+        object: any;
+        pageContext?: ITelemetryPageContext;
+    }
+    interface IWsEventTelemetryImpression extends IWsEventTelemetry {
+        edata?: ITelemetryEdata;
+        object?: any;
+        pageContext?: ITelemetryPageContext;
+    }
+    interface IWsEventTelemetrySearch extends IWsEventTelemetry {
+        type: string;
+        subType?: string;
+        query?: string;
+        filters?: string;
+        size?: number;
+        locale?: any;
+    }
+    interface IWsEventTelemetryHeartBeat extends IWsEventTelemetry {
+        type: string;
+        id: string;
+    }
+    type WsEventTelemetryInteract = IWsEvents<IWsEventTelemetryInteract>;
+    type WsEventTelemetryFeedback = IWsEvents<IWsEventTelemetryFeedback>;
+    type WsEventTelemetryImpression = IWsEvents<IWsEventTelemetryImpression>;
+    type WsEventTelemetrySearch = IWsEvents<IWsEventTelemetrySearch>;
+    type WsEventTelemetryHeartBeat = IWsEvents<IWsEventTelemetryHeartBeat>;
+    enum EnumTelemetryMediaActivity {
+        PLAYED = "PLAYED",
+        PAUSED = "PAUSED",
+        SEEKED = "SEEKED",
+        ENDED = "ENDED",
+        VOLUME_CHANGE = "VOLUME_CHANGE",
+        MUTE = "MUTE",
+        UNMUTE = "UNMUTE",
+        PLAYBACK_SPEED_CHANGE = "PLAYBACK_SPEED_CHANGE",
+        FULLSCREEN_ACTIVATED = "FULLSCREEN_ACTIVATED",
+        FULLSCREEN_DEACTIVATED = "FULLSCREEN_DEACTIVATED",
+        PICTURE_IN_PICTURE_ACTIVATED = "PICTURE_IN_PICTURE_ACTIVATED",
+        PICTURE_IN_PICTURE_DEACTIVATED = "PICTURE_IN_PICTURE_DEACTIVATED",
+        NONE = "NONE"
+    }
+    enum EnumTelemetryMediaState {
+        PLAYING = "PLAYING",
+        PAUSED = "PAUSED",
+        ENDED = "ENDED",
+        BUFFERING = "BUFFERING",
+        NOT_STARTED = "NOT_STARTED"
+    }
+    interface IWsEventTelemetryMediaData extends IWsEventTelemetry {
+        currentState: EnumTelemetryMediaState;
+        activityType: EnumTelemetryMediaActivity;
+        currentTime: number | null;
+        totalTime: number | null;
+        maxedSeekedTime: number;
+        activityStartedAt?: Date | null;
+    }
+    type WsEventTelemetryMedia = IWsEvents<IWsEventTelemetryMediaData>;
+    enum EnumTelemetrymodules {
+        CONTENT = "content",
+        FEEDBACK = "feedback",
+        COURSE = "course",
+        PROGRAM = "program",
+        EXPLORE = "explore",
+        LEARN = "learn",
+        HOME = "home",
+        DASHBOARD = "dashboard",
+        SEARCH = "search",
+        DISCUSS = "Discuss",
+        COMPETENCY = "competency",
+        EVENTS = "events",
+        CAREER = "career",
+        PROFILE = "profile",
+        NETWORK = "network",
+        SUPPORT = "support",
+        KARMAPOINTS = "karmapoints",
+        PLATFORM_RATING = "platformrating"
+    }
+    enum EnumInteractTypes {
+        CLICK = "click"
+    }
+    enum EnumInteractSubTypes {
+        COURSE_TAB = "course-tab",
+        CAREER_TAB = "career-tab",
+        NETWORK_TAB = "network-tab",
+        COMPETENCY_TAB = "competency-tab",
+        PROFILE_EDIT_TAB = "profile-edit-tab",
+        DISCUSS_TAB = "discuss-tab",
+        EVENTS_TAB = "events-tab",
+        SIDE_MENU = "side-menu",
+        HOME_PAGE_STRIP_TABS = "home-page-strip-tabs",
+        HUB_MENU = "hub-menu",
+        PORTAL_NUDGE = "portal_nudge",
+        CERTIFICATE = "certificate"
+    }
+}

package/lib/services/event.service.d.ts

@@ -0,0 +1,30 @@
+import { WsEvents } from './event.model';
+import { UtilityService } from './utility.service';
+export declare class EventService {
+    private utilitySvc;
+    todaysEvents: any;
+    private eventsSubject;
+    events$: import("rxjs").Observable<WsEvents.IWsEvents<any>>;
+    private eventsChatbotSubject;
+    chatbotEvents$: import("rxjs").Observable<WsEvents.IWsEvents<any>>;
+    private eventsGetStartSubject;
+    getStartEvents$: import("rxjs").Observable<WsEvents.IWsEvents<any>>;
+    private eventsPRSubject;
+    getPREvents$: import("rxjs").Observable<WsEvents.IWsEvents<any>>;
+    environment: any;
+    constructor(environment: any, utilitySvc: UtilityService);
+    dispatchEvent<T>(event: WsEvents.IWsEvents<T>): void;
+    dispatchChatbotEvent<T>(event: WsEvents.IWsEvents<T>): void;
+    dispatchGetStartedEvent<T>(event: WsEvents.IWsEvents<T>): void;
+    dispatchPlatformRatingEvent<T>(event: WsEvents.IWsEvents<T>): void;
+    raiseInteractTelemetry(edata: WsEvents.ITelemetryEdata, object: any, pageContext?: WsEvents.ITelemetryPageContext): void;
+    raiseFeedbackTelemetry(edata: WsEvents.ITelemetryEdata, object: any, from?: string): void;
+    raiseCustomImpression(object: any, pageContext?: WsEvents.ITelemetryPageContext): void;
+    private getContext;
+    handleTabTelemetry(subType: string, data: WsEvents.ITelemetryTabData, object?: any): void;
+    getPublicUrl(url: string): string;
+    allEventDateFormat(datetime: any): string;
+    compareDate(startDate: any): boolean;
+    customDateFormat(date: any, time: any): string;
+    setEventListData(eventObj: any): void;
+}

package/lib/services/logger.service.d.ts

@@ -0,0 +1,15 @@
+import { ConfigurationsService } from './configurations.service';
+export declare class LoggerService {
+    private configSvc;
+    constructor(configSvc: ConfigurationsService);
+    private consoleError;
+    private consoleInfo;
+    private consoleLog;
+    private consoleWarn;
+    private noConsole;
+    readonly error: (message?: any, ...optionalParams: any[]) => void;
+    readonly info: (message?: any, ...optionalParams: any[]) => void;
+    readonly log: (message?: any, ...optionalParams: any[]) => void;
+    readonly warn: (message?: any, ...optionalParams: any[]) => void;
+    removeConsoleAccess(): void;
+}

package/lib/services/ms-office.model.d.ts

@@ -0,0 +1,6 @@
+export interface IWsMsTokenModelResponse {
+    accessToken?: string;
+    expiresOn?: string;
+    resource?: string;
+    tokenType?: string;
+}

package/lib/services/multilingual-translations.service.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '@angular/common/http';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject } from 'rxjs';
+import { ConfigurationsService } from './configurations.service';
+export declare class MultilingualTranslationsService {
+    private translate;
+    private http;
+    private configSvc;
+    selectedLang: string;
+    languageSelected: BehaviorSubject<boolean>;
+    languageSelectedObservable: import("rxjs").Observable<boolean>;
+    editProfileDetails: string;
+    constructor(translate: TranslateService, http: HttpClient, configSvc: ConfigurationsService);
+    getLanguage(): void;
+    translateLabelWithoutspace(label: string, type: any, subtype: any): any;
+    translateLabel(label: string, type: any, subtype: any): any;
+    translateActualLabel(label: string, type: any, subtype: any): any;
+    editProfileDetailsAPI(data: any): import("rxjs").Observable<any>;
+    updatelanguageSelected(state: any, lang: any, userid: any): void;
+}

package/lib/services/nps-grid.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '@angular/common/http';
+export declare class NPSGridService {
+    private http;
+    private telemetryEvents;
+    updateTelemetryDataObservable: import("rxjs").Observable<boolean>;
+    constructor(http: HttpClient);
+    updateTelemetryData(state: boolean): void;
+    getFeedStatus(id: any): import("rxjs").Observable<any>;
+    getFormData(formid: any): import("rxjs").Observable<any>;
+    submitPlatformRating(req: any): import("rxjs").Observable<any>;
+    deleteFeed(req: any): import("rxjs").Observable<any>;
+}

package/lib/services/subapplication-respond.service.d.ts

@@ -0,0 +1,23 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { WidgetContentService } from './widget-content.service';
+import { ConfigurationsService } from './configurations.service';
+import { EventService } from './event.service';
+import { TelemetryService } from './telemetry.service';
+export declare class SubapplicationRespondService {
+    private configSvc;
+    private contentSvc;
+    private activatedRoute;
+    private router;
+    private eventSvc;
+    private teleSvc;
+    subAppname: string;
+    continueLearningData: any;
+    contentWindowinfo: any;
+    loaded: boolean;
+    constructor(configSvc: ConfigurationsService, contentSvc: WidgetContentService, activatedRoute: ActivatedRoute, router: Router, eventSvc: EventService, teleSvc: TelemetryService);
+    loadedRespond(contentWindow: any, applicationName: string, id?: string): void;
+    continueLearningRespond(id: string, continueLearning: any): void;
+    telemetryEvents(tData: any): void;
+    unsubscribeResponse(): void;
+    changeContextrespond(): void;
+}

package/lib/services/telemetry.service.d.ts

@@ -0,0 +1,56 @@
+import { NsInstanceConfig } from './configurations.model';
+import { ConfigurationsService } from './configurations.service';
+import { WsEvents } from './event.model';
+import { EventService } from './event.service';
+import { LoggerService } from './logger.service';
+import { Router } from '@angular/router';
+import { NPSGridService } from './nps-grid.service';
+export declare class TelemetryService {
+    private configSvc;
+    private eventsSvc;
+    private logger;
+    private router;
+    private npsSvc;
+    previousUrl: string | null;
+    telemetryConfig: NsInstanceConfig.ITelemetryConfig | null;
+    pData: any;
+    contextCdata: never[];
+    isAnonymousTelemetry: boolean;
+    telArray: any;
+    externalApps: any;
+    environment: any;
+    constructor(configSvc: ConfigurationsService, eventsSvc: EventService, environment: any, logger: LoggerService, router: Router, npsSvc: NPSGridService);
+    private navigationStart;
+    readonly isAnonymousTelemetryRequired: boolean;
+    private updateTelemetryConfig;
+    private initializeConfig;
+    readonly getTelemetrySessionId: string;
+    readonly rootOrgId: string;
+    triggerNPSUpdate(data: any): void;
+    start(edata: any, data: any, pageContext?: WsEvents.ITelemetryPageContext): void;
+    end(edata: any, data: any, pageContext?: WsEvents.ITelemetryPageContext): void;
+    audit(type: string, props: string, data: any): void;
+    heartbeat(type: string, id: string): void;
+    impression(data?: any, objectType?: any): void;
+    externalImpression(impressionData: any): void;
+    addCustomListenerForPlatformRating(): void;
+    addCustomListenerForGetStart(): void;
+    addCustomListener(): void;
+    addCustomImpressionListener(): void;
+    addTimeSpentListener(): void;
+    addCustomEventListener(): void;
+    addPlayerListener(): void;
+    addInteractListener(): void;
+    addFeedbackListener(): void;
+    addHearbeatListener(): void;
+    addSearchListener(): void;
+    getPageDetails(): {
+        pageid: string;
+        pageUrl: string;
+        pageUrlParts: string[];
+        refferUrl: string | null;
+        objectId: string | null;
+        module: string;
+    };
+    extractContentIdFromUrlParts(urlParts: string[]): string | null;
+}

package/lib/services/user-preference.model.d.ts

@@ -0,0 +1,34 @@
+export interface IUserPreference {
+    selectedTheme: string;
+    selectedFont: string;
+    selectedLocale: string;
+    isDarkMode: boolean;
+    isIntranetAllowed?: boolean;
+    isRTL: boolean;
+    colorPallet: string[];
+    defaultCardType: string;
+    pinnedApps: string;
+    selectedLangGroup?: string;
+    completedActivity: string[];
+    completedTour?: boolean;
+    profileSettings: string[];
+}
+export interface IPortalUrls {
+    igot: string;
+    spv: string;
+    mdo: string;
+    cbc: string;
+    cbp: string;
+    frac: string;
+}
+export interface IProfile {
+    showProfilePicture: boolean;
+    showUserInterest: boolean;
+    showKbFollowed: boolean;
+    showPlaylist: boolean;
+    showAuthoredByMe: boolean;
+    showReviewedByMe: boolean;
+    showBadgeDetails: boolean;
+    showBlogs: boolean;
+    showQnA: boolean;
+}

package/lib/services/user-preference.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '@angular/common/http';
+import { IUserPreference } from './user-preference.model';
+import { ConfigurationsService } from './configurations.service';
+export declare class UserPreferenceService {
+    private http;
+    private configurationSvc;
+    constructor(http: HttpClient, configurationSvc: ConfigurationsService);
+    initialize(): void;
+    fetchUserPreference(): Promise<IUserPreference>;
+    saveUserPreference(changedUserPref?: Partial<IUserPreference>): Promise<boolean>;
+}

package/lib/services/utility.service.d.ts

@@ -0,0 +1,31 @@
+import { Platform } from '@angular/cdk/platform';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Router, ActivatedRoute } from '@angular/router';
+import { WsEvents } from './event.model';
+interface IRecursiveData {
+    identifier: string;
+    children: null | IRecursiveData[];
+}
+export declare class UtilityService {
+    private http;
+    private platform;
+    private router;
+    private route;
+    currentRouteData: any[];
+    constructor(http: HttpClient, platform: Platform, router: Router, route: ActivatedRoute);
+    private getChildRouteData;
+    readonly randomId: number;
+    getJson<T>(url: string): Observable<T>;
+    getLeafNodes<T extends IRecursiveData>(node: T, nodes: T[]): T[];
+    getPath<T extends IRecursiveData>(node: T, id: string): T[];
+    private hasPath;
+    readonly isMobile: boolean;
+    readonly isIos: boolean;
+    readonly isAndroid: boolean;
+    readonly isAndroidApp: boolean;
+    readonly iOsAppRef: any;
+    setRouteData(data: any): void;
+    readonly routeData: WsEvents.ITelemetryPageContext;
+}
+export {};

package/lib/services/value.service.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { BreakpointObserver } from '@angular/cdk/layout';
+export declare class ValueService {
+    private breakpointObserver;
+    constructor(breakpointObserver: BreakpointObserver);
+    isXSmall$: Observable<boolean>;
+    isLtMedium$: Observable<boolean>;
+}