@memberjunction/ng-explorer-core 0.9.2

package/dist/lib/single-record/single-record.component.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { Metadata } from '@memberjunction/core';
+import { MJGlobal } from '@memberjunction/global';
+import { Container } from '@memberjunction/ng-container-directives';
+import { BaseFormComponent } from '../generic/base-form-component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+import * as i3 from "@progress/kendo-angular-indicators";
+import * as i4 from "@memberjunction/ng-container-directives";
+function SingleRecordComponent_kendo_loader_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "kendo-loader", 2);
+} }
+function SingleRecordComponent_ng_template_1_Template(rf, ctx) { }
+export class SingleRecordComponent {
+    constructor(route) {
+        this.route = route;
+        this.recordId = -1;
+        this.entityName = '';
+        this.loadComplete = new EventEmitter();
+        this.appDescription = '';
+        this.useGenericForm = false;
+        this.loading = true;
+    }
+    ngOnInit() {
+    }
+    ngAfterViewInit() {
+        this.LoadForm(this.recordId, this.entityName);
+    }
+    LoadForm(recordId, entityName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Perform any necessary actions with the ViewID, such as fetching data
+            if (recordId && entityName) {
+                this.entityName = entityName;
+                this.recordId = recordId;
+                const formReg = MJGlobal.Instance.ClassFactory.GetRegistration(BaseFormComponent, entityName);
+                const md = new Metadata();
+                const entity = md.Entities.find(e => {
+                    return e.Name === entityName;
+                });
+                const permissions = entity === null || entity === void 0 ? void 0 : entity.GetUserPermisions(md.CurrentUser);
+                if (formReg) {
+                    const record = yield md.GetEntityObject(entityName);
+                    if (record) {
+                        yield record.Load(recordId);
+                        const viewContainerRef = this.formContainer.viewContainerRef;
+                        viewContainerRef.clear();
+                        const componentRef = viewContainerRef.createComponent(formReg.SubClass);
+                        componentRef.instance.record = record;
+                        componentRef.instance.userPermissions = permissions;
+                        this.useGenericForm = false;
+                        this.loadComplete.emit();
+                    }
+                    else
+                        throw new Error(`Unable to load entity ${entityName} with ID ${recordId}`);
+                }
+                this.loading = false;
+            }
+        });
+    }
+}
+SingleRecordComponent.ɵfac = function SingleRecordComponent_Factory(t) { return new (t || SingleRecordComponent)(i0.ɵɵdirectiveInject(i1.ActivatedRoute)); };
+SingleRecordComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SingleRecordComponent, selectors: [["app-single-record"]], viewQuery: function SingleRecordComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(Container, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.formContainer = _t.first);
+    } }, inputs: { recordId: "recordId", entityName: "entityName" }, outputs: { loadComplete: "loadComplete" }, decls: 2, vars: 1, consts: [["type", "converging-spinner", 4, "ngIf"], ["mjContainer", ""], ["type", "converging-spinner"]], template: function SingleRecordComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, SingleRecordComponent_kendo_loader_0_Template, 1, 0, "kendo-loader", 0);
+        i0.ɵɵtemplate(1, SingleRecordComponent_ng_template_1_Template, 0, 0, "ng-template", 1);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.loading);
+    } }, dependencies: [i2.NgIf, i3.LoaderComponent, i4.Container] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SingleRecordComponent, [{
+        type: Component,
+        args: [{ selector: 'app-single-record', template: "<kendo-loader *ngIf=\"loading\" type=\"converging-spinner\" ></kendo-loader>\r\n<ng-template mjContainer></ng-template>" }]
+    }], function () { return [{ type: i1.ActivatedRoute }]; }, { formContainer: [{
+            type: ViewChild,
+            args: [Container, { static: true }]
+        }], recordId: [{
+            type: Input
+        }], entityName: [{
+            type: Input
+        }], loadComplete: [{
+            type: Output
+        }] }); })();

package/dist/lib/single-report/single-report.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { ReportEntity } from '@memberjunction/core-entities';
+import { SkipColumnInfo, SkipData } from '../ask-skip/ask-skip.component';
+import { DynamicReportComponent } from '../generic/dynamic-report';
+import * as i0 from "@angular/core";
+export declare class SingleReportComponent implements OnInit {
+    reportId: number;
+    loadComplete: EventEmitter<any>;
+    loadStarted: EventEmitter<any>;
+    theReport: DynamicReportComponent;
+    ReportEntity: ReportEntity;
+    reportData: any[];
+    ReportConfiguration: SkipData | undefined;
+    get IsChart(): boolean;
+    get IsTable(): boolean;
+    get Columns(): SkipColumnInfo[];
+    get Report(): DynamicReportComponent;
+    ngOnInit(): void;
+    doLoad(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleReportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SingleReportComponent, "app-single-report", never, { "reportId": "reportId"; }, { "loadComplete": "loadComplete"; "loadStarted": "loadStarted"; }, never, never, false, never>;
+}

package/dist/lib/single-report/single-report.component.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { LogError, Metadata, RunReport } from '@memberjunction/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@memberjunction/ng-container-directives";
+import * as i2 from "../generic/dynamic-report";
+const _c0 = ["theReport"];
+export class SingleReportComponent {
+    constructor() {
+        this.loadComplete = new EventEmitter();
+        this.loadStarted = new EventEmitter();
+    }
+    get IsChart() {
+        return this.theReport.IsChart;
+    }
+    get IsTable() {
+        return this.theReport.IsTable;
+    }
+    get Columns() {
+        return this.theReport.Columns;
+    }
+    get Report() {
+        return this.theReport;
+    }
+    ngOnInit() {
+        this.doLoad();
+    }
+    doLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // get info on the report we are loading
+                this.loadStarted.emit();
+                const md = new Metadata();
+                this.ReportEntity = (yield md.GetEntityObject('Reports'));
+                yield this.ReportEntity.Load(this.reportId);
+                this.ReportConfiguration = JSON.parse(this.ReportEntity.ReportConfiguration);
+                const runReport = new RunReport();
+                const result = yield runReport.RunReport({ ReportID: this.reportId });
+                if (result && result.Success && result.Results.length > 0) {
+                    this.reportData = result.Results;
+                    if (this.ReportConfiguration && this.ReportConfiguration.SQLResults)
+                        this.ReportConfiguration.SQLResults.results = this.reportData; // put the report data into the right spot so the dynamic report knows where to get it
+                }
+                else {
+                    // report has an invalid configuration
+                    throw new Error('Error running report: invalid value from ReportConfiguration field ');
+                }
+                this.loadComplete.emit();
+            }
+            catch (err) {
+                LogError(err);
+            }
+        });
+    }
+}
+SingleReportComponent.ɵfac = function SingleReportComponent_Factory(t) { return new (t || SingleReportComponent)(); };
+SingleReportComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SingleReportComponent, selectors: [["app-single-report"]], viewQuery: function SingleReportComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.theReport = _t.first);
+    } }, inputs: { reportId: "reportId" }, outputs: { loadComplete: "loadComplete", loadStarted: "loadStarted" }, decls: 2, vars: 4, consts: [["mjFillContainer", "", 3, "ShowDetailsTab", "SkipData", "ConversationID", "ConversationDetailID"], ["theReport", ""]], template: function SingleReportComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "app-dynamic-report", 0, 1);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ShowDetailsTab", true)("SkipData", ctx.ReportConfiguration)("ConversationID", ctx.ReportEntity.ConversationID)("ConversationDetailID", ctx.ReportEntity.ConversationDetailID);
+    } }, dependencies: [i1.FillContainer, i2.DynamicReportComponent] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SingleReportComponent, [{
+        type: Component,
+        args: [{ selector: 'app-single-report', template: "<app-dynamic-report mjFillContainer #theReport [ShowDetailsTab]=\"true\" [SkipData]=\"ReportConfiguration\"\r\n                    [ConversationID]=\"ReportEntity.ConversationID\"\r\n                    [ConversationDetailID]=\"ReportEntity.ConversationDetailID\"></app-dynamic-report>" }]
+    }], null, { reportId: [{
+            type: Input
+        }], loadComplete: [{
+            type: Output
+        }], loadStarted: [{
+            type: Output
+        }], theReport: [{
+            type: ViewChild,
+            args: ['theReport', { static: true }]
+        }] }); })();

package/dist/lib/single-search-result/single-search-result.component.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter, AfterViewInit } from '@angular/core';
+import { RunViewParams } from '@memberjunction/core';
+import { UserViewGridComponent } from '@memberjunction/ng-user-view-grid';
+import * as i0 from "@angular/core";
+export declare class SingleSearchResultComponent implements AfterViewInit {
+    entity: string;
+    searchInput: string;
+    loadComplete: EventEmitter<any>;
+    loadStarted: EventEmitter<any>;
+    userViewGrid: UserViewGridComponent;
+    get params(): RunViewParams;
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSearchResultComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SingleSearchResultComponent, "app-single-search-result", never, { "entity": "entity"; "searchInput": "searchInput"; }, { "loadComplete": "loadComplete"; "loadStarted": "loadStarted"; }, never, never, false, never>;
+}

package/dist/lib/single-search-result/single-search-result.component.js

@@ -0,0 +1,60 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { UserViewGridComponent } from '@memberjunction/ng-user-view-grid';
+import * as i0 from "@angular/core";
+import * as i1 from "@memberjunction/ng-user-view-grid";
+export class SingleSearchResultComponent {
+    constructor() {
+        this.entity = '';
+        this.searchInput = '';
+        this.loadComplete = new EventEmitter();
+        this.loadStarted = new EventEmitter();
+    }
+    get params() {
+        const p = {
+            EntityName: this.entity,
+            ExtraFilter: "ID > 0",
+            UserSearchString: this.searchInput,
+        };
+        return p;
+    }
+    ngAfterViewInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loadStarted.emit();
+            yield this.userViewGrid.Refresh(this.params);
+            this.loadComplete.emit();
+        });
+    }
+}
+SingleSearchResultComponent.ɵfac = function SingleSearchResultComponent_Factory(t) { return new (t || SingleSearchResultComponent)(); };
+SingleSearchResultComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SingleSearchResultComponent, selectors: [["app-single-search-result"]], viewQuery: function SingleSearchResultComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(UserViewGridComponent, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.userViewGrid = _t.first);
+    } }, inputs: { entity: "entity", searchInput: "searchInput" }, outputs: { loadComplete: "loadComplete", loadStarted: "loadStarted" }, decls: 1, vars: 0, template: function SingleSearchResultComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "mj-user-view-grid");
+    } }, dependencies: [i1.UserViewGridComponent] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SingleSearchResultComponent, [{
+        type: Component,
+        args: [{ selector: 'app-single-search-result', template: "<mj-user-view-grid\n>\n</mj-user-view-grid>" }]
+    }], null, { entity: [{
+            type: Input
+        }], searchInput: [{
+            type: Input
+        }], loadComplete: [{
+            type: Output
+        }], loadStarted: [{
+            type: Output
+        }], userViewGrid: [{
+            type: ViewChild,
+            args: [UserViewGridComponent]
+        }] }); })();

package/dist/lib/single-view/single-view.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter, AfterViewInit, OnInit } from '@angular/core';
+import { GridRowClickedEvent, UserViewGridComponent } from '@memberjunction/ng-user-view-grid';
+import { EntityInfo } from '@memberjunction/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { UserViewEntity } from '@memberjunction/core-entities';
+import { SharedService } from '../shared/shared.service';
+import * as i0 from "@angular/core";
+export declare class SingleViewComponent implements AfterViewInit, OnInit {
+    private router;
+    private route;
+    private sharedService;
+    viewGrid: UserViewGridComponent;
+    viewId: number | null;
+    selectedView: UserViewEntity | null;
+    loadComplete: EventEmitter<any>;
+    selectedEntity: EntityInfo | null;
+    showSearch: boolean;
+    searchText: string;
+    private searchDebounce$;
+    private _deferLoadCount;
+    constructor(router: Router, route: ActivatedRoute, sharedService: SharedService);
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    private initialLoad;
+    handleRowClick(args: GridRowClickedEvent): Promise<void>;
+    LoadView(viewInfo: UserViewEntity): Promise<void>;
+    Refresh(): Promise<void>;
+    onSearch(inputValue: string): void;
+    private setupSearchDebounce;
+    private search;
+    viewPropertiesDialogClosed(args: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SingleViewComponent, "app-single-view", never, { "viewId": "viewId"; "selectedView": "selectedView"; }, { "loadComplete": "loadComplete"; }, never, never, false, never>;
+}

package/dist/lib/single-view/single-view.component.js

@@ -0,0 +1,154 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Component, ViewChild, Input, Output, EventEmitter } from '@angular/core';
+import { UserViewGridComponent } from '@memberjunction/ng-user-view-grid';
+import { Metadata } from '@memberjunction/core';
+import { distinctUntilChanged, Subject } from "rxjs";
+import { debounceTime } from "rxjs/operators";
+import { ViewInfo } from '@memberjunction/core-entities';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../shared/shared.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@progress/kendo-angular-inputs";
+import * as i6 from "@memberjunction/ng-container-directives";
+import * as i7 from "@memberjunction/ng-user-view-grid";
+import * as i8 from "../user-view-properties/view-properties-dialog.component";
+function SingleViewComponent_kendo_textbox_2_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "kendo-textbox", 5);
+    i0.ɵɵlistener("valueChange", function SingleViewComponent_kendo_textbox_2_Template_kendo_textbox_valueChange_0_listener($event) { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.onSearch($event)); })("ngModelChange", function SingleViewComponent_kendo_textbox_2_Template_kendo_textbox_ngModelChange_0_listener($event) { i0.ɵɵrestoreView(_r2); const ctx_r3 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r3.searchText = $event); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("clearButton", true)("ngModel", ctx_r0.searchText);
+} }
+export class SingleViewComponent {
+    constructor(router, route, sharedService) {
+        this.router = router;
+        this.route = route;
+        this.sharedService = sharedService;
+        this.viewId = -1;
+        this.selectedView = null;
+        this.loadComplete = new EventEmitter();
+        this.selectedEntity = null;
+        this.showSearch = false;
+        this.searchText = '';
+        this.searchDebounce$ = new Subject();
+        this._deferLoadCount = 0;
+    }
+    ngAfterViewInit() {
+        this.initialLoad();
+    }
+    ngOnInit() {
+        this.setupSearchDebounce();
+    }
+    initialLoad() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.viewId) {
+                const md = new Metadata();
+                const view = yield ViewInfo.GetViewEntity(this.viewId);
+                if (view) {
+                    yield this.LoadView(view);
+                    const e = md.Entities.find(e => e.ID === view.EntityID);
+                    if (e) {
+                        this.selectedEntity = e;
+                        this.showSearch = e.AllowUserSearchAPI;
+                    }
+                }
+            }
+        });
+    }
+    handleRowClick(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // tell the router to navigate instead of raising an event directly. router will in turn handle raising the event as required
+            this.router.navigate(['resource', 'record', args.recordId], { queryParams: { Entity: args.entityName } });
+        });
+    }
+    LoadView(viewInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // load up the view
+            if (viewInfo && viewInfo.ID && viewInfo.ID > 0)
+                this.selectedView = viewInfo;
+            yield this.viewGrid.Refresh({
+                ViewEntity: viewInfo,
+                ViewID: viewInfo.ID,
+                UserSearchString: this.searchText
+            });
+            this.loadComplete.emit();
+        });
+    }
+    Refresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.selectedView)
+                yield this.LoadView(this.selectedView);
+        });
+    }
+    onSearch(inputValue) {
+        this.searchDebounce$.next(inputValue);
+    }
+    setupSearchDebounce() {
+        this.searchDebounce$.pipe(debounceTime(500), // updated to 500ms to reduce API calls and since most people don't type super fast
+        distinctUntilChanged()).subscribe((inputValue) => {
+            this.search(inputValue);
+        });
+    }
+    search(inputValue) {
+        if (this.selectedView && this.selectedView.ID && this.selectedView.ID > 0) {
+            this.viewGrid.Refresh({
+                ViewID: this.selectedView.ID,
+                UserSearchString: inputValue
+            });
+        }
+    }
+    viewPropertiesDialogClosed(args) {
+        if (args && args.Saved && args.ViewEntity) {
+            this.selectedView = args.ViewEntity;
+            this.Refresh();
+        }
+    }
+}
+SingleViewComponent.ɵfac = function SingleViewComponent_Factory(t) { return new (t || SingleViewComponent)(i0.ɵɵdirectiveInject(i1.Router), i0.ɵɵdirectiveInject(i1.ActivatedRoute), i0.ɵɵdirectiveInject(i2.SharedService)); };
+SingleViewComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SingleViewComponent, selectors: [["app-single-view"]], viewQuery: function SingleViewComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(UserViewGridComponent, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.viewGrid = _t.first);
+    } }, inputs: { viewId: "viewId", selectedView: "selectedView" }, outputs: { loadComplete: "loadComplete" }, decls: 5, vars: 3, consts: [["mjFillContainer", ""], [1, "searchBox"], ["id", "txtSearch", "placeholder", "Search here...", "kendoTextBox", "", 3, "clearButton", "ngModel", "valueChange", "ngModelChange", 4, "ngIf"], [3, "ViewID", "dialogClosed"], ["mjFillContainer", "", 3, "AutoNavigate", "rowClicked"], ["id", "txtSearch", "placeholder", "Search here...", "kendoTextBox", "", 3, "clearButton", "ngModel", "valueChange", "ngModelChange"]], template: function SingleViewComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0)(1, "div", 1);
+        i0.ɵɵtemplate(2, SingleViewComponent_kendo_textbox_2_Template, 1, 2, "kendo-textbox", 2);
+        i0.ɵɵelementStart(3, "app-view-properties-dialog", 3);
+        i0.ɵɵlistener("dialogClosed", function SingleViewComponent_Template_app_view_properties_dialog_dialogClosed_3_listener($event) { return ctx.viewPropertiesDialogClosed($event); });
+        i0.ɵɵelementEnd()();
+        i0.ɵɵelementStart(4, "mj-user-view-grid", 4);
+        i0.ɵɵlistener("rowClicked", function SingleViewComponent_Template_mj_user_view_grid_rowClicked_4_listener($event) { return ctx.handleRowClick($event); });
+        i0.ɵɵelementEnd()();
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", ctx.showSearch);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ViewID", ctx.selectedView == null ? null : ctx.selectedView.ID);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("AutoNavigate", false);
+    } }, dependencies: [i3.NgIf, i4.NgControlStatus, i4.NgModel, i5.TextBoxComponent, i6.FillContainer, i7.UserViewGridComponent, i8.ViewPropertiesDialogComponent] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SingleViewComponent, [{
+        type: Component,
+        args: [{ selector: 'app-single-view', template: "<div mjFillContainer>\r\n  <div class=\"card-container\" class=\"searchBox\">\r\n    <kendo-textbox\r\n      id=\"txtSearch\"\r\n      *ngIf=\"showSearch\"\r\n      placeholder=\"Search here...\"\r\n      kendoTextBox\r\n      (valueChange)=\"onSearch($event)\"\r\n      [clearButton]=\"true\"\r\n      [(ngModel)]=\"searchText\"\r\n    ></kendo-textbox>\r\n\r\n    <app-view-properties-dialog [ViewID]=\"selectedView?.ID\" (dialogClosed)=\"this.viewPropertiesDialogClosed($event)\" ></app-view-properties-dialog>\r\n  </div>\r\n\r\n  <mj-user-view-grid (rowClicked)=\"handleRowClick($event)\" [AutoNavigate]=\"false\" mjFillContainer></mj-user-view-grid>\r\n</div>\r\n" }]
+    }], function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.SharedService }]; }, { viewGrid: [{
+            type: ViewChild,
+            args: [UserViewGridComponent, { static: true }]
+        }], viewId: [{
+            type: Input
+        }], selectedView: [{
+            type: Input
+        }], loadComplete: [{
+            type: Output
+        }] }); })();

package/dist/lib/user-notifications/user-notifications.component.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef, AfterViewInit } from '@angular/core';
+import { SharedService } from '../shared/shared.service';
+import { UserNotificationEntity } from '@memberjunction/core-entities';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class UserNotificationsComponent implements AfterViewInit {
+    sharedService: SharedService;
+    private router;
+    allRadio: ElementRef;
+    unreadRadio: ElementRef;
+    readRadio: ElementRef;
+    radioSelected: string;
+    currentFilter: string;
+    constructor(sharedService: SharedService, router: Router);
+    ngAfterViewInit(): void;
+    get NotificationsToShow(): UserNotificationEntity[];
+    isNotificationClickable(notification: UserNotificationEntity): boolean;
+    notificationUrl(notification: UserNotificationEntity): {
+        urlParts: string[];
+        queryString: string;
+    };
+    get AllNotifications(): UserNotificationEntity[];
+    selectReadOption(option: string): void;
+    onReadRadioChanged(event: Event): void;
+    onFilterChanged(value: string): void;
+    getItemTitleClass(notification: UserNotificationEntity): "notification-title notification-title-unread" | "notification-title";
+    getItemWrapperClass(notification: UserNotificationEntity): string;
+    markAsRead(notification: UserNotificationEntity, bRead: boolean): Promise<void>;
+    notificationClicked(notification: UserNotificationEntity): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserNotificationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserNotificationsComponent, "app-user-notifications", never, {}, {}, never, never, false, never>;
+}