@phonghq/go-chat 1.0.4 → 1.0.6

package/dist/test/composable/useDigibot.js

@@ -0,0 +1,22 @@
+//PINIA
+export const digibotData = {
+    id: -98,
+    receiver_id: 101,
+    username: 'digibot',
+    customer_phone: '',
+    avatar: '',
+    last_message: '',
+    last_message_time: '',
+    created_at: '',
+    updated_at: '',
+    unread_count: 0,
+    status: 1,
+    color: '#4F46E5',
+};
+export const digibotId = -98;
+export function useDigibot() {
+    return {
+        digibotData,
+        digibotId,
+    };
+}

package/dist/test/composable/useInitData.js

@@ -0,0 +1,84 @@
+import { ref } from 'vue';
+import { sdkInit } from '../plugins/sdk';
+import { dataProfile, getProfile, loginLink } from '../utils/chat/auth';
+import { routerPush } from '../utils/chat/chat-router';
+import { PAGE } from '../constant/general';
+import { subscribeToTopic, unsubscribeFromTopic } from '../plugins/mqtt';
+import { TOPIC_DETAIL_CALL } from '../constant/mqtt';
+import { getWebSocket } from '../plugins/websocket';
+//PINIA
+export const isRouterReady = ref(false);
+export function useInitData() {
+    const NOTIFY_ID_APPOINTMENT_NAME = 'notifyIdAppointment';
+    const initPage = async (data) => {
+        try {
+            isRouterReady.value = false;
+            const sdk_res = await sdkInit({ id: data.id, token: data.token, domain: data.domain });
+            if (sdk_res.tenant_error) {
+                const api_link_res = await loginApiLink();
+                // if (api_link_res.client_error) {
+                //   routerPush(PAGE.TENANT_ERROR)
+                //   return
+                // }
+            }
+            // connectMqtt()
+            await initData();
+            if (data.response == 'mobile') {
+                routerPush(PAGE.CHAT_LIST);
+            }
+            else {
+                routerPush(PAGE.HOME);
+            }
+        }
+        catch (error) {
+            console.log(error);
+        }
+        finally {
+            isRouterReady.value = true;
+        }
+    };
+    const initData = async () => {
+        await getProfile();
+        getWebSocket();
+        unsubscribeFromTopic(TOPIC_DETAIL_CALL + dataProfile.value?.id);
+        subscribeToTopic(TOPIC_DETAIL_CALL + dataProfile.value?.id);
+    };
+    const loginApiLink = async () => {
+        try {
+            const queryString = window.location.search;
+            const urlParams = new URLSearchParams(queryString);
+            const tenant_id = urlParams.get('tenant_id') || '';
+            const phone = urlParams.get('phone') || '';
+            const message = urlParams.get('message') || '';
+            const customer_name = urlParams.get('customer_name') || '';
+            const business_name = urlParams.get('business_name') || '';
+            if (!tenant_id || !phone || !message || !customer_name || !business_name)
+                return { client_error: true };
+            const param = {
+                tenant_id,
+                phone,
+                message,
+                customer_name,
+                business_name
+            };
+            await loginLink(param);
+            clearApiParams();
+            return {};
+        }
+        catch (error) {
+            console.log(error);
+            return { client_error: true };
+        }
+        finally {
+        }
+    };
+    const clearApiParams = () => {
+        const url = new URL(window.location.href);
+        url.search = "";
+        window.history.replaceState({}, document.title, url);
+    };
+    return {
+        NOTIFY_ID_APPOINTMENT_NAME,
+        initPage
+    };
+}

package/dist/test/composable/useModalConfirm.js

@@ -0,0 +1,39 @@
+import { ref } from 'vue';
+// export type ConfirmPayload = {
+//   headerTitle?: string
+//   bodyTitle?: string
+//   bodyImage?: string
+//   bodyMessage?: string
+//   confirmButtonText?: string
+//   cancelButtonText?: string
+//   timeOut?: number //seconds
+//   type?: 'confirm' | 'information'
+// }
+//
+// export type ConfirmPayloadPromise = AddPromise<ConfirmPayload>
+const handleConfirm = ref(null);
+function setHandleConfirm(callback) {
+    handleConfirm.value = callback;
+}
+export function useModalConfirm() {
+    function setHandleConfirm(callback) {
+        handleConfirm.value = callback;
+    }
+    function modalConfirm(data) {
+        return new Promise((resolve, reject) => {
+            if (handleConfirm.value == null) {
+                reject('Modal is not already active');
+                return;
+            }
+            handleConfirm.value({
+                ...data,
+                resolve,
+                reject
+            });
+        });
+    }
+    return {
+        setHandleConfirm,
+        modalConfirm
+    };
+}

package/dist/test/constant/color.js

@@ -0,0 +1,43 @@
+export var Status_Color;
+(function (Status_Color) {
+    Status_Color["Orange"] = "#F2994A";
+    Status_Color["Blue_Teal"] = "#F2994A";
+})(Status_Color || (Status_Color = {}));
+var Color;
+(function (Color) {
+    Color["Primary"] = "#0051E6";
+    Color["Primary_Hover"] = "#699FF5";
+    Color["Primary_RGB"] = "41, 121, 255";
+    Color["Error"] = "#ff3b3b";
+    Color["Error_Hover"] = "#FF8A75";
+    Color["Success"] = "#1DA91D";
+    Color["Success_Hover"] = "#5FD9A0";
+    Color["Success_Bg"] = "#E9FFE4";
+    Color["Warning"] = "#f3a22c";
+    Color["Text"] = "#333333";
+    Color["Link"] = "#1890ff";
+    Color["Default_Appointment"] = "#rgb(244, 185, 124)";
+    Color["Done_Appointment"] = "#00d652";
+    Color["Cancel_Appointment"] = "#ff0000";
+})(Color || (Color = {}));
+export default Color;
+export function defineRootColor() {
+    const root = document.querySelector(':root');
+    if (root) {
+        root.style?.setProperty('--chat-color-primary', Color.Primary);
+        // root.style?.setProperty('--chat-color-primary_hover', Color.Primary_Hover)
+        // root.style?.setProperty('--chat-color-primary_rgb', Color.Primary_RGB)
+        // root.style?.setProperty('--chat-color-error', Color.Error)
+        // root.style?.setProperty('--chat-color-error_hover', Color.Error_Hover)
+        root.style?.setProperty('--chat-color-success', Color.Success);
+        // root.style?.setProperty('--chat-color-success-bg', Color.Success_Bg)
+        // root.style?.setProperty('--chat-color-success_hover', Color.Success_Hover)
+        // root.style?.setProperty('--chat-color-second-success', Color.Success)
+        // root.style?.setProperty('--chat-color-warning', Color.Warning)
+        // root.style?.setProperty('--chat-color-text', Color.Text)
+        // root.style?.setProperty('--chat-color-link', Color.Link)
+        // root.style?.setProperty('--chat-color-default_appointment', Color.Default_Appointment)
+        // root.style?.setProperty('--chat-color-done_appointment', Color.Done_Appointment)
+        // root.style?.setProperty('--chat-color-cancel_appointment', Color.Cancel_Appointment)
+    }
+}

package/dist/test/constant/datetime.js

@@ -0,0 +1,5 @@
+export const DATE_FORMATS = {
+    DATE_FORMAT: 'YYYY-MM-DD',
+    DATE_FORMAT_FULL: 'YYYY-MM-DD HH:mm:ss',
+    TIME_12_FORMAT: 'hh:mm A'
+};

package/dist/test/constant/general.js

@@ -0,0 +1,9 @@
+export var PAGE;
+(function (PAGE) {
+    PAGE["HOME"] = "home";
+    PAGE["CUSTOMER_DETAIL"] = "customer_detail";
+    PAGE["CUSTOMER_CHECK_IN"] = "customer_check_in";
+    PAGE["CUSTOMER_APPOINTMENT"] = "customer_appointment";
+    PAGE["TENANT_ERROR"] = "tenant_error";
+    PAGE["CHAT_LIST"] = "chat_list";
+})(PAGE || (PAGE = {}));

package/dist/test/constant/message.js

@@ -0,0 +1,8 @@
+export const MessageState = {
+    Sending: "sending",
+    Sent: "sent",
+    Read: "read",
+    Failed: "failed",
+    Uploading: "uploading",
+    Uploaded: "uploaded"
+};

package/dist/test/constant/mqtt.js

@@ -0,0 +1,11 @@
+export const TOPIC_DETAIL_CHAT = 'chat/message/';
+export const TOPIC_DETAIL_CALL = 'call/message/';
+export const TOPIC_HOME = [
+    'chat/conversation/update/',
+    'chat/conversation/read_message/',
+    'chat/conversation/update_list/'
+];
+export const TOPIC_STATUS_USER = 'user/status/';
+// export CALL_STATE = {
+//   Offer: 'offer',
+// }

package/dist/test/constant/user.js

@@ -0,0 +1,9 @@
+export var CalendarStatus;
+(function (CalendarStatus) {
+    CalendarStatus["Confirmed"] = "confirmed";
+    CalendarStatus["Scheduled"] = "scheduled";
+    CalendarStatus["Canceled"] = "canceled";
+    CalendarStatus["Done"] = "done";
+    CalendarStatus["Reminder"] = "reminder";
+    CalendarStatus["Waiting"] = "wait_list";
+})(CalendarStatus || (CalendarStatus = {}));

package/dist/test/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/test/plugins/axios-gci.js

@@ -0,0 +1,25 @@
+import axios from 'axios';
+const instance = axios.create({
+    timeout: 20000,
+    headers: {
+        'Content-Type': 'application/json'
+    }
+});
+export const setAxiosGciInstance = (token, domain, id) => {
+    instance.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    instance.defaults.baseURL = domain;
+    instance.defaults.headers.common['G-ClientID'] = id || '';
+};
+instance.interceptors.response.use((response) => {
+    console.log(response);
+    const data = response?.data;
+    if (data?.status == 'OK' && data?.result?.status == 'OK' && data?.result?.data) {
+        return Promise.resolve(data?.result?.data);
+    }
+    else {
+        return Promise.reject(data?.message ?? 'Error');
+    }
+}, async (error) => {
+    return Promise.reject(error.response?.data || error);
+});
+export default instance;

package/dist/test/plugins/axios.js

@@ -0,0 +1,85 @@
+import axios from 'axios';
+const baseURL = 'https://go-chat.dev01.dtsmart.dev/';
+// const baseURL = 'http://192.168.1.152:8085/'
+const instance = axios.create({
+    baseURL,
+    timeout: 20000,
+    headers: {
+        'Content-Type': 'application/json'
+    }
+});
+export const setAxiosInstance = (token, domain) => {
+    instance.defaults.headers.common['Authorization'] = `Bearer ${token}`;
+    instance.defaults.baseURL = domain || baseURL;
+};
+instance.interceptors.request.use((config) => {
+    const token = config?.token || localStorage.getItem('chat_token');
+    if (token) {
+        config.headers.Authorization = `Bearer ${token}`;
+    }
+    return config;
+}, (error) => Promise.reject(error));
+let isRefreshing = false;
+let failedQueue = [];
+const processQueue = (error, token = null) => {
+    failedQueue.forEach((prom) => {
+        if (token) {
+            prom.resolve(token);
+        }
+        else {
+            prom.reject(error);
+        }
+    });
+    failedQueue = [];
+};
+instance.interceptors.response.use((response) => {
+    const data = response?.data;
+    if (data.files) {
+        return Promise.resolve(data.files);
+    }
+    if (data?.status && data?.data) {
+        return Promise.resolve(data.data);
+    }
+    else {
+        return Promise.reject(data?.messages ?? 'Error');
+    }
+}, async (error) => {
+    const originalRequest = error.config;
+    if (error.response?.status === 403 && !originalRequest._retry) {
+        originalRequest._retry = true;
+        if (isRefreshing) {
+            return new Promise((resolve, reject) => {
+                failedQueue.push({
+                    resolve: (token) => {
+                        originalRequest.headers['Authorization'] = 'Bearer ' + token;
+                        resolve(instance(originalRequest));
+                    },
+                    reject: (err) => reject(err)
+                });
+            });
+        }
+        isRefreshing = true;
+        const authStore = null;
+        try {
+            const body = {
+                refresh_token: localStorage.getItem('refresh_token') || ''
+            };
+            const res = await authStore.refreshToken(body);
+            const newToken = res.data.token;
+            localStorage.setItem('chat_token', newToken);
+            instance.defaults.headers.common['Authorization'] = 'Bearer ' + newToken;
+            console.log(newToken, 'asgfasf');
+            processQueue(null, newToken);
+            return instance(originalRequest);
+        }
+        catch (err) {
+            processQueue(err, null);
+            return Promise.reject(err);
+        }
+        finally {
+            isRefreshing = false;
+        }
+    }
+    return Promise.reject(error.response?.data || error);
+});
+export default instance;

package/dist/test/plugins/mqtt.js

@@ -0,0 +1,128 @@
+import mqtt from 'mqtt/dist/mqtt.min';
+const mqttOptions = { qos: 1, retain: false };
+// const mqttClient = ref<MqttClient | null>(null)
+let mqttClient = null;
+const subscribedTopics = new Set();
+let dataCallBack = [];
+export const connectMqtt = () => {
+    return new Promise((resolve, reject) => {
+        console.log(mqttClient);
+        if (mqttClient && mqttClient?.connected) {
+            console.log('MQTT already connected');
+            return resolve();
+        }
+        const userInfo = JSON.parse(localStorage.getItem('user') || '{}');
+        const clientId = userInfo?.id;
+        const MQTT_OPTIONS = {
+            clientId: `${clientId}_${Date.now()}_${Math.floor(Math.random() * 1000)}`,
+            host: 'mqtt-digital-signage.dev01.dtsmart.dev',
+            port: 443,
+            protocol: 'wss',
+            username: 'admin123',
+            password: 'admin123',
+            clean: true,
+            reconnectPeriod: 1000,
+            path: '/mqtt'
+        };
+        const { host, port, path, ...options } = MQTT_OPTIONS;
+        const connectUrl = `wss://${host}:${port}${path}`;
+        mqttClient = mqtt.connect(connectUrl, options);
+        mqttClient?.on('connect', () => {
+            console.log('MQTT Connected Successfully');
+            subscribedTopics.forEach((topic) => mqttClient?.subscribe(topic));
+            mqttClient?.on('message', (topic, message) => {
+                try {
+                    let data = message;
+                    if (message instanceof Uint8Array) {
+                        const decoder = new TextDecoder('utf-8');
+                        data = JSON.parse(decoder.decode(message));
+                    }
+                    dataCallBack
+                        .filter((e) => e.topic === topic)
+                        .forEach((e) => {
+                        e.callBack(topic, data);
+                    });
+                }
+                catch (e) {
+                    console.error('Error parsing message:', e);
+                }
+            });
+            resolve();
+        });
+        mqttClient?.on('close', () => {
+            console.log('MQTT Disconnected');
+        });
+        mqttClient?.on('error', (err) => {
+            console.error('MQTT Error:', err);
+            reject(err);
+        });
+    });
+};
+export const disconnectMqtt = () => {
+    if (mqttClient) {
+        mqttClient?.end(false, {}, () => {
+            console.log('MQTT Disconnected');
+            mqttClient = null;
+        });
+    }
+};
+export const subscribeToTopic = (topic) => {
+    if (subscribedTopics.has(topic)) {
+        console.log(`Already subscribed to ${topic}`);
+        return;
+    }
+    if (mqttClient?.connected || true) {
+        mqttClient?.subscribe(topic, mqttOptions, (err) => {
+            if (!err) {
+                subscribedTopics.add(topic);
+                console.log(`Subscribed to ${topic}`);
+            }
+            else {
+                console.error(`Failed to subscribe ${topic}`, err);
+            }
+        });
+    }
+};
+export const unsubscribeFromTopic = (topic) => {
+    if (mqttClient?.connected || true) {
+        mqttClient?.unsubscribe(topic, (err) => {
+            if (!err) {
+                subscribedTopics.delete(topic);
+                console.log(`Unsubscribed from ${topic}`);
+            }
+            else {
+                console.error(`Failed to unsubscribe ${topic}`, err);
+            }
+        });
+    }
+    else {
+        subscribedTopics.delete(topic);
+    }
+};
+export const publishMessage = (topic, payload) => {
+    if (mqttClient?.connected && payload) {
+        const message = typeof payload !== 'string' ? JSON.stringify(payload) : payload;
+        mqttClient?.publish(topic, message, { qos: 1, retain: false }, (err) => {
+            if (!err) {
+                // console.log(`Published message to ${topic}`)
+            }
+            else {
+                console.error(`Failed to publish message to ${topic}`, err);
+            }
+        });
+    }
+    else {
+        console.warn('MQTT not connected, cannot publish');
+    }
+};
+export const addHandleMqttMessage = (key, topic, callBack) => {
+    removeHandleMqttMessage(key);
+    dataCallBack.push({ key, callBack, topic });
+};
+export const removeHandleMqttMessage = (key) => {
+    const index = dataCallBack.findIndex((e) => e.key === key);
+    if (index > -1) {
+        dataCallBack.splice(index, 1);
+    }
+};
+export const getMqttInstance = () => mqttClient;

package/dist/test/plugins/sdk.js

@@ -0,0 +1,83 @@
+import Gap, { GapApiVersion } from 'gap-nodejs-sdk';
+import { GapMiniAppSdk } from 'gap-miniapp-sdk';
+import logger from '../utils/logger';
+import { loginTenant, setDataLogin } from '../utils/chat/auth';
+import { setAxiosGciInstance } from '../plugins/axios-gci';
+const baseSdk = new Gap.BaseApi(GapApiVersion.V1);
+const gapMiniAppSdk = (function () {
+    let instance;
+    // let domain = '';
+    // let gClient = '';
+    // let token = '';
+    // if (process.env.NODE_ENV === "development") {
+    //     domain = import.meta.env.VITE_DOMAIN;
+    //     gClient = import.meta.env.VITE_GCLIENT_ID;
+    //     token = import.meta.env.VITE_TOKEN;
+    // }
+    function createInstance() {
+        return new GapMiniAppSdk(logger);
+    }
+    return {
+        getInstance: function () {
+            if (!instance) {
+                instance = createInstance();
+            }
+            return instance;
+        },
+        getAccessToken: async function () {
+            let domain = '';
+            let gClient = '';
+            let token = '';
+            try {
+                let userAgent;
+                if (gapMiniAppSdk.getInstance().detectPlatform()) {
+                    userAgent = gapMiniAppSdk.getInstance().detectPlatform();
+                }
+                if (userAgent) {
+                    gapMiniAppSdk.getInstance().setPlatformExecutor(userAgent);
+                    const response = await gapMiniAppSdk.getInstance().getAccessToken();
+                    if (response &&
+                        typeof response.token !== 'undefined' &&
+                        response.token != '') {
+                        domain = response.domain;
+                        gClient = response.gClientId;
+                        token = response.token;
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return { domain, gClient, token };
+        }
+    };
+})();
+const sdkInit = (data) => {
+    return new Promise(async (resolve, reject) => {
+        let status = false;
+        try {
+            let { domain, gClient, token } = await gapMiniAppSdk.getAccessToken();
+            domain = data.domain || domain || '';
+            gClient = data.id || gClient || '';
+            token = data.token || token || '';
+            if (!domain || !gClient || !token) {
+                resolve({ status, tenant_error: true });
+                return;
+            }
+            setAxiosGciInstance(token, domain, gClient);
+            await loginTenant({ tenant_id: gClient });
+            status = true;
+            setDataLogin(gClient, token, domain);
+            localStorage.setItem('chat_id', gClient);
+            localStorage.setItem('chat_accessToken', token);
+            localStorage.setItem('chat_domain', domain);
+            resolve({ status });
+        }
+        catch (error) {
+            resolve({ status, tenant_error: true });
+            console.error(error);
+            // reject(error)
+        }
+    });
+};
+export { sdkInit, gapMiniAppSdk, baseSdk };

package/dist/test/plugins/websocket.js

@@ -0,0 +1,65 @@
+import { tryParseJson } from '../utils/json';
+let socket = null;
+let dataCallBack = [];
+export function initWebSocket(server) {
+    // Create WebSocket connection.
+    socket = new WebSocket('wss://web-socket.dev01.dtsmart.dev');
+    // socket.addEventListener('open', (event: any) => {
+    //   console.log('fffffff')
+    //   socket.send('Hello Server!')
+    // })
+    //
+    // socket.addEventListener('message', (event: any) => {
+    //   console.log('Message from server ', event.data)
+    // })
+    socket.onopen = (event) => {
+        console.log('Connected!');
+    };
+    socket.onmessage = (event) => {
+        const data = tryParseJson(event.data);
+        dataCallBack.forEach((e) => {
+            e.callBack(data);
+        });
+    };
+    socket.onclose = (event) => {
+        console.log('Disconnected:', event.reason);
+    };
+    socket.onerror = (event) => {
+        console.error('Socket error:', event);
+    };
+}
+const socketSend = (data) => {
+    let request = typeof data == 'string' ? data : JSON.stringify(data);
+    socket.send(request);
+};
+export const getWebSocket = async () => {
+    const url = 'https://web-socket.dev01.dtsmart.dev/ws/connect';
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify({
+                clientId: 'test1'
+            }),
+            headers: {
+                Authorization: 'Bearer -Qixt-ZztiBA5Dxl-EIWG7f2TDhK-ZCj'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Response status: ${response.status}`);
+        }
+        const result = await response.json();
+    }
+    catch (error) {
+        console.error(error.message);
+    }
+};
+export const addHandleWebSK = (key, callBack) => {
+    removeHandleWebSK(key);
+    dataCallBack.push({ key, callBack });
+};
+export const removeHandleWebSK = (key) => {
+    const index = dataCallBack.findIndex((e) => e.key === key);
+    if (index > -1) {
+        dataCallBack.splice(index, 1);
+    }
+};

package/dist/test/types/call.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/chat/auth.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/chat/global.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/chat/promise.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/chat/user.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/conversation.js

@@ -0,0 +1 @@
+export {};

package/dist/test/types/global.js

@@ -0,0 +1,15 @@
+export {};
+// declare global {
+//   /**
+//    * Now declare things that go in the global namespace,
+//    * or augment existing declarations in the global namespace.
+//    */
+//   type AddPromise<T = unknown> = T & {
+//     resolve: Resolve
+//     reject?: Reject
+//   }
+//
+//   // PROMISE
+//   declare type Resolve = typeof ReturnType<Promise.resolve>
+//   declare type Reject = typeof ReturnType<Promise.reject>
+// }

package/dist/test/types/message.js

@@ -0,0 +1 @@
+export {};