@memberjunction/ng-shared 0.9.3 → 0.9.10

package/dist/lib/base-resource-component.d.ts

@@ -0,0 +1,34 @@
+import { BaseEntity } from "@memberjunction/core";
+export declare abstract class BaseResourceComponent {
+    Data: ResourceData;
+    private _loadComplete;
+    get LoadComplete(): boolean;
+    private _loadStarted;
+    get LoadStarted(): boolean;
+    private _loadCompleteEvent;
+    get LoadCompleteEvent(): any;
+    set LoadCompleteEvent(value: any);
+    private _loadStartedEvent;
+    get LoadStartedEvent(): any;
+    set LoadStartedEvent(value: any);
+    private _resourceRecordSavedEvent;
+    get ResourceRecordSavedEvent(): any;
+    set ResourceRecordSavedEvent(value: any);
+    protected NotifyLoadComplete(): void;
+    protected NotifyLoadStarted(): void;
+    protected ResourceRecordSaved(resourceRecordEntity: BaseEntity): void;
+    abstract GetResourceDisplayName(data: ResourceData): Promise<string>;
+}
+export declare class ResourceData {
+    constructor(data?: any);
+    ID: number;
+    Name: string;
+    ResourceTypeID: number;
+    ResourceRecordID: any;
+    Configuration: any;
+    /**
+     * Returns the name of the resource type based on the ResourceTypeID
+     */
+    get ResourceType(): string;
+    get ResourceIcon(): string;
+}

package/dist/lib/base-resource-component.js

@@ -0,0 +1,75 @@
+import { SharedService } from "./shared.service";
+export class BaseResourceComponent {
+    constructor() {
+        this.Data = new ResourceData();
+        this._loadComplete = false;
+        this._loadStarted = false;
+        this._loadCompleteEvent = null;
+        this._loadStartedEvent = null;
+        this._resourceRecordSavedEvent = null;
+    }
+    get LoadComplete() {
+        return this._loadComplete;
+    }
+    get LoadStarted() {
+        return this._loadStarted;
+    }
+    get LoadCompleteEvent() {
+        return this._loadCompleteEvent;
+    }
+    set LoadCompleteEvent(value) {
+        this._loadCompleteEvent = value;
+    }
+    get LoadStartedEvent() {
+        return this._loadStartedEvent;
+    }
+    set LoadStartedEvent(value) {
+        this._loadStartedEvent = value;
+    }
+    get ResourceRecordSavedEvent() {
+        return this._resourceRecordSavedEvent;
+    }
+    set ResourceRecordSavedEvent(value) {
+        this._resourceRecordSavedEvent = value;
+    }
+    NotifyLoadComplete() {
+        this._loadComplete = true;
+        if (this._loadCompleteEvent) {
+            this._loadCompleteEvent();
+        }
+    }
+    NotifyLoadStarted() {
+        this._loadStarted = true;
+        if (this._loadStartedEvent) {
+            this._loadStartedEvent();
+        }
+    }
+    ResourceRecordSaved(resourceRecordEntity) {
+        this.Data.ResourceRecordID = resourceRecordEntity.PrimaryKey.Value;
+        if (this._resourceRecordSavedEvent) {
+            this._resourceRecordSavedEvent(resourceRecordEntity);
+        }
+    }
+}
+export class ResourceData {
+    constructor(data = null) {
+        if (data) {
+            this.ID = data.ID;
+            this.Name = data.Name;
+            this.ResourceTypeID = data.ResourceTypeID;
+            this.ResourceRecordID = data.ResourceRecordID;
+            this.Configuration = data.Configuration;
+        }
+    }
+    /**
+     * Returns the name of the resource type based on the ResourceTypeID
+     */
+    get ResourceType() {
+        const rt = SharedService.Instance.ResourceTypes.find(rt => rt.ID === this.ResourceTypeID);
+        return rt ? rt.Name : '';
+    }
+    get ResourceIcon() {
+        const rt = SharedService.Instance.ResourceTypes.find(rt => rt.ID === this.ResourceTypeID);
+        return rt ? rt.Icon : '';
+    }
+}

package/dist/lib/shared.service.d.ts

@@ -0,0 +1,94 @@
+import { EntityInfo, PrimaryKeyValue } from '@memberjunction/core';
+import { ResourceTypeEntity, UserNotificationEntity, ViewColumnInfo } from '@memberjunction/core-entities';
+import { Observable } from 'rxjs';
+import { NotificationService } from "@progress/kendo-angular-notification";
+import * as i0 from "@angular/core";
+export declare class SharedService {
+    private notificationService;
+    private static _instance;
+    private static _loaded;
+    private static _resourceTypes;
+    private tabChange;
+    tabChange$: Observable<unknown>;
+    constructor(notificationService: NotificationService);
+    static get Instance(): SharedService;
+    /**
+     * Returns the current session ID, which is automatically created when the service is instantiated.
+     */
+    get SessionId(): string;
+    get ResourceTypes(): ResourceTypeEntity[];
+    get ViewResourceType(): ResourceTypeEntity;
+    get RecordResourceType(): ResourceTypeEntity;
+    get DashboardResourceType(): ResourceTypeEntity;
+    get ReportResourceType(): ResourceTypeEntity;
+    get SearchResultsResourceType(): ResourceTypeEntity;
+    ResourceTypeByID(id: number): ResourceTypeEntity | undefined;
+    ResourceTypeByName(name: string): ResourceTypeEntity | undefined;
+    static RefreshData(): Promise<void>;
+    static GeneratePrimaryKeyValueString(pkVals: PrimaryKeyValue[]): string;
+    static ParsePrimaryKeys(entity: EntityInfo, routeSegment: string): PrimaryKeyValue[];
+    FormatColumnValue(col: ViewColumnInfo, value: any, maxLength?: number, trailingChars?: string): any;
+    ConvertMarkdownStringToHtmlList(listType: HtmlListType, text: string): string;
+    InvokeManualResize(delay?: number): void;
+    PushStatusUpdates(): Observable<string>;
+    private _currentUserImage;
+    get CurrentUserImage(): string | Blob;
+    set CurrentUserImage(value: string | Blob);
+    private static _userNotifications;
+    static get UserNotifications(): UserNotificationEntity[];
+    static get UnreadUserNotifications(): UserNotificationEntity[];
+    static get UnreadUserNotificationCount(): number;
+    /**
+     * Creates a notification in the database and refreshes the UI. Returns the notification object.
+     * @param title
+     * @param message
+     * @param resourceTypeId
+     * @param resourceRecordId
+     * @param resourceConfiguration Any object, it is converted to a string by JSON.stringify and stored in the database
+     * @returns
+     */
+    CreateNotification(title: string, message: string, resourceTypeId: number | null, resourceRecordId: number | null, resourceConfiguration: any | null): Promise<UserNotificationEntity>;
+    static RefreshUserNotifications(): Promise<void>;
+    /**
+     * Creates a message that is not saved to the User Notifications table, but is displayed to the user.
+     * @param message - text to display
+     * @param style - display styling
+     * @param hideAfter - option to auto hide after the specified delay in milliseconds
+     */
+    CreateSimpleNotification(message: string, style?: "none" | "success" | "error" | "warning" | "info", hideAfter?: number): void;
+    private _resourceTypeMap;
+    /**
+     * Maps a Resource Type record Name column to the corresponding route segment
+     * @param resourceTypeName
+     * @returns
+     */
+    mapResourceTypeNameToRouteSegment(resourceTypeName: string): string | null;
+    /**
+     * Maps a route segment to the corresponding Resource Type record Name column
+     * @param resourceRouteSegment
+     * @returns
+     */
+    mapResourceTypeRouteSegmentToName(resourceRouteSegment: string): string | null;
+    kendoSVGIcon(iconName: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SharedService>;
+}
+export declare const HtmlListType: {
+    readonly Unordered: "Unordered";
+    readonly Ordered: "Ordered";
+};
+export type HtmlListType = typeof HtmlListType[keyof typeof HtmlListType];
+export declare const EventCodes: {
+    readonly ViewClicked: "ViewClicked";
+    readonly EntityRecordClicked: "EntityRecordClicked";
+    readonly AddDashboard: "AddDashboard";
+    readonly AddReport: "AddReport";
+    readonly AddQuery: "AddQuery";
+    readonly ViewCreated: "ViewCreated";
+    readonly ViewUpdated: "ViewUpdated";
+    readonly RunSearch: "RunSearch";
+    readonly ViewNotifications: "ViewNotifications";
+    readonly PushStatusUpdates: "PushStatusUpdates";
+    readonly UserNotificationsUpdated: "UserNotificationsUpdated";
+};
+export type EventCodes = typeof EventCodes[keyof typeof EventCodes];

package/dist/lib/shared.service.js

@@ -0,0 +1,326 @@
+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 { Injectable } from '@angular/core';
+import { LogError, Metadata, RunView } from '@memberjunction/core';
+import { MJEventType, MJGlobal } from '@memberjunction/global';
+import { Subject } from 'rxjs';
+import { kendoSVGIcon } from './util';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-notification";
+export class SharedService {
+    constructor(notificationService) {
+        this.notificationService = notificationService;
+        this.tabChange = new Subject();
+        this.tabChange$ = this.tabChange.asObservable();
+        this._currentUserImage = '/assets/user.png';
+        this._resourceTypeMap = [
+            { routeSegment: 'record', name: 'records' },
+            { routeSegment: 'view', name: 'user views' },
+            { routeSegment: 'search', name: 'search results' },
+            { routeSegment: 'report', name: 'reports' },
+            { routeSegment: 'query', name: 'queries' },
+            { routeSegment: 'dashboard', name: 'dashboards' }
+        ];
+        if (SharedService._instance) {
+            // return existing instance which will short circuit the creation of a new instance
+            return SharedService._instance;
+        }
+        // first time this has been called, so return ourselves since we're in the constructor
+        SharedService._instance = this;
+        MJGlobal.Instance.GetEventListener(true).subscribe((event) => {
+            switch (event.event) {
+                case MJEventType.DisplaySimpleNotificationRequest:
+                    // received the message to display a notification to the user, so do that...
+                    const messageData = event.args;
+                    this.CreateSimpleNotification(messageData.message, messageData.style, messageData.DisplayDuration);
+                    break;
+                case MJEventType.ComponentEvent:
+                    if (event.eventCode === EventCodes.UserNotificationsUpdated) {
+                        // refresh the user notifications
+                        SharedService.RefreshUserNotifications();
+                    }
+                    break;
+                case MJEventType.LoggedIn:
+                    if (SharedService._loaded === false)
+                        SharedService.RefreshData();
+                    // got the login, now subscribe to push status updates here so we can then raise them as events in MJ Global locally
+                    this.PushStatusUpdates().subscribe((status) => {
+                        var _a, _b, _c;
+                        const statusObj = JSON.parse(status.message);
+                        // pass along as an event so anyone else who wants to know about the push status update can do stuff
+                        MJGlobal.Instance.RaiseEvent({
+                            event: MJEventType.ComponentEvent,
+                            eventCode: EventCodes.PushStatusUpdates,
+                            args: statusObj,
+                            component: this
+                        });
+                        if (((_a = statusObj.type) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase()) === 'usernotifications') {
+                            if (statusObj.details && ((_b = statusObj.details.action) === null || _b === void 0 ? void 0 : _b.trim().toLowerCase()) === 'create') {
+                                // we have changes to user notifications, so refresh them
+                                this.CreateSimpleNotification('New Notification Available', "success", 2000);
+                                SharedService.RefreshUserNotifications();
+                            }
+                        }
+                        else {
+                            // otherwise just post it as a simple notification, except Skip messages, we will let Skip handle those
+                            if (((_c = statusObj.type) === null || _c === void 0 ? void 0 : _c.trim().toLowerCase()) !== 'askskip') {
+                                this.CreateSimpleNotification(statusObj.message, "success", 2500);
+                            }
+                        }
+                    });
+                    break;
+            }
+        });
+    }
+    static get Instance() {
+        return SharedService._instance;
+    }
+    /**
+     * Returns the current session ID, which is automatically created when the service is instantiated.
+     */
+    get SessionId() {
+        return Metadata.Provider.sessionId;
+    }
+    get ResourceTypes() {
+        return SharedService._resourceTypes;
+    }
+    get ViewResourceType() {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === 'user views');
+    }
+    get RecordResourceType() {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === 'records');
+    }
+    get DashboardResourceType() {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === 'dashboards');
+    }
+    get ReportResourceType() {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === 'reports');
+    }
+    get SearchResultsResourceType() {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === 'search results');
+    }
+    ResourceTypeByID(id) {
+        return SharedService._resourceTypes.find(rt => rt.ID === id);
+    }
+    ResourceTypeByName(name) {
+        return SharedService._resourceTypes.find(rt => rt.Name.trim().toLowerCase() === name.trim().toLowerCase());
+    }
+    static RefreshData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // if we have a provider, then we can load the data, otherwise load isn't done yet
+            const md = new Metadata();
+            const rtResult = yield md.GetAndCacheDatasetByName('ResourceTypes');
+            if (rtResult && rtResult.Success) {
+                const data = rtResult.Results.find(r => r.EntityName === 'Resource Types');
+                if (data) {
+                    SharedService._resourceTypes = data.Results;
+                    SharedService._loaded = true;
+                }
+            }
+            SharedService.RefreshUserNotifications(); // also call this initially when refreshing the dataset...
+        });
+    }
+    static GeneratePrimaryKeyValueString(pkVals) {
+        return pkVals.map(pk => pk.FieldName + '|' + pk.Value).join('||');
+    }
+    static ParsePrimaryKeys(entity, routeSegment) {
+        if (!routeSegment.includes('|')) {
+            // If not, return a single element array with a default field name
+            return [{ FieldName: entity.PrimaryKey.Name, Value: routeSegment }];
+        }
+        else {
+            const parts = routeSegment.split('||');
+            const pkVals = [];
+            for (let p of parts) {
+                const kv = p.split('|');
+                pkVals.push({ FieldName: kv[0], Value: kv[1] });
+            }
+            return pkVals;
+        }
+    }
+    FormatColumnValue(col, value, maxLength = 0, trailingChars = "...") {
+        if (value === null || value === undefined)
+            return value;
+        try {
+            const retVal = col.EntityField.FormatValue(value, 0);
+            if (maxLength > 0 && retVal && retVal.length > maxLength)
+                return retVal.substring(0, maxLength) + trailingChars;
+            else
+                return retVal;
+        }
+        catch (e) {
+            LogError(e);
+            return value;
+        }
+    }
+    ConvertMarkdownStringToHtmlList(listType, text) {
+        const listTag = listType === HtmlListType.Unordered ? 'ul' : 'ol';
+        if (!text.includes('\n')) {
+            return text;
+        }
+        const listItems = text.split('\n').map(line => `<li>${line.trim().replace(/^-\s*/, '')}</li>`).join('');
+        return `<${listTag}>${listItems}</${listTag}>`;
+    }
+    InvokeManualResize(delay = 50) {
+        setTimeout(() => {
+            MJGlobal.Instance.RaiseEvent({
+                event: MJEventType.ManualResizeRequest,
+                eventCode: '',
+                args: null,
+                component: this
+            });
+        }, delay); // give the tabstrip time to render
+    }
+    PushStatusUpdates() {
+        const gp = Metadata.Provider;
+        return gp.PushStatusUpdates();
+    }
+    get CurrentUserImage() {
+        return this._currentUserImage;
+    }
+    set CurrentUserImage(value) {
+        this._currentUserImage = value;
+    }
+    static get UserNotifications() {
+        return SharedService._userNotifications;
+    }
+    static get UnreadUserNotifications() {
+        return SharedService._userNotifications.filter(n => n.Unread);
+    }
+    static get UnreadUserNotificationCount() {
+        return SharedService.UnreadUserNotifications.length;
+    }
+    /**
+     * Creates a notification in the database and refreshes the UI. Returns the notification object.
+     * @param title
+     * @param message
+     * @param resourceTypeId
+     * @param resourceRecordId
+     * @param resourceConfiguration Any object, it is converted to a string by JSON.stringify and stored in the database
+     * @returns
+     */
+    CreateNotification(title, message, resourceTypeId, resourceRecordId, resourceConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const md = new Metadata();
+            const notification = yield md.GetEntityObject('User Notifications');
+            notification.Title = title;
+            notification.Message = message;
+            if (resourceTypeId)
+                notification.ResourceTypeID = resourceTypeId;
+            if (resourceRecordId)
+                notification.ResourceRecordID = resourceRecordId;
+            if (resourceConfiguration)
+                notification.ResourceConfiguration = JSON.stringify(resourceConfiguration);
+            notification.UserID = md.CurrentUser.ID;
+            notification.Unread = true;
+            const result = yield notification.Save();
+            if (result) {
+                SharedService.RefreshUserNotifications();
+            }
+            // test
+            this.CreateSimpleNotification(notification.Message, "success", 2500);
+            return notification;
+        });
+    }
+    static RefreshUserNotifications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rv = new RunView();
+                const md = new Metadata();
+                const result = yield rv.RunView({
+                    EntityName: 'User Notifications',
+                    ExtraFilter: 'UserID=' + md.CurrentUser.ID,
+                    OrderBy: 'CreatedAt DESC'
+                });
+                if (result && result.Success) {
+                    SharedService._userNotifications = result.Results;
+                }
+            }
+            catch (e) {
+                LogError(e);
+            }
+        });
+    }
+    /**
+     * Creates a message that is not saved to the User Notifications table, but is displayed to the user.
+     * @param message - text to display
+     * @param style - display styling
+     * @param hideAfter - option to auto hide after the specified delay in milliseconds
+     */
+    CreateSimpleNotification(message, style = "success", hideAfter) {
+        const props = {
+            content: message,
+            cssClass: "button-notification",
+            animation: { type: "slide", duration: 400 },
+            position: { horizontal: "center", vertical: "top" },
+            type: { style: style, icon: true }
+        };
+        if (hideAfter)
+            props.hideAfter = hideAfter;
+        else
+            props.closable = true;
+        this.notificationService.show(props);
+    }
+    /**
+     * Maps a Resource Type record Name column to the corresponding route segment
+     * @param resourceTypeName
+     * @returns
+     */
+    mapResourceTypeNameToRouteSegment(resourceTypeName) {
+        const item = this._resourceTypeMap.find(rt => rt.name.trim().toLowerCase() === resourceTypeName.trim().toLowerCase());
+        if (item)
+            return item.routeSegment;
+        else
+            return null;
+    }
+    /**
+     * Maps a route segment to the corresponding Resource Type record Name column
+     * @param resourceRouteSegment
+     * @returns
+     */
+    mapResourceTypeRouteSegmentToName(resourceRouteSegment) {
+        const item = this._resourceTypeMap.find(rt => rt.routeSegment.trim().toLowerCase() === resourceRouteSegment.trim().toLowerCase());
+        if (item)
+            return item.name;
+        else
+            return null;
+    }
+    kendoSVGIcon(iconName) {
+        return kendoSVGIcon(iconName);
+    }
+}
+SharedService._loaded = false;
+SharedService._resourceTypes = [];
+SharedService._userNotifications = [];
+SharedService.ɵfac = function SharedService_Factory(t) { return new (t || SharedService)(i0.ɵɵinject(i1.NotificationService)); };
+SharedService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SharedService, factory: SharedService.ɵfac, providedIn: 'root' });
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SharedService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.NotificationService }], null); })();
+export const HtmlListType = {
+    Unordered: 'Unordered',
+    Ordered: 'Ordered',
+};
+export const EventCodes = {
+    ViewClicked: "ViewClicked",
+    EntityRecordClicked: "EntityRecordClicked",
+    AddDashboard: "AddDashboard",
+    AddReport: "AddReport",
+    AddQuery: "AddQuery",
+    ViewCreated: "ViewCreated",
+    ViewUpdated: "ViewUpdated",
+    RunSearch: "RunSearch",
+    ViewNotifications: "ViewNotifications",
+    PushStatusUpdates: "PushStatusUpdates",
+    UserNotificationsUpdated: "UserNotificationsUpdated"
+};

package/dist/public-api.d.ts

@@ -1,3 +1,5 @@
 export * from './lib/util';
 export * from './lib/urlPipe';
+export * from './lib/shared.service';
+export * from './lib/base-resource-component';
 export * from './module';

package/dist/public-api.js

@@ -3,4 +3,6 @@
  */
 export * from './lib/util';
 export * from './lib/urlPipe';
+export * from './lib/shared.service';
+export * from './lib/base-resource-component';
 export * from './module';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/ng-shared",
-  "version": "0.9.3",
+  "version": "0.9.10",
   "description": "MemberJunction: Angular Shared Package - utility functions and other reusable elements used across other MJ Angular packages",
   "main": "./dist/public-api.js",
   "typings": "./dist/public-api.d.ts",