@memberjunction/server 0.9.93 → 0.9.95

package/src/generic/PushStatusResolver.ts

@@ -0,0 +1,41 @@
+import { Arg, Field, ID, ObjectType, Resolver, ResolverFilterData, Root, Subscription } from 'type-graphql';
+
+export const PUSH_STATUS_UPDATES_TOPIC = 'PUSH_STATUS_UPDATES';
+
+@ObjectType()
+export class PushStatusNotification {
+  @Field(() => String, { nullable: true })
+  message?: string;
+
+  @Field((_type) => Date)
+  date!: Date;
+
+  @Field((_type) => ID)
+  sessionId!: string;
+}
+
+export interface PushStatusNotificationPayload {
+  message?: string;
+  sessionId: string;
+}
+
+interface PushStatusNotificationArgs {
+  sessionId: string;
+}
+
+@Resolver()
+export class PushStatusResolver {
+  @Subscription(() => PushStatusNotification, {
+    topics: PUSH_STATUS_UPDATES_TOPIC,
+    filter: ({ payload, args, context }: ResolverFilterData<PushStatusNotificationPayload, PushStatusNotificationArgs, any>) => {
+      console.log('context', context);
+      return payload.sessionId === args.sessionId;
+    },
+  })
+  statusUpdates(
+    @Root() { message }: PushStatusNotificationPayload,
+    @Arg('sessionId', () => String) sessionId: string
+  ): PushStatusNotification {
+    return { message, date: new Date(), sessionId };
+  }
+}

package/src/generic/ResolverBase.ts

@@ -0,0 +1,285 @@
+import { EntityPermissionType, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { AuditLogEntity, UserViewEntity } from '@memberjunction/core-entities';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { PubSubEngine } from 'type-graphql';
+import { DataSource } from 'typeorm';
+
+import { UserPayload } from '../types';
+import { RunDynamicViewInput, RunViewByIDInput, RunViewByNameInput } from './RunViewResolver';
+
+export class ResolverBase {
+  async findBy(dataSource: DataSource, entity: string, params: any) {
+    // build the SQL query based on the params passed in
+    const md = new Metadata();
+    const e = md.Entities.find((e) => e.Name === entity);
+    if (!e) throw new Error(`Entity ${entity} not found in metadata`);
+    // now build a SQL string using the entityInfo and using the properties in the params object
+    let sql = `SELECT * FROM ${e.SchemaName}.${e.BaseView} WHERE `;
+    const keys = Object.keys(params);
+    keys.forEach((k, i) => {
+      if (i > 0) sql += ' AND ';
+      // look up the field in the entityInfo to see if it needs quotes
+      const field = e.Fields.find((f) => f.Name === k);
+      if (!field) throw new Error(`Field ${k} not found in entity ${entity}`);
+      const quotes = field.NeedsQuotes ? "'" : '';
+      sql += `${k} = ${quotes}${params[k]}${quotes}`;
+    });
+
+    // ok, now we have a SQL string, run it and return the results
+    const result = await dataSource.query(sql);
+    return result;
+  }
+
+  async RunViewByNameGeneric(viewInput: RunViewByNameInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    try {
+      const viewInfo: UserViewEntity = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName }));;
+      return this.RunViewGenericInternal(
+        viewInfo,
+        dataSource,
+        viewInput.ExtraFilter,
+        viewInput.OrderBy,
+        viewInput.UserSearchString,
+        viewInput.ExcludeUserViewRunID,
+        viewInput.OverrideExcludeFilter,
+        viewInput.SaveViewResults,
+        viewInput.Fields,
+        viewInput.IgnoreMaxRows,
+        viewInput.ExcludeDataFromAllPriorViewRuns,
+        viewInput.ForceAuditLog,
+        viewInput.AuditLogDescription,
+        userPayload,
+        pubSub
+      );
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async RunViewByIDGeneric(viewInput: RunViewByIDInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    try {
+      const viewInfo: UserViewEntity = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { ID: viewInput.ViewID }));
+      return this.RunViewGenericInternal(
+        viewInfo,
+        dataSource,
+        viewInput.ExtraFilter,
+        viewInput.OrderBy,
+        viewInput.UserSearchString,
+        viewInput.ExcludeUserViewRunID,
+        viewInput.OverrideExcludeFilter,
+        viewInput.SaveViewResults,
+        viewInput.Fields,
+        viewInput.IgnoreMaxRows,
+        viewInput.ExcludeDataFromAllPriorViewRuns,
+        viewInput.ForceAuditLog,
+        viewInput.AuditLogDescription,
+        userPayload,
+        pubSub
+      );
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async RunDynamicViewGeneric(viewInput: RunDynamicViewInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+    try {
+      const md = new Metadata();
+      const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
+      if (!entity) throw new Error(`Entity ${viewInput.EntityName} not found in metadata`);
+
+      const viewInfo: UserViewEntity = {
+        ID: -1,
+        Entity: viewInput.EntityName,
+        EntityID: entity.ID as number,
+        EntityBaseView: entity.BaseView as string,
+      } as UserViewEntity; // only providing a few bits of data here, but it's enough to get the view to run
+
+      return this.RunViewGenericInternal(
+        viewInfo,
+        dataSource,
+        viewInput.ExtraFilter,
+        viewInput.OrderBy,
+        viewInput.UserSearchString,
+        viewInput.ExcludeUserViewRunID,
+        viewInput.OverrideExcludeFilter,
+        false,
+        viewInput.Fields,
+        viewInput.IgnoreMaxRows,
+        false,
+        viewInput.ForceAuditLog,
+        viewInput.AuditLogDescription,
+        userPayload,
+        pubSub
+      );
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  protected CheckUserReadPermissions(entityName: string, userPayload: UserPayload | null) {
+    const md = new Metadata();
+    const entityInfo = md.Entities.find((e) => e.Name === entityName);
+    if (!userPayload) throw new Error(`userPayload is null`);
+
+    // first check permissions, the logged in user must have read permissions on the entity to run the view
+    if (entityInfo) {
+      const userInfo = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload.email.toLowerCase().trim()); // get the user record from MD so we have ROLES attached, don't use the one from payload directly
+      if (!userInfo) throw new Error(`User ${userPayload.email} not found in metadata`);
+
+      const userPermissions = entityInfo.GetUserPermisions(userInfo);
+      if (!userPermissions.CanRead) throw new Error(`User ${userPayload.email} does not have read permissions on ${entityInfo.Name}`);
+    } else throw new Error(`Entity not found in metadata`);
+  }
+
+  protected async RunViewGenericInternal(
+    viewInfo: UserViewEntity,
+    dataSource: DataSource,
+    extraFilter: string,
+    orderBy: string,
+    userSearchString: string,
+    excludeUserViewRunID: number | undefined,
+    overrideExcludeFilter: string | undefined,
+    saveViewResults: boolean | undefined,
+    fields: string[] | undefined,
+    ignoreMaxRows: boolean | undefined,
+    excludeDataFromAllPriorViewRuns: boolean | undefined,
+    forceAuditLog: boolean | undefined,
+    auditLogDescription: string | undefined,
+    userPayload: UserPayload | null,
+    pubSub: PubSubEngine
+  ) {
+    try {
+      if (viewInfo && userPayload) {
+        const md = new Metadata();
+        const user = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
+        if (!user) throw new Error(`User ${userPayload?.email} not found in metadata`);
+
+        const entityInfo = md.Entities.find((e) => e.Name === viewInfo.Entity);
+        if (!entityInfo) throw new Error(`Entity ${viewInfo.Entity} not found in metadata`);
+
+        const rv = new RunView();
+        const result = await rv.RunView(
+          {
+            ViewID: viewInfo.ID,
+            ViewName: viewInfo.Name,
+            EntityName: viewInfo.Entity,
+            ExtraFilter: extraFilter,
+            OrderBy: orderBy,
+            Fields: fields,
+            UserSearchString: userSearchString,
+            ExcludeUserViewRunID: excludeUserViewRunID,
+            OverrideExcludeFilter: overrideExcludeFilter,
+            SaveViewResults: saveViewResults,
+            ExcludeDataFromAllPriorViewRuns: excludeDataFromAllPriorViewRuns,
+            IgnoreMaxRows: ignoreMaxRows,
+            ForceAuditLog: forceAuditLog,
+            AuditLogDescription: auditLogDescription,
+          },
+          user
+        );
+
+        return result;
+      } else return null;
+    } catch (err) {
+      console.log(err);
+      throw err;
+    }
+  }
+
+  protected async createRecordAccessAuditLogRecord(userPayload: UserPayload, entityName: string, recordId: any): Promise<any> {
+    try {
+      const md = new Metadata();
+      const entityInfo = md.Entities.find((e) => e.Name.trim().toLowerCase() === entityName.trim().toLowerCase());
+      if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
+
+      if (entityInfo.AuditRecordAccess) {
+        const userInfo = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
+        const auditLogTypeName = 'Record Accessed';
+        const auditLogType = md.AuditLogTypes.find((a) => a.Name.trim().toLowerCase() === auditLogTypeName.trim().toLowerCase());
+
+        if (!userInfo) throw new Error(`User ${userPayload?.email} not found in metadata`);
+        if (!auditLogType) throw new Error(`Audit Log Type ${auditLogTypeName} not found in metadata`);
+
+        return await this.createAuditLogRecord(userPayload, null, auditLogTypeName, 'Success', null, entityInfo.ID, recordId);
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  }
+
+  protected getRowLevelSecurityWhereClause(entityName: string, userPayload: UserPayload, type: EntityPermissionType, returnPrefix: string) {
+    const md = new Metadata();
+    const entityInfo = md.Entities.find((e) => e.Name.trim().toLowerCase() === entityName.trim().toLowerCase());
+    if (!entityInfo) throw new Error(`Entity ${entityName} not found in metadata`);
+    const user = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
+    if (!user) throw new Error(`User ${userPayload?.email} not found in metadata`);
+
+    return entityInfo.GetUserRowLevelSecurityWhereClause(user, type, returnPrefix);
+  }
+
+  protected async createAuditLogRecord(
+    userPayload: UserPayload,
+    authorizationName: string | null,
+    auditLogTypeName: string,
+    status: string,
+    details: string | null,
+    entityId: number,
+    recordId: any | null
+  ): Promise<any> {
+    try {
+      const md = new Metadata();
+      const userInfo = UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload?.email.toLowerCase().trim());
+      const authorization = authorizationName
+        ? md.Authorizations.find((a) => a.Name.trim().toLowerCase() === authorizationName.trim().toLowerCase())
+        : null;
+      const auditLogType = md.AuditLogTypes.find((a) => a.Name.trim().toLowerCase() === auditLogTypeName.trim().toLowerCase());
+
+      if (!userInfo) throw new Error(`User ${userPayload?.email} not found in metadata`);
+      if (!auditLogType) throw new Error(`Audit Log Type ${auditLogTypeName} not found in metadata`);
+
+      const auditLog = <AuditLogEntity>await md.GetEntityObject('Audit Logs', userInfo); // must pass user context on back end as we're not authenticated the same way as the front end
+      auditLog.NewRecord();
+      auditLog.UserID = userInfo.ID;
+      auditLog.AuditLogTypeName = auditLogType.Name;
+      if (authorization) auditLog.AuthorizationName = authorization.Name;
+      auditLog.Status = status;
+      if (details) auditLog.Details = details;
+      auditLog.EntityID = entityId;
+      if (recordId) auditLog.RecordID = recordId;
+
+      if (await auditLog.Save()) return auditLog;
+      else throw new Error(`Error saving audit log record`);
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  protected safeFirstArrayElement(arr: any[]) {
+    if (arr && arr.length > 0) {
+      return arr[0];
+    }
+    return null;
+  }
+
+  protected packageSPParam(paramValue: any, quoteString: string) {
+    return paramValue === null || paramValue === undefined ? null : quoteString + paramValue + quoteString;
+  }
+
+  protected GetUserFromEmail(email: string): UserInfo | undefined {
+    const md = new Metadata();
+    return UserCache.Users.find((u) => u.Email.toLowerCase().trim() === email.toLowerCase().trim());
+  }
+  protected GetUserFromPayload(userPayload: UserPayload): UserInfo | undefined {
+    if (!userPayload || !userPayload.email) return undefined;
+
+    const md = new Metadata();
+    return UserCache.Users.find((u) => u.Email.toLowerCase().trim() === userPayload.email.toLowerCase().trim());
+  }
+
+  public get MJCoreSchema(): string {
+    return Metadata.Provider.ConfigData.MJCoreSchemaName;
+  }
+}

package/src/generic/RunViewResolver.ts

@@ -0,0 +1,350 @@
+import { Arg, Ctx, Field, InputType, Int, ObjectType, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+import { ResolverBase } from './ResolverBase';
+
+/********************************************************************************
+ * The PURPOSE of this resolver is to provide a generic way to run a view and return the results.
+ * The best practice is to use the strongly typed sub-class of this resolver for each entity.
+ * that way you get back strongly typed results. If you need a generic way to call a view and get
+ * back the results, and have your own type checking in place, this resolver can be used.
+ *
+ */
+//****************************************************************************
+// INPUT TYPE for Running Views
+//****************************************************************************
+@InputType()
+export class RunViewByIDInput {
+  @Field(() => Int)
+  ViewID: number;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid condition to append to the view WHERE clause. For example, UpdatedAt >= Some Date - if not provided, no filter is applied',
+  })
+  ExtraFilter: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid order by clause sort the results on the server. For example, CreatedAt DESC to order by row creation date in reverse order. Any Valid SQL Order By clause is okay - if not provided, no server-side sorting is applied',
+  })
+  OrderBy: string;
+
+  @Field(() => [String], {
+    nullable: true,
+    description:
+      'Optional, array of entity field names, if not provided, ID and all other columns used in the view columns are returned. If provided, only the fields in the array are returned.',
+  })
+  Fields?: string[];
+
+  @Field(() => String, { nullable: true })
+  UserSearchString: string;
+
+  @Field(() => Int, { nullable: true, description: 'Pass in a UserViewRun ID value to exclude all records from that run from results' })
+  ExcludeUserViewRunID?: number;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Pass in a valid condition to append to the view WHERE clause to override the Exclude List. For example, UpdatedAt >= Some Date',
+  })
+  OverrideExcludeFilter?: string;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'If set to True, the results of this view are saved into a new UserViewRun record and the UserViewRun.ID is passed back in the results.',
+  })
+  SaveViewResults?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'if set to true, the resulting data will filter out ANY records that were ever returned by this view, when the SaveViewResults property was set to true. This is useful if you want to run a particular view over time and make sure the results returned each time are new to the view.',
+  })
+  ExcludeDataFromAllPriorViewRuns?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'if set to true, if there IS any UserViewMaxRows property set for the entity in question, it will be IGNORED. This is useful in scenarios where you want to programmatically run a view and get ALL the data back, regardless of the MaxRows setting on the entity.',
+  })
+  IgnoreMaxRows?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'If set to true, an Audit Log record will be created for the view run, regardless of the property settings in the entity for auditing view runs',
+  })
+  ForceAuditLog?: boolean;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      "if provided and either ForceAuditLog is set, or the entity's property settings for logging view runs are set to true, this will be used as the Audit Log Description.",
+  })
+  AuditLogDescription?: string;
+}
+
+@InputType()
+export class RunViewByNameInput {
+  @Field(() => String)
+  ViewName: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid condition to append to the view WHERE clause. For example, UpdatedAt >= Some Date - if not provided, no filter is applied',
+  })
+  ExtraFilter: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid order by clause sort the results on the server. For example, CreatedAt DESC to order by row creation date in reverse order. Any Valid SQL Order By clause is okay - if not provided, no server-side sorting is applied',
+  })
+  OrderBy: string;
+
+  @Field(() => [String], {
+    nullable: true,
+    description:
+      'Optional, array of entity field names, if not provided, ID and all other columns used in the view are returned. If provided, only the fields in the array are returned.',
+  })
+  Fields?: string[];
+
+  @Field(() => String, { nullable: true })
+  UserSearchString: string;
+
+  @Field(() => Int, { nullable: true, description: 'Pass in a UserViewRun ID value to exclude all records from that run from results' })
+  ExcludeUserViewRunID?: number;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Pass in a valid condition to append to the view WHERE clause to override the Exclude List. For example, UpdatedAt >= Some Date',
+  })
+  OverrideExcludeFilter?: string;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'If set to True, the results of this view are saved into a new UserViewRun record and the UserViewRun.ID is passed back in the results.',
+  })
+  SaveViewResults?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'if set to true, the resulting data will filter out ANY records that were ever returned by this view, when the SaveViewResults property was set to true. This is useful if you want to run a particular view over time and make sure the results returned each time are new to the view.',
+  })
+  ExcludeDataFromAllPriorViewRuns?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'if set to true, if there IS any UserViewMaxRows property set for the entity in question, it will be IGNORED. This is useful in scenarios where you want to programmatically run a view and get ALL the data back, regardless of the MaxRows setting on the entity.',
+  })
+  IgnoreMaxRows?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'If set to true, an Audit Log record will be created for the view run, regardless of the property settings in the entity for auditing view runs',
+  })
+  ForceAuditLog?: boolean;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      "if provided and either ForceAuditLog is set, or the entity's property settings for logging view runs are set to true, this will be used as the Audit Log Description.",
+  })
+  AuditLogDescription?: string;
+}
+@InputType()
+export class RunDynamicViewInput {
+  @Field(() => String)
+  EntityName: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid condition to use as the view WHERE clause. For example, UpdatedAt >= Some Date - if not provided, no filter is applied',
+  })
+  ExtraFilter: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Optional, pass in a valid order by clause sort the results on the server. For example, CreatedAt DESC to order by row creation date in reverse order. Any Valid SQL Order By clause is okay - if not provided, no server-side sorting is applied',
+  })
+  OrderBy: string;
+
+  @Field(() => [String], {
+    nullable: true,
+    description:
+      'Optional, array of entity field names, if not provided, all columns are returned. If provided, only the fields in the array are returned.',
+  })
+  Fields?: string[];
+
+  @Field(() => String, { nullable: true })
+  UserSearchString: string;
+
+  @Field(() => Int, { nullable: true, description: 'Pass in a UserViewRun ID value to exclude all records from that run from results' })
+  ExcludeUserViewRunID?: number;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      'Pass in a valid condition to append to the view WHERE clause to override the Exclude List. For example, UpdatedAt >= Some Date',
+  })
+  OverrideExcludeFilter?: string;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'if set to true, if there IS any UserViewMaxRows property set for the entity in question, it will be IGNORED. This is useful in scenarios where you want to programmatically run a view and get ALL the data back, regardless of the MaxRows setting on the entity.',
+  })
+  IgnoreMaxRows?: boolean;
+
+  @Field(() => Boolean, {
+    nullable: true,
+    description:
+      'If set to true, an Audit Log record will be created for the view run, regardless of the property settings in the entity for auditing view runs',
+  })
+  ForceAuditLog?: boolean;
+
+  @Field(() => String, {
+    nullable: true,
+    description:
+      "if provided and either ForceAuditLog is set, or the entity's property settings for logging view runs are set to true, this will be used as the Audit Log Description.",
+  })
+  AuditLogDescription?: string;
+}
+
+@ObjectType()
+export class RunViewResultRow {
+  @Field(() => Int)
+  ID: number;
+
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => String)
+  Data: string;
+}
+
+@ObjectType()
+export class RunViewResult {
+  @Field(() => [RunViewResultRow])
+  Results: RunViewResultRow[];
+
+  @Field(() => Int, { nullable: true })
+  UserViewRunID?: number;
+
+  @Field(() => Int, { nullable: true })
+  RowCount: number;
+
+  @Field(() => Int, { nullable: true })
+  TotalRowCount: number;
+
+  @Field(() => Int, { nullable: true })
+  ExecutionTime: number;
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+
+  @Field(() => Boolean, { nullable: false })
+  Success: boolean;
+}
+
+@Resolver(RunViewResultRow)
+export class RunViewResolver extends ResolverBase {
+  @Query(() => RunViewResult)
+  async RunViewByName(
+    @Arg('input', () => RunViewByNameInput) input: RunViewByNameInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    pubSub: PubSubEngine
+  ) {
+    try {
+      const rawData = await super.RunViewByNameGeneric(input, dataSource, userPayload, pubSub);
+      if (rawData === null) return null;
+
+      const entityId = await dataSource.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE Name='${input.ViewName}'`);
+      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      return {
+        Results: returnData,
+        UserViewRunID: rawData?.UserViewRunID,
+        RowCount: rawData?.RowCount,
+        TotalRowCount: rawData?.TotalRowCount,
+        ExecutionTime: rawData?.ExecutionTime,
+      };
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  @Query(() => RunViewResult)
+  async RunViewByID(
+    @Arg('input', () => RunViewByIDInput) input: RunViewByIDInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    pubSub: PubSubEngine
+  ) {
+    try {
+      const rawData = await super.RunViewByIDGeneric(input, dataSource, userPayload, pubSub);
+      if (rawData === null) return null;
+
+      const entityId = await dataSource.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE ID=${input.ViewID}`);
+      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      return {
+        Results: returnData,
+        UserViewRunID: rawData?.UserViewRunID,
+        RowCount: rawData?.RowCount,
+        TotalRowCount: rawData?.TotalRowCount,
+        ExecutionTime: rawData?.ExecutionTime,
+      };
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  @Query(() => RunViewResult)
+  async RunDynamicView(
+    @Arg('input', () => RunDynamicViewInput) input: RunDynamicViewInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    pubSub: PubSubEngine
+  ) {
+    try {
+      const rawData = await super.RunDynamicViewGeneric(input, dataSource, userPayload, pubSub);
+      if (rawData === null) return null;
+
+      const entityId = await dataSource.query(`SELECT ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input.EntityName}'`);
+      const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
+      return {
+        Results: returnData,
+        UserViewRunID: rawData?.UserViewRunID,
+        RowCount: rawData?.RowCount,
+        TotalRowCount: rawData?.TotalRowCount,
+        ExecutionTime: rawData?.ExecutionTime,
+      };
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  protected processRawData(rawData: any[], entityId: number): RunViewResultRow[] {
+    const returnResult = [];
+    for (let i = 0; i < rawData.length; i++) {
+      const row = rawData[i];
+      returnResult.push({
+        ID: row.ID,
+        EntityID: entityId,
+        Data: JSON.stringify(row),
+      });
+    }
+    return returnResult;
+  }
+}