@memberjunction/server 0.9.165 → 0.9.166

package/src/resolvers/AskSkipResolver.ts

@@ -10,7 +10,7 @@ import { promisify } from 'util';
 const gzip = promisify(zlib.gzip);
 
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver';
-import { ConversationDetailEntity, ConversationEntity, DataContextEntity, DataContextItemEntity, UserNotificationEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
+import { ConversationDetailEntity, ConversationEntity, DataContextEntity, DataContextItemEntity, UserNotificationEntity, UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
 import { DataSource } from 'typeorm';
 import { ___skipAPIOrgId, ___skipAPIurl } from '../config';
 
@@ -64,16 +64,16 @@ export class AskSkipResolver {
   @Query(() => AskSkipResultType)
   async ExecuteAskSkipAnalysisQuery(
     @Arg('UserQuestion', () => String) UserQuestion: string,
-    @Arg('ViewId', () => Int) ViewId: number,
     @Arg('ConversationId', () => Int) ConversationId: number,
     @Ctx() { dataSource, userPayload }: AppContext,
-    @PubSub() pubSub: PubSubEngine
+    @PubSub() pubSub: PubSubEngine,
+    @Arg('DataContextId', () => Int, { nullable: true }) DataContextId?: number
   ) {
     const md = new Metadata();
     const user = UserCache.Instance.Users.find((u) => u.Email === userPayload.email);
     if (!user) throw new Error(`User ${userPayload.email} not found in UserCache`);
 
-    const {convoEntity, dataContextEntity, convoDetailEntity, dataContext} = await this.HandleCreationOfEntityObjects(dataSource, ConversationId, UserQuestion, user, userPayload, md, ViewId);
+    const {convoEntity, dataContextEntity, convoDetailEntity, dataContext} = await this.HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId);
 
     const OrganizationId = ___skipAPIOrgId;
 
@@ -100,16 +100,17 @@ export class AskSkipResolver {
     return this.HandleSkipRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity);
   }
 
-  protected async HandleCreationOfEntityObjects(dataSource: DataSource, 
-                                                ConversationId: number, 
-                                                UserQuestion: string, 
-                                                user: UserInfo,
-                                                userPayload: UserPayload, 
-                                                md: Metadata,
-                                                ViewId: number): Promise<{convoEntity: ConversationEntity, 
-                                                                        dataContextEntity: DataContextEntity, 
-                                                                        convoDetailEntity: ConversationDetailEntity, 
-                                                                        dataContext: SkipDataContext}> {
+
+  protected async HandleSkipInitialObjectLoading(dataSource: DataSource, 
+                                                 ConversationId: number, 
+                                                 UserQuestion: string, 
+                                                 user: UserInfo,
+                                                 userPayload: UserPayload, 
+                                                 md: Metadata,
+                                                 DataContextId: number): Promise<{convoEntity: ConversationEntity, 
+                                                                         dataContextEntity: DataContextEntity, 
+                                                                         convoDetailEntity: ConversationDetailEntity, 
+                                                                         dataContext: SkipDataContext}> {
     const convoEntity = <ConversationEntity>await md.GetEntityObject('Conversations', user);
     let dataContextEntity: DataContextEntity;
 
@@ -121,21 +122,27 @@ export class AskSkipResolver {
         convoEntity.Name = AskSkipResolver._defaultNewChatName;
 
         dataContextEntity = await md.GetEntityObject<DataContextEntity>('Data Contexts', user);
-        dataContextEntity.NewRecord();
-        dataContextEntity.UserID = user.ID;
-        dataContextEntity.Name = 'Data Context for Skip Conversation';
-        if (await dataContextEntity.Save()) {
-          convoEntity.DataContextID = dataContextEntity.ID;
-          if (await convoEntity.Save()) {
-            ConversationId = convoEntity.ID;
+        if (!DataContextId || DataContextId <= 0) {
+          dataContextEntity.NewRecord();
+          dataContextEntity.UserID = user.ID;
+          dataContextEntity.Name = 'Data Context for Skip Conversation';
+          if (!await dataContextEntity.Save())
+            throw new Error(`Creating a new data context failed`);
+        }
+        else {
+          await dataContextEntity.Load(DataContextId);
+        }
+        convoEntity.DataContextID = dataContextEntity.ID;
+        if (await convoEntity.Save()) {
+          ConversationId = convoEntity.ID;
+          if (!DataContextId || dataContextEntity.ID <= 0) {
+            // only do this if we created a new data context for this conversation
             dataContextEntity.Name += ` ${ConversationId}`;
-            await dataContextEntity.Save();
+            await dataContextEntity.Save();  
           }
-          else 
-            throw new Error(`Creating a new conversation failed`);
         }
-        else
-          throw new Error(`Creating a new data context failed`);
+        else 
+          throw new Error(`Creating a new conversation failed`);
       } 
       else { 
         throw new Error(`User ${userPayload.email} not found in UserCache`);
@@ -143,6 +150,11 @@ export class AskSkipResolver {
     } else {
       await convoEntity.Load(ConversationId); // load the existing conversation, will need it later
       dataContextEntity = await md.GetEntityObject<DataContextEntity>('Data Contexts', user);
+
+      // note - we ignore the parameter DataContextId if it is passed in, we will use the data context from the conversation that is saved. If a user wants to change the data context for a convo, they can do that elsewhere
+      if (DataContextId && DataContextId > 0 && DataContextId !== convoEntity.DataContextID) 
+        console.log(`AskSkipResolver: DataContextId ${DataContextId} was passed in but it was ignored because it was different than the DataContextID in the conversation ${convoEntity.DataContextID}`);
+
       await dataContextEntity.Load(convoEntity.DataContextID);
     }
 
@@ -169,23 +181,50 @@ export class AskSkipResolver {
       for (const r of result) {
         const item = new SkipDataContextItem();
         item.Type = r.Type;
-        item.RecordID = r.RecordID;
-        item.RecordName = r.RecordName;
+        switch (item.Type) {
+          case 'full_entity':
+            item.EntityID = r.EntityID;  
+            break;
+          case 'single_record':
+            item.RecordID = r.RecordID;  
+            item.EntityID = r.EntityID;  
+            break;
+          case 'query':
+            item.QueryID = r.QueryID; // map the QueryID in our database to the RecordID field in the object model for runtime use
+            break;
+          case 'sql':
+            item.SQL = r.SQL;  
+            break;
+          case 'view':
+            item.ViewID = r.ViewID;
+            item.EntityID = r.EntityID;
+            break;
+        }
+        if (item.EntityID) {
+          item.Entity = md.Entities.find((e) => e.ID === item.EntityID);
+          item.EntityName = item.Entity.Name;
+          if (item.Type === 'full_entity')
+            item.RecordName = item.EntityName;
+        }
+        if (item.Type === 'query' && item.QueryID) {
+          const q = md.Queries.find((q) => q.ID === item.QueryID);
+          item.RecordName = q?.Name;
+        }
+        if (item.Type === 'view' && item.ViewID) {
+          const v = await md.GetEntityObject<UserViewEntityExtended>('User Views', user);
+          await v.Load(item.ViewID);
+          item.RecordName = v.Name;
+          item.ViewEntity = v;
+        }
         item.Data = r.Data && r.Data.length > 0 ? JSON.parse(r.Data) : item.Data; // parse the stored data if it was saved, otherwise leave it to whatever the object's default is
         item.AdditionalDescription = r.AdditionalDescription;
+        item.DataContextItemID = r.ID;
         dataContext.Items.push(item);
       }
     }
 
-    // now if we don't already have this view in our data context, we will add it
-    if (ViewId && !dataContext.Items.find(i => i.Type === 'view' && i.RecordID === ViewId))
-      dataContext.Items.push(
-        {
-          Type: 'view',
-          RecordID: ViewId,
-          Data: await this.getViewData(ViewId, user),
-        } as SkipDataContextItem
-      );    
+
+    /// TODO   next up we need to modify MJExplorer to handle the data context stuff and then we can finish this method
 
     return {dataContext, convoEntity, dataContextEntity, convoDetailEntity};
   }
@@ -410,7 +449,7 @@ export class AskSkipResolver {
               const item = new SkipDataContextItem();
               item.Type = 'sql';
               item.Data = result;
-              item.RecordName = dr.text;
+              item.SQL = dr.text;
               item.AdditionalDescription = dr.description;
               dataContext.Items.push(item);
               break;
@@ -424,7 +463,7 @@ export class AskSkipResolver {
                   const item = new SkipDataContextItem();
                   item.Type = 'query';
                   item.Data = result.Results;
-                  item.RecordID = query.ID;
+                  item.QueryID = query.ID;
                   item.RecordName = query.Name;
                   item.AdditionalDescription = dr.description;
                   dataContext.Items.push(item);    
@@ -532,9 +571,24 @@ export class AskSkipResolver {
         dciEntity.NewRecord();
       dciEntity.DataContextID = dataContextEntity.ID;
       dciEntity.Type = item.Type;
-      dciEntity.RecordID = item.RecordID;
-      if (item.Type === 'sql')
-        dciEntity.SQL = item.RecordName; // the SQL field in the database is where we store the SQL, in the object model it ends up in the RecordName property, mapping it here
+      switch (item.Type) {
+        case 'full_entity':
+        case 'single_record':
+          const e = item.Entity || md.Entities.find((e) => e.Name === item.EntityName);
+          dciEntity.EntityID = e.ID;
+          if (item.Type === 'single_record')
+            dciEntity.RecordID = item.RecordID;
+          break;
+        case 'view':
+          dciEntity.ViewID = item.ViewID;  
+          break;
+        case 'query':
+          dciEntity.QueryID = item.QueryID;  
+          break;
+        case 'sql':
+          dciEntity.SQL = item.SQL;  
+          break;
+      }
       dciEntity.DataJSON = JSON.stringify(item.Data);
       await dciEntity.Save();
     }