c2-desafiox 1.0.136 → 1.0.138

package/dist/models/WhatsAppTemplate.d.ts

@@ -0,0 +1,72 @@
+import { Schema, Types } from "mongoose";
+import { IDefault } from "./IDefault";
+export declare enum WhatsAppTemplateStatus {
+    APPROVED = "APPROVED",
+    PENDING = "PENDING",
+    REJECTED = "REJECTED",
+    PAUSED = "PAUSED",
+    DISABLED = "DISABLED",
+    IN_APPEAL = "IN_APPEAL",
+    DELETED = "DELETED"
+}
+export declare enum WhatsAppTemplateCategory {
+    MARKETING = "MARKETING",
+    UTILITY = "UTILITY",
+    AUTHENTICATION = "AUTHENTICATION"
+}
+export type WhatsAppTemplateComponentType = "HEADER" | "BODY" | "FOOTER" | "BUTTONS";
+export type WhatsAppTemplateHeaderFormat = "TEXT" | "IMAGE" | "VIDEO" | "DOCUMENT" | "LOCATION";
+export type WhatsAppTemplateVariableKind = "text" | "media";
+export interface IWhatsAppTemplateButton {
+    type?: string;
+    text?: string;
+    url?: string;
+    phoneNumber?: string;
+    example?: string[];
+}
+export interface IWhatsAppTemplateComponent {
+    type: string;
+    format?: string;
+    text?: string;
+    example?: unknown;
+    buttons?: IWhatsAppTemplateButton[];
+}
+export interface IWhatsAppTemplateVariable {
+    key: string;
+    component: string;
+    buttonIndex?: number;
+    index?: number;
+    name?: string;
+    label: string;
+    example?: string;
+    kind: WhatsAppTemplateVariableKind;
+}
+export interface IWhatsAppTemplate extends IDefault {
+    _id?: Types.ObjectId;
+    externalId?: string;
+    wabaId?: string;
+    name: string;
+    language: string;
+    status: string;
+    category?: string;
+    parameterFormat?: string;
+    qualityScore?: string;
+    rejectedReason?: string;
+    components: IWhatsAppTemplateComponent[];
+    variables: IWhatsAppTemplateVariable[];
+    lastSyncedAt?: Date;
+}
+export declare const WhatsAppTemplateSchema: Schema<IWhatsAppTemplate, import("mongoose").Model<IWhatsAppTemplate, any, any, any, import("mongoose").Document<unknown, any, IWhatsAppTemplate, any> & IWhatsAppTemplate & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IWhatsAppTemplate, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IWhatsAppTemplate>, {}> & import("mongoose").FlatRecord<IWhatsAppTemplate> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare function extractPlaceholders(text?: string): string[];
+export declare function extractWhatsAppTemplateVariables(components: IWhatsAppTemplateComponent[]): IWhatsAppTemplateVariable[];
+export declare function applyWhatsAppTemplateValues(text: string | undefined, values: Record<string, string>, prefix: string): string;
+export declare function renderWhatsAppTemplateContent(template: Pick<IWhatsAppTemplate, "components" | "name">, values?: Record<string, string>): string;
+export declare function buildWhatsAppSendComponents(template: Pick<IWhatsAppTemplate, "components" | "parameterFormat">, values?: Record<string, string>): Record<string, unknown>[];

package/dist/models/WhatsAppTemplate.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppTemplateSchema = exports.WhatsAppTemplateCategory = exports.WhatsAppTemplateStatus = void 0;
+exports.extractPlaceholders = extractPlaceholders;
+exports.extractWhatsAppTemplateVariables = extractWhatsAppTemplateVariables;
+exports.applyWhatsAppTemplateValues = applyWhatsAppTemplateValues;
+exports.renderWhatsAppTemplateContent = renderWhatsAppTemplateContent;
+exports.buildWhatsAppSendComponents = buildWhatsAppSendComponents;
+const mongoose_1 = require("mongoose");
+var WhatsAppTemplateStatus;
+(function (WhatsAppTemplateStatus) {
+    WhatsAppTemplateStatus["APPROVED"] = "APPROVED";
+    WhatsAppTemplateStatus["PENDING"] = "PENDING";
+    WhatsAppTemplateStatus["REJECTED"] = "REJECTED";
+    WhatsAppTemplateStatus["PAUSED"] = "PAUSED";
+    WhatsAppTemplateStatus["DISABLED"] = "DISABLED";
+    WhatsAppTemplateStatus["IN_APPEAL"] = "IN_APPEAL";
+    WhatsAppTemplateStatus["DELETED"] = "DELETED";
+})(WhatsAppTemplateStatus || (exports.WhatsAppTemplateStatus = WhatsAppTemplateStatus = {}));
+var WhatsAppTemplateCategory;
+(function (WhatsAppTemplateCategory) {
+    WhatsAppTemplateCategory["MARKETING"] = "MARKETING";
+    WhatsAppTemplateCategory["UTILITY"] = "UTILITY";
+    WhatsAppTemplateCategory["AUTHENTICATION"] = "AUTHENTICATION";
+})(WhatsAppTemplateCategory || (exports.WhatsAppTemplateCategory = WhatsAppTemplateCategory = {}));
+const WhatsAppTemplateButtonSchema = new mongoose_1.Schema({
+    type: { type: String },
+    text: { type: String },
+    url: { type: String },
+    phoneNumber: { type: String },
+    example: [{ type: String }],
+}, { _id: false });
+const WhatsAppTemplateComponentSchema = new mongoose_1.Schema({
+    type: { type: String, required: true },
+    format: { type: String },
+    text: { type: String },
+    example: { type: mongoose_1.Schema.Types.Mixed },
+    buttons: [WhatsAppTemplateButtonSchema],
+}, { _id: false });
+const WhatsAppTemplateVariableSchema = new mongoose_1.Schema({
+    key: { type: String, required: true },
+    component: { type: String, required: true },
+    buttonIndex: { type: Number },
+    index: { type: Number },
+    name: { type: String },
+    label: { type: String, required: true },
+    example: { type: String },
+    kind: { type: String, enum: ["text", "media"], required: true, default: "text" },
+}, { _id: false });
+exports.WhatsAppTemplateSchema = new mongoose_1.Schema({
+    externalId: { type: String },
+    wabaId: { type: String },
+    name: { type: String, required: true },
+    language: { type: String, required: true },
+    status: { type: String, required: true },
+    category: { type: String },
+    parameterFormat: { type: String },
+    qualityScore: { type: String },
+    rejectedReason: { type: String },
+    components: { type: [WhatsAppTemplateComponentSchema], default: [] },
+    variables: { type: [WhatsAppTemplateVariableSchema], default: [] },
+    lastSyncedAt: { type: Date },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" },
+});
+exports.WhatsAppTemplateSchema.index({ name: 1, language: 1 }, { unique: true });
+exports.WhatsAppTemplateSchema.index({ status: 1, name: 1 });
+exports.WhatsAppTemplateSchema.index({ externalId: 1 });
+const PLACEHOLDER_RE = /\{\{\s*([a-zA-Z_][\w]*|\d+)\s*\}\}/g;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function firstExampleString(example, fallbackIndex = 0) {
+    const record = asRecord(example);
+    const headerText = record.header_text;
+    if (Array.isArray(headerText) && headerText[fallbackIndex] != null)
+        return String(headerText[fallbackIndex]);
+    const headerHandle = record.header_handle;
+    if (Array.isArray(headerHandle) && headerHandle[0] != null)
+        return String(headerHandle[0]);
+    const bodyText = record.body_text;
+    if (Array.isArray(bodyText) && Array.isArray(bodyText[0]) && bodyText[0][fallbackIndex] != null) {
+        return String(bodyText[0][fallbackIndex]);
+    }
+    const named = record.body_text_named_params;
+    if (Array.isArray(named) && named[fallbackIndex]) {
+        const row = asRecord(named[fallbackIndex]);
+        if (row.example != null)
+            return String(row.example);
+    }
+    const headerNamed = record.header_text_named_params;
+    if (Array.isArray(headerNamed) && headerNamed[fallbackIndex]) {
+        const row = asRecord(headerNamed[fallbackIndex]);
+        if (row.example != null)
+            return String(row.example);
+    }
+    return undefined;
+}
+function extractPlaceholders(text) {
+    if (!text)
+        return [];
+    const found = [];
+    const seen = new Set();
+    const re = new RegExp(PLACEHOLDER_RE.source, "g");
+    let match;
+    while ((match = re.exec(text))) {
+        const token = match[1];
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        found.push(token);
+    }
+    return found;
+}
+function placeholderLabel(component, token, kind) {
+    if (kind === "media") {
+        if (component === "HEADER")
+            return "Mídia do cabeçalho (URL)";
+        return `Mídia (${component})`;
+    }
+    const where = component === "HEADER" ? "cabeçalho" : component === "BODY" ? "corpo" : component === "BUTTON" ? "botão" : component.toLowerCase();
+    return isNaN(Number(token)) ? `${where}: {{${token}}}` : `${where} {{${token}}}`;
+}
+function extractWhatsAppTemplateVariables(components) {
+    const variables = [];
+    for (const component of components) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "IMAGE" || format === "VIDEO" || format === "DOCUMENT") {
+                variables.push({
+                    key: "header.media",
+                    component: "HEADER",
+                    label: placeholderLabel("HEADER", "media", "media"),
+                    example: firstExampleString(component.example),
+                    kind: "media",
+                });
+            }
+        }
+        if (type === "HEADER" || type === "BODY") {
+            const tokens = extractPlaceholders(component.text);
+            tokens.forEach((token, order) => {
+                const index = Number(token);
+                variables.push({
+                    key: `${type.toLowerCase()}.${token}`,
+                    component: type,
+                    index: Number.isFinite(index) ? index : order + 1,
+                    name: Number.isFinite(index) ? undefined : token,
+                    label: placeholderLabel(type, token, "text"),
+                    example: firstExampleString(component.example, Number.isFinite(index) ? index - 1 : order),
+                    kind: "text",
+                });
+            });
+        }
+        if (type === "BUTTONS") {
+            (component.buttons || []).forEach((button, buttonIndex) => {
+                const tokens = extractPlaceholders(button.url);
+                tokens.forEach((token, order) => {
+                    const index = Number(token);
+                    variables.push({
+                        key: `button.${buttonIndex}.${token}`,
+                        component: "BUTTON",
+                        buttonIndex,
+                        index: Number.isFinite(index) ? index : order + 1,
+                        name: Number.isFinite(index) ? undefined : token,
+                        label: `botão ${button.text || buttonIndex + 1} {{${token}}}`,
+                        example: button.example?.[order],
+                        kind: "text",
+                    });
+                });
+            });
+        }
+    }
+    return variables;
+}
+function applyWhatsAppTemplateValues(text, values, prefix) {
+    if (!text)
+        return "";
+    return text.replace(PLACEHOLDER_RE, (_full, token) => {
+        const exact = values[`${prefix}.${token}`];
+        if (exact != null && exact !== "")
+            return exact;
+        const byToken = values[token];
+        if (byToken != null && byToken !== "")
+            return byToken;
+        return `{{${token}}}`;
+    });
+}
+function renderWhatsAppTemplateContent(template, values = {}) {
+    const parts = [];
+    for (const component of template.components || []) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "TEXT") {
+                const text = applyWhatsAppTemplateValues(component.text, values, "header");
+                if (text)
+                    parts.push(text);
+            }
+            else if (values["header.media"]) {
+                parts.push(values["header.media"]);
+            }
+        }
+        if (type === "BODY") {
+            const text = applyWhatsAppTemplateValues(component.text, values, "body");
+            if (text)
+                parts.push(text);
+        }
+        if (type === "FOOTER" && component.text) {
+            parts.push(component.text);
+        }
+        if (type === "BUTTONS") {
+            for (const button of component.buttons || []) {
+                if (button.text)
+                    parts.push(button.text);
+            }
+        }
+    }
+    return parts.join("\n\n").trim() || template.name;
+}
+function buildWhatsAppSendComponents(template, values = {}) {
+    const named = String(template.parameterFormat || "").toUpperCase() === "NAMED";
+    const payload = [];
+    for (const component of template.components || []) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "IMAGE" || format === "VIDEO" || format === "DOCUMENT") {
+                const link = values["header.media"];
+                if (link) {
+                    const mediaType = format.toLowerCase();
+                    payload.push({
+                        type: "header",
+                        parameters: [{ type: mediaType, [mediaType]: { link } }],
+                    });
+                }
+                continue;
+            }
+            const tokens = extractPlaceholders(component.text);
+            if (!tokens.length)
+                continue;
+            payload.push({
+                type: "header",
+                parameters: tokens.map((token) => parameterOf(token, values, "header", named)),
+            });
+        }
+        if (type === "BODY") {
+            const tokens = extractPlaceholders(component.text);
+            if (!tokens.length)
+                continue;
+            payload.push({
+                type: "body",
+                parameters: tokens.map((token) => parameterOf(token, values, "body", named)),
+            });
+        }
+        if (type === "BUTTONS") {
+            (component.buttons || []).forEach((button, buttonIndex) => {
+                const tokens = extractPlaceholders(button.url);
+                if (!tokens.length)
+                    return;
+                payload.push({
+                    type: "button",
+                    sub_type: "url",
+                    index: String(buttonIndex),
+                    parameters: tokens.map((token) => ({
+                        type: "text",
+                        text: values[`button.${buttonIndex}.${token}`] || values[token] || "",
+                    })),
+                });
+            });
+        }
+    }
+    return payload;
+}
+function parameterOf(token, values, prefix, named) {
+    const text = values[`${prefix}.${token}`] || values[token] || "";
+    if (named && isNaN(Number(token))) {
+        return { type: "text", parameter_name: token, text };
+    }
+    return { type: "text", text };
+}

package/dist/models/index.d.ts

@@ -23,3 +23,4 @@ export * from "./Ticket";
 export * from "./TicketGuess";
 export * from "./TicketOrder";
 export * from "./WalletMoviment";
+export * from "./WhatsAppTemplate";

package/dist/models/index.js

@@ -39,3 +39,4 @@ __exportStar(require("./Ticket"), exports);
 __exportStar(require("./TicketGuess"), exports);
 __exportStar(require("./TicketOrder"), exports);
 __exportStar(require("./WalletMoviment"), exports);
+__exportStar(require("./WhatsAppTemplate"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-desafiox",
-  "version": "1.0.136",
+  "version": "1.0.138",
   "description": "Modelagem TypeScript/Mongoose para o jogo Escalada X (times, campeonatos, fases, rodadas, confrontos, desafios)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",