@memberjunction/server 0.9.165 → 0.9.168

package/src/resolvers/AskSkipResolver.ts

@@ -2,7 +2,8 @@ import { Arg, Ctx, Field, Int, ObjectType, PubSub, PubSubEngine, Query, Resolver
 import { LogError, LogStatus, Metadata, RunQuery, RunQueryParams, RunView, UserInfo } from '@memberjunction/core';
 import { AppContext, UserPayload } from '../types';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { SkipDataContext, SkipDataContextItem, SkipAPIRequest, SkipAPIResponse, SkipMessage, SkipAPIAnalysisCompleteResponse, SkipAPIDataRequestResponse, SkipAPIClarifyingQuestionResponse } from '@memberjunction/skip-types';
+import { DataContext, DataContextItem } from '@memberjunction/data-context'
+import { SkipAPIRequest, SkipAPIResponse, SkipMessage, SkipAPIAnalysisCompleteResponse, SkipAPIDataRequestResponse, SkipAPIClarifyingQuestionResponse } from '@memberjunction/skip-types';
 import axios from 'axios';
 import zlib from 'zlib';
 import { promisify } from 'util';
@@ -10,7 +11,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 +65,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 +101,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: DataContext}> {
     const convoEntity = <ConversationEntity>await md.GetEntityObject('Conversations', user);
     let dataContextEntity: DataContextEntity;
 
@@ -121,21 +123,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 +151,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);
     }
 
@@ -156,7 +169,7 @@ export class AskSkipResolver {
     convoDetailEntity.Set('Sequence', 1); // using weakly typed here because we're going to get rid of this field soon
     await convoDetailEntity.Save();
 
-    const dataContext: SkipDataContext = new SkipDataContext();
+    const dataContext: DataContext = new DataContext();
     const dciEntityInfo = md.Entities.find((e) => e.Name === 'Data Context Items');
     if (!dciEntityInfo)
       throw new Error(`Data Context Items entity not found`);
@@ -167,25 +180,52 @@ export class AskSkipResolver {
       throw new Error(`Error running SQL: ${sql}`);
     else {
       for (const r of result) {
-        const item = new SkipDataContextItem();
+        const item = new DataContextItem();
         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};
   }
@@ -247,7 +287,7 @@ export class AskSkipResolver {
   protected async HandleSkipRequest(input: SkipAPIRequest, UserQuestion: string, user: UserInfo, dataSource: DataSource, 
                                     ConversationId: number, userPayload: UserPayload, pubSub: PubSubEngine, md: Metadata, 
                                     convoEntity: ConversationEntity, convoDetailEntity: ConversationDetailEntity,
-                                    dataContext: SkipDataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
+                                    dataContext: DataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
     LogStatus(`Sending request to Skip API: ${___skipAPIurl}`)
 
     // Convert JSON payload to a Buffer and compress it
@@ -331,7 +371,7 @@ export class AskSkipResolver {
 
   protected async HandleAnalysisComplete(apiRequest: SkipAPIRequest, apiResponse: SkipAPIAnalysisCompleteResponse, UserQuestion: string, user: UserInfo, dataSource: DataSource, 
                                          ConversationId: number, userPayload: UserPayload, pubSub: PubSubEngine, convoEntity: ConversationEntity, convoDetailEntity: ConversationDetailEntity,
-                                         dataContext: SkipDataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
+                                         dataContext: DataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
     // analysis is complete
     // all done, wrap things up
     const md = new Metadata();
@@ -383,7 +423,7 @@ export class AskSkipResolver {
 
   protected async HandleDataRequestPhase(apiRequest: SkipAPIRequest, apiResponse: SkipAPIDataRequestResponse, UserQuestion: string, user: UserInfo, dataSource: DataSource, 
                                          ConversationId: number, userPayload: UserPayload, pubSub: PubSubEngine, convoEntity: ConversationEntity, convoDetailEntity: ConversationDetailEntity,
-                                         dataContext: SkipDataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
+                                         dataContext: DataContext, dataContextEntity: DataContextEntity): Promise<AskSkipResultType> {
     // our job in this method is to go through each of the data requests from the Skip API, get the data, and then go back to the Skip API again and to the next phase
     try {  
       const _maxDataGatheringRetries = 5;
@@ -407,10 +447,10 @@ export class AskSkipResolver {
               if (!result) 
                 throw new Error(`Error running SQL: ${sql}`);
   
-              const item = new SkipDataContextItem();
+              const item = new DataContextItem();
               item.Type = 'sql';
               item.Data = result;
-              item.RecordName = dr.text;
+              item.SQL = dr.text;
               item.AdditionalDescription = dr.description;
               dataContext.Items.push(item);
               break;
@@ -421,10 +461,10 @@ export class AskSkipResolver {
                 const rq = new RunQuery();
                 const result = await rq.RunQuery({QueryID: query.ID}, user)  
                 if (result && result.Success) {
-                  const item = new SkipDataContextItem();
+                  const item = new DataContextItem();
                   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);    
@@ -491,7 +531,7 @@ export class AskSkipResolver {
    * @param userPayload 
    * @returns 
    */
-  protected async FinishConversationAndNotifyUser(apiResponse: SkipAPIAnalysisCompleteResponse, dataContext: SkipDataContext, dataContextEntity: DataContextEntity, md: Metadata, user: UserInfo, convoEntity: ConversationEntity, pubSub: PubSubEngine, userPayload: UserPayload): Promise<{AIMessageConversationDetailID: number}> {
+  protected async FinishConversationAndNotifyUser(apiResponse: SkipAPIAnalysisCompleteResponse, dataContext: DataContext, dataContextEntity: DataContextEntity, md: Metadata, user: UserInfo, convoEntity: ConversationEntity, pubSub: PubSubEngine, userPayload: UserPayload): Promise<{AIMessageConversationDetailID: number}> {
     const sTitle = apiResponse.reportTitle; 
     const sResult = JSON.stringify(apiResponse);
 
@@ -532,9 +572,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();
     }