@phonghq/go-chat 1.0.72 → 1.0.74

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/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/plugins/axios-gci.d.ts

@@ -0,0 +1,3 @@
+declare const instance: import("axios").AxiosInstance;
+export declare const setAxiosGciInstance: (token: string, domain: string, id: string) => void;
+export default instance;

package/dist/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?.status == 200) && 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/plugins/axios.d.ts

@@ -0,0 +1,3 @@
+declare const instance: import("axios").AxiosInstance;
+export declare const setAxiosInstance: (token: string, domain?: string) => void;
+export default instance;

package/dist/plugins/axios.js

@@ -0,0 +1,84 @@
+import axios from 'axios';
+// const baseURL = 'https://go-chat.dev01.dtsmart.dev/'
+const baseURL = 'https://go-chat-backend.gci-app2.dtsmart.dev';
+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;
+            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/plugins/mqtt.d.ts

@@ -0,0 +1,8 @@
+import mqtt from 'mqtt';
+export declare const connectMqtt: () => Promise<void>;
+export declare const subscribeToTopic: (topic: string) => void;
+export declare const unsubscribeFromTopic: (topic: string) => Promise<void>;
+export declare const publishMessage: (topic: string, payload: any) => Promise<void>;
+export declare const addHandleMqttMessage: (key: string, topic: string, callBack: any) => void;
+export declare const removeHandleMqttMessage: (key: string) => void;
+export declare const getMqttInstance: () => mqtt.MqttClient | null;

package/dist/plugins/mqtt.js

@@ -0,0 +1,189 @@
+// import mqtt from 'mqtt/dist/mqtt.min'
+import mqtt from 'mqtt';
+import { tryParseJson } from '../utils/json';
+const mqttOptions = { qos: 1, retain: false };
+// const mqttClient = ref<MqttClient | null>(null)
+let mqttClient = null;
+let _clientTime = `_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+let _isConnected = false;
+const subscribedTopics = new Set();
+let dataCallBack = [];
+let reconnectCount = 0;
+const MAX_RECONNECT = 5;
+export const connectMqtt = async () => {
+    const res = await _setupMqtt();
+    if (res?.is_new_connect) {
+        subscribedTopics.forEach((topic) => {
+            mqttClient?.subscribe(topic, mqttOptions, (err) => {
+                if (!err) {
+                    console.log(`Subscribed to ${topic}`);
+                }
+                else {
+                    console.error(`Failed to subscribe ${topic}`, err);
+                }
+            });
+        });
+        mqttClient?.on('message', (topic, message) => {
+            try {
+                let data = message;
+                if (message instanceof Uint8Array) {
+                    const decoder = new TextDecoder('utf-8');
+                    data = tryParseJson(decoder.decode(message));
+                }
+                console.log(data, topic);
+                dataCallBack
+                    .filter((e) => {
+                    return _getSameTopic(topic, e.topic);
+                })
+                    .forEach((e) => {
+                    e.callBack(topic, data);
+                });
+            }
+            catch (e) {
+                console.error('Error parsing message:', e);
+            }
+        });
+    }
+};
+const _getSameTopic = (topic_response, topic) => {
+    if (topic_response == topic)
+        return true;
+    if (!topic.indexOf('+'))
+        return false;
+    const topic_parts = topic.split('/');
+    const topic_response_parts = topic_response.split('/');
+    if (topic_parts.length !== topic_response_parts.length)
+        return false;
+    return topic_parts.every((part, i) => {
+        return part === '+' || part === topic_response_parts[i];
+    });
+};
+const _setupMqtt = () => {
+    return new Promise((resolve, reject) => {
+        reconnectCount = 0;
+        if (mqttClient && _isConnected) {
+            return resolve({});
+        }
+        mqttClient?.removeAllListeners();
+        const userInfo = JSON.parse(localStorage.getItem('user') || '{}');
+        const clientId = userInfo?.id;
+        const MQTT_OPTIONS = {
+            protocolVersion: 5,
+            clientId: `${clientId}_${_clientTime}`,
+            // host: 'mqtt-digital-signage.dev01.dtsmart.dev',
+            host: 'gap-broker.fast-boy.net',
+            port: 443,
+            protocol: 'wss',
+            // username: 'admin123',
+            // password: 'admin123',
+            clean: false,
+            reconnectPeriod: 1000,
+            path: '/mqtt'
+        };
+        const { host, port, path, ...options } = MQTT_OPTIONS;
+        const connectUrl = `wss://${host}:${port}${path}`;
+        mqttClient = mqtt.connect(connectUrl, options);
+        mqttClient?.on('reconnect', () => {
+            console.log('Reconnecting...');
+            reconnectCount++;
+            if (reconnectCount >= MAX_RECONNECT) {
+                reject();
+            }
+        });
+        mqttClient?.on('offline', () => {
+            _isConnected = false;
+        });
+        mqttClient?.on('close', () => {
+            _isConnected = false;
+        });
+        mqttClient?.on('error', (err) => {
+            _isConnected = false;
+            reject(err);
+        });
+        mqttClient?.on('connect', () => {
+            _isConnected = true;
+            setTimeout(() => {
+                resolve({ is_new_connect: true });
+            }, 200);
+        });
+    });
+};
+const _disconnectMqtt = () => {
+    if (mqttClient) {
+        mqttClient?.removeAllListeners();
+        mqttClient?.end(false, {}, () => {
+            mqttClient = null;
+        });
+    }
+};
+export const subscribeToTopic = (topic) => {
+    if (subscribedTopics.has(topic) || !topic) {
+        return;
+    }
+    if (_isConnected) {
+        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 = async (topic) => {
+    if (!topic)
+        return;
+    if (!_isConnected || !mqttClient) {
+        subscribedTopics.delete(topic);
+        return;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            mqttClient?.unsubscribe(topic, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        subscribedTopics.delete(topic);
+        console.log(`Unsubscribed from ${topic}`);
+    }
+    catch (err) {
+        console.error(`Failed to unsubscribe ${topic}`, err);
+    }
+};
+export const publishMessage = async (topic, payload) => {
+    if (!_isConnected) {
+        await connectMqtt();
+    }
+    if (_isConnected && payload) {
+        const message = typeof payload !== 'string' ? JSON.stringify(payload) : payload;
+        mqttClient?.publish(topic, message, {
+            qos: 1,
+            retain: false,
+            properties: {
+                messageExpiryInterval: 60
+            }
+        }, (err) => {
+            if (!err) {
+            }
+            else {
+                console.error(`Failed to publish message to ${topic}`, err);
+            }
+        });
+    }
+};
+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/plugins/pocketbase.d.ts

@@ -0,0 +1,5 @@
+import PocketBase from 'pocketbase';
+declare const instance: PocketBase;
+export declare const createBusinessTenantPhone: (data: any) => Promise<void>;
+export declare const checkHasBusinessTenantPhone: (id: any) => Promise<boolean>;
+export default instance;

package/dist/plugins/pocketbase.js

@@ -0,0 +1,15 @@
+import PocketBase from 'pocketbase';
+const instance = new PocketBase("https://gap-calendar-log.gci-app.dtsmart.dev/");
+export const createBusinessTenantPhone = async (data) => {
+    await instance.collection('go_chat_service').create(data);
+};
+export const checkHasBusinessTenantPhone = async (id) => {
+    try {
+        await instance.collection('go_chat_service').getFirstListItem(`tenant_id="${id}"`);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+export default instance;

package/dist/plugins/sdk.d.ts

@@ -0,0 +1,18 @@
+import { GapMiniAppSdk } from 'gap-miniapp-sdk';
+declare const gapMiniAppSdk: {
+    getInstance: () => GapMiniAppSdk;
+    getAccessToken: () => Promise<{
+        domain: string;
+        gClient: string;
+        token: string;
+    }>;
+};
+declare const sdkInit: (data: {
+    id?: string;
+    token?: string;
+    domain?: string;
+}) => Promise<{
+    status: boolean;
+    tenant_error?: boolean;
+}>;
+export { sdkInit, gapMiniAppSdk };

package/dist/plugins/sdk.js

@@ -0,0 +1,73 @@
+import { GapMiniAppSdk } from 'gap-miniapp-sdk';
+import logger from '../utils/logger';
+import { loginTenant, setDataLogin } from '../utils/chat/store/auth';
+import { setAxiosGciInstance } from '../plugins/axios-gci';
+const gapMiniAppSdk = (function () {
+    let instance;
+    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 };

package/dist/plugins/websocket.d.ts

@@ -0,0 +1,15 @@
+export declare function initWebSocket(): Promise<any>;
+export declare const socketSend: (data: any) => void;
+export declare const getWebSocket: () => Promise<any>;
+export declare const addHandleWebSK: (key: string, callBack: any) => void;
+export declare const removeHandleWebSK: (key: string) => void;
+export declare class WebSocketClient {
+    private socket;
+    private dataCallbacks;
+    private server;
+    constructor(server: string, callBack: ((message: any) => any));
+    init(): Promise<void>;
+    send(data: any): void;
+    sendDefault(data: any): void;
+    disconnect(): void;
+}

package/dist/plugins/websocket.js

@@ -0,0 +1,151 @@
+import { tryParseJson } from '../utils/json';
+import { dataProfile } from '../utils/chat/store/auth';
+let socket = null;
+let dataCallBack = [];
+let callId = '';
+// const BASE_URL = 'wss://web-socket.dev01.dtsmart.dev/web-stream'
+const BASE_URL = 'wss://web-socket-test.dev01.dtsmart.dev/web-stream';
+const BARE_URL_INBOUND = 'https://web-socket.dev01.dtsmart.dev';
+export function initWebSocket() {
+    return new Promise((resolve, reject) => {
+        if (socket && socket.readyState === 1) {
+            console.log("WebSocket đã kết nối, bỏ qua connect.");
+            resolve('Connected');
+            return;
+        }
+        const timer = setTimeout(() => {
+            socket?.close?.();
+            reject(new Error("WebSocket connection timeout"));
+        }, 5000);
+        // socket = new WebSocket('wss://' + callId)
+        socket = new WebSocket(BASE_URL);
+        socket.binaryType = 'arraybuffer';
+        socket.onopen = (event) => {
+            clearTimeout(timer);
+            resolve('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);
+            reject(event);
+        };
+    });
+}
+export const socketSend = (data) => {
+    try {
+        let request = typeof data == 'string' ? data : JSON.stringify(data);
+        socket?.send(data);
+    }
+    catch (e) {
+        console.log(e);
+    }
+};
+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: dataProfile.value?.tenant_id
+            }),
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: 'Bearer -Qixt-ZztiBA5Dxl-EIWG7f2TDhK-ZCj'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Response status: ${response.status}`);
+        }
+        const result = await response.json();
+        callId = result?.wsUrl;
+        return result;
+    }
+    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);
+    }
+};
+export class WebSocketClient {
+    socket = null;
+    dataCallbacks = null;
+    server;
+    constructor(server, callBack) {
+        this.server = server;
+        this.dataCallbacks = callBack;
+    }
+    async init() {
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                reject(new Error("Missing uuid!"));
+            this.socket = new WebSocket(BASE_URL + '?call_uuid=' + this.server);
+            console.log(BASE_URL + '?call_uuid=' + this.server);
+            this.socket.binaryType = "arraybuffer";
+            const timeout = setTimeout(() => {
+                reject(new Error("⏰ WebSocket connection timeout"));
+            }, 5000); // 5s timeout
+            this.socket.onopen = () => {
+                clearTimeout(timeout);
+                resolve(); // Kết nối thành công
+            };
+            this.socket.onmessage = (event) => {
+                const data = tryParseJson(event.data);
+                console.log(data);
+                this.dataCallbacks?.(data);
+            };
+            this.socket.onclose = (event) => {
+            };
+            this.socket.onerror = (event) => {
+                clearTimeout(timeout);
+                reject(new Error("WebSocket connection error"));
+            };
+        });
+    }
+    send(data) {
+        try {
+            const message = typeof data === 'string' ? data : JSON.stringify(data);
+            this.socket?.send(message);
+        }
+        catch (e) {
+            console.error('Send error:', e);
+        }
+    }
+    sendDefault(data) {
+        try {
+            this.socket?.send(data);
+        }
+        catch (e) {
+            console.error('Send error:', e);
+        }
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.onopen = null;
+            this.socket.onmessage = null;
+            this.socket.onclose = null;
+            this.socket.onerror = null;
+            if (this.socket.readyState === WebSocket.OPEN) {
+                this.socket.close(1000, "Manual disconnect");
+                console.log("🔌 WebSocket closed manually");
+            }
+            this.socket = null;
+        }
+        this.dataCallbacks = null;
+    }
+}