contactstudiocstools 1.0.224

package/dist/runtime/components/Organism.Tabulation.vue

@@ -0,0 +1,237 @@
+<template>
+  <article class="flex flex-col">
+    <!-- select -->
+    <MoleculeSelectTreeSearchable
+      :select-tree="getTree"
+      :class="{ error: !isValid }"
+      label="Tabulação"
+      @add="add"
+    />
+
+    <!-- accordion -->
+    <div class="accordion accordion-bordered mt-3">
+      <details
+        v-for="(levels, j) in tabulation"
+        :key="j"
+        class="item"
+        :open="takenote"
+      >
+        <summary class="max-h-none flex flex-wrap gap-4">
+          <!-- items -->
+          <div
+            v-for="({ label }, i) in levels"
+            :key="i"
+            class="flex"
+          >
+            <!-- label -->
+            <span
+              class="badge badge-soft-secondary mr-2"
+              v-text="getTree.labels[i]"
+            />
+            <!-- value -->
+            <span
+              class="badge badge-solid-primary"
+              v-text="label"
+            />
+            <!-- arrow -->
+            <i
+              v-if="!i"
+              class="bi-arrow-left-right ml-4"
+            />
+          </div>
+        </summary>
+
+        <!-- schedule -->
+        <article v-if="isSchedule">
+          <MoleculeFieldGroup
+            :rules="[
+              () => {
+                if (!additionals.SCHEDULE)
+                  return 'O horário de agendamento é obrigatório';
+                return true;
+              },
+            ]"
+            label="Horário do Agendamento"
+            :class="{ error: scheduleIsInvalid }"
+          >
+            <!-- additionals -->
+            <AtomFieldDate
+              v-model="additionals.SCHEDULE"
+              :min="new Date().toISOString().split('.')[0]"
+              type="datetime-local"
+              @change="persist"
+            />
+          </MoleculeFieldGroup>
+        </article>
+
+        <!-- observation -->
+        <article>
+          <MoleculeFieldGroup
+            :rules="getRulesNote"
+            :class="{ error: noteIsInvalid }"
+          >
+            <AtomFieldTextarea
+              v-model="note"
+              rows="5"
+              placeholder="Observação"
+              @blur="persist"
+            />
+          </MoleculeFieldGroup>
+        </article>
+
+        <div class="divider mx-5" />
+
+        <MoleculeFieldGroup
+          :ref="bindMoleculeFieldGroupRef"
+          class="px-5 mb-4 mt-3"
+          :rules="getRulesManifestation"
+          label="Manifestação Vinculada"
+        >
+          <label
+            class="input flex flex-wrap items-center gap-1 !px-2"
+            tooltip="Vincule na seção 'Manifestação'"
+          >
+            <span
+              v-if="manifestationIsEmpty"
+              class="text-xs py-0.5 pl-1"
+            >Nenhuma manifestação vinculada</span>
+            <i
+              v-else
+              class="bi-check-circle-fill text-success px-1"
+            />
+            <span
+              v-for="({ label }, k) in manifestation"
+              :key="k"
+              class="badge badge-soft-secondary"
+              v-text="label"
+            />
+          </label>
+        </MoleculeFieldGroup>
+      </details>
+    </div>
+  </article>
+</template>
+
+<script setup lang="ts">
+import { ref, reactive, computed, watch } from "vue";
+import { INodes, IRules, ISelectTree } from "./types";
+import MoleculeFieldGroup from "./Molecule.FieldGroup.vue";
+
+// props
+interface IProps {
+  nodes: INodes;
+  takenote?: boolean;
+  manifestation?: INodes;
+  persist?: Function;
+  defaults?: { tabulation: INodes[]; note: string };
+}
+const props = defineProps<IProps>();
+
+// computed
+const noteIsEmpty = computed<boolean>(() => {
+  return !note.value.trim();
+});
+const manifestationIsEmpty = computed<boolean>(() => {
+  return !props.manifestation || props.manifestation?.length === 0;
+});
+const noteIsInvalid = computed<boolean>(() => {
+  return props.takenote && noteIsEmpty.value;
+});
+const manifestationIsInvalid = computed<boolean>(() => {
+  return takeManifestation.value && manifestationIsEmpty.value;
+});
+const getRulesNote = computed<IRules>(() => {
+  return [() => (noteIsInvalid.value ? "Observação Obrigatória" : true)];
+});
+const getRulesManifestation = computed<IRules>(() => {
+  return [() => !manifestationIsInvalid.value ?? "Manifestação Obrigatória"];
+});
+const isValid = computed<boolean>(() => {
+  if (noteIsInvalid.value) return false;
+  if (manifestationIsInvalid.value) return false;
+  if (scheduleIsInvalid.value) return false;
+  return !!tabulation.length;
+});
+const getTree = computed<ISelectTree>(() => {
+  return {
+    labels: ["GRUPO", "TABULAÇÃO"],
+    nodes: props.nodes,
+  };
+});
+const isSchedule = computed<boolean>(() => {
+  if (!tabulation.length) return false;
+  return tabulation[0][1].primitive.acao.tipo === "AGENDADOR";
+});
+const scheduleIsInvalid = computed<boolean>(() => {
+  return isSchedule.value && !additionals.SCHEDULE;
+});
+const takeManifestation = computed<boolean>(() => {
+  if (!tabulation[0]) return false
+  return tabulation[0][1].primitive.acao.required_manifestation ?? false
+})
+const getNote = computed<string>(() => {
+  if (!props.manifestation) return note.value
+
+  const levels = props.manifestation.map(level => level.label)
+  return `Manifestação: ${levels.join(" > ")}\n${note.value}`
+})
+
+// data
+const MoleculeFieldGroupRef = ref<InstanceType<
+  typeof MoleculeFieldGroup
+> | null>(null);
+const tabulation = reactive<INodes[]>(props.defaults?.tabulation ?? []);
+const note = ref<string>(props.defaults?.note ?? "");
+const additionals = reactive<any>({});
+
+// methods
+function add(nodes: INodes): void {
+  tabulation[0] = nodes;
+
+  persist();
+}
+function persist(): void {
+  if (!props.persist) return;
+
+  props.persist({
+    tabulation: tabulation,
+    note: note.value,
+    additionals,
+  });
+}
+function append({ tabulation: tab, note: nt, add }: any): void {
+  tabulation.push(...tab);
+  note.value = nt;
+  Object.assign(additionals, add);
+}
+function reset(): void {
+  tabulation.length = 0;
+}
+function bindMoleculeFieldGroupRef(ref?: any) {
+  MoleculeFieldGroupRef.value = ref
+}
+
+// watchers
+watch(
+  () => props.manifestation,
+  () => { MoleculeFieldGroupRef.value?.validateAndSetState() },
+  { deep: true }
+);
+watch(
+  () => takeManifestation.value,
+  () => { MoleculeFieldGroupRef.value?.validateAndSetState() }
+);
+
+// expose
+defineExpose({
+  tabulation,
+  note: getNote,
+  additionals,
+  isValid,
+  isSchedule,
+  append,
+  reset,
+});
+</script>
+
+<style scoped></style>

package/dist/runtime/components/types/dto.d.ts

@@ -0,0 +1,16 @@
+import { IDoubts, IMailing, IPauses, ISchedules, IUser, IChatContacts, INodes, IChatMessage, IFlows, IClientHistories, IPortfolioSchedules } from ".";
+export declare function IPortfolioSchedulesDTO(primitives: any[]): IPortfolioSchedules;
+export declare function IClientHistoriesDTO(primitives: any[]): IClientHistories;
+export declare function FlowsDTO(primitives: any[]): IFlows;
+export declare function ChatMessageTextDTO(primitive: any): IChatMessage;
+export declare function ChatMessageOptionDTO(primitive: any): IChatMessage;
+export declare function ChatMessageFileDTO(primitive: any): IChatMessage;
+export declare function NodesManifestationDTO(primitives: any[]): INodes;
+export declare function NodesTabulationDTO(primitives: any[]): INodes;
+export declare function ChatContactsDTO({ primitives, identifier, message, date, }: any): IChatContacts;
+export declare function SchedulesDTO({ data }: any): ISchedules;
+export declare function WarnsDTO(primitive: any): string[];
+export declare function PausesDTO({ lista_pausa }: any): IPauses;
+export declare function DoubtsDTO(primitives: any[]): IDoubts;
+export declare function UserDTO(primitive: any): IUser;
+export declare function MailingDTO(primitives: any[]): IMailing;

package/dist/runtime/components/types/dto.mjs

@@ -0,0 +1,236 @@
+import {
+  EFieldTypes,
+  EChatMessageTypes
+} from "./index.mjs";
+export function IPortfolioSchedulesDTO(primitives) {
+  const schedules = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    schedules.push({
+      identifier: primitive.telephone,
+      slots: primitive.slots,
+      date: new Date(primitive.wallet_date),
+      avatar: primitive.avatar,
+      primitive
+    });
+  }
+  return schedules;
+}
+export function IClientHistoriesDTO(primitives) {
+  const histories = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    histories.push({
+      agent: primitive.nome_ultima_tabulacao || "Operador Inexistente",
+      lastMovementDate: new Date(primitive.data_ultima_tabulacao) ?? null,
+      lastTabulation: primitive.ultima_tabulacao,
+      mailing: primitive.mailing,
+      observation: primitive.observation,
+      primitive
+    });
+  }
+  return histories;
+}
+export function FlowsDTO(primitives) {
+  const flows = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    flows.push({
+      name: primitive.flow_name,
+      description: primitive.description_flow,
+      slots: primitive.slots
+    });
+  }
+  return flows;
+}
+function FieldSelectOptionsDTO(primitives) {
+  const options = [];
+  if (!primitives)
+    return [];
+  for (const { nome, label } of primitives) {
+    options.push({ value: nome, label });
+  }
+  return options;
+}
+function ChatMessageDTO(primitive) {
+  const { when, content, user_defined_fields } = primitive;
+  const isRobot = content.who.type === "robot";
+  return {
+    type: EChatMessageTypes.text,
+    who: content.who.label,
+    date: new Date(when),
+    primary: isRobot || !!user_defined_fields.agent,
+    primitive,
+    text: ""
+  };
+}
+export function ChatMessageTextDTO(primitive) {
+  const message = ChatMessageDTO(primitive);
+  message.type = EChatMessageTypes.text;
+  message.text = primitive.content.message.text;
+  return message;
+}
+export function ChatMessageOptionDTO(primitive) {
+  const message = ChatMessageDTO(primitive);
+  message.type = EChatMessageTypes.option;
+  message.selected = true;
+  message.text = primitive.content.message.caption;
+  return message;
+}
+export function ChatMessageFileDTO(primitive) {
+  const message = ChatMessageDTO(primitive);
+  message.type = EChatMessageTypes.file;
+  message.text = "\u{1F4C4} Arquivo";
+  return message;
+}
+export function NodesManifestationDTO(primitives) {
+  const nodes = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    const { children, name } = primitive;
+    if (!children) {
+      nodes.push({ value: name, label: name, primitive });
+      continue;
+    }
+    nodes.push({
+      children: NodesManifestationDTO(children),
+      value: name,
+      label: name,
+      primitive
+    });
+  }
+  return nodes;
+}
+export function NodesTabulationDTO(primitives) {
+  const nodes = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    const { label, nome, tabulacoes } = primitive;
+    if (!tabulacoes) {
+      nodes.push({ value: nome, primitive, label });
+      continue;
+    }
+    nodes.push({
+      children: NodesTabulationDTO(tabulacoes),
+      value: nome,
+      primitive,
+      label
+    });
+  }
+  return nodes;
+}
+export function ChatContactsDTO({
+  primitives,
+  identifier,
+  message,
+  date
+}) {
+  const contacts = [];
+  if (!primitives)
+    return [];
+  for (const primitive of primitives) {
+    const { contact_id, data } = primitive;
+    contacts.push({
+      id: contact_id,
+      on: true,
+      label: data[identifier],
+      avatar: primitive.avatar,
+      entrydate: new Date(primitive.creation_date * 1e3),
+      primitive,
+      date,
+      message
+    });
+  }
+  return contacts;
+}
+export function SchedulesDTO({ data }) {
+  const schedules = [];
+  if (!data)
+    return [];
+  for (const schedule of data) {
+    schedules.push({
+      cardID: schedule.card_id,
+      priority: schedule.priority || 0,
+      contactName: schedule.contact_name,
+      customerID: schedule.customer_id,
+      scheduling: /* @__PURE__ */ new Date(),
+      lastInteraction: /* @__PURE__ */ new Date(),
+      lastTabulation: /* @__PURE__ */ new Date(),
+      mailing: schedule.mailing
+    });
+  }
+  return schedules;
+}
+export function WarnsDTO(primitive) {
+  return primitive;
+}
+export function PausesDTO({ lista_pausa }) {
+  const pauses = [{ value: "available", label: "Disponivel" }];
+  for (const { nome, label } of lista_pausa) {
+    pauses.push({
+      value: nome,
+      label
+    });
+  }
+  return pauses;
+}
+export function DoubtsDTO(primitives) {
+  if (!primitives)
+    return [];
+  return primitives[0].doubt;
+}
+export function UserDTO(primitive) {
+  if (!primitive.info_agente) {
+    primitive.info_agente = {};
+  }
+  return {
+    company: primitive.empresa,
+    campaign: primitive.info_agente.codigo_campanha ?? "",
+    nickname: primitive.nome,
+    name: primitive.short_name,
+    access: [],
+    primitive
+  };
+}
+export function MailingDTO(primitives) {
+  const mailing = [];
+  primitives = primitives.sort(
+    (a, b) => a.config.ordem - b.config.ordem
+  );
+  for (const field of primitives) {
+    mailing.push({
+      icon: field.config.editavel ? "bi-input-cursor-text" : "bi-lock",
+      type: getFieldType(field),
+      name: field.nome,
+      label: field.config.label,
+      required: field.config.required_field,
+      disabled: !field.config.editavel,
+      regex: new RegExp(field.regex),
+      primitive: field,
+      options: FieldSelectOptionsDTO(field.values),
+      maxlength: field.tipo.max,
+      messages: {
+        error: field.config.ajuda
+      }
+    });
+  }
+  return mailing;
+}
+function getFieldType({ combo, tipo }) {
+  if (combo)
+    return EFieldTypes.select;
+  if (tipo.large)
+    return EFieldTypes.textarea;
+  if (tipo.formato === "NUMERO")
+    return EFieldTypes.number;
+  if (tipo.formato === "TELEFONE")
+    return EFieldTypes.phone;
+  if (tipo.formato === "DATA")
+    return EFieldTypes.date;
+  return EFieldTypes.text;
+}

package/dist/runtime/components/types/helpers.d.ts

@@ -0,0 +1,39 @@
+import { EUserStatus, IChatContact, IPause, IChatMessage, IDDI } from ".";
+export declare class Persist {
+    static set(label: string, value: any): void;
+    static get(label: string): any;
+    static remove(label: string): any;
+}
+export declare function getDefaultDDI(): IDDI;
+export declare function getDDI(phone: string): Promise<any>;
+export declare function deepEqual(obj1: any, obj2: any): boolean;
+export declare function getAccessControl(access: string[], key: string): string;
+export declare function searchZipCode({ models, field }: any): Promise<void>;
+export declare function logout(): Promise<void>;
+export declare function getMinutesBetweenDates(start: Date, end: Date): number;
+export declare function randomID(): string;
+export declare function getTokenProgressData(token: string): Promise<any>;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function getContactIdentifierByMailing(primitive: any[]): string;
+export declare function newUUID(): string;
+export declare function getTimeByDate(date: Date): string;
+export declare function getCurrentStatus({ status, current_status, unavailable_status, }: any): EUserStatus;
+export declare function getNextStatus({ next_status, standby_unavailable_status, }: any): EUserStatus;
+export declare function getPauseByLabel({ primitive, pauses }: any): IPause;
+export declare function isEquals(one: string, two: string): boolean;
+export declare function normalize(str: string): string;
+export declare function chatInteractionIsTemplate(primitive: any): boolean;
+export declare function chatInteractionIsEvent(primitive: any): boolean;
+export declare function eventTypeIsTyping(primitive: any): boolean;
+export declare function typingIsOn(primitive: any): boolean;
+export declare function chatInteractionIsCommand(primitive: any): boolean;
+export declare function treatChatMessage(primitive: any): IChatMessage;
+export declare function chatMessageIsText(primitive: any): boolean;
+export declare function chatMessageIsReadOnly(primitive: any): boolean;
+export declare function chatMessageIsOption(primitive: any): boolean;
+export declare function chatMessageIsFile(primitive: any): boolean;
+export declare function getContactByRoomID({ contacts, roomID }: any): IChatContact;
+export declare function newChatHistoryEvent({ company, roomID, nickname, name, }: any): any;
+export declare function newChatTextMessage({ company, roomID, nickname, name, text, }: any): any;
+export declare function newChatFileMessage({ roomID, company, nickname, name, type, caption, url, }: any): any;
+export declare function newChatTypingEvent({ roomID, company, nickname, name, typing, }: any): any;