@botonic/plugin-flow-builder 0.46.2 → 2.23.0

package/src/content-fields/flow-queue-status-conditional.tsx

@@ -1,130 +0,0 @@
-import { EventAction, type EventConditionalQueueStatus } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import { getArgumentsByLocale } from '../functions'
-import { HubtypeQueuesApi } from '../services/hubtype-queues-api'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type {
-  HtFunctionArguments,
-  HtFunctionResult,
-} from './hubtype-fields/function'
-import type {
-  HtQueueStatusConditionalNode,
-  HtQueueStatusConditionalResultMapping,
-} from './hubtype-fields/queue-status-conditional'
-
-enum QueueStatusResult {
-  OPEN = 'open',
-  CLOSED = 'closed',
-  OPEN_WITHOUT_AGENTS = 'open-without-agents',
-}
-
-type ConditionalQueueStatusArgs = {
-  queueId: string
-  queueName: string
-  checkAvailableAgents: boolean
-}
-
-export class FlowQueueStatusConditional extends ContentFieldsBase {
-  public arguments: HtFunctionArguments[] = []
-  public resultMapping: HtQueueStatusConditionalResultMapping
-  public conditionalResult?: HtFunctionResult
-  public queueId: string = ''
-  public queueName: string = ''
-  public isQueueOpen: boolean = false
-  public isAvailableAgent: boolean = false
-
-  static async fromHubtypeCMS(
-    component: HtQueueStatusConditionalNode,
-    locale: string
-  ): Promise<FlowQueueStatusConditional> {
-    const newChannelConditional = new FlowQueueStatusConditional(component.id)
-    newChannelConditional.code = component.code
-    newChannelConditional.arguments = component.content.arguments
-    newChannelConditional.resultMapping = component.content
-      .result_mapping as HtQueueStatusConditionalResultMapping
-    await newChannelConditional.setConditionalResult(locale)
-
-    return newChannelConditional
-  }
-
-  async setConditionalResult(locale: string): Promise<void> {
-    const args = getArgumentsByLocale(this.arguments, locale)
-
-    const queueId = args.find(arg => arg.name === 'queue_id')?.value || ''
-    const queueName = args.find(arg => arg.name === 'queue_name')?.value || ''
-    const checkAvailableAgents =
-      (args.find(arg => arg.name === 'check_available_agents')
-        ?.value as unknown as boolean) || false
-
-    const queueStatus = await this.conditionalQueueStatus({
-      queueId,
-      queueName,
-      checkAvailableAgents,
-    })
-
-    const conditionalResult = this.resultMapping.find(
-      rMap => rMap.result === queueStatus
-    )
-
-    if (!conditionalResult) {
-      throw new Error(
-        `No conditional result found for node ${this.code} with queue: ${queueName}`
-      )
-    }
-    this.conditionalResult = conditionalResult
-    this.followUp = conditionalResult.target
-  }
-
-  async conditionalQueueStatus({
-    queueId,
-    checkAvailableAgents,
-    queueName,
-  }: ConditionalQueueStatusArgs): Promise<QueueStatusResult> {
-    const queuesApi = new HubtypeQueuesApi(queueId, checkAvailableAgents)
-    const data = await queuesApi.getAvailability()
-    this.queueId = queueId
-    this.queueName = queueName
-    this.isQueueOpen = data.open
-    this.isAvailableAgent = data.available_agents > 0
-
-    if (checkAvailableAgents && data.open && data.available_agents === 0) {
-      return QueueStatusResult.OPEN_WITHOUT_AGENTS
-    }
-
-    return data.open ? QueueStatusResult.OPEN : QueueStatusResult.CLOSED
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-    if (!this.conditionalResult?.result) {
-      console.warn(
-        `Tracking event for node ${this.code} but no conditional result found`
-      )
-    }
-    const eventQueueStatusConditional: EventConditionalQueueStatus = {
-      action: EventAction.ConditionalQueueStatus,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      queueId: this.queueId,
-      queueName: this.queueName,
-      isQueueOpen: this.isQueueOpen,
-      isAvailableAgent: this.isAvailableAgent,
-    }
-    const { action, ...eventArgs } = eventQueueStatusConditional
-    await trackEvent(request, action, eventArgs)
-  }
-
-  toBotonic(): JSX.Element {
-    return <></>
-  }
-}

package/src/content-fields/flow-rating.tsx

@@ -1,99 +0,0 @@
-import { isDev, isWebchat, isWhatsapp } from '@botonic/core'
-import {
-  type ActionRequest,
-  CustomRatingMessage,
-  Text,
-  WhatsappButtonList,
-} from '@botonic/react'
-
-import { getFlowBuilderPlugin } from '../helpers'
-import { trackOneContent } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import { FlowButton } from './flow-button'
-import { type HtRatingNode, RatingType } from './hubtype-fields'
-
-export class FlowRating extends ContentFieldsBase {
-  public text = ''
-  public sendButtonText = ''
-  public ratingType = RatingType.Stars
-  public buttons: FlowButton[] = []
-  public openListButtonText = ''
-
-  static fromHubtypeCMS(cmsText: HtRatingNode, locale: string): FlowRating {
-    const newRating = new FlowRating(cmsText.id)
-    newRating.code = cmsText.code
-    newRating.text = FlowRating.getTextByLocale(locale, cmsText.content.text)
-    newRating.sendButtonText = FlowRating.getTextByLocale(
-      locale,
-      cmsText.content.send_button_text
-    )
-    newRating.ratingType = cmsText.content.rating_type
-    newRating.buttons = cmsText.content.buttons.map(button =>
-      FlowButton.fromRating(button)
-    )
-    newRating.openListButtonText = FlowRating.getTextByLocale(
-      locale,
-      cmsText.content.open_list_button_text
-    )
-    newRating.followUp = cmsText.follow_up
-
-    return newRating
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    await trackOneContent(request, this)
-  }
-
-  toBotonic(id: string, request: ActionRequest): JSX.Element {
-    const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-    const customRatingMessageEnabled =
-      flowBuilderPlugin.customRatingMessageEnabled
-    const replacedText = this.replaceVariables(this.text, request)
-
-    if (isWhatsapp(request.session)) {
-      return (
-        <WhatsappButtonList
-          body={replacedText}
-          button={this.openListButtonText}
-          sections={[
-            {
-              rows: this.buttons.map(button => ({
-                id: button.payload as string,
-                title: button.text,
-              })),
-            },
-          ]}
-        />
-      )
-    }
-
-    if (
-      (isWebchat(request.session) || isDev(request.session)) &&
-      customRatingMessageEnabled
-    ) {
-      const payloads = this.buttons
-        .map(button => button.payload)
-        .slice()
-        .reverse()
-
-      return (
-        <CustomRatingMessage
-          alt={replacedText}
-          payloads={payloads}
-          messageText={replacedText}
-          buttonText={this.sendButtonText}
-          ratingType={this.ratingType}
-        />
-      )
-    }
-
-    return (
-      <Text key={id}>
-        {replacedText}
-        {this.buttons.map((button, buttonIndex) =>
-          button.renderButton(buttonIndex)
-        )}
-      </Text>
-    )
-  }
-}

package/src/content-fields/flow-text.tsx

@@ -1,82 +0,0 @@
-import type {
-  BotExecutorMessage,
-  TextMessage,
-  TextWithButtonsMessage,
-} from '@botonic/core'
-import { type ActionRequest, Text } from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import { EMPTY_PAYLOAD, SOURCE_INFO_SEPARATOR } from '../constants'
-import { trackOneContent } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import { FlowButton } from './flow-button'
-import { HtButtonStyle, type HtTextNode } from './hubtype-fields'
-
-export class FlowText extends ContentFieldsBase {
-  public text = ''
-  public buttons: FlowButton[] = []
-  public buttonStyle = HtButtonStyle.BUTTON
-
-  static fromHubtypeCMS(
-    cmsText: HtTextNode,
-    locale: string,
-    cmsApi: FlowBuilderApi
-  ): FlowText {
-    const newText = new FlowText(cmsText.id)
-    newText.code = cmsText.code
-    newText.buttonStyle = cmsText.content.buttons_style || HtButtonStyle.BUTTON
-    newText.text = FlowText.getTextByLocale(locale, cmsText.content.text)
-    newText.buttons = cmsText.content.buttons.map(button =>
-      FlowButton.fromHubtypeCMS(button, locale, cmsApi)
-    )
-    newText.followUp = cmsText.follow_up
-
-    return newText
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    await trackOneContent(request, this)
-    for (const button of this.buttons) {
-      await button.trackFlow(request)
-    }
-  }
-
-  static fromAIAgent(
-    id: string,
-    textMessage: TextMessage | TextWithButtonsMessage | BotExecutorMessage
-  ): JSX.Element {
-    if (textMessage.type === 'text') {
-      return <Text key={id}>{textMessage.content.text}</Text>
-    }
-
-    return (
-      <Text key={id}>
-        {textMessage.content.text}
-        {textMessage.content.buttons.map((button, buttonIndex) => {
-          const buttonData = {
-            id: `${id}-button-${buttonIndex}`,
-            text: button.text,
-            url: button.url,
-            target: button.target,
-            payload:
-              button.payload ||
-              `${EMPTY_PAYLOAD}${SOURCE_INFO_SEPARATOR}${buttonIndex}`,
-          }
-          return FlowButton.fromAIAgent(buttonData).renderButton(buttonIndex)
-        })}
-      </Text>
-    )
-  }
-
-  toBotonic(id: string, request: ActionRequest): JSX.Element {
-    const replacedText = this.replaceVariables(this.text, request)
-    return (
-      <Text key={id}>
-        {replacedText}
-        {this.buttons.map((button, buttonIndex) =>
-          button.renderButton(buttonIndex, this.buttonStyle)
-        )}
-      </Text>
-    )
-  }
-}

package/src/content-fields/flow-video.tsx

@@ -1,26 +0,0 @@
-import { type ActionRequest, Video } from '@botonic/react'
-
-import { trackOneContent } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtVideoNode } from './hubtype-fields'
-
-export class FlowVideo extends ContentFieldsBase {
-  public src = ''
-
-  static fromHubtypeCMS(component: HtVideoNode, locale: string): FlowVideo {
-    const newVideo = new FlowVideo(component.id)
-    newVideo.code = component.code
-    newVideo.src = FlowVideo.getVideoByLocale(locale, component.content.video)
-    newVideo.followUp = component.follow_up
-
-    return newVideo
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    await trackOneContent(request, this)
-  }
-
-  toBotonic(id: string): JSX.Element {
-    return <Video key={id} src={this.src} />
-  }
-}

package/src/content-fields/flow-webview.tsx

@@ -1,46 +0,0 @@
-import { EventAction, type EventWebviewActionTriggered } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtWebviewExits, HtWebviewNode } from './hubtype-fields'
-
-export class FlowWebview extends ContentFieldsBase {
-  public webviewTargetId: string = ''
-  public webviewName: string = ''
-  public webviewComponentName: string = ''
-  public exits: HtWebviewExits[] = []
-
-  static fromHubtypeCMS(component: HtWebviewNode): FlowWebview {
-    const newWebview = new FlowWebview(component.id)
-    newWebview.webviewTargetId = component.content.webview_target_id
-    newWebview.webviewName = component.content.webview_name
-    newWebview.webviewComponentName = component.content.webview_component_name
-    newWebview.exits = component.content.exits
-    newWebview.followUp = component.follow_up
-
-    return newWebview
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-
-    const eventWebviewActionTriggered: EventWebviewActionTriggered = {
-      action: EventAction.WebviewActionTriggered,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      webviewTargetId: this.webviewTargetId,
-      webviewName: this.webviewName,
-    }
-    const { action, ...eventArgs } = eventWebviewActionTriggered
-    await trackEvent(request, action, eventArgs)
-  }
-}

package/src/content-fields/flow-whatsapp-cta-url-button.tsx

@@ -1,209 +0,0 @@
-import { isWhatsapp } from '@botonic/core'
-import {
-  type ActionRequest,
-  Button,
-  Text,
-  WhatsappCTAUrlButton,
-  WhatsappCTAUrlHeaderType,
-} from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import { trackOneContent } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import { FlowButton } from './flow-button'
-import type { HtUrlNode, HtWhatsappCTAUrlButtonNode } from './hubtype-fields'
-
-export class FlowWhatsappCtaUrlButtonNode extends ContentFieldsBase {
-  public text = ''
-  public header?: string
-  public headerType?: WhatsappCTAUrlHeaderType
-  public headerImage?: string
-  public headerVideo?: string
-  public headerDocument?: string
-  public footer?: string
-  public displayText = ''
-  public url: string = ''
-
-  static fromHubtypeCMS(
-    component: HtWhatsappCTAUrlButtonNode,
-    locale: string,
-    cmsApi: FlowBuilderApi
-  ): FlowWhatsappCtaUrlButtonNode {
-    const whatsappCtaUrlButton = new FlowWhatsappCtaUrlButtonNode(component.id)
-    whatsappCtaUrlButton.code = component.code
-    whatsappCtaUrlButton.text = FlowWhatsappCtaUrlButtonNode.getTextByLocale(
-      locale,
-      component.content.text
-    )
-    FlowWhatsappCtaUrlButtonNode.setHeader(
-      whatsappCtaUrlButton,
-      component,
-      locale
-    )
-    whatsappCtaUrlButton.footer = FlowWhatsappCtaUrlButtonNode.getTextByLocale(
-      locale,
-      component.content.footer
-    )
-    const button = FlowButton.fromHubtypeCMS(
-      component.content.button,
-      locale,
-      cmsApi
-    )
-    whatsappCtaUrlButton.displayText = button.text
-    const urlId = FlowButton.getUrlId(component.content.button, locale)
-    if (urlId) {
-      const urlNode = cmsApi.getNodeById<HtUrlNode>(urlId)
-      whatsappCtaUrlButton.url = urlNode.content.url
-    }
-    whatsappCtaUrlButton.followUp = component.follow_up
-
-    return whatsappCtaUrlButton
-  }
-
-  private static setHeader(
-    whatsappCtaUrlButton: FlowWhatsappCtaUrlButtonNode,
-    component: HtWhatsappCTAUrlButtonNode,
-    locale: string
-  ) {
-    // If header is set, set header_type to text, this is need to be compatible with the old version of the component
-    if (component.content.header.length > 0) {
-      component.content.header_type = WhatsappCTAUrlHeaderType.Text
-    }
-
-    whatsappCtaUrlButton.headerType = component.content
-      .header_type as WhatsappCTAUrlHeaderType
-
-    if (component.content.header_type === WhatsappCTAUrlHeaderType.Text) {
-      whatsappCtaUrlButton.header =
-        FlowWhatsappCtaUrlButtonNode.getTextByLocale(
-          locale,
-          component.content.header
-        )
-    }
-
-    if (
-      component.content.header_type === WhatsappCTAUrlHeaderType.Image &&
-      component.content.header_image
-    ) {
-      whatsappCtaUrlButton.headerImage =
-        FlowWhatsappCtaUrlButtonNode.getAssetByLocale(
-          locale,
-          component.content.header_image
-        )
-    }
-
-    if (
-      component.content.header_type === WhatsappCTAUrlHeaderType.Video &&
-      component.content.header_video
-    ) {
-      whatsappCtaUrlButton.headerVideo =
-        FlowWhatsappCtaUrlButtonNode.getAssetByLocale(
-          locale,
-          component.content.header_video
-        )
-    }
-
-    if (
-      component.content.header_type === WhatsappCTAUrlHeaderType.Document &&
-      component.content.header_document
-    ) {
-      whatsappCtaUrlButton.headerDocument =
-        FlowWhatsappCtaUrlButtonNode.getAssetByLocale(
-          locale,
-          component.content.header_document
-        )
-    }
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    await trackOneContent(request, this)
-  }
-
-  toBotonic(id: string, request: ActionRequest): JSX.Element {
-    const replacedText = this.replaceVariables(this.text, request)
-
-    if (!isWhatsapp(request.session)) {
-      return (
-        <Text>
-          {replacedText}
-          <Button url={this.url}>{this.displayText}</Button>
-        </Text>
-      )
-    }
-
-    if (
-      this.headerType === WhatsappCTAUrlHeaderType.Image &&
-      this.headerImage
-    ) {
-      return (
-        <WhatsappCTAUrlButton
-          key={id}
-          body={replacedText}
-          headerType={this.headerType}
-          headerImage={this.headerImage}
-          footer={this.footer}
-          displayText={this.displayText}
-          url={this.url}
-        />
-      )
-    }
-
-    if (
-      this.headerType === WhatsappCTAUrlHeaderType.Video &&
-      this.headerVideo
-    ) {
-      return (
-        <WhatsappCTAUrlButton
-          key={id}
-          body={replacedText}
-          headerType={this.headerType}
-          headerVideo={this.headerVideo}
-          footer={this.footer}
-          displayText={this.displayText}
-          url={this.url}
-        />
-      )
-    }
-
-    if (
-      this.headerType === WhatsappCTAUrlHeaderType.Document &&
-      this.headerDocument
-    ) {
-      return (
-        <WhatsappCTAUrlButton
-          key={id}
-          body={replacedText}
-          headerType={this.headerType}
-          headerDocument={this.headerDocument}
-          footer={this.footer}
-          displayText={this.displayText}
-          url={this.url}
-        />
-      )
-    }
-
-    if (this.headerType === WhatsappCTAUrlHeaderType.Text && this.header) {
-      return (
-        <WhatsappCTAUrlButton
-          key={id}
-          body={replacedText}
-          header={this.header}
-          headerType={this.headerType}
-          footer={this.footer}
-          displayText={this.displayText}
-          url={this.url}
-        />
-      )
-    }
-
-    return (
-      <WhatsappCTAUrlButton
-        key={id}
-        body={replacedText}
-        footer={this.footer}
-        displayText={this.displayText}
-        url={this.url}
-      />
-    )
-  }
-}