@jeraldj/discussions-ui 8.0.3-v16

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

@@ -0,0 +1,254 @@
+import { Inject, Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { urlConfig } from './../config/url.config';
+/* tslint:disable */
+import * as _ from 'lodash';
+import { CsModule } from '@jeraldj/client-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@jeraldj/client-services";
+/* tslint:enable */
+export const CONTEXT_PROPS = {
+    cid: 'cid',
+    tid: 'tid',
+    uid: 'uid'
+};
+export class DiscussionService {
+    constructor(http, csModule) {
+        this.http = http;
+        this.csModule = csModule;
+        // tslint:disable-next-line:variable-name
+        this._context = {};
+        this.alertEvent = new Subject();
+        // TODO: Take from the logged in user data;
+        // this.usr = this.configSvc.userProfile
+        this.usr = { userId: '1234' };
+        console.log('CsModule init---', CsModule.instance);
+        this.csDiscussionService = CsModule.instance.discussionService;
+    }
+    initializeUserDetails(userId) {
+        userId = userId;
+        this.userDetails = JSON.parse(sessionStorage.getItem('dFUserDetails'));
+        this.fetchUserProfile(userId).subscribe(response => {
+            this.userDetails = response;
+            sessionStorage.setItem('dFUserDetails', JSON.stringify(response));
+        }, (error) => {
+            // TODO: toaster error
+            console.log('error fetching user details');
+        });
+    }
+    appendPage(page, url) {
+        if (page) {
+            return `${url}?page=${page}`;
+        }
+        return `${url}?page=1`;
+    }
+    fetchAllTags() {
+        // const tags = this.http.get(urlConfig.getAllTags())
+        //   .toPromise();
+        // return tags;
+        console.log('innn fetchAllTags');
+        return this.csDiscussionService.fetchAllTags();
+    }
+    createPost(data) {
+        // return this.http.post(urlConfig.createPost(), data);
+        return this.csDiscussionService.createPost(data);
+    }
+    /**
+     * @description To get all the categories
+     */
+    fetchAllCategories() {
+        // return this.http.get<NSDiscussData.ICategorie[]>(urlConfig.getAllCategories()).pipe(
+        //   map((data: any) => {
+        //       // Taking only "categories" from the response
+        //       const resp = (data as any).categories;
+        //       return resp;
+        //   }),
+        //   catchError( error => {
+        //     return throwError( 'Something went wrong!' );
+        //   })
+        // );
+        console.log('in fetchall categories');
+        return this.csDiscussionService.fetchAllCategories().pipe(map((data) => data.categories));
+    }
+    fetchSingleCategoryDetails(cid) {
+        return this.csDiscussionService.fetchSingleCategoryDetails(cid);
+        // return this.http.get<NSDiscussData.ICategorie>(urlConfig.getSingleCategoryDetails(cid));
+    }
+    fetchSingleCategoryDetailsSort(cid, sort, page) {
+        return this.csDiscussionService.fetchSingleCategoryDetails(cid);
+    }
+    fetchAllTag() {
+        return this.csDiscussionService.fetchAllTags();
+        // return this.http.get(urlConfig.getAllTags());
+    }
+    contextBasedTags(data) {
+        return this.csDiscussionService.contextBasedTags(data);
+        // return this.http.get(urlConfig.getAllTags());
+    }
+    fetchPostDetails() {
+        return this.csDiscussionService.fetchAllTags();
+        // return this.http.get(urlConfig.getAllTags());
+    }
+    votePost(pid, data) {
+        return this.csDiscussionService.votePost(pid, data);
+        // const url = urlConfig.votePost(pid);
+        // return this.http.post(url, data);
+    }
+    deleteVotePost(pid) {
+        // const url = urlConfig.votePost(pid);
+        // return this.http.delete(url);
+        return this.csDiscussionService.deleteVotePost(pid);
+    }
+    bookmarkPost(pid) {
+        // const url = urlConfig.bookmarkPost(pid);
+        // return this.http.post(url, {});
+        return this.csDiscussionService.bookmarkPost(pid);
+    }
+    deleteBookmarkPost(pid) {
+        // const url = urlConfig.bookmarkPost(pid);
+        // return this.http.delete(url);
+        return this.csDiscussionService.deleteBookmarkPost(pid);
+    }
+    replyPost(tid, data) {
+        // const url = urlConfig.replyPost(tid);
+        // return this.http.post(url, data);
+        return this.csDiscussionService.replyPost(tid, data);
+    }
+    fetchRecentPost(pageId) {
+        return this.csDiscussionService.recentPost(_.get(this._userDetails, 'username'), pageId);
+    }
+    getTagBasedDiscussion(tag, page) {
+        return this.csDiscussionService.getTagBasedDiscussion(tag);
+    }
+    getContextBasedDiscussion(data) {
+        return this.csDiscussionService.getContextBasedDiscussion(data);
+    }
+    getContextBasedTagDiscussion(data) {
+        return this.csDiscussionService.getContextBasedTagDiscussion(data);
+    }
+    fetchPopularD(page) {
+        return this.csDiscussionService.popularPost(page);
+    }
+    fetchTopicById(topicId, slug, page) {
+        // let url = urlConfig.getTopic() + '/' + topicId.toString() + '/' + slug;
+        // url = this.appendPage(page, url);
+        // return this.http.get(url);
+        return this.csDiscussionService.fetchTopicById(topicId, slug, page);
+    }
+    fetchTopicByIdSort(topicId, sort, page) {
+        // let url = urlConfig.getTopic + topicId.toString();
+        // url = this.appendPage(page, url);
+        // return this.http.get(`${url}&sort=${sort}`);
+        return this.csDiscussionService.fetchTopicById(topicId, sort, page);
+    }
+    fetchUnreadCOunt() {
+        // return this.http.get<any>(urlConfig.unread());
+        return this.csDiscussionService.fetchUnreadCOunt();
+    }
+    // fetchProfile() {
+    //   // return this.http.get(urlConfig.profile());
+    //   return this.csDiscussionService.fetchProfile();
+    // }
+    fetchProfileInfo(slug) {
+        // return this.http.get(urlConfig.fetchProfile(slug));
+        return this.csDiscussionService.fetchProfileInfo(slug);
+    }
+    fetchUpvoted(pageId) {
+        // return this.http.get(urlConfig.listUpVote(_.get(this._userDetails, 'username')));
+        return this.csDiscussionService.fetchUpvoted(_.get(this._userDetails, 'username'), pageId);
+    }
+    fetchDownvoted(pageId) {
+        // return this.http.get(urlConfig.listDownVoted(_.get(this._userDetails, 'username')));
+        return this.csDiscussionService.fetchDownvoted(_.get(this._userDetails, 'username'), pageId);
+    }
+    fetchSaved(pageId) {
+        // return this.http.get(urlConfig.listSaved(_.get(this._userDetails, 'username')));
+        return this.csDiscussionService.fetchSaved(_.get(this._userDetails, 'username'), pageId);
+    }
+    fetchBestPost(pageId) {
+        return this.csDiscussionService.fetchBestPost(_.get(this._userDetails, 'username'), pageId);
+    }
+    fetchUserProfile(userId) {
+        // return this.http.get<any>(urlConfig.userDetails(userName));
+        return this.csDiscussionService.getUserDetails(userId);
+    }
+    getContextBasedTopic(slug, pageId) {
+        // return this.http.get(urlConfig.getContextBasedTopics(slug));
+        return this.csDiscussionService.getContextBasedTopic(slug, pageId);
+    }
+    registerUser(data) {
+        return this.http.post(urlConfig.registerUser(), data);
+    }
+    createForum(data) {
+        return this.csDiscussionService.createForum(data);
+    }
+    getForumIds(data) {
+        return this.csDiscussionService.getForumIds(data).toPromise();
+    }
+    set userDetails(userDetails) {
+        this._userDetails = userDetails;
+    }
+    get userDetails() {
+        return this._userDetails;
+    }
+    set userId(userId) {
+        this._userId = userId;
+    }
+    get userId() {
+        return this._userId;
+    }
+    set forumIds(ids) {
+        this._forumIds = ids;
+    }
+    get forumIds() {
+        return this._forumIds;
+    }
+    setContext(key, value) {
+        if (CONTEXT_PROPS[key]) {
+            this._context[key] = value;
+        }
+        else {
+            console.log('Context can not be set for this key: ', key);
+        }
+    }
+    getContext(key) {
+        return key ? this._context[key] : this._context;
+    }
+    editPost(pid, data) {
+        return this.csDiscussionService.editPost(pid, data);
+    }
+    deletePost(pid, uid) {
+        return this.csDiscussionService.deletePost(pid, uid);
+    }
+    editTopic(tid, data) {
+        return this.csDiscussionService.editTopic(tid, data);
+    }
+    deleteTopic(tid) {
+        return this.csDiscussionService.deleteTopic(tid);
+    }
+    /** To check the error code and show alert message
+     *  if it is 502 - error
+     */
+    showTrafficAlert(errorObject) {
+        const errorCode = _.get(errorObject, 'response.responseCode');
+        if (errorCode) {
+            if ([502, '502'].includes(errorCode)) {
+                this.alertEvent.next();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DiscussionService, deps: [{ token: i1.HttpClient }, { token: 'CsModule' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DiscussionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DiscussionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.CsModule, decorators: [{
+                    type: Inject,
+                    args: ['CsModule']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discussion.service.js","sourceRoot":"","sources":["../../../../../projects/discussion-ui/src/lib/services/discussion.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { of as observableOf, throwError as observableThrowError, Observable, throwError, Subject } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\nimport { HttpClient, HttpResponse } from '@angular/common/http';\nimport { urlConfig } from './../config/url.config';\nimport { NSDiscussData } from '../models/discuss.model';\n\n/* tslint:disable */\nimport * as _ from 'lodash'\nimport { CsDiscussionService } from '@jeraldj/client-services/services/discussion';\nimport { CsModule } from '@jeraldj/client-services';\n/* tslint:enable */\n\nexport const CONTEXT_PROPS = {\n  cid: 'cid',\n  tid: 'tid',\n  uid: 'uid'\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DiscussionService {\n\n  // tslint:disable-next-line:variable-name\n  private _userDetails: any;\n\n  // tslint:disable-next-line:variable-name\n  private _userId: any;\n\n  // tslint:disable-next-line:variable-name\n  private _forumIds: any;\n  private csDiscussionService: CsDiscussionService;\n\n  // tslint:disable-next-line:variable-name\n  private _context: any = {};\n\n  public alertEvent = new Subject();\n\n  usr: any;\n\n  constructor(\n    private http: HttpClient,\n    @Inject('CsModule') private csModule: CsModule\n  ) {\n    // TODO: Take from the logged in user data;\n    // this.usr = this.configSvc.userProfile\n    this.usr = { userId: '1234' };\n    console.log('CsModule init---', CsModule.instance);\n    this.csDiscussionService = CsModule.instance.discussionService;\n\n  }\n\n  initializeUserDetails(userId) {\n    userId = userId\n    this.userDetails = JSON.parse(sessionStorage.getItem('dFUserDetails'))\n    this.fetchUserProfile(userId).subscribe(response => {\n      this.userDetails = response;\n      sessionStorage.setItem('dFUserDetails', JSON.stringify(response));\n    }, (error) => {\n      // TODO: toaster error\n      console.log('error fetching user details');\n    });\n  }\n\n  appendPage(page: any, url: string) {\n    if (page) {\n      return `${url}?page=${page}`;\n    }\n    return `${url}?page=1`;\n  }\n\n  fetchAllTags() {\n    // const tags = this.http.get(urlConfig.getAllTags())\n    //   .toPromise();\n    // return tags;\n    console.log('innn fetchAllTags');\n    return this.csDiscussionService.fetchAllTags();\n  }\n\n  createPost(data: any) {\n    // return this.http.post(urlConfig.createPost(), data);\n    return this.csDiscussionService.createPost(data);\n  }\n  /**\n   * @description To get all the categories\n   */\n\n  fetchAllCategories() {\n    // return this.http.get<NSDiscussData.ICategorie[]>(urlConfig.getAllCategories()).pipe(\n    //   map((data: any) => {\n    //       // Taking only \"categories\" from the response\n    //       const resp = (data as any).categories;\n    //       return resp;\n    //   }),\n    //   catchError( error => {\n    //     return throwError( 'Something went wrong!' );\n    //   })\n    // );\n    console.log('in fetchall categories');\n    return this.csDiscussionService.fetchAllCategories().pipe(\n      map((data: any) => data.categories)\n    );\n  }\n\n  fetchSingleCategoryDetails(cid: any) {\n    return this.csDiscussionService.fetchSingleCategoryDetails(cid);\n    // return this.http.get<NSDiscussData.ICategorie>(urlConfig.getSingleCategoryDetails(cid));\n  }\n  fetchSingleCategoryDetailsSort(cid: number, sort: any, page?: any) {\n    return this.csDiscussionService.fetchSingleCategoryDetails(cid);\n  }\n\n  fetchAllTag() {\n    return this.csDiscussionService.fetchAllTags();\n    // return this.http.get(urlConfig.getAllTags());\n  }\n\n  contextBasedTags(data) {\n    return this.csDiscussionService.contextBasedTags(data);\n    // return this.http.get(urlConfig.getAllTags());\n  }\n\n  fetchPostDetails() {\n    return this.csDiscussionService.fetchAllTags();\n    // return this.http.get(urlConfig.getAllTags());\n  }\n\n  votePost(pid: number, data: any) {\n    return this.csDiscussionService.votePost(pid, data);\n    // const url = urlConfig.votePost(pid);\n    // return this.http.post(url, data);\n  }\n\n  deleteVotePost(pid: number) {\n    // const url = urlConfig.votePost(pid);\n    // return this.http.delete(url);\n    return this.csDiscussionService.deleteVotePost(pid);\n  }\n\n  bookmarkPost(pid: number) {\n    // const url = urlConfig.bookmarkPost(pid);\n    // return this.http.post(url, {});\n    return this.csDiscussionService.bookmarkPost(pid);\n  }\n\n  deleteBookmarkPost(pid: number) {\n    // const url = urlConfig.bookmarkPost(pid);\n    // return this.http.delete(url);\n    return this.csDiscussionService.deleteBookmarkPost(pid);\n  }\n\n  replyPost(tid: number, data: any) {\n    // const url = urlConfig.replyPost(tid);\n    // return this.http.post(url, data);\n    return this.csDiscussionService.replyPost(tid, data);\n  }\n\n  fetchRecentPost(pageId?) {\n    return this.csDiscussionService.recentPost(_.get(this._userDetails, 'username'), pageId);\n  }\n\n  getTagBasedDiscussion(tag?: string, page?: any) {\n    return this.csDiscussionService.getTagBasedDiscussion(tag);\n  }\n\n  getContextBasedDiscussion(data) {\n    return this.csDiscussionService.getContextBasedDiscussion(data);\n  }\n\n  getContextBasedTagDiscussion(data) {\n    return this.csDiscussionService.getContextBasedTagDiscussion(data);\n  }\n\n  fetchPopularD(page?: any) {\n    return this.csDiscussionService.popularPost(page);\n  }\n\n  fetchTopicById(topicId: number, slug?: any, page?: any) {\n    // let url = urlConfig.getTopic() + '/' + topicId.toString() + '/' + slug;\n    // url = this.appendPage(page, url);\n    // return this.http.get(url);\n    return this.csDiscussionService.fetchTopicById(topicId, slug, page);\n  }\n\n  fetchTopicByIdSort(topicId: number, sort: any, page?: any) {\n    // let url = urlConfig.getTopic + topicId.toString();\n    // url = this.appendPage(page, url);\n    // return this.http.get(`${url}&sort=${sort}`);\n    return this.csDiscussionService.fetchTopicById(topicId, sort, page);\n  }\n\n  fetchUnreadCOunt() {\n    // return this.http.get<any>(urlConfig.unread());\n    return this.csDiscussionService.fetchUnreadCOunt();\n\n  }\n  // fetchProfile() {\n  //   // return this.http.get(urlConfig.profile());\n  //   return this.csDiscussionService.fetchProfile();\n  // }\n  fetchProfileInfo(slug: string) {\n    // return this.http.get(urlConfig.fetchProfile(slug));\n    return this.csDiscussionService.fetchProfileInfo(slug);\n  }\n  fetchUpvoted(pageId: number) {// 0\n    // return this.http.get(urlConfig.listUpVote(_.get(this._userDetails, 'username')));\n    return this.csDiscussionService.fetchUpvoted(_.get(this._userDetails, 'username'), pageId);\n  }\n  fetchDownvoted(pageId: number) { // 0\n    // return this.http.get(urlConfig.listDownVoted(_.get(this._userDetails, 'username')));\n    return this.csDiscussionService.fetchDownvoted(_.get(this._userDetails, 'username'), pageId);\n  }\n  fetchSaved(pageId: number) { // 0 this.usr.userId\n    // return this.http.get(urlConfig.listSaved(_.get(this._userDetails, 'username')));\n    return this.csDiscussionService.fetchSaved(_.get(this._userDetails, 'username'), pageId);\n  }\n\n  fetchBestPost(pageId: number) {\n    return this.csDiscussionService.fetchBestPost(_.get(this._userDetails, 'username'), pageId);\n  }\n\n  fetchUserProfile(userId) {\n    // return this.http.get<any>(urlConfig.userDetails(userName));\n    return this.csDiscussionService.getUserDetails(userId);\n  }\n\n  getContextBasedTopic(slug: string, pageId: number) {\n    // return this.http.get(urlConfig.getContextBasedTopics(slug));\n    return this.csDiscussionService.getContextBasedTopic(slug, pageId);\n  }\n\n  registerUser(data) {\n    return this.http.post(urlConfig.registerUser(), data);\n  }\n\n  createForum(data) {\n    return this.csDiscussionService.createForum(data)\n  }\n\n  getForumIds(data) {\n    return this.csDiscussionService.getForumIds(data).toPromise()\n  }\n\n  set userDetails(userDetails) {\n    this._userDetails = userDetails;\n  }\n\n  get userDetails() {\n    return this._userDetails;\n  }\n\n  set userId(userId) {\n    this._userId = userId;\n  }\n\n  get userId() {\n    return this._userId;\n  }\n\n  set forumIds(ids) {\n    this._forumIds = ids;\n  }\n\n  get forumIds() {\n    return this._forumIds;\n  }\n\n  setContext(key, value) {\n    if (CONTEXT_PROPS[key]) {\n      this._context[key] = value;\n    } else {\n      console.log('Context can not be set for this key: ', key);\n    }\n  }\n\n  getContext(key?: string) {\n    return key ? this._context[key] : this._context;\n  }\n\n  editPost(pid: number, data: any) {\n    return this.csDiscussionService.editPost(pid, data);\n  }\n\n  deletePost(pid: number, uid: number) {\n    return this.csDiscussionService.deletePost(pid, uid);\n  }\n\n  editTopic(tid: number, data: any) {\n    return this.csDiscussionService.editTopic(tid, data);\n  }\n\n  deleteTopic(tid: number) {\n    return this.csDiscussionService.deleteTopic(tid);\n  }\n\n  /** To check the error code and show alert message\n   *  if it is 502 - error \n   */\n  showTrafficAlert(errorObject) {\n    const errorCode = _.get(errorObject, 'response.responseCode')\n    if (errorCode) {\n      if ([502, '502'].includes(errorCode)) {\n        this.alertEvent.next();\n      }\n    }\n  }\n\n}\n"]}

package/esm2022/lib/telemetry-utils.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+/* tslint:disable */
+import * as _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "./discussion-events.service";
+import * as i2 from "@angular/router";
+export class TelemetryUtilsService {
+    constructor(discussionEvents, router) {
+        this.discussionEvents = discussionEvents;
+        this.router = router;
+        this._context = [];
+        this.currentObj = {};
+    }
+    setContext(context) {
+        this._context = context;
+        this.currentObj = _.last(context);
+    }
+    uppendContext(data) {
+        const matchedC = _.find(this._context, { id: data.id });
+        if (!_.isEmpty(data) && !_.isEqual(data, matchedC)) {
+            this._context.push(data);
+        }
+        this.currentObj = _.last(this._context);
+    }
+    deleteContext(prevTopic) {
+        const topic = _.find(this._context, prevTopic);
+        if (topic) {
+            this._context = _.reject(this._context, topic);
+        }
+    }
+    getContext() {
+        return this._context;
+    }
+    logImpression(pageId) {
+        this.discussionEvents.emitTelemetry({});
+        const impressionEvent = {
+            eid: 'IMPRESSION',
+            edata: {
+                type: 'view',
+                pageid: pageId,
+                uri: this.router.url
+            }
+        };
+        if (this.currentObj) {
+            impressionEvent.context = { cdata: [{
+                        id: _.get(this.currentObj, 'id').toString(),
+                        type: _.get(this.currentObj, 'type')
+                    }
+                ] };
+        }
+        this.discussionEvents.emitTelemetry(impressionEvent);
+    }
+    logInteract(event, pageId) {
+        const target = _.get(event, 'currentTarget.attributes.id') || _.get(event, 'target.attributes.id') ||
+            _.get(event, 'srcElement.attributes.id');
+        const interactEvent = {
+            eid: 'INTERACT',
+            edata: {
+                id: _.get(target, 'value') || _.get(event, 'action'),
+                type: 'CLICK',
+                pageid: pageId
+            }
+        };
+        if (this.currentObj) {
+            const object = {
+                id: _.get(this.currentObj, 'id').toString(),
+                type: _.get(this.currentObj, 'type'),
+                ver: '1'
+            };
+            object['rollup'] = this._context.length > 1 ? this.getRollUp() : {};
+            interactEvent.context = {
+                cdata: [{
+                        id: _.get(this.currentObj, 'id').toString(),
+                        type: _.get(this.currentObj, 'type')
+                    }], object
+            };
+        }
+        this.discussionEvents.emitTelemetry(interactEvent);
+    }
+    getRollUp() {
+        const rollUp = {};
+        const data = _.reject(this._context, this.currentObj);
+        if (this._context.length > 1) {
+            data.forEach((element, index) => {
+                console.log('rollup', element);
+                rollUp['l' + (index + 1)] = element.toString();
+            });
+        }
+        if (_.get(this.currentObj, 'type') !== 'Post') {
+            return rollUp;
+        }
+        return {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TelemetryUtilsService, deps: [{ token: i1.DiscussionEventsService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TelemetryUtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TelemetryUtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DiscussionEventsService }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry-utils.service.js","sourceRoot":"","sources":["../../../../projects/discussion-ui/src/lib/telemetry-utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { DiscussionEventsService } from './discussion-events.service';\nimport { Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\n/* tslint:disable */\nimport * as _ from 'lodash'\n/* tslint:enable */\ninterface ITelemetryObj {\n  eid: string,\n  edata: {},\n  context?: {}\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TelemetryUtilsService {\n\n  _context = []\n  currentObj = {};\n\n  constructor(\n    private discussionEvents: DiscussionEventsService,\n    private router: Router\n  ) { }\n\n  setContext(context) {\n    this._context = context;\n    this.currentObj = _.last(context);\n  }\n\n  uppendContext(data) {\n    const matchedC = _.find(this._context, { id: data.id });\n    if (!_.isEmpty(data) && !_.isEqual(data, matchedC)) {\n      this._context.push(data);\n    }\n    this.currentObj = _.last(this._context);\n  }\n\n  deleteContext(prevTopic) {\n    const topic = _.find(this._context, prevTopic);\n    if (topic) {\n      this._context = _.reject(this._context, topic);\n    }\n  }\n\n  getContext() {\n    return this._context;\n  }\n\n  logImpression(pageId) {\n    this.discussionEvents.emitTelemetry({});\n    const impressionEvent: ITelemetryObj = {\n      eid: 'IMPRESSION',\n      edata: {\n        type: 'view',\n        pageid: pageId,\n        uri: this.router.url\n      }\n    }\n    if (this.currentObj) {\n      impressionEvent.context = { cdata: [{\n        id: _.get(this.currentObj, 'id').toString(),\n        type: _.get(this.currentObj, 'type') }\n      ]};\n    }\n    this.discussionEvents.emitTelemetry(impressionEvent);\n  }\n\n  logInteract(event, pageId) {\n    const target = _.get(event, 'currentTarget.attributes.id') ||  _.get(event, 'target.attributes.id') ||\n     _.get(event, 'srcElement.attributes.id');\n    const interactEvent: ITelemetryObj = {\n      eid: 'INTERACT',\n      edata: {\n        id: _.get(target, 'value') || _.get(event, 'action'),\n        type: 'CLICK',\n        pageid: pageId\n      }\n    };\n\n    if (this.currentObj) {\n      const object = {\n        id: _.get(this.currentObj, 'id').toString(),\n        type: _.get(this.currentObj, 'type'),\n        ver: '1'\n      };\n      object['rollup'] = this._context.length > 1 ?  this.getRollUp() : {};\n      interactEvent.context = {\n        cdata: [{\n          id: _.get(this.currentObj, 'id').toString(),\n          type: _.get(this.currentObj, 'type')\n        }], object\n      };\n    }\n\n    this.discussionEvents.emitTelemetry(interactEvent);\n  }\n\n  getRollUp() {\n\n      const rollUp = {};\n      const data = _.reject(this._context, this.currentObj);\n\n      if (this._context.length > 1) {\n        data.forEach((element, index) => {\n          console.log('rollup', element);\n          rollUp['l' + (index + 1)] = element.toString();\n        });\n      }\n\n      if (_.get(this.currentObj, 'type') !== 'Post') {\n        return rollUp;\n      }\n\n      return {};\n\n  }\n\n}\n"]}

package/esm2022/lib/wrapper/base-wrapper/base-wrapper.component.mjs

@@ -0,0 +1,41 @@
+import { Component, Input } from '@angular/core';
+import { EventsService } from '../../events.service';
+import { NavigationServiceService } from '../../navigation-service.service';
+import * as _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "../../navigation-service.service";
+import * as i2 from "../../events.service";
+import * as i3 from "../../services/config.service";
+import * as i4 from "../../services/discussion.service";
+export class BaseWrapperComponent {
+    constructor(navigationServiceService, eventService, configSvc, discussionService) {
+        this.navigationServiceService = navigationServiceService;
+        this.eventService = eventService;
+        this.configSvc = configSvc;
+        this.discussionService = discussionService;
+    }
+    ngOnInit() {
+        this.navigationServiceService.initService('wrapperService');
+        this.configSvc.setConfigFromWidgetBaseClass(this.config);
+        this.discussionService.userId = _.get(this.config, 'userName');
+        const rawCategories = _.get(this.config, 'categories');
+        this.discussionService.forumIds = _.get(rawCategories, 'result');
+        this.discussionService.initializeUserDetails(this.config.userName);
+        this.eventService.toggleMenuItem.subscribe((data) => {
+            this.wrapperEventListener(data);
+            this.state = data.action;
+        });
+        this.wrapperInit();
+    }
+    wrapperInit() { }
+    wrapperEventListener(data) { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseWrapperComponent, deps: [{ token: i1.NavigationServiceService }, { token: i2.EventsService }, { token: i3.ConfigService }, { token: i4.DiscussionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: BaseWrapperComponent, selector: "sb-base-wrapper", inputs: { config: "config" }, providers: [NavigationServiceService, EventsService], ngImport: i0, template: "<p>base-wrapper works!</p>\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sb-base-wrapper', providers: [NavigationServiceService, EventsService], template: "<p>base-wrapper works!</p>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.NavigationServiceService }, { type: i2.EventsService }, { type: i3.ConfigService }, { type: i4.DiscussionService }]; }, propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/wrapper/category-widget/category-widget.component.mjs

@@ -0,0 +1,37 @@
+import { Component } from '@angular/core';
+import * as CONSTANTS from '../../common/constants.json';
+import { BaseWrapperComponent } from '../base-wrapper/base-wrapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/config.service";
+import * as i2 from "../../services/discussion.service";
+import * as i3 from "../../navigation-service.service";
+import * as i4 from "../../events.service";
+import * as i5 from "../../components/discuss-all/discuss-all.component";
+export class CategoryWidgetComponent extends BaseWrapperComponent {
+    constructor(configSvc, discussionService, navigationServiceService, eventService) {
+        super(navigationServiceService, eventService, configSvc, discussionService);
+        this.detailsToggle = true;
+        this.category = CONSTANTS.CATEGORY;
+        this.detailsPage = CONSTANTS.CATEGORY_DETAILS;
+        this.homePage = CONSTANTS.CATEGORY_HOME;
+    }
+    wrapperInit() {
+        this.state = this.detailsPage;
+    }
+    stateChange(event) {
+        this.state = event.action;
+        if (event.action === this.detailsPage) {
+            this.tid = event.tid;
+            this.slug = event.title;
+        }
+    }
+    wrapperEventListener(data) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CategoryWidgetComponent, deps: [{ token: i1.ConfigService }, { token: i2.DiscussionService }, { token: i3.NavigationServiceService }, { token: i4.EventsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CategoryWidgetComponent, selector: "sb-category-widget", usesInheritance: true, ngImport: i0, template: "<div class='widget-container'>\n    <!-- <lib-discuss-category *ngIf='state === category ' [categoryAction]='homePage' (stateChange)='stateChange($event)'></lib-discuss-category>\n    <lib-discuss-home *ngIf='state === homePage' [categoryHomeAction]='detailsPage' (stateChange)='stateChange($event)'></lib-discuss-home> -->\n    <!-- <lib-discussion-details *ngIf='state === detailsPage' [widget]=\"true\" [topicId]='tid' [slug]='slug'></lib-discussion-details> -->\n    <lib-discuss-all [context]='context'></lib-discuss-all>\n</div>", styles: [".widget-container{display:flex;width:100%}\n"], dependencies: [{ kind: "component", type: i5.DiscussAllComponent, selector: "lib-discuss-all", inputs: ["context", "categoryAction"], outputs: ["stateChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CategoryWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sb-category-widget', template: "<div class='widget-container'>\n    <!-- <lib-discuss-category *ngIf='state === category ' [categoryAction]='homePage' (stateChange)='stateChange($event)'></lib-discuss-category>\n    <lib-discuss-home *ngIf='state === homePage' [categoryHomeAction]='detailsPage' (stateChange)='stateChange($event)'></lib-discuss-home> -->\n    <!-- <lib-discussion-details *ngIf='state === detailsPage' [widget]=\"true\" [topicId]='tid' [slug]='slug'></lib-discussion-details> -->\n    <lib-discuss-all [context]='context'></lib-discuss-all>\n</div>", styles: [".widget-container{display:flex;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.DiscussionService }, { type: i3.NavigationServiceService }, { type: i4.EventsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/wrapper/tags-widget/tags-widget.component.mjs

@@ -0,0 +1,33 @@
+import { Component } from '@angular/core';
+import { BaseWrapperComponent } from '../base-wrapper/base-wrapper.component';
+import * as CONSTANTS from '../../common/constants.json';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/config.service";
+import * as i2 from "../../services/discussion.service";
+import * as i3 from "../../navigation-service.service";
+import * as i4 from "../../events.service";
+import * as i5 from "../../components/discuss-tags/discuss-tags.component";
+import * as i6 from "@angular/common";
+export class TagsWidgetComponent extends BaseWrapperComponent {
+    constructor(configSvc, discussionService, navigationServiceService, eventService) {
+        super(navigationServiceService, eventService, configSvc, discussionService);
+        this.tags = CONSTANTS.TAGS;
+        this.tagsAll = CONSTANTS.TAGSALL;
+    }
+    wrapperInit() {
+        this.state = this.tags;
+    }
+    wrapperEventListener(data) {
+        // if (data.action === this.tags || data.action === this.tagName) {
+        //   this.state = data.action
+        // }
+        this.tagName = data.tagName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TagsWidgetComponent, deps: [{ token: i1.ConfigService }, { token: i2.DiscussionService }, { token: i3.NavigationServiceService }, { token: i4.EventsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TagsWidgetComponent, selector: "sb-tags-widget", usesInheritance: true, ngImport: i0, template: "<div >\n    <lib-discuss-tags *ngIf='state === tags'></lib-discuss-tags>\n    <!-- <lib-tag-all-discussion *ngIf='state === tagsAll' [tagName]='tagName'></lib-tag-all-discussion> -->\n    <!-- <lib-discuss-home *ngIf='state === homePage'></lib-discuss-home>\n    <lib-discussion-details *ngIf='state === detailsPage' [topicId]='tid' [slug]='slug'></lib-discussion-details> -->\n</div>", styles: [""], dependencies: [{ kind: "component", type: i5.DiscussTagsComponent, selector: "lib-discuss-tags", outputs: ["stateChange"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TagsWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sb-tags-widget', template: "<div >\n    <lib-discuss-tags *ngIf='state === tags'></lib-discuss-tags>\n    <!-- <lib-tag-all-discussion *ngIf='state === tagsAll' [tagName]='tagName'></lib-tag-all-discussion> -->\n    <!-- <lib-discuss-home *ngIf='state === homePage'></lib-discuss-home>\n    <lib-discussion-details *ngIf='state === detailsPage' [topicId]='tid' [slug]='slug'></lib-discussion-details> -->\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.DiscussionService }, { type: i3.NavigationServiceService }, { type: i4.EventsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/wrapper-navigate.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { EventEmitter } from 'events';
+import * as i0 from "@angular/core";
+import * as i1 from "./events.service";
+//TODO: Need to cleanup this service since we are not gonna use
+export class WrapperNavigateService {
+    constructor(_eventService) {
+        this._eventService = _eventService;
+        this.closeSideNav = new EventEmitter();
+    }
+    navigate(input) {
+        //  this._eventService.toggle(input)
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WrapperNavigateService, deps: [{ token: i1.EventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WrapperNavigateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WrapperNavigateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.EventsService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JhcHBlci1uYXZpZ2F0ZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZGlzY3Vzc2lvbi11aS9zcmMvbGliL3dyYXBwZXItbmF2aWdhdGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7OztBQU90QywrREFBK0Q7QUFDL0QsTUFBTSxPQUFPLHNCQUFzQjtJQUlqQyxZQUFvQixhQUE0QjtRQUE1QixrQkFBYSxHQUFiLGFBQWEsQ0FBZTtRQUZoRCxpQkFBWSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUE7SUFFbUIsQ0FBQztJQUVyRCxRQUFRLENBQUMsS0FBSztRQUNkLG9DQUFvQztJQUNwQyxDQUFDOytHQVJVLHNCQUFzQjttSEFBdEIsc0JBQXNCLGNBSnJCLE1BQU07OzRGQUlQLHNCQUFzQjtrQkFMbEMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBFdmVudEVtaXR0ZXIgfSBmcm9tICdldmVudHMnO1xuaW1wb3J0IHsgRXZlbnRzU2VydmljZSB9IGZyb20gJy4vZXZlbnRzLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcblxuLy9UT0RPOiBOZWVkIHRvIGNsZWFudXAgdGhpcyBzZXJ2aWNlIHNpbmNlIHdlIGFyZSBub3QgZ29ubmEgdXNlXG5leHBvcnQgY2xhc3MgV3JhcHBlck5hdmlnYXRlU2VydmljZSB7XG5cbiAgY2xvc2VTaWRlTmF2ID0gbmV3IEV2ZW50RW1pdHRlcigpXG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBfZXZlbnRTZXJ2aWNlOiBFdmVudHNTZXJ2aWNlKSB7IH1cblxuICBuYXZpZ2F0ZShpbnB1dCl7IFxuICAvLyAgdGhpcy5fZXZlbnRTZXJ2aWNlLnRvZ2dsZShpbnB1dClcbiAgfVxufVxuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,29 @@
+/*
+ * Public API Surface of discussion-ui
+ */
+export * from './lib/discussion-ui.module';
+export * from './lib/discussion-events.service';
+export * from './lib/models/discussion-config.model';
+export * from './lib/services/config.service';
+export * from './lib/services/discussion.service';
+export * from './lib/wrapper-navigate.service';
+export * from './lib/discussion-events.service';
+export * from './lib/events.service';
+export * from './lib/navigation-service.service';
+export * from './lib/services/abstract-config.service';
+export * from './lib/wrapper/category-widget/category-widget.component';
+export * from './lib/wrapper/base-wrapper/base-wrapper.component';
+export * from './lib/wrapper/tags-widget/tags-widget.component';
+export * from './lib/components/components.module';
+export * from './lib/components/discuss-all/discuss-all.component';
+export * from './lib/components/discuss-category/discuss-category.component';
+export * from './lib/components/discuss-home/discuss-home.component';
+export * from './lib/components/discuss-start/discuss-start.component';
+export * from './lib/components/discuss-tags/discuss-tags.component';
+export * from './lib/components/discussion-details/discussion-details.component';
+export * from './lib/components/lib-entry/lib-entry.component';
+export * from './lib/components/my-discussion/my-discussion.component';
+export * from './lib/components/side-pannel/side-pannel.component';
+export * from './lib/components/tag-all-discussion/tag-all-discussion.component';
+export * from './lib/components/trending-tags/trending-tags.component';
+//# sourceMappingURL=data:application/json;base64,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