[Components] dixa #15252

Sources
 - New Customer Satisfaction Rating (Instant)
 - New Conversation Status Changed (Instant)
 - New Message Added (Instant)
 - New Tag Added (Instant)

Actions
 - Create Conversation
 - Add Message
 - Set Custom Contact Attributes
 - Tag Conversation

Author: luancazarine

components/dixa/actions/add-message/add-message.mjs

@@ -1,56 +1,65 @@
 import dixa from "../../dixa.app.mjs";
-import { axios } from "@pipedream/platform";
 
 export default {
   key: "dixa-add-message",
   name: "Add Message to Conversation",
-  description: "Adds a message to an existing conversation. [See the documentation]().",
-  version: "0.0.{{ts}}",
+  description: "Adds a message to an existing conversation. [See the documentation](https://docs.dixa.io/openapi/dixa-api/v1/tag/Conversations/#tag/Conversations/operation/postConversationsConversationidMessages).",
+  version: "0.0.1",
   type: "action",
   props: {
     dixa,
-    conversationId: {
+    endUserId: {
       propDefinition: [
         dixa,
-        "conversationId",
+        "endUserId",
       ],
     },
-    attachments: {
+    conversationId: {
       propDefinition: [
         dixa,
-        "attachments",
+        "conversationId",
+        ({ endUserId }) => ({
+          endUserId,
+        }),
       ],
-      optional: true,
     },
     content: {
-      propDefinition: [
-        dixa,
-        "content",
-      ],
-      optional: true,
+      type: "string",
+      label: "Content",
+      description: "Content of the message",
     },
-    externalId: {
+    direction: {
       propDefinition: [
         dixa,
-        "externalId",
+        "direction",
       ],
-      optional: true,
+      reloadProps: true,
     },
-    integrationEmail: {
+    agentId: {
       propDefinition: [
         dixa,
-        "integrationEmail",
+        "agentId",
       ],
-      optional: true,
     },
   },
+  async additionalProps(props) {
+    props.agentId.hidden = !this.direction === "Outbound";
+    return {};
+  },
   async run({ $ }) {
     const response = await this.dixa.addMessage({
+      $,
       conversationId: this.conversationId,
-      attachments: this.attachments,
-      content: this.content,
-      externalId: this.externalId,
-      integrationEmail: this.integrationEmail,
+      data: {
+        content: {
+          agentId: this.direction === "Outbound"
+            ? this.agentId
+            : undefined,
+          value: this.content,
+          _type: "Text",
+        },
+        _type: this.direction,
+      },
     });
     $.export("$summary", `Added message to conversation ${this.conversationId}`);
     return response;

components/dixa/actions/create-conversation/create-conversation.mjs

@@ -1,51 +1,102 @@
 import dixa from "../../dixa.app.mjs";
-import { axios } from "@pipedream/platform";
 
 export default {
   key: "dixa-create-conversation",
   name: "Create Conversation",
-  description: "Creates a new email or contact form-based conversation. [See the documentation](https://docs.dixa.io/openapi).",
-  version: "0.0.{{ts}}",
+  description: "Creates a new email or contact form-based conversation. [See the documentation](https://docs.dixa.io/openapi/dixa-api/v1/tag/Conversations/#tag/Conversations/operation/postConversations).",
+  version: "0.0.1",
   type: "action",
   props: {
-    dixa: {
-      type: "app",
-      app: "dixa",
+    dixa,
+    requesterId: {
+      propDefinition: [
+        dixa,
+        "endUserId",
+      ],
+      label: "Requester Id",
     },
-    subject: {
+    direction: {
       propDefinition: [
-        "dixa",
-        "subject",
+        dixa,
+        "direction",
+      ],
+      reloadProps: true,
+    },
+    channel: {
+      type: "string",
+      label: "Channel",
+      description: "For outbound, only Email is supported. Inbound also supports ContactForm.",
+      options: [
+        "Email",
+        "ContactForm",
       ],
     },
     emailIntegrationId: {
       propDefinition: [
-        "dixa",
+        dixa,
         "emailIntegrationId",
       ],
     },
-    messageType: {
+    subject: {
       propDefinition: [
-        "dixa",
-        "messageType",
+        dixa,
+        "subject",
       ],
     },
+    message: {
+      type: "string",
+      label: "Message",
+      description: "The content message.",
+    },
     language: {
       propDefinition: [
-        "dixa",
+        dixa,
         "language",
       ],
       optional: true,
     },
+    agentId: {
+      propDefinition: [
+        dixa,
+        "agentId",
+      ],
+      optional: true,
+    },
+  },
+  async additionalProps(props) {
+    props.agentId.hidden = !this.direction === "Outbound";
+    props.channel.options = this.direction === "Outbound"
+      ? [
+        "Email",
+      ]
+      : [
+        "ContactForm",
+        "Email",
+      ];
+    return {};
   },
   async run({ $ }) {
     const response = await this.dixa.createConversation({
-      subject: this.subject,
-      emailIntegrationId: this.emailIntegrationId,
-      messageType: this.messageType,
-      language: this.language,
+      $,
+      data: {
+        subject: this.subject,
+        emailIntegrationId: this.emailIntegrationId,
+        language: this.language,
+        requesterId: this.requesterId,
+        message: {
+          agentId: this.direction === "Outbound"
+            ? this.agentId
+            : undefined,
+          content: {
+            _type: "Text",
+            value: this.message,
+          },
+          _type: this.direction,
+        },
+        _type: this.channel,
+      },
     });
-    $.export("$summary", `Created conversation with subject: ${response.subject} and ID: ${response.id}`);
+    $.export("$summary", `Created conversation with Id: ${response.data.id}`);
     return response;
   },
 };

components/dixa/actions/set-custom-contact-attributes/set-custom-contact-attributes.mjs

@@ -1,32 +1,96 @@
 import dixa from "../../dixa.app.mjs";
-import { axios } from "@pipedream/platform";
 
 export default {
   key: "dixa-set-custom-contact-attributes",
   name: "Set Custom Contact Attributes",
   description: "Updates custom attributes for a specified user. [See the documentation]()",
-  version: "0.0.{{ts}}",
+  version: "0.0.1",
   type: "action",
   props: {
     dixa,
     userId: {
       propDefinition: [
         dixa,
-        "userId",
+        "endUserId",
       ],
+      reloadProps: true,
     },
-    attributes: {
-      propDefinition: [
-        dixa,
-        "attributes",
-      ],
-      optional: true,
+  },
+  async additionalProps() {
+    const props = {};
+    const { data } = await this.dixa.listCustomAttributes();
+
+    for (const item of data) {
+      if (item.isDeactivated || item.isArchived || item.entityType != "Contact") continue;
+
+      props[item.id] = {
+        type: "string",
+        label: item.label,
+        description: item.description,
+        optional: !item.isRequired,
+        default: item.inputDefinition.placeholder,
+      };
+
+      if (item.inputDefinition._type === "Select") {
+        props[item.id].options = this.prepareOptions(item.inputDefinition.options);
+      }
+    }
+    return props;
+  },
+  methods: {
+    prepareOptions(options, parentVal = "", parentLabel = "") {
+      const newOptions = [];
+
+      for (const opt of options) {
+        const newLabel = parentLabel
+          ? `${parentLabel} - ${opt.label}`
+          : opt.label;
+
+        const newVal = parentVal
+          ? `${parentVal}/${opt.value}`
+          : opt.value;
+
+        if (opt.nestedOptions.length) {
+          newOptions.push(...this.prepareOptions(opt.nestedOptions, newVal, newLabel));
+        } else {
+          newOptions.push({
+            label: newLabel,
+            value: newVal,
+          });
+        }
+      }
+      return newOptions;
+    },
+    async prepareData(data) {
+      const response = {};
+      const { data: customAttributes } = await this.dixa.listCustomAttributes();
+      Object.entries(data).map(([
+        key,
+        val,
+      ]) => {
+        const customAttribute = customAttributes.find((attr) => attr.id === key);
+
+        response[key] = customAttribute.inputDefinition._type != "Text"
+          ? val.split("/")
+          : val;
+      });
+      return response;
     },
   },
   async run({ $ }) {
-    const response = await this.dixa.updateCustomAttributes({
-      userId: this.userId,
-      attributes: this.attributes,
+    const {
+      dixa,
+      // eslint-disable-next-line no-unused-vars
+      prepareOptions,
+      prepareData,
+      userId,
+      ...data
+    } = this;
+
+    const response = await dixa.updateCustomAttributes({
+      $,
+      userId,
+      data: await prepareData(data),
     });
     $.export("$summary", `Updated custom attributes for user ${this.userId}`);
     return response;

components/dixa/actions/tag-conversation/tag-conversation.mjs

@@ -1,21 +1,26 @@
 import dixa from "../../dixa.app.mjs";
-import { axios } from "@pipedream/platform";
 
 export default {
   key: "dixa-tag-conversation",
   name: "Add Tag to Conversation",
-  description: "Adds a tag to a conversation. [See the documentation]()",
-  version: "0.0.{{ts}}",
+  description: "Adds a tag to a conversation. [See the documentation](https://docs.dixa.io/openapi/dixa-api/v1/tag/Tags/#tag/Tags/operation/putConversationsConversationidTagsTagid)",
+  version: "0.0.1",
   type: "action",
   props: {
-    dixa: {
-      type: "app",
-      app: "dixa",
+    dixa,
+    endUserId: {
+      propDefinition: [
+        dixa,
+        "endUserId",
+      ],
     },
     conversationId: {
       propDefinition: [
         dixa,
         "conversationId",
+        ({ endUserId }) => ({
+          endUserId,
+        }),
       ],
     },
     tagId: {
@@ -27,6 +32,7 @@ export default {
   },
   async run({ $ }) {
     const response = await this.dixa.addTag({
+      $,
       conversationId: this.conversationId,
       tagId: this.tagId,
     });

components/dixa/common/utils.mjs

@@ -0,0 +1,24 @@
+export const parseObject = (obj) => {
+  if (!obj) return undefined;
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (typeof item === "string") {
+        try {
+          return JSON.parse(item);
+        } catch (e) {
+          return item;
+        }
+      }
+      return item;
+    });
+  }
+  if (typeof obj === "string") {
+    try {
+      return JSON.parse(obj);
+    } catch (e) {
+      return obj;
+    }
+  }
+  return obj;
+};