Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.whatsapp;

import org.json.JSONArray;

import org.json.JSONObject;

import java.util.ArrayList;

import java.util.List;

/**

 * Request builders and response parsers for the BotPenguin gateway.

 *

 * <p>Deliberately static and Spring-free: the nesting rules below are the part most likely to be got

 * wrong, and keeping them here lets them be tested directly with no context and no mocking.</p>

 */

public final class BotPenguinPayloads {

    private BotPenguinPayloads() {

    }

    // ------------------------------------------------------------------

    // Session messages  (POST /wa/send-message)

    // ------------------------------------------------------------------

    public static JSONObject textMessage(String userName, String waId, String body, List<String> tags) {

        JSONObject payload = base(userName, waId, "text", tags);

        payload.put("message", new JSONObject().put("text", body));

        return payload;

    }

    /**

     * Media session message. The gateway names the URL {@code source} and the caption {@code label} —

     * not {@code link}/{@code caption} as the template endpoint does.

     */

    public static JSONObject mediaMessage(String userName, String waId, String type, String source,

                                          String label, List<String> tags) {

        JSONObject message = new JSONObject().put("source", source);

        if (isPresent(label)) {

            message.put("label", label);

        }

        JSONObject payload = base(userName, waId, type, tags);

        payload.put("message", message);

        return payload;

    }

    private static JSONObject base(String userName, String waId, String type, List<String> tags) {

        JSONObject payload = new JSONObject();

        payload.put("userName", userName);

        payload.put("wa_id", waId);

        payload.put("type", type);

        putTags(payload, tags);

        return payload;

    }

    // ------------------------------------------------------------------

    // Template messages  (POST /wa/send-template)

    // ------------------------------------------------------------------

    public static JSONObject template(String userName, String waId, String templateId, String assignTo,

                                      List<String> tags, List<WhatsappTemplateComponent> components,

                                      boolean nameBasedParams) {

        JSONObject payload = new JSONObject();

        payload.put("userName", userName);

        payload.put("wa_id", waId);

        payload.put("templateId", templateId);

        // An unrecognised assignTo is a plausible cause of a rejected send, so send it only when set.

        if (isPresent(assignTo)) {

            payload.put("assignTo", assignTo);

        }

        putTags(payload, tags);

        payload.put("params", params(components, nameBasedParams));

        return payload;

    }

    private static JSONArray params(List<WhatsappTemplateComponent> components, boolean nameBasedParams) {

        JSONArray params = new JSONArray();

        if (components == null) {

            return params;

        }

        for (WhatsappTemplateComponent component : components) {

            JSONArray parameters = new JSONArray();

            for (WhatsappTemplateParam param : component.getParameters()) {

                parameters.put(parameter(param, nameBasedParams));

            }

            params.put(new JSONObject()

                    .put("type", component.getType())

                    .put("parameters", parameters));

        }

        return params;

    }

    /**

     * A text parameter carries a flat {@code text} key; a media parameter carries a nested object named

     * after its own type and no {@code text} key at all.

     *

     * <p>{@code parameter_name} is emitted only for name-based templates. Sending it to a positional

     * template — or omitting it on a name-based one — fails without a useful error, which is why the

     * template registry carries that flag rather than leaving it to the caller.</p>

     */

    private static JSONObject parameter(WhatsappTemplateParam param, boolean nameBasedParams) {

        JSONObject json = new JSONObject();

        json.put("type", param.getType());

        if (param.isText()) {

            json.put("text", param.getText());

        } else {

            JSONObject media = new JSONObject().put("link", param.getLink());

            if (isPresent(param.getFileName())) {

                media.put("filename", param.getFileName());

            }

            json.put(param.getType(), media);

        }

        if (nameBasedParams && isPresent(param.getParameterName())) {

            json.put("parameter_name", param.getParameterName());

        }

        return json;

    }

    private static void putTags(JSONObject payload, List<String> tags) {

        if (tags == null || tags.isEmpty()) {

            return;

        }

        JSONArray array = new JSONArray();

        for (String tag : tags) {

            if (isPresent(tag)) {

                array.put(tag);

            }

        }

        if (array.length() > 0) {

            payload.put("tags", array);

        }

    }

    // ------------------------------------------------------------------

    // Responses

    // ------------------------------------------------------------------

    /** Outcome of a send, as read from the gateway body. */

    public static final class SendResult {

        private final boolean success;

        private final String externalId;

        private final String status;

        private final String error;

        SendResult(boolean success, String externalId, String status, String error) {

            this.success = success;

            this.externalId = externalId;

            this.status = status;

            this.error = error;

        }

        public boolean isSuccess() {

            return success;

        }

        public String getExternalId() {

            return externalId;

        }

        public String getStatus() {

            return status;

        }

        public String getError() {

            return error;

        }

    }

    /**

     * Reads a send response.

     *

     * <p>This has to carry the whole burden of deciding success, because the HTTP client used for these

     * calls returns the response body without inspecting the status code — a 401 arrives looking exactly

     * like a 200. Treating "the call did not throw" as success would report a delivered invoice to the

     * store operator while the customer received nothing, and with no delivery webhook nothing would

     * ever contradict it. So: anything that is not an explicit {@code success: true} is a failure, and a

     * body we cannot parse is a failure rather than an exception.</p>

     */

    public static SendResult parseSend(String response) {

        if (!isPresent(response)) {

            return new SendResult(false, null, null, "empty response");

        }

        JSONObject json;

        try {

            json = new JSONObject(response);

        } catch (Exception e) {

            return new SendResult(false, null, null, "unparseable response: " + truncate(response));

        }

        if (!json.optBoolean("success", false)) {

            return new SendResult(false, null, null, errorText(json, response));

        }

        JSONObject data = data(json);

        if (data == null) {

            return new SendResult(false, null, null, "success with no data: " + truncate(response));

        }

        String externalId = firstNonEmpty(data, "_id", "id", "messageId");

        String status = data.optString("status", null);

        if (!isPresent(externalId)) {

            // Recorded as sent, but nothing to match a future delivery receipt against.

            return new SendResult(true, null, status, "success with no message id");

        }

        return new SendResult(true, externalId, status, null);

    }

    /** Parses the approved-template list. Returns an empty list rather than throwing on a bad body. */

    public static List<BotPenguinTemplateInfo> parseTemplates(String response) {

        List<BotPenguinTemplateInfo> templates = new ArrayList<>();

        if (!isPresent(response)) {

            return templates;

        }

        JSONArray rows;

        try {

            rows = new JSONObject(response).optJSONArray("data");

        } catch (Exception e) {

            return templates;

        }

        if (rows == null) {

            return templates;

        }

        for (int i = 0; i < rows.length(); i++) {

            JSONObject row = rows.optJSONObject(i);

            if (row == null) {

                continue;

            }

            JSONObject configuration = row.optJSONObject("configuration");

            if (configuration == null) {

                configuration = new JSONObject();

            }

            templates.add(new BotPenguinTemplateInfo(

                    row.optString("_id", null),

                    row.optString("templateId", null),

                    configuration.optString("name", null),

                    configuration.optString("language", null),

                    configuration.optString("parameterFormat", null),

                    row.optString("status", null)));

        }

        return templates;

    }

    private static JSONObject data(JSONObject json) {

        JSONObject data = json.optJSONObject("data");

        if (data != null) {

            return data;

        }

        JSONArray array = json.optJSONArray("data");

        if (array != null && array.length() > 0) {

            return array.optJSONObject(0);

        }

        return null;

    }

    private static String errorText(JSONObject json, String raw) {

        String message = firstNonEmpty(json, "message", "error", "errors");

        return isPresent(message) ? message : truncate(raw);

    }

    private static String firstNonEmpty(JSONObject json, String... keys) {

        for (String key : keys) {

            if (json.has(key)) {

                String value = json.optString(key, null);

                if (isPresent(value)) {

                    return value;

                }

            }

        }

        return null;

    }

    private static String truncate(String value) {

        if (value == null) {

            return null;

        }

        return value.length() <= 200 ? value : value.substring(0, 200);

    }

    private static boolean isPresent(String value) {

        return value != null && !value.trim().isEmpty();

    }

}