@memberjunction/core 0.9.164 → 0.9.166

package/dist/MJCore/src/generic/applicationInfo.d.ts

@@ -0,0 +1,26 @@
+import { BaseInfo } from './baseInfo';
+import { EntityInfo } from './entityInfo';
+import { IMetadataProvider } from './interfaces';
+export declare class ApplicationEntityInfo extends BaseInfo {
+    ApplicationName: string;
+    EntityID: number;
+    Sequence: number;
+    DefaultForNewUser: boolean;
+    Application: string;
+    Entity: string;
+    EntityBaseTable: string;
+    EntityCodeName: string;
+    EntityClassName: string;
+    EntityBaseTableCodeName: string;
+    private _EntityInfo;
+    get EntityInfo(): EntityInfo;
+    _setEntity(entity: EntityInfo): void;
+    constructor(initData?: any);
+}
+export declare class ApplicationInfo extends BaseInfo {
+    Name: string;
+    Description: string;
+    private _ApplicationEntities;
+    get ApplicationEntities(): ApplicationEntityInfo[];
+    constructor(md: IMetadataProvider, initData?: any);
+}

package/dist/MJCore/src/generic/applicationInfo.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationInfo = exports.ApplicationEntityInfo = void 0;
+const baseInfo_1 = require("./baseInfo");
+class ApplicationEntityInfo extends baseInfo_1.BaseInfo {
+    get EntityInfo() {
+        return this._EntityInfo;
+    }
+    _setEntity(entity) {
+        this._EntityInfo = entity;
+    }
+    constructor(initData = null) {
+        super();
+        this.ApplicationName = null;
+        this.EntityID = null;
+        this.Sequence = null;
+        this.DefaultForNewUser = null;
+        this.Application = null;
+        this.Entity = null;
+        this.EntityBaseTable = null;
+        this.EntityCodeName = null;
+        this.EntityClassName = null;
+        this.EntityBaseTableCodeName = null;
+        this._EntityInfo = null;
+        this.copyInitData(initData);
+    }
+}
+exports.ApplicationEntityInfo = ApplicationEntityInfo;
+class ApplicationInfo extends baseInfo_1.BaseInfo {
+    get ApplicationEntities() {
+        return this._ApplicationEntities;
+    }
+    constructor(md, initData = null) {
+        super();
+        this.Name = null;
+        this.Description = null;
+        this._ApplicationEntities = [];
+        this.copyInitData(initData);
+        if (initData) {
+            let ae = initData.ApplicationEntities || initData._ApplicationEntities;
+            if (ae) {
+                const mdEntities = md.Entities;
+                this._ApplicationEntities = [];
+                for (let i = 0; i < ae.length; i++) {
+                    // 
+                    const aei = new ApplicationEntityInfo(ae[i]);
+                    this._ApplicationEntities.push(aei);
+                    const match = mdEntities.find(e => e.ID == ae[i].EntityID);
+                    if (match)
+                        aei._setEntity(match);
+                }
+            }
+        }
+    }
+}
+exports.ApplicationInfo = ApplicationInfo;
+//# sourceMappingURL=applicationInfo.js.map

package/dist/MJCore/src/generic/applicationInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applicationInfo.js","sourceRoot":"","sources":["../../../../src/generic/applicationInfo.ts"],"names":[],"mappings":";;;AAAA,yCAAqC;AAIrC,MAAa,qBAAsB,SAAQ,mBAAQ;IAa/C,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,WAAW,CAAA;IAC3B,CAAC;IAED,UAAU,CAAC,MAAkB;QACzB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAA;IAC7B,CAAC;IAED,YAAa,WAAgB,IAAI;QAC7B,KAAK,EAAE,CAAA;QArBX,oBAAe,GAAW,IAAI,CAAA;QAC9B,aAAQ,GAAW,IAAI,CAAA;QACvB,aAAQ,GAAW,IAAI,CAAA;QACvB,sBAAiB,GAAY,IAAI,CAAA;QACjC,gBAAW,GAAW,IAAI,CAAA;QAC1B,WAAM,GAAW,IAAI,CAAA;QACrB,oBAAe,GAAW,IAAI,CAAA;QAC9B,mBAAc,GAAW,IAAI,CAAA;QAC7B,oBAAe,GAAW,IAAI,CAAA;QAC9B,4BAAuB,GAAW,IAAI,CAAA;QAE9B,gBAAW,GAAe,IAAI,CAAA;QAWlC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAA;IAC/B,CAAC;CACJ;AAzBD,sDAyBC;AAED,MAAa,eAAgB,SAAQ,mBAAQ;IAKzC,IAAW,mBAAmB;QAC1B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;IAED,YAAa,EAAqB,EAAE,WAAgB,IAAI;QACpD,KAAK,EAAE,CAAA;QATX,SAAI,GAAW,IAAI,CAAA;QACnB,gBAAW,GAAW,IAAI,CAAA;QAElB,yBAAoB,GAA4B,EAAE,CAAA;QAOtD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAA;QAC3B,IAAI,QAAQ,EAAE,CAAC;YACX,IAAI,EAAE,GAAG,QAAQ,CAAC,mBAAmB,IAAI,QAAQ,CAAC,oBAAoB,CAAC;YACvE,IAAI,EAAE,EAAE,CAAC;gBACL,MAAM,UAAU,GAAG,EAAE,CAAC,QAAQ,CAAC;gBAC/B,IAAI,CAAC,oBAAoB,GAAG,EAAE,CAAC;gBAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACjC,GAAG;oBACH,MAAM,GAAG,GAAG,IAAI,qBAAqB,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;oBAC5C,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAEnC,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;oBAC1D,IAAI,KAAK;wBACL,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;gBAC7B,CAAC;YACL,CAAC;QACL,CAAC;IACL,CAAC;CAEJ;AA9BD,0CA8BC"}

package/dist/MJCore/src/generic/baseEntity.d.ts

@@ -0,0 +1,195 @@
+import { EntityFieldInfo, EntityInfo, EntityFieldTSType, EntityPermissionType, RecordChange, ValidationResult, EntityRelationshipInfo, PrimaryKeyValue } from './entityInfo';
+import { EntitySaveOptions, IEntityDataProvider } from './interfaces';
+import { UserInfo } from './securityInfo';
+import { TransactionGroupBase } from './transactionGroup';
+export declare class EntityField {
+    private _entityFieldInfo;
+    private _OldValue;
+    private _Value;
+    private _NeverSet;
+    get Name(): string;
+    get FieldType(): EntityFieldTSType;
+    get SQLType(): string;
+    get IsPrimaryKey(): boolean;
+    get NeedsQuotes(): boolean;
+    /**
+     * Removes spaces from the field name and returns the result.
+     */
+    get CodeName(): string;
+    get IsUnique(): boolean;
+    get Value(): any;
+    get ReadOnly(): boolean;
+    get EntityFieldInfo(): EntityFieldInfo;
+    set Value(value: any);
+    get Dirty(): boolean;
+    FormatValue(decimals?: number, currency?: string): string;
+    Validate(): ValidationResult;
+    constructor(fieldInfo: EntityFieldInfo, Value?: any);
+    ResetOldValue(): void;
+    get OldValue(): any;
+}
+export declare class DataObjectRelatedEntityParam {
+    relatedEntityName: string;
+    filter?: string;
+}
+export declare class DataObjectParams {
+    oldValues: boolean;
+    omitNullValues: boolean;
+    omitEmptyStrings: boolean;
+    excludeFields: string[];
+    includeRelatedEntityData: boolean;
+    relatedEntityList: DataObjectRelatedEntityParam[];
+}
+export declare class BaseEntityAIActionParams {
+    name: string;
+    actionId: number;
+    modelId: number;
+    systemPrompt: string;
+    userMessage: string;
+    result: any;
+}
+export declare abstract class BaseEntity {
+    private _EntityInfo;
+    private _Fields;
+    private _recordLoaded;
+    private _contextCurrentUser;
+    private _transactionGroup;
+    constructor(Entity: EntityInfo);
+    /**
+     * Returns true if the record has been saved to the database, false otherwise. This is a useful property to check to determine if the record is a "New Record" or an existing one.
+     */
+    get IsSaved(): boolean;
+    get TransactionGroup(): TransactionGroupBase;
+    set TransactionGroup(group: TransactionGroupBase);
+    get EntityInfo(): EntityInfo;
+    get Fields(): EntityField[];
+    GetFieldByName(fieldName: string): EntityField;
+    get Dirty(): boolean;
+    get PrimaryKey(): EntityField;
+    get PrimaryKeys(): EntityField[];
+    get RecordLoaded(): boolean;
+    /**
+     * Sets the value of a given field. If the field doesn't exist, nothing happens.
+     * @param FieldName
+     * @param Value
+     */
+    Set(FieldName: string, Value: any): void;
+    /**
+     * Returns the value of the field with the given name. If the field is a date, and the value is a string, it will be converted to a date object.
+     * @param FieldName
+     * @returns
+     */
+    Get(FieldName: string): any;
+    /**
+     * Sets any number of values on the entity object from the object passed in. The properties of the object being passed in must either match the field name (in most cases) or the CodeName (which is only different from field name if field name has spaces in it)
+     * @param object
+     * @param ignoreNonExistentFields
+     */
+    SetMany(object: any, ignoreNonExistentFields?: boolean): void;
+    GetAll(oldValues?: boolean): {};
+    /**
+     * This utility method calls GetDataObject() internally and formats the result as a JSON string. If you want to get the data as an object instead of a string, call GetDataObject() directly.
+     * @param params
+     * @param minifyJSON
+     * @returns
+     */
+    GetDataObjectJSON(params: DataObjectParams, minifyJSON?: boolean): Promise<string>;
+    /**
+     * This utility method generates a completely new object that has properties that map to the fields and values in the entity at the time it is called. It is a copy, NOT a link, so any changes
+     * made to the object after calling this method will NOT be reflected in the object that is returned. This is useful for things like sending data to a client, or for use in a view model.
+     * @param params
+     * @returns
+     */
+    GetDataObject(params: DataObjectParams): Promise<any>;
+    GetRelatedEntityData(re: EntityRelationshipInfo, filter?: string): Promise<any[]>;
+    private init;
+    /**
+     * This method will copy the values from the other entity object into the current one. This is useful for things like cloning a record.
+     * This method will ONLY copy values for fields that exist in the current entity object. If the other object has fields that don't exist in the current object, they will be ignored.
+     * @param other
+     * @param includePrimaryKeys - if true, the primary keys will be copied as well, if false, they will be ignored, defaults to false and generally you want to leave it that way
+     */
+    CopyFrom(other: BaseEntity, includePrimaryKeys?: boolean): boolean;
+    set ContextCurrentUser(user: UserInfo);
+    get ContextCurrentUser(): UserInfo;
+    /**
+     * This method will create a new state for the object that is equivalent to a new record including default values.
+     * @returns
+     */
+    NewRecord(): boolean;
+    /**
+     * Saves the current state of the object to the database. Uses the active provider to handle the actual saving of the record. If the record is new, it will be created, if it already exists, it will be updated.
+     * @param options
+     * @returns
+     */
+    Save(options?: EntitySaveOptions): Promise<boolean>;
+    protected get ActiveUser(): UserInfo;
+    /**
+     * Utility method that returns true if the given permission being checked is enabled for the current user, and false if not.
+     * @param type
+     * @param throwError
+     * @returns
+     */
+    CheckPermissions(type: EntityPermissionType, throwError: boolean): boolean;
+    protected ThrowPermissionError(u: UserInfo, type: EntityPermissionType, additionalInfoMessage: string): void;
+    /**
+     * This method will revert the internal state of the object back to what it was when it was last saved, or if never saved, from when it was intially loaded from the database. This is useful if you want to offer a user an "undo" type of feature in a UI.
+     * @returns
+     */
+    Revert(): boolean;
+    /**
+     * * This method loads a single record from the database. Make sure you first get the correct BaseEntity sub-class for your entity by calling Metadata.GetEntityObject() first. From there, you can
+     * call this method to load your records.
+     * * NOTE: You should not be calling this method directly from outside of a sub-class in most cases. You will use the auto-generated sub-classes that have overriden versions of this method that blow out the primary keys into individual parameters. This is much easier to program against.
+     * @param PrimaryKeyValues An array of objects that contain the field name and value for the primary key of the record you want to load. For example, if you have a table called "Customers" with a primary key of "ID", you would pass in an array with a single object like this: {FieldName: "ID", Value: 1234}.
+     * *If you had a composite primary key, you would pass in an array with multiple objects, one for each field in the primary key. You may ONLY pass in the primary key fields, no other fields are allowed.
+     * @param EntityRelationshipsToLoad Optional, you can specify the names of the relationships to load up. This is an expensive operation as it loads up an array of the related entity objects for the main record, so use it sparingly.
+     * @returns true if success, false otherwise
+     */
+    InnerLoad(PrimaryKeyValues: PrimaryKeyValue[], EntityRelationshipsToLoad?: string[]): Promise<boolean>;
+    protected ValidatePrimaryKeyArray(PrimaryKeyValues: PrimaryKeyValue[]): void;
+    /**
+     * This method is meant to be used only in situations where you are sure that the data you are loading is current in the database. MAKE SURE YOU ARE PASSING IN ALL FIELDS.
+     * The Dirty flags and other internal state will assume what is loading from the data parameter you pass in is equivalent to what is in the database. Generally speaking, you should use Load() instead of this method. The main use case(s) where this makes sense are:
+     *  (1) On the server if you are pulling data you know is fresh from say the result of another DB operation
+     *  (2) If on any tier you run a fresh RunView result, that gives you data from the database, you can then instantiate objects via Metadata.GetEntityObject() and then use this with the result from the RunView call
+     *  *** Note: for the #2 use case, when you call the RunView Object RunView() method with the ResultType='entity_object', you'll get an array of BaseEntity-derived objects instead of simple objects, that functionality utilizes this method
+     * @param data
+     * @returns
+     */
+    LoadFromData(data: any): boolean;
+    /**
+     * This method is used automatically within Save() and is used to determine if the state of the object is valid relative to the validation rules that are defined in metadata. In addition, sub-classes can
+     * override or wrap this base class method to add other logic for validation.
+     * @returns
+     */
+    Validate(): ValidationResult;
+    /**
+     * This method deletes a record from the database. You must call Load() first in order to load the context of the record you are deleting.
+     * @returns
+     */
+    Delete(): Promise<boolean>;
+    /**
+     * Called before an Action is executed by the AI Engine
+     * This is intended to be overriden by subclass as needed, these methods called at the right time by the execution context
+     */
+    BeforeEntityAIAction(params: BaseEntityAIActionParams): Promise<boolean>;
+    /**
+     * Called after an Action is executed by the AI Engine
+     */
+    AfterEntityAIAction(params: BaseEntityAIActionParams): Promise<boolean>;
+    private static _globalProviderKey;
+    static get Provider(): IEntityDataProvider;
+    static set Provider(value: IEntityDataProvider);
+    /**
+     * Returns a list of changes made to this record, over time. Keep in mind this is only going to return valid data if you have the TrackRecordChanges bit set to 1 on the entity you're working with.
+     */
+    get RecordChanges(): Promise<RecordChange[]>;
+    /**
+     * Static Utility method to get RecordChanges for a given entityName/PrimaryKeyValue combination
+     * @param entityName
+     * @param PrimaryKeyValue
+     * @returns
+     */
+    static GetRecordChanges(entityName: string, PrimaryKeyValue: any): Promise<RecordChange[]>;
+}