@deeksha2309/sunbird-collection-editor 8.0.7

package/esm2022/lib/services/question/question.service.mjs

@@ -0,0 +1,167 @@
+import { Injectable } from '@angular/core';
+import * as _ from 'lodash-es';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/data/data.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../config/config.service";
+import * as i4 from "../../services/public-data/public-data.service";
+import * as i5 from "../editor/editor.service";
+export class QuestionService {
+    constructor(dataService, http, configService, publicDataService, editorService) {
+        this.dataService = dataService;
+        this.configService = configService;
+        this.publicDataService = publicDataService;
+        this.editorService = editorService;
+        this.http = http;
+    }
+    readQuestion(questionId, leafFormConfigfields) {
+        // tslint:disable-next-line:max-line-length
+        let field = this.configService.editorConfig.readQuestionFields;
+        field = leafFormConfigfields ? field + leafFormConfigfields : field;
+        const option = {
+            url: `${this.configService.urlConFig.URLS.QUESTION.READ}${questionId}`,
+            param: {
+                fields: field
+            }
+        };
+        return this.publicDataService.get(option);
+    }
+    updateHierarchyQuestionCreate(hierarchyBody) {
+        const requestObj = {
+            data: hierarchyBody
+        };
+        const req = {
+            url: this.configService.urlConFig.URLS[this.editorService.editorConfig.config.objectType].HIERARCHY_UPDATE,
+            data: {
+                request: requestObj
+            }
+        };
+        return this.publicDataService.patch(req);
+    }
+    updateHierarchyQuestionUpdate(hierarchyBody) {
+        const requestObj = {
+            data: hierarchyBody
+        };
+        const req = {
+            url: this.configService.urlConFig.URLS[this.editorService.editorConfig.config.objectType].HIERARCHY_UPDATE,
+            data: {
+                request: requestObj
+            }
+        };
+        return this.publicDataService.patch(req);
+    }
+    getAssetMedia(req) {
+        const reqParam = {
+            url: _.get(this.configService.urlConFig, 'URLS.compositSearch'),
+            data: {
+                request: {
+                    filters: {
+                        contentType: 'Asset',
+                        compatibilityLevel: {
+                            min: 1,
+                            max: 2
+                        },
+                        status: ['Live'],
+                    },
+                    limit: 50,
+                }
+            }
+        };
+        reqParam.data.request = req ? _.merge({}, reqParam.data.request, req) : reqParam;
+        return this.publicDataService.post(reqParam);
+    }
+    createMediaAsset(req) {
+        const reqParam = {
+            url: _.get(this.configService.urlConFig, 'URLS.CONTENT.CREATE'),
+            data: {
+                request: {
+                    content: {
+                        contentType: 'Asset',
+                        language: ['English'],
+                        code: uuidv4(),
+                    }
+                }
+            }
+        };
+        reqParam.data.request = req ? _.merge({}, reqParam.data.request, req) : reqParam;
+        return this.publicDataService.post(reqParam);
+    }
+    uploadMedia(req, assetId) {
+        let reqParam = {
+            url: `${this.configService.urlConFig.URLS.CONTENT.UPLOAD}${assetId}`,
+            data: req.data
+        };
+        reqParam = req ? _.merge({}, reqParam, req) : reqParam;
+        return this.publicDataService.post(reqParam);
+    }
+    generatePreSignedUrl(req, contentId) {
+        const reqParam = {
+            url: `${this.configService.urlConFig.URLS.CONTENT.UPLOAD_URL}${contentId}`,
+            data: {
+                request: req
+            }
+        };
+        return this.publicDataService.post(reqParam);
+    }
+    getVideo(videoId) {
+        const reqParam = {
+            url: `${this.configService.urlConFig.URLS.CONTENT.READ}${videoId}`
+        };
+        return this.publicDataService.get(reqParam);
+    }
+    getQuestionList(req, field) {
+        const reqParam = {
+            url: this.configService.urlConFig.URLS.QuestionSet.QUESTION_LIST,
+            data: {
+                request: {
+                    search: {
+                        identifier: req
+                    }
+                }
+            }
+        };
+        if (field) {
+            reqParam.param = { fields: field };
+        }
+        return this.publicDataService.post(reqParam);
+    }
+    updateQuestion(questionId, requestBody) {
+        const req = {
+            url: `${this.configService.urlConFig.URLS.QUESTION.UPDATE}${questionId}`,
+            data: {
+                request: requestBody
+            }
+        };
+        return this.publicDataService.patch(req);
+    }
+    upsertQuestion(questionId, requestBody) {
+        if (questionId) {
+            const req = {
+                url: `${this.configService.urlConFig.URLS.QUESTION.UPDATE}${questionId}`,
+                data: {
+                    request: requestBody
+                }
+            };
+            return this.publicDataService.patch(req);
+        }
+        else {
+            const req = {
+                url: this.configService.urlConFig.URLS.QUESTION.CREATE,
+                data: {
+                    request: requestBody
+                }
+            };
+            return this.publicDataService.post(req);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QuestionService, deps: [{ token: i1.DataService }, { token: i2.HttpClient }, { token: i3.ConfigService }, { token: i4.PublicDataService }, { token: i5.EditorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QuestionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: QuestionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }, { type: i2.HttpClient }, { type: i3.ConfigService }, { type: i4.PublicDataService }, { type: i5.EditorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"question.service.js","sourceRoot":"","sources":["../../../../../../projects/collection-editor-library/src/lib/services/question/question.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { DataService } from '../../services/data/data.service';\nimport { PublicDataService } from '../../services/public-data/public-data.service';\nimport { ServerResponse } from '../../interfaces/serverResponse';\nimport * as _ from 'lodash-es';\nimport { v4 as uuidv4 } from 'uuid';\nimport { HttpClient } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nimport { ConfigService } from '../config/config.service';\nimport { EditorService } from '../editor/editor.service';\n@Injectable({\n  providedIn: 'root'\n})\nexport class QuestionService {\n  public http: HttpClient;\n  constructor(public dataService: DataService, http: HttpClient, private configService: ConfigService,\n    private publicDataService: PublicDataService, private editorService: EditorService) {\n    this.http = http;\n  }\n\n  readQuestion(questionId, leafFormConfigfields?) {\n    // tslint:disable-next-line:max-line-length\n    let field = this.configService.editorConfig.readQuestionFields;\n    field = leafFormConfigfields ? field + leafFormConfigfields : field;\n    const option = {\n      url: `${this.configService.urlConFig.URLS.QUESTION.READ}${questionId}`,\n      param: {\n        fields: field\n      }\n    };\n    return this.publicDataService.get(option);\n  }\n\n  updateHierarchyQuestionCreate(hierarchyBody): Observable<ServerResponse> {\n    const requestObj = {\n      data: hierarchyBody\n    };\n    const req = {\n      url: this.configService.urlConFig.URLS[this.editorService.editorConfig.config.objectType].HIERARCHY_UPDATE,\n      data: {\n        request: requestObj\n      }\n    };\n    return this.publicDataService.patch(req);\n  }\n\n  updateHierarchyQuestionUpdate(hierarchyBody): Observable<ServerResponse> {\n    const requestObj = {\n      data: hierarchyBody\n    };\n    const req = {\n      url: this.configService.urlConFig.URLS[this.editorService.editorConfig.config.objectType].HIERARCHY_UPDATE,\n      data: {\n        request: requestObj\n      }\n    };\n    return this.publicDataService.patch(req);\n  }\n\n  getAssetMedia(req?: object) {\n    const reqParam = {\n      url: _.get(this.configService.urlConFig, 'URLS.compositSearch'),\n      data: {\n        request: {\n          filters: {\n            contentType: 'Asset',\n            compatibilityLevel: {\n              min: 1,\n              max: 2\n            },\n            status: ['Live'],\n          },\n          limit: 50,\n        }\n      }\n    };\n    reqParam.data.request = req ? _.merge({}, reqParam.data.request, req) : reqParam;\n    return this.publicDataService.post(reqParam);\n  }\n\n  createMediaAsset(req?: object) {\n    const reqParam = {\n      url: _.get(this.configService.urlConFig, 'URLS.CONTENT.CREATE'),\n      data: {\n        request: {\n          content: {\n            contentType: 'Asset',\n            language: ['English'],\n            code: uuidv4(),\n          }\n        }\n      }\n    };\n    reqParam.data.request = req ? _.merge({}, reqParam.data.request, req) : reqParam;\n    return this.publicDataService.post(reqParam);\n  }\n\n  uploadMedia(req, assetId: any) {\n    let reqParam = {\n      url: `${this.configService.urlConFig.URLS.CONTENT.UPLOAD}${assetId}`,\n      data: req.data\n    };\n    reqParam = req ? _.merge({}, reqParam, req) : reqParam;\n    return this.publicDataService.post(reqParam);\n  }\n\n  generatePreSignedUrl(req, contentId: any) {\n    const reqParam = {\n      url: `${this.configService.urlConFig.URLS.CONTENT.UPLOAD_URL}${contentId}`,\n      data: {\n        request: req\n      }\n    };\n    return this.publicDataService.post(reqParam);\n  }\n\n  getVideo(videoId) {\n    const reqParam = {\n      url: `${this.configService.urlConFig.URLS.CONTENT.READ}${videoId}`\n    };\n    return this.publicDataService.get(reqParam);\n  }\n\n  getQuestionList(req, field?: any) {\n    const reqParam: any = {\n      url: this.configService.urlConFig.URLS.QuestionSet.QUESTION_LIST,\n      data: {\n        request: {\n          search: {\n            identifier: req\n          }\n        }\n      }\n    };\n    if (field) {\n      reqParam.param = { fields: field };\n    }\n    return this.publicDataService.post(reqParam);\n  }\n\n  updateQuestion(questionId, requestBody): Observable<ServerResponse> {\n    const req = {\n      url: `${this.configService.urlConFig.URLS.QUESTION.UPDATE}${questionId}`,\n      data: {\n        request: requestBody\n      }\n    };\n    return this.publicDataService.patch(req);\n  }\n\n  upsertQuestion(questionId, requestBody): Observable<ServerResponse> {\n    if (questionId) {\n      const req = {\n        url: `${this.configService.urlConFig.URLS.QUESTION.UPDATE}${questionId}`,\n        data: {\n          request: requestBody\n        }\n      };\n      return this.publicDataService.patch(req);\n    } else {\n      const req = {\n        url: this.configService.urlConFig.URLS.QUESTION.CREATE,\n        data: {\n          request: requestBody\n        }\n      };\n      return this.publicDataService.post(req);\n    }\n  }\n\n}\n"]}

package/esm2022/lib/services/telemetry/telemetry.service.mjs

@@ -0,0 +1,120 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as _ from 'lodash-es';
+import { CsTelemetryModule } from '@project-sunbird/client-services/telemetry';
+import * as i0 from "@angular/core";
+import * as i1 from "../helper/helper.service";
+import * as i2 from "../config/config.service";
+export class EditorTelemetryService {
+    constructor(helperService, configService) {
+        this.helperService = helperService;
+        this.configService = configService;
+        this.telemetryEvent = new EventEmitter();
+    }
+    initializeTelemetry(config) {
+        this.duration = new Date().getTime();
+        this.context = config.context;
+        this.channel = config.context.channel;
+        this.pdata = this.context.pdata;
+        this.sid = this.context.sid;
+        this.uid = this.context.uid;
+        this.env = this.context.env;
+        this.pdata.pid = `${this.context.pdata.pid}.${this.env}`;
+        this.rollup = this.context.contextRollup;
+        if (!CsTelemetryModule.instance.isInitialised) {
+            CsTelemetryModule.instance.init({});
+            CsTelemetryModule.instance.telemetryService.initTelemetry({
+                config: {
+                    pdata: config.context.pdata,
+                    env: config.context.env,
+                    channel: config.context.channel,
+                    did: config.context.did,
+                    authtoken: config.context.authToken || '',
+                    uid: config.context.uid || '',
+                    sid: config.context.sid,
+                    batchsize: 20,
+                    mode: config.context.mode,
+                    host: config.context.host || document.location.origin,
+                    endpoint: config.context.endpoint || _.get(this.configService.urlConFig, 'URLS.telemetry'),
+                    tags: config.context.tags,
+                    cdata: this.context.cdata || []
+                },
+                userOrgDetails: {}
+            });
+        }
+        this.telemetryObject = {
+            id: config.context.identifier,
+            type: 'Content',
+            ver: '1.0',
+            rollup: this.context.objectRollup || {}
+        };
+    }
+    set telemetryPageId(value) {
+        this._telemetryPageId = value;
+    }
+    get telemetryPageId() {
+        return this._telemetryPageId;
+    }
+    getTelemetryInteractEdata(id, type, subtype, pageid, extra) {
+        return _.omitBy({
+            id,
+            type,
+            subtype,
+            pageid,
+            extra
+        }, _.isUndefined);
+    }
+    start(edata) {
+        CsTelemetryModule.instance.telemetryService.raiseStartTelemetry({
+            options: this.getEventOptions(),
+            edata
+        });
+    }
+    end(edata) {
+        if (CsTelemetryModule.instance.isInitialised) {
+            CsTelemetryModule?.instance?.telemetryService?.raiseEndTelemetry({
+                edata,
+                options: this.getEventOptions()
+            });
+        }
+    }
+    interact(eventData) {
+        CsTelemetryModule.instance.telemetryService.raiseInteractTelemetry({
+            options: this.getEventOptions(),
+            edata: eventData.edata
+        });
+    }
+    impression(edata) {
+        CsTelemetryModule.instance.telemetryService.raiseImpressionTelemetry({
+            options: this.getEventOptions(),
+            edata
+        });
+    }
+    error(edata) {
+        CsTelemetryModule.instance.telemetryService.raiseErrorTelemetry({
+            edata
+        });
+    }
+    getEventOptions() {
+        return ({
+            object: this.telemetryObject,
+            context: {
+                channel: this.channel,
+                pdata: this.pdata,
+                env: this.env,
+                sid: this.sid,
+                uid: this.uid,
+                cdata: this.context.cdata || [],
+                rollup: this.rollup || {}
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EditorTelemetryService, deps: [{ token: i1.HelperService }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EditorTelemetryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EditorTelemetryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HelperService }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.service.js","sourceRoot":"","sources":["../../../../../../projects/collection-editor-library/src/lib/services/telemetry/telemetry.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable } from '@angular/core';\nimport * as _ from 'lodash-es';\nimport { CsTelemetryModule } from '@project-sunbird/client-services/telemetry';\nimport { IEditorConfig, Context } from '../../interfaces/editor';\nimport { HelperService } from '../helper/helper.service';\nimport { ConfigService } from '../config/config.service';\n@Injectable({\n  providedIn: 'root'\n})\nexport class EditorTelemetryService {\n  duration: number;\n  channel: string;\n  telemetryEvent = new EventEmitter<any>();\n  private context: Context;\n  private telemetryObject: any;\n  private pdata: any;\n  private sid: string;\n  private uid: string;\n  private rollup: any;\n  private env: string;\n  // tslint:disable-next-line:variable-name\n  private _telemetryPageId: any;\n\n  constructor(public helperService: HelperService, public configService: ConfigService) { }\n\n  initializeTelemetry(config: IEditorConfig) {\n    this.duration = new Date().getTime();\n    this.context = config.context;\n    this.channel = config.context.channel;\n    this.pdata = this.context.pdata;\n    this.sid = this.context.sid;\n    this.uid = this.context.uid;\n    this.env = this.context.env;\n    this.pdata.pid = `${this.context.pdata.pid}.${this.env}`;\n    this.rollup = this.context.contextRollup;\n    if (!CsTelemetryModule.instance.isInitialised) {\n      CsTelemetryModule.instance.init({});\n      CsTelemetryModule.instance.telemetryService.initTelemetry(\n        {\n          config: {\n            pdata: config.context.pdata,\n            env: config.context.env,\n            channel: config.context.channel,\n            did: config.context.did,\n            authtoken: config.context.authToken || '',\n            uid: config.context.uid || '',\n            sid: config.context.sid,\n            batchsize: 20,\n            mode: config.context.mode,\n            host: config.context.host || document.location.origin,\n            endpoint: config.context.endpoint || _.get(this.configService.urlConFig, 'URLS.telemetry'),\n            tags: config.context.tags,\n            cdata: this.context.cdata || []\n          },\n          userOrgDetails: {}\n        }\n      );\n    }\n\n    this.telemetryObject = {\n      id: config.context.identifier,\n      type: 'Content',\n      ver: '1.0', // TODO :: config.metadata.pkgVersion + ''\n      rollup: this.context.objectRollup || {}\n    };\n  }\n\n  set telemetryPageId(value: any) {\n    this._telemetryPageId = value;\n  }\n\n  get telemetryPageId() {\n    return this._telemetryPageId;\n  }\n\n  getTelemetryInteractEdata(id: string, type: string, subtype: string, pageid: string, extra?: any) {\n    return _.omitBy({\n      id,\n      type,\n      subtype,\n      pageid,\n      extra\n    }, _.isUndefined);\n  }\n\n  public start(edata) {\n    CsTelemetryModule.instance.telemetryService.raiseStartTelemetry(\n      {\n        options: this.getEventOptions(),\n        edata\n      }\n    );\n  }\n  public end(edata) {\n    if (CsTelemetryModule.instance.isInitialised) {\n      CsTelemetryModule?.instance?.telemetryService?.raiseEndTelemetry({\n        edata,\n        options: this.getEventOptions()\n      });\n    }\n  }\n\n  public interact(eventData) {\n    CsTelemetryModule.instance.telemetryService.raiseInteractTelemetry({\n      options: this.getEventOptions(),\n      edata: eventData.edata\n    });\n  }\n\n\n  public impression(edata) {\n    CsTelemetryModule.instance.telemetryService.raiseImpressionTelemetry({\n      options: this.getEventOptions(),\n      edata\n    });\n  }\n\n  public error(edata) {\n    CsTelemetryModule.instance.telemetryService.raiseErrorTelemetry({\n      edata\n    });\n  }\n\n  public getEventOptions() {\n    return ({\n      object: this.telemetryObject,\n      context: {\n        channel: this.channel,\n        pdata: this.pdata,\n        env: this.env,\n        sid: this.sid,\n        uid: this.uid,\n        cdata: this.context.cdata || [],\n        rollup: this.rollup || {}\n      }\n    });\n  }\n\n}\n"]}

package/esm2022/lib/services/toaster/toaster.service.mjs

@@ -0,0 +1,105 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to show toaster
+ *
+ */
+export class ToasterService {
+    /**
+        * Constructor to create injected service(s) object
+        */
+    constructor() {
+        this.options = {
+            position: 'topCenter',
+            titleSize: '18',
+            timeout: 6000,
+            transitionIn: 'flipInX',
+            transitionOut: 'flipOutX'
+        };
+        this.iziToast = iziToast; // global object
+    }
+    InfoToasterCritical(title, message) {
+        iziToast.show({
+            title,
+            message,
+            class: 'sb-toaster sb-toast-success sb-toast-normal',
+            position: 'topCenter',
+            timeout: 6000,
+            transitionIn: 'flipInX',
+            transitionOut: 'flipOutX'
+        });
+    }
+    /**
+     * Format success message
+     * @memberOf Services.toasterService
+     * @param string  message - Success message
+     */
+    success(title, message) {
+        this.iziToast.success({
+            title,
+            message: message ? message : '',
+            class: 'sb-toaster sb-toast-normal sb-toast-success',
+            ...this.options
+        });
+    }
+    /**
+     * Format information message
+     * @memberOf Services.toasterService
+     * @param string  message - Info message
+     */
+    info(title, message) {
+        this.iziToast.info({
+            title,
+            message: message ? message : '',
+            class: 'sb-toaster sb-toast-normal sb-toast-info',
+            ...this.options
+        });
+    }
+    /**
+     * Format error message
+     * @memberOf Services.toasterService
+     * @param string  message - Error message
+     */
+    error(title, message) {
+        this.iziToast.error({
+            title,
+            message: message ? message : '',
+            class: 'sb-toaster sb-toast-normal sb-toast-danger',
+            ...this.options
+        });
+    }
+    /**
+     * Format warning message
+     * @memberOf Services.toasterService
+     * @param string  message - Warning message
+     */
+    warning(title, message) {
+        this.iziToast.warning({
+            title,
+            message: message ? message : '',
+            class: 'sb-toaster sb-toast-normal sb-toast-warning',
+            ...this.options
+        });
+    }
+    /**
+     * Simple info message
+     * @memberOf Services.toasterService
+     * @param string  message - Simple info message
+     */
+    simpleInfo(title, position, message) {
+        this.iziToast.info({
+            title,
+            message: message ? message : '',
+            position: position ? position : 'topCenter'
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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