@memberjunction/server 0.9.93 → 0.9.95

package/src/resolvers/MergeRecordsResolver.ts

@@ -0,0 +1,178 @@
+import { LogError, Metadata } from '@memberjunction/core';
+import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+
+@ObjectType()
+export class EntityDependencyResult {
+  @Field(() => String)
+  EntityName: string; // required
+
+  @Field(() => String)
+  RelatedEntityName: string; // required
+
+  @Field(() => String)
+  FieldName: string; // required
+}
+
+@Resolver(EntityDependencyResult)
+export class EntityDependencyResolver {
+    @Query(() => [EntityDependencyResult])
+    async GetEntityDependencies(
+        @Arg('entityName', () => String) entityName: string,
+        @Arg('recordId', () => Int) recordId: number,
+        @Ctx() { dataSource, userPayload }: AppContext,
+        @PubSub() pubSub: PubSubEngine
+    ) {
+        try {
+        const md = new Metadata();
+        return md.GetEntityDependencies(entityName);
+        } 
+        catch (err) {
+            LogError(err);
+            throw new Error(err.message);
+        }
+    }
+ 
+}
+
+
+@ObjectType()
+export class RecordDependencyResult {
+  @Field(() => String)
+  EntityName: string; // required
+
+  @Field(() => String)
+  RelatedEntityName: string; // required
+
+  @Field(() => String)
+  FieldName: string; // required
+
+  @Field(() => Int)
+  RecordID: number;
+}
+
+@Resolver(RecordDependencyResult)
+export class RecordDependencyResolver {
+    @Query(() => [RecordDependencyResult])
+    async GetRecordDependencies(
+      @Arg('entityName', () => String) entityName: string,
+      @Arg('recordId', () => Int) recordId: number,
+      @Ctx() { dataSource, userPayload }: AppContext,
+      @PubSub() pubSub: PubSubEngine
+    ) {
+        try {
+            const md = new Metadata();
+            const result = await md.GetRecordDependencies(entityName, recordId)    
+            return result;
+        }
+        catch (e) {
+            LogError(e);
+            throw e;
+        }
+    }
+}
+
+@InputType()
+class FieldMapping {
+    @Field(() => String)
+    FieldName: string;
+
+    @Field(() => String)
+    Value: string;
+}
+
+@ObjectType()
+class FieldMappingOutput {
+    @Field(() => String)
+    FieldName: string;
+
+    @Field(() => String)
+    Value: string;
+}
+
+@InputType()
+export class RecordMergeRequest {
+    @Field(() => String)
+    EntityName: string;
+
+    @Field(() => String)
+    SurvivingRecordPrimaryKeyValue: string;
+
+    @Field(() => [Int])
+    RecordsToMerge: number[];
+
+    @Field(() => [FieldMapping], { nullable: true })
+    FieldMap?: FieldMapping[];
+}
+
+@ObjectType()
+export class RecordMergeRequestOutput {
+    @Field(() => String)
+    EntityName: string;
+
+    @Field(() => Int)
+    SurvivingRecordID: number;
+
+    @Field(() => [Int])
+    RecordsToMerge: number[];
+
+    @Field(() => [FieldMappingOutput], { nullable: true })
+    FieldMap?: FieldMappingOutput[];
+}
+
+
+@ObjectType()
+export class RecordMergeDetailResult {
+    @Field(() => Int)
+    RecordID: number;
+
+    @Field(() => Boolean)
+    Success: boolean; 
+
+    @Field(() => Int, {nullable: true})
+    RecordMergeDeletionLogID?: number;
+
+    @Field(() => String, {nullable: true})
+    Message?: string;  
+} 
+
+@ObjectType()
+export class RecordMergeResult {
+  @Field(() => Boolean)
+  Success: boolean; 
+
+  @Field(() => String, {nullable: true})
+  OverallStatus: string;  
+
+  @Field(() => Int, {nullable: true})
+  RecordMergeLogID: number;
+
+  @Field(() => [RecordMergeDetailResult])
+  RecordStatus: RecordMergeDetailResult[]; 
+
+  @Field(() => RecordMergeRequestOutput)
+  Request: RecordMergeRequestOutput; 
+}
+
+@Resolver(RecordMergeResult)
+export class RecordMergeResolver {
+    @Mutation(() => RecordMergeResult)
+    async MergeRecords(
+      @Arg('request', () => RecordMergeRequest) request: RecordMergeRequest,
+      @Ctx() { dataSource, userPayload }: AppContext,
+      @PubSub() pubSub: PubSubEngine
+    ) {
+        try {
+            const md = new Metadata();
+            const result = await md.MergeRecords(request, userPayload.userRecord);    
+            return result;
+        }
+        catch (e) {
+            LogError(e);
+            throw e;
+        }
+    }
+}
+
+
+export default EntityDependencyResolver;

package/src/resolvers/ReportResolver.ts

@@ -0,0 +1,56 @@
+import { RunReport } from '@memberjunction/core';
+import { Arg, Ctx, Field, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+
+@ObjectType()
+export class RunReportResultType {
+  @Field()
+  ReportID: number;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  Results: string;
+
+  @Field()
+  RowCount: number;
+
+  @Field()
+  ExecutionTime: number;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@Resolver(RunReportResultType)
+export class ReportResolver {
+  @Query(() => RunReportResultType)
+  async GetReportData(@Arg('ReportID', () => Int) ReportID: number, @Ctx() {}: AppContext): Promise<RunReportResultType> {
+    const runReport = new RunReport();
+    const result = await runReport.RunReport({ ReportID: ReportID });
+    return {
+      ReportID: ReportID,
+      Success: result.Success,
+      Results: JSON.stringify(result.Results),
+      RowCount: result.RowCount,
+      ExecutionTime: result.ExecutionTime,
+      ErrorMessage: result.ErrorMessage,
+    };
+    // // run the sql and return the data
+    // const sqlReport = "SELECT GeneratedSQLText FROM vwReports WHERE ID = " + ReportID;
+    // const reportInfo = await dataSource.query(sqlReport);
+    // if (reportInfo && reportInfo.length > 0) {
+    //     const start = new Date().getTime();
+    //     const sql = reportInfo[0].GeneratedSQLText;
+    //     const result = await dataSource.query(sql);
+    //     const end = new Date().getTime();
+    //     if (result)
+    //         return {Success: true, ReportID: ReportID, Results: JSON.stringify(result), RowCount: result.length, ExecutionTime: end-start, ErrorMessage: ''};
+    //     else
+    //         return {Success: false, ReportID: ReportID, Results: '[]', RowCount: 0, ExecutionTime: end - start, ErrorMessage: 'Error running report SQL'};
+    // }
+    // else
+    //     return {Success: false, ReportID: ReportID, Results: '[]', RowCount: 0, ExecutionTime: 0, ErrorMessage: 'Report not found'};
+  }
+}

package/src/resolvers/UserFavoriteResolver.ts

@@ -0,0 +1,123 @@
+import { Metadata } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, Query, Resolver } from '@memberjunction/server';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserFavoriteEntity } from '@memberjunction/core-entities';
+
+import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated';
+
+//****************************************************************************
+// INPUT TYPE for User Favorite Queries
+//****************************************************************************
+@InputType()
+export class UserFavoriteSearchParams {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => String)
+  PrimaryKeyValue: string;
+
+  @Field(() => Int)
+  UserID: number;
+}
+
+@InputType()
+export class UserFavoriteSetParams {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => String)
+  PrimaryKeyValue: string;
+
+  @Field(() => Int)
+  UserID: number;
+
+  @Field(() => Boolean)
+  IsFavorite: boolean;
+}
+
+@ObjectType()
+export class UserFavoriteResult {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => String)
+  PrimaryKeyValue: string;
+
+  @Field(() => Int)
+  UserID: number;
+
+  @Field(() => Boolean)
+  IsFavorite: boolean;
+
+  @Field(() => Boolean)
+  Success: boolean;
+}
+
+@Resolver(UserFavorite_)
+export class UserFavoriteResolver extends UserFavoriteResolverBase {
+  @Query(() => [UserFavorite_])
+  async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Favorites', { UserID });
+  }
+
+  @Query(() => [UserFavorite_])
+  async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Favorites', params);
+  }
+
+  @Query(() => UserFavoriteResult)
+  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {}: AppContext) {
+    const md = new Metadata();
+    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    if (e)
+      return {
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        PrimaryKeyValue: params.PrimaryKeyValue,
+        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValue),
+        Success: true,
+      };
+    else throw new Error(`Entity ID:${params.EntityID} not found`);
+  }
+
+  @Mutation(() => UserFavoriteResult)
+  SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload }: AppContext) {
+    const md = new Metadata();
+    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);
+    if (e) {
+      md.SetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValue, params.IsFavorite, u);
+      return {
+        Success: true,
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        PrimaryKeyValue: params.PrimaryKeyValue,
+        IsFavorite: params.IsFavorite,
+      };
+    } else throw new Error(`Entity ID:${params.EntityID} not found`);
+  }
+
+  @Mutation(() => UserFavorite_)
+  async AddUserFavorite(
+    @Arg('input', () => UserFavoriteSearchParams) input: UserFavoriteSearchParams,
+    @Ctx() { dataSource, userPayload }: AppContext
+  ) {
+    const [existing] = await this.findBy(dataSource, 'User Favorites', input);
+    if (existing) 
+      return existing;
+
+    const md = new Metadata();
+
+    const ufEntity = <UserFavoriteEntity>await md.GetEntityObject('User Favorites', userPayload.userRecord);
+    ufEntity.NewRecord();
+    ufEntity.EntityID = input.EntityID;
+    ufEntity.RecordID = input.PrimaryKeyValue;
+    ufEntity.UserID = input.UserID;
+    if (await ufEntity.Save()) 
+      return ufEntity.GetAll();
+    else 
+      throw new Error('Error saving user favorite');
+}
+}
+
+export default UserFavoriteResolver;

package/src/resolvers/UserResolver.ts

@@ -0,0 +1,29 @@
+import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
+import { User_, UserResolverBase } from '../generated/generated';
+
+@Resolver(User_)
+export class UserResolver extends UserResolverBase {
+  @Query(() => User_)
+  async CurrentUser(@Ctx() { dataSource, userPayload }: AppContext) {
+    return await this.UserByEmail(userPayload.email, { dataSource, userPayload });
+  }
+
+  @Query(() => User_)
+  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource }: AppContext) {
+    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { ID }));
+  }
+
+  @Query(() => User_)
+  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { dataSource }: AppContext) {
+    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { EmployeeID }));
+  }
+
+  @Query(() => User_)
+  async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { dataSource }: AppContext) {
+    // const searchEmail = userEmailMap[Email] ?? Email;
+    const searchEmail = Email;
+    const returnVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { Email: searchEmail }));
+    return returnVal;
+  }
+}
+export default UserResolver;

package/src/resolvers/UserViewResolver.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Metadata } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
+import { DataSource } from 'typeorm';
+import { UserView_, UserViewResolverBase } from '../generated/generated';
+import { UserResolver } from './UserResolver';
+
+@Resolver(UserView_)
+export class UserViewResolver extends UserViewResolverBase {
+  @Query(() => [UserView_])
+  async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Views', { UserID });
+  }
+
+  @Query(() => [UserView_])
+  async DefaultViewByUserAndEntity(
+    @Arg('UserID', () => Int) UserID: number,
+    @Arg('EntityID', () => Int) EntityID: number,
+    @Ctx() { dataSource }: AppContext
+  ) {
+    return await this.findBy(dataSource, 'User Views', { UserID, EntityID, IsDefault: true });
+  }
+
+  @Query(() => [UserView_])
+  async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
+    return await this.findBy(dataSource, 'User Views', {
+      UserID: await this.getCurrentUserID(dataSource, userPayload),
+      EntityID,
+      IsDefault: true,
+    });
+  }
+
+  protected async getCurrentUserID(dataSource: DataSource, userPayload: UserPayload): Promise<number> {
+    const userResolver = new UserResolver();
+    const user = await userResolver.UserByEmail(userPayload.email, { dataSource, userPayload });
+    return user.ID;
+  }
+
+  @Query(() => [UserView_])
+  async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
+    return this.findBy(dataSource, 'User Views', { UserID: await this.getCurrentUserID(dataSource, userPayload), EntityID });
+  }
+
+  @Query(() => [UserView_])
+  async UpdateWhereClause(@Arg('ID', () => Int) ID: number, @Ctx() { userPayload }: AppContext) {
+    // in this query we want to update the uesrView record in the DB with a new where clause
+    // this should normally not be a factor but we have this exposed in the GraphQL API so that
+    // a dev can force the update if desired from the client. The normal path is just to update
+    // filter state which in turn will be used to update the where clause in the entity sub-class.
+    const md = new Metadata();
+    const u = this.GetUserFromPayload(userPayload);
+    const viewEntity = await md.GetEntityObject('User Views', u);
+    await viewEntity.Load(ID);
+    viewEntity.UpdateWhereClause();
+    if (await viewEntity.Save()) {
+      return viewEntity.GetAll();
+    } else {
+      throw new Error('Failed to update where clause');
+    }
+  }
+}
+
+export default UserViewResolver;