@telia-ace/knowledge-widget-bot-provider 0.0.1-alpha.1 → 0.0.1-alpha.4

package/lib/interface/entry.interface.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var widget_conversation_1 = require("@telia-ace/widget-conversation");
+var server_entry_type_enum_1 = require("../contract/enum/server-entry-type.enum");
+var store_helper_1 = require("../helper/store.helper");
+var EntryInterface = /** @class */ (function () {
+    function EntryInterface() {
+        this.helpActionKey = 'help';
+        this.nextActionKey = 'next';
+    }
+    // transform the entry based on its type
+    EntryInterface.prototype.transform = function (entry) {
+        var entryType = server_entry_type_enum_1.ServerEntryTypeEnum[entry.type];
+        switch (entryType) {
+            case server_entry_type_enum_1.ServerEntryTypeEnum.List:
+                return {
+                    id: entry.id,
+                    message: this.listTransform(entry),
+                    entry: entry,
+                    isUser: false,
+                };
+            case server_entry_type_enum_1.ServerEntryTypeEnum.Text:
+                return {
+                    id: entry.id,
+                    message: this.textTransform(entry),
+                    entry: entry,
+                    isUser: false,
+                };
+            case server_entry_type_enum_1.ServerEntryTypeEnum.Text:
+                return {
+                    id: entry.id,
+                    message: this.listTransform(entry),
+                    entry: entry,
+                    isUser: false,
+                };
+        }
+    };
+    // transform an array of entries
+    EntryInterface.prototype.transformArray = function (entryArray) {
+        var _this = this;
+        var returnArray = [];
+        entryArray.forEach(function (o) {
+            var x = _this.transform(o);
+            if (!!x)
+                returnArray.push(x);
+        });
+        return returnArray;
+    };
+    // gets the text that should be printed as a user message on action
+    EntryInterface.prototype.getUserMessage = function (action) {
+        var entry = store_helper_1.StoreHelper.getEntry(action);
+        return this.getTitleFromEntry(entry, action);
+    };
+    EntryInterface.prototype.listTransform = function (entry) {
+        if (!entry.content)
+            return undefined;
+        var object = this.getListActions(entry.content.items, this.getContentText(entry), entry.actions, entry.localState);
+        return object;
+    };
+    EntryInterface.prototype.getContentText = function (entry) {
+        if (entry.content.html)
+            return { body: entry.content.html };
+        if (entry.content.header)
+            return { title: entry.content.header };
+    };
+    EntryInterface.prototype.textTransform = function (entry) {
+        if (!!entry.content.items)
+            return this.listTransform(entry);
+        return [
+            widget_conversation_1.ConversationMessageListItemType.HTML,
+            { body: entry.content.html.replace('\n', '') },
+        ];
+    };
+    EntryInterface.prototype.getListActions = function (items, text, actions, state) {
+        var _this = this;
+        var list = [];
+        var mainListContent = {};
+        var mainList = [
+            this.getListType(state),
+            { actions: mainListContent },
+        ];
+        if (text && text.title) {
+            list.push([widget_conversation_1.ConversationMessageListItemType.Header, text.title]);
+        }
+        if (text && text.body) {
+            list.push([widget_conversation_1.ConversationMessageListItemType.HTML, { body: text.body }]);
+        }
+        list.push(mainList);
+        items.forEach(function (o) {
+            switch (o.actionKey) {
+                case _this.helpActionKey: {
+                    list.push([widget_conversation_1.ConversationMessageListItemType.Separator, undefined]);
+                    list.push([
+                        widget_conversation_1.ConversationMessageListItemType.NoGoodAlternative,
+                        { body: o.title },
+                    ]);
+                    break;
+                }
+                case _this.nextActionKey: {
+                    if (!!actions['next'] && actions['next'].take === items.length + 1)
+                        mainListContent[o.actionKey] = o.title;
+                    // console.log(actions['next'], actions['next'].take, items.length, items.length - 2)
+                    break;
+                }
+                default: {
+                    mainListContent[o.actionKey] = o.title;
+                    // mainListContent.push(this.getItemObject(o))
+                }
+            }
+        });
+        return list;
+    };
+    EntryInterface.prototype.getListType = function (state) {
+        if ((state === null || state === void 0 ? void 0 : state.$type) === 'Humany.Matching.Bots.Conversations.GuideListState, Humany.Matching')
+            return widget_conversation_1.ConversationMessageListItemType.LinkList;
+        else if ((state === null || state === void 0 ? void 0 : state.$type) ===
+            'Humany.Matching.Bots.Conversations.States.GuideFeedbackState, Humany.Matching')
+            return widget_conversation_1.ConversationMessageListItemType.FeedbackList;
+        else
+            return widget_conversation_1.ConversationMessageListItemType.ButtonList;
+    };
+    EntryInterface.prototype.getTitleFromEntry = function (entry, action) {
+        if (!!entry) {
+            var entryType = server_entry_type_enum_1.ServerEntryTypeEnum[entry.type];
+            switch (entryType) {
+                case server_entry_type_enum_1.ServerEntryTypeEnum.List:
+                    return this.getTitleFromList(entry, action);
+                case server_entry_type_enum_1.ServerEntryTypeEnum.Text:
+                    return this.textTransform(entry);
+            }
+        }
+    };
+    EntryInterface.prototype.getTitleFromList = function (entry, action) {
+        return entry.content.items.find(function (o) { return o.actionKey == action; }).title;
+    };
+    return EntryInterface;
+}());
+exports.default = EntryInterface;

package/lib/interface/middleware/contact-expanded.interface.js

@@ -0,0 +1,50 @@
+"use strict";
+// import { convertToStringAttributes } from "@humany/widget-ui";
+// import { ServerEntry } from "../../contract/model/http/server-entry.model";
+// import { StoreHelper } from "../../helper/store.helper";
+// export default class ContactExpandedInterface {
+//   name = "contact-expanded-handler";
+//   constructor() {}
+//   process(entries: ServerEntry[], action?: string): ServerEntry[] {
+//     let didSelect = false;
+//     let didCategorySelect = false;
+//     if (!action) return entries;
+//     const entry = StoreHelper.getEntry(action);
+//     if (
+//       entry.actions &&
+//       entry.actions[action] &&
+//       entry.actions[action].$type.indexOf("SelectContactMethod") !== -1
+//     ) {
+//       didSelect = true;
+//     }
+//     if (
+//       entry.actions &&
+//       entry.actions[action] &&
+//       entry.actions[action].$type.indexOf("SelectContactCategory") !== -1
+//     ) {
+//       didCategorySelect = true;
+//     }
+//     entries
+//       .filter(
+//         (e) =>
+//           e.type === "Contact" ||
+//           (e.type === "List" &&
+//             e.tags.indexOf("contact") > -1 &&
+//             e.tags.indexOf("category") === -1)
+//       ).forEach((e) => {
+//         if (e.type === "List") {
+//           if (e.content && e.content.items && e.content.items.length === 1) {
+//             const item = e.content.items[0];
+//             const hasForm = !!item && !!item.body && !!item.body.form;
+//             if (hasForm) {
+//               e.content.items[0].inline = !didCategorySelect;
+//               if (didSelect) {
+//                 e.content.items[0].expanded = true;
+//               }
+//             }
+//           }
+//         }
+//       });
+//     return entries;
+//   }
+// }

package/lib/interface/middleware/legacy-contact-methods.interface.js

@@ -0,0 +1,394 @@
+"use strict";
+// import { Container } from "@webprovisions/platform";
+// import { ServerEntry } from "../../contract/model/http/server-entry.model";
+// import { MiddlewareHelper } from "../../helper/middleware.helper";
+// export const mapContactMethodType = (cm: any): string => {
+//   const a = cm.exitConfiguration.split(".");
+//   if (a.indexOf("phone") > -1) {
+//     return "phone";
+//   }
+//   if (a.indexOf("freetext") > -1) {
+//     return "free-text";
+//   }
+//   if (a.indexOf("email") > -1) {
+//     return "email";
+//   }
+//   if (a.indexOf("link") > -1) {
+//     return "link";
+//   }
+//   if (a.indexOf("custom") > -1 && a.indexOf("adapter") > -1) {
+//     return "custom-adapter";
+//   }
+//   if (a.indexOf("chat") > -1) {
+//     return "chat";
+//   }
+//   if (a.indexOf("callback") > -1) {
+//     return "callback";
+//   }
+//   return "";
+// };
+// const fetchContactMethods = (
+//   matchingServiceClient: ServiceClient,
+//   guideId: string,
+//   connectionKey: string
+// ): any => {
+//   return new Promise((resolve) => {
+//     if (guideId) {
+//       matchingServiceClient.getGuide(
+//         guideId,
+//         connectionKey,
+//         { statisticsDisabled: true },
+//         (guide: GuideViewApiResponse) => {
+//           const contactMethods = [guide.ContactMethod].concat(
+//             guide.ContactMethods ? guide.ContactMethods : []
+//           );
+//           resolve(contactMethods);
+//         }
+//       );
+//     } else {
+//       matchingServiceClient.contactMethods((contactMethods: any) => {
+//         resolve(contactMethods.Matches);
+//       });
+//     }
+//   });
+// };
+// export const mapContactMethod = (
+//   match: any,
+//   contactMethods: ContactMethodPlatform,
+//   entryId?: string,
+//   actionKey?: string
+// ) => {
+//   const adapter = match.exits[0].adapter;
+//   const clientName = adapter.customClientName || adapter.clientName;
+//   // const contactMethodType =
+//   //   contactMethods.get(clientName) || <ContactMethodType>{};
+//   const contactMethod: any = {
+//     entryId,
+//     actionKey,
+//     clientName,
+//     canRender: true,
+//     id: `${match.id}`,
+//     title: match.title,
+//     body: adapter.settings,
+//     type: mapContactMethodType(match),
+//     description:
+//       match.description && match.description.length
+//         ? match.description
+//         : undefined,
+//     expanded: false,
+//     inline: true,
+//     uriName: match.uriName,
+//   };
+//   if (
+//     match.defaultIcon &&
+//     match.defaultIcon.content &&
+//     match.defaultIcon.type
+//   ) {
+//     contactMethod.symbol = {
+//       type: match.defaultIcon.type,
+//       content: match.defaultIcon.content,
+//     };
+//   }
+//   const hasForm =
+//     match.form &&
+//     (match.form.hasValueComponents || match.form.HasValueComponents);
+//   if (hasForm) {
+//     const formId = contactMethod.id || "";
+//     const builder = FormBuilder.fromLegacyForm(formId, match.form, null);
+//     // builder.createComponent(submitButton(texts.get("forms.submit"), "submit"));
+//     contactMethod.body.form = builder.get();
+//     contactMethod.inline = false;
+//     if (match.expandFormAutomatically) {
+//       contactMethod.expanded = true;
+//       contactMethod.inline = true;
+//     }
+//   }
+//   if (contactMethod.type === "free-text" || contactMethod.type === "phone") {
+//     contactMethod.expanded =
+//       contactMethod.body.displayTextBeforeClick === "false";
+//   }
+//   if (contactMethod.type === "link") {
+//     contactMethod.expanded = true;
+//   }
+//   if (match.exitConfiguration === "custom.adapter") {
+//     if (hasForm) {
+//       contactMethod.inline = false;
+//     } else {
+//       contactMethod.expanded = true;
+//     }
+//   }
+//   return contactMethod;
+// };
+// // Displays confirmation text after contact method form has been submitted
+// // const respondContactMethodSubmitted = (
+// //   dataSource: DataSource,
+// //   data: { entryId: string; confirmationText: string; type: string },
+// // ) => {
+// //   dataSource.respond(data.entryId, data.type, {
+// //     completedMessage: data.confirmationText,
+// //   });
+// // };
+// const modifyActionsForExpandedItems = (entry: ServerEntry) => {
+//   const keysToModify = entry.content.items
+//     .filter((item: any) => {
+//       if (!item.data) {
+//         return false;
+//       }
+//       return item.data.expandFormAutomatically;
+//     })
+//     .map((item: any) => item.actionKey);
+//   return Object.keys(entry.actions).reduce<any>((acc, actionKey: any) => {
+//     const action = entry.actions[actionKey];
+//     if (keysToModify.indexOf(actionKey) > -1) {
+//       acc[actionKey] = {
+//         ...action,
+//         $type:
+//           "Humany.Matching.Bots.Conversations.Actions.ContactMethodCompleted, Humany.Matching",
+//       };
+//     } else {
+//       acc[actionKey] = action;
+//     }
+//     return acc;
+//   }, {});
+// };
+// const storeLegacyContactMethod = (container: any, legacyContactMethod: any) => {
+//   return lock(container)(() => {
+//     return container.getAsync("storage").then((storage: StorageProvider) => {
+//       return storage.session
+//         .getItem("legacyContactMethods")
+//         .then((legacyContactMethods) => {
+//           return legacyContactMethods || container.get("legacyContactMethods");
+//         })
+//         .then((legacyContactMethods) => {
+//           let legacyContactMethodsToStore = legacyContactMethods;
+//           if (!legacyContactMethodsToStore) {
+//             legacyContactMethodsToStore = {};
+//             container.register(
+//               "legacyContactMethods",
+//               legacyContactMethodsToStore
+//             );
+//           }
+//           legacyContactMethodsToStore[legacyContactMethod.id] = {
+//             entity: legacyContactMethod,
+//           };
+//           return storage.session.setItem(
+//             "legacyContactMethods",
+//             legacyContactMethods
+//           );
+//         });
+//     });
+//   });
+// };
+// class ContactMethodResolver {
+//   cache: Map<string, Promise<any>> = new Map<string, Promise<any>>();
+//   constructor(
+//     private matchingClient: ServiceClient,
+//     private container: any,
+//     private contactMethods: ContactMethodPlatform
+//   ) {}
+//   add(content: any, entryId: string) {
+//     const { id, guideId, connectionKey } = content;
+//     const key = (guideId || "") + (connectionKey || "") || "all";
+//     let promise = this.cache.get(key);
+//     if (promise) {
+//       promise.then((contactMethodEntity) => {
+//         Object.assign(
+//           content,
+//           mapContactMethod(
+//             contactMethodEntity,
+//             this.contactMethods,
+//             entryId
+//           )
+//         );
+//       });
+//     } else {
+//       promise = <Promise<any>>fetchContactMethods(
+//         this.matchingClient,
+//         guideId,
+//         connectionKey
+//       )
+//         .then((contactMethodEntites: any) => {
+//           const contactMethodEntity = contactMethodEntites.find(
+//             (entity: any) => entity.Id === id
+//           );
+//           const { Form } = contactMethodEntity;
+//           return Object.assign({}, camilize(contactMethodEntity), {
+//             form: Form,
+//           });
+//         })
+//         .then((contactMethodEntity: any) => {
+//           storeLegacyContactMethod(this.container, contactMethodEntity);
+//           Object.assign(
+//             content,
+//             mapContactMethod(
+//               contactMethodEntity,
+//               this.contactMethods,
+//               entryId
+//             )
+//           );
+//           return contactMethodEntity;
+//         });
+//       this.cache.set(key, promise);
+//     }
+//   }
+//   wait(): Promise<any> {
+//     return Promise.all(Array.from(this.cache.values()));
+//   }
+// }
+// export default class ContactInterface {
+//   name = "contact";
+//   private container: Container;
+//   constructor() {
+//     this.initalize();
+//     this.container = <Container>MiddlewareHelper.getContainer();
+//   }
+//   process(entries: ServerEntry[]): Promise<ServerEntry[]> {
+//     return Promise.all([
+//       <Promise<ContactMethodPlatform>>this.container.getAsync("contactMethods"),
+//       <Promise<ServiceClient>>this.container.getAsync("matchingClient")
+//     ])
+//       .then(result => {
+//         let contactMethods = result[0];
+//         let matchingClient = result[1];
+//         // remove Text entries without text or html props.
+//         const updatedEntries = entries.filter(
+//           (entry) =>
+//             !(
+//               entry.type === "Text" &&
+//               entry.content &&
+//               !entry.content.text &&
+//               !entry.content.html
+//             )
+//         );
+//         const resolver = new ContactMethodResolver(
+//           matchingClient,
+//           this.container,
+//           contactMethods
+//         );
+//         // get all contact method lists
+//         const lists = updatedEntries.filter(
+//           (entry) => entry.type === "List" && entry.tags.indexOf("contact") > -1
+//         );
+//         // iterate and patch legacy items by mapping the 'data' attribute
+//         lists.forEach((entry) => {
+//           if (entry.content.items) {
+//             // if the list contains already expanded contact methods,
+//             // we do not want to use the action type ContactMethodCompleted
+//             // instead of ContactMethodSelected
+//             entry.actions = modifyActionsForExpandedItems(entry);
+//             entry.content.items.forEach((item: any) => {
+//               if (item.data) {
+//                 storeLegacyContactMethod(this.container, item.data);
+//                 Object.assign(
+//                   item,
+//                   mapContactMethod(
+//                     item.data,
+//                     contactMethods,
+//                     entry.id,
+//                     item.actionKey
+//                   )
+//                 );
+//                 delete item.data;
+//               }
+//             });
+//           }
+//         });
+//         // get all single contact methods
+//         const singles = updatedEntries.filter(
+//           (entry) =>
+//             entry.type === "Contact" &&
+//             entry.content.id &&
+//             !entry.content.clientName
+//         );
+//         singles.forEach((entry) => resolver.add(entry.content, entry.id));
+//         return resolver.wait().then(() => {
+//           // patch with ContactMethodType
+//           updatedEntries
+//             .filter(
+//               (entry) =>
+//                 entry.type === "Contact" &&
+//                 entry.content &&
+//                 !entry.content.contactMethodType
+//             )
+//             .forEach((entry) => {
+//               // // const contactMethodType =
+//               // //   contactMethods.get(entry.content.clientName) ||
+//               // //   <ContactMethodType>{};
+//               entry.content.canRender = true;
+//             });
+//           updatedEntries
+//             .filter((entry) => entry.type === "Contact")
+//             .forEach((entry) => {
+//               entry.type = "List";
+//               const { timestamp, ...content } = entry.content;
+//               entry.content = { timestamp, items: [{ ...content }] };
+//               if (entry.tags.indexOf("contact") === -1) {
+//                 entry.tags.push("contact");
+//               }
+//             });
+//           return entries;
+//         });
+//       });
+//   }
+//   initalize() {
+//     // this.widget.events.subscribe(
+//     //   'contact-method:invoked',
+//     //   async (event, data) => {
+//     //     const { method, contactMethod, result } = data;
+//     //     const { entryId } = contactMethod;
+//     //     // TODO: Currently we need to look up the contact method entry in the full "unwashed"
+//     //     // stream as it does not exist in the "regular" washed stream.
+//     //     // This should be handled differently by perhaps storing a reference in
+//     //     // the parent entity to the contact method entry in some way.
+//     //     const entry = StoreHelper.getEntryStore()
+//     //       .find(e => e.id === entryId);
+//     //     if (method === 'submit' && result.success && !result.preventResponse) {
+//     //       let actionType = 'submitted';
+//     //       if (
+//     //         entry &&
+//     //         entry.actions &&
+//     //         Object.keys(entry.actions).length >= 1 &&
+//     //         !entry.actions.submitted
+//     //       ) {
+//     //         const item = entry.content.items
+//     //           .find((item: any) => item.id === contactMethod.id);
+//     //         if (item && item.actionKey && entry.actions[item.actionKey]) {
+//     //           actionType = item.actionKey;
+//     //         }
+//     //       }
+//     //       // respondContactMethodSubmitted(dataSource, {
+//     //       //   entryId,
+//     //       //   type: actionType,
+//     //       //   confirmationText: result.confirmationText,
+//     //       // });
+//     //       if (entry) {
+//     //         // Disable form
+//     //         const item = entry.content.items
+//     //           .find((item: any) => item.id === contactMethod.id);
+//     //         if (item && item.body && item.body.form) {
+//     //           item.body.form.layout['ui:disabled'] = true;
+//     //         }
+//     //       }
+//     //     }
+//     //     if (entry) {
+//     //       if (entry.type === 'List') {
+//     //         const updatedItems = entry.content.items.map((item: any) => {
+//     //           if (item.id === contactMethod.id) {
+//     //             return contactMethod;
+//     //           }
+//     //           return item;
+//     //         });
+//     //         writer.update(entryId, { items: updatedItems });
+//     //         writer.commit();
+//     //       } else if (
+//     //         entry.type === 'ContactMethod' ||
+//     //         entry.type === 'Contact'
+//     //       ) {
+//     //         writer.update(contactMethod.entryId, contactMethod);
+//     //         writer.commit();
+//     //       }
+//     //     }
+//     //   },
+//     // );
+//   }
+// }

package/lib/interface/middleware/paging.interface.d.ts

@@ -0,0 +1,4 @@
+import { ServerEntry } from "../../contract/model/http/server-entry.model";
+export default class PagingInterface {
+    process(entries: ServerEntry[]): ServerEntry[];
+}

package/lib/interface/middleware/paging.interface.js

@@ -0,0 +1,55 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var store_helper_1 = require("../../helper/store.helper");
+var PagingInterface = /** @class */ (function () {
+    function PagingInterface() {
+    }
+    PagingInterface.prototype.process = function (entries) {
+        var pagingEntry = entries.find(function (e) { return e.tags.indexOf("paging") > -1; });
+        if (pagingEntry) {
+            var stream = store_helper_1.StoreHelper.getEntryStore().filter(function (e) { return e.tags.indexOf("paging") > -1 && e.id === pagingEntry.id; });
+            if (stream.length > 0) {
+                // Get the paging entry with the highest take count
+                var last_1 = stream.reduce(function (acc, entry) {
+                    if (entry.actions.next &&
+                        entry.actions.next.take >= acc.actions.next.take) {
+                        return entry;
+                    }
+                    return acc;
+                }, stream[0]); // tslint:disable-line:align
+                // If there is a paging entry with higher take count than the entry to be written,
+                // it should be updated to use the paging data from the highest take count entry
+                if (last_1.actions.next.take > pagingEntry.actions.next.take) {
+                    entries.forEach(function (entry) {
+                        if (entry.id === pagingEntry.id) {
+                            entry.actions.next = __assign(__assign({}, entry.actions.next), { take: last_1.actions.next.take, skip: last_1.actions.next.skip });
+                        }
+                    });
+                }
+            }
+            // if items is null or undefined it should
+            // overwrite with an empty array
+            entries.forEach(function (entry) {
+                if (entry.id === pagingEntry.id &&
+                    entry.content &&
+                    entry.content.timestamp) {
+                    entry.content = __assign(__assign({}, entry.content), { items: (entry.content && entry.content.items) || [] });
+                }
+            });
+        }
+        return entries;
+    };
+    return PagingInterface;
+}());
+exports.default = PagingInterface;

package/lib/interface/middleware/processor.interface.d.ts

@@ -0,0 +1,10 @@
+import { ServerEntry } from '../../contract/model/http/server-entry.model';
+export default class ProcessorInterface {
+    process(entries: ServerEntry[]): ServerEntry[];
+    processUpdate(entry: ServerEntry | undefined, updateEntryArray: ServerEntry[]): ServerEntry[];
+    private handleActionUpdateOrInsert;
+    private deletePaging;
+    private delete;
+    private merge;
+    private moveLoader;
+}