@memberjunction/ng-explorer-core 0.9.200 → 0.9.204

package/dist/shared/shared.service.js

@@ -1,324 +0,0 @@
-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 '@memberjunction/ng-shared';
-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;
-                        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
-                            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/shared/urlPipe.d.ts

@@ -1,7 +0,0 @@
-import { PipeTransform } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class URLPipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<URLPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<URLPipe, "formatUrl", false>;
-}

package/dist/shared/urlPipe.js

@@ -1,16 +0,0 @@
-import { Pipe } from '@angular/core';
-import * as i0 from "@angular/core";
-export class URLPipe {
-    transform(value) {
-        if (value && !value.includes('http'))
-            return 'https://' + value;
-        else
-            return value;
-    }
-}
-URLPipe.ɵfac = function URLPipe_Factory(t) { return new (t || URLPipe)(); };
-URLPipe.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "formatUrl", type: URLPipe, pure: true });
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(URLPipe, [{
-        type: Pipe,
-        args: [{ name: 'formatUrl' }]
-    }], null, null); })();