@droppii-org/chat-sdk 0.1.71 → 0.1.73

package/dist/src/hooks/message/useSendMessage.js

@@ -0,0 +1,563 @@
+import { MessageStatus, MessageType, } from "@openim/wasm-client-sdk";
+import { CustomMessageType, } from "../../types/customMessage";
+import { DChatSDK } from "../../constants/sdk";
+import { v4 as uuidv4 } from "uuid";
+import { useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import { pushNewMessage, removeOneMessage, updateOneMessage, } from "./useMessage";
+import { emit } from "../../utils/events";
+import useConversationStore from "../../store/conversation";
+import useAuthStore from "../../store/auth";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { generateContentBasedOnMessageType } from "../../utils/common";
+import { extractLinkUrls } from "../../utils/link";
+import { SessionStatus, SessionTag } from "../../types/chat";
+import { updateSession } from "../../hooks/session/useUpdateSession";
+import { invalidateSessionQueries } from "../../utils/queryHelpers";
+const messageFileStore = new Map();
+const MEDIA_CONTENT_TYPES = new Set([
+    MessageType.PictureMessage,
+    MessageType.VideoMessage,
+    MessageType.FileMessage,
+]);
+export const isMediaResendable = (message) => !MEDIA_CONTENT_TYPES.has(message.contentType) ||
+    messageFileStore.has(message.clientMsgID);
+export const createTextMessage = async (text) => {
+    let textMessage = await DChatSDK.createTextMessage(text, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createTextMessage", errCode, errMsg);
+        return null;
+    });
+    return textMessage;
+};
+export const createImageMessageByFile = async (file) => {
+    let imageMessage = await DChatSDK.createImageMessageByFile(file, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createImageMessageByFile", errCode, errMsg);
+        return null;
+    });
+    return imageMessage;
+};
+export const createMergerMessage = async (mergerMsgParams) => {
+    let mergerMessage = await DChatSDK.createMergerMessage(mergerMsgParams, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createMergerMessage", errCode, errMsg);
+        return null;
+    });
+    return mergerMessage;
+};
+export const createVideoMessageByFile = async (file) => {
+    let videoMessage = await DChatSDK.createVideoMessageByFile(file, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createVideoMessageByFile", errCode, errMsg);
+        return null;
+    });
+    return videoMessage;
+};
+export const createFileMessageByFile = async (file) => {
+    let fileMessage = await DChatSDK.createFileMessageByFile(file, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createFileMessageByFile", errCode, errMsg);
+        return null;
+    });
+    return fileMessage;
+};
+export const createUrlTextMessage = async (text, urls) => {
+    let textMessage = await DChatSDK.createUrlTextMessage(text, JSON.stringify(urls), new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createUrlTextMessage", errCode, errMsg);
+        return null;
+    });
+    return textMessage;
+};
+export const createCustomMessageByParams = async (params) => {
+    let customMessage = await DChatSDK.createCustomMessage(params, new Date().getTime().toString())
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createCustomMessage", errCode, errMsg);
+        return null;
+    });
+    return customMessage;
+};
+export const createCustomMessage = async (payload) => {
+    return createCustomMessageByParams({
+        data: JSON.stringify(payload.data),
+        extension: payload.type,
+        description: payload.type === CustomMessageType.Order ? payload.data.orderCode : "",
+    });
+};
+export const createQuoteMessage = async (text, quotedMessage) => {
+    let textMessage = await DChatSDK.createQuoteMessage({
+        text,
+        message: JSON.stringify(quotedMessage),
+    })
+        .then(({ data }) => {
+        return data;
+    })
+        .catch(({ errCode, errMsg }) => {
+        console.error("createQuoteMessage", errCode, errMsg);
+        return null;
+    });
+    return textMessage;
+};
+export const useSendMessage = (options) => {
+    var _a;
+    const { t } = useTranslation("common");
+    const queryClient = useQueryClient();
+    const conversationData = useConversationStore((state) => state.conversationData);
+    const quotedMessage = useConversationStore((state) => state.quotedMessage);
+    const setQuotedMessage = useConversationStore((state) => state.setQuotedMessage);
+    const { userID: recvID, groupID } = conversationData || {};
+    const scrollEvent = (_a = options === null || options === void 0 ? void 0 : options.scrollEvent) !== null && _a !== void 0 ? _a : "CHAT_LIST_SCROLL_TO_BOTTOM";
+    const syncSessionAfterPublicMessage = useCallback(async (currentSession) => {
+        if (!(currentSession === null || currentSession === void 0 ? void 0 : currentSession.id)) {
+            return;
+        }
+        const shouldUpdateStatus = currentSession.status === SessionStatus.WAITING_PROCESS ||
+            currentSession.tag === SessionTag.AWAITING_REPLY ||
+            currentSession.tag === SessionTag.TEMPORARILY_PAUSED;
+        if (!shouldUpdateStatus) {
+            return;
+        }
+        try {
+            const response = await apiInstance.put(ENDPOINTS.chatService.updateSession(currentSession.id), {
+                status: SessionStatus.IN_PROCESS,
+                applicationType: useAuthStore.getState().applicationType,
+            });
+            const updatedSession = response.data.data;
+            if (!updatedSession) {
+                return;
+            }
+            updateSession(updatedSession);
+            await invalidateSessionQueries(queryClient);
+        }
+        catch (error) {
+            console.error("syncSessionAfterPublicMessage", error);
+        }
+    }, [queryClient]);
+    const dispatchMessage = useCallback(async (message, currentSession) => {
+        var _a, _b, _c, _d, _e, _f;
+        const desc = generateContentBasedOnMessageType(message.contentType, ((_a = message === null || message === void 0 ? void 0 : message.textElem) === null || _a === void 0 ? void 0 : _a.content) || "", t, {
+            duration: (_b = message.videoElem) === null || _b === void 0 ? void 0 : _b.duration,
+            fileName: (_c = message.fileElem) === null || _c === void 0 ? void 0 : _c.fileName,
+        }, message === null || message === void 0 ? void 0 : message.customElem) || t("new_message");
+        const pushMeta = (_e = (_d = options === null || options === void 0 ? void 0 : options.resolveOfflinePushMeta) === null || _d === void 0 ? void 0 : _d.call(options, { desc })) !== null && _e !== void 0 ? _e : {
+            title: (conversationData === null || conversationData === void 0 ? void 0 : conversationData.showName) || "Droppii Chat",
+            icon: (conversationData === null || conversationData === void 0 ? void 0 : conversationData.faceURL) || "",
+            conversationId: (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) || "",
+        };
+        const { data: successMessage } = await DChatSDK.sendMessage({
+            recvID: recvID || "",
+            groupID: groupID || "",
+            message,
+            offlinePushInfo: {
+                title: pushMeta.title,
+                desc,
+                ex: JSON.stringify({
+                    icon: pushMeta.icon,
+                    conversationId: pushMeta.conversationId,
+                    title: pushMeta.title,
+                    desc,
+                }),
+                iOSPushSound: "default",
+                iOSBadgeCount: true,
+            },
+        });
+        updateOneMessage(Object.assign(Object.assign({}, successMessage), { ex: successMessage.ex || message.ex || "{}", isInternal: (_f = successMessage.isInternal) !== null && _f !== void 0 ? _f : message.isInternal }));
+        if (!message.isInternal) {
+            await syncSessionAfterPublicMessage(currentSession);
+        }
+        messageFileStore.delete(message.clientMsgID);
+    }, [
+        groupID,
+        recvID,
+        syncSessionAfterPublicMessage,
+        t,
+        conversationData === null || conversationData === void 0 ? void 0 : conversationData.showName,
+        conversationData === null || conversationData === void 0 ? void 0 : conversationData.faceURL,
+        conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID,
+        options === null || options === void 0 ? void 0 : options.resolveOfflinePushMeta,
+    ]);
+    const sendMessage = useCallback(async (message, currentSession) => {
+        pushNewMessage(message);
+        emit(scrollEvent);
+        try {
+            await dispatchMessage(message, currentSession);
+            return true;
+        }
+        catch (error) {
+            console.error("sendMessage", error);
+            updateOneMessage(Object.assign(Object.assign({}, message), { status: MessageStatus.Failed }));
+            return false;
+        }
+    }, [dispatchMessage, scrollEvent]);
+    const resendMessage = useCallback(async (failedMessage) => {
+        var _a;
+        const storedFiles = messageFileStore.get(failedMessage.clientMsgID);
+        if (!storedFiles) {
+            let newTextPayload = null;
+            const textContent = ((_a = failedMessage.textElem) === null || _a === void 0 ? void 0 : _a.content) || failedMessage.content || "";
+            if (failedMessage.contentType === MessageType.CustomMessage) {
+                newTextPayload = failedMessage.customElem
+                    ? await createCustomMessageByParams({
+                        data: failedMessage.customElem.data,
+                        extension: failedMessage.customElem.extension,
+                        description: failedMessage.customElem.description,
+                    })
+                    : null;
+            }
+            else if (failedMessage.contentType === MessageType.UrlTextMessage &&
+                failedMessage.urlTextElem) {
+                newTextPayload = await createUrlTextMessage(textContent, failedMessage.urlTextElem.urls);
+            }
+            else {
+                newTextPayload = await createTextMessage(textContent);
+            }
+            if (!newTextPayload) {
+                updateOneMessage(Object.assign(Object.assign({}, failedMessage), { status: MessageStatus.Failed }));
+                return;
+            }
+            const conversationID = (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) || "";
+            await DChatSDK.deleteMessageFromLocalStorage({
+                conversationID,
+                clientMsgID: failedMessage.clientMsgID,
+            });
+            removeOneMessage(failedMessage.clientMsgID);
+            await sendMessage(Object.assign(Object.assign({}, newTextPayload), { ex: failedMessage.ex, isInternal: failedMessage.isInternal }));
+            return;
+        }
+        let newPayload = null;
+        if (storedFiles.type === "image" && failedMessage.pictureElem) {
+            const { sourcePicture, bigPicture, snapshotPicture, sourcePath } = failedMessage.pictureElem;
+            newPayload = await createImageMessageByFile({
+                sourcePicture,
+                bigPicture,
+                snapshotPicture,
+                sourcePath,
+                file: storedFiles.file,
+            });
+        }
+        else if (storedFiles.type === "video" && failedMessage.videoElem) {
+            const elem = failedMessage.videoElem;
+            newPayload = await createVideoMessageByFile({
+                videoPath: elem.videoPath,
+                duration: elem.duration,
+                videoType: elem.videoType,
+                snapshotPath: elem.snapshotPath,
+                videoUUID: elem.videoUUID,
+                videoUrl: elem.videoUrl,
+                videoSize: elem.videoSize,
+                snapshotUUID: elem.snapshotUUID,
+                snapshotSize: elem.snapshotSize,
+                snapshotUrl: elem.snapshotUrl,
+                snapshotWidth: elem.snapshotWidth,
+                snapshotHeight: elem.snapshotHeight,
+                videoFile: storedFiles.videoFile,
+                snapshotFile: storedFiles.snapshotFile,
+            });
+        }
+        else if (storedFiles.type === "file" && failedMessage.fileElem) {
+            const elem = failedMessage.fileElem;
+            newPayload = await createFileMessageByFile({
+                filePath: elem.filePath,
+                fileName: elem.fileName,
+                uuid: elem.uuid,
+                sourceUrl: elem.sourceUrl,
+                fileSize: elem.fileSize,
+                file: storedFiles.file,
+            });
+        }
+        if (!newPayload) {
+            updateOneMessage(Object.assign(Object.assign({}, failedMessage), { status: MessageStatus.Failed }));
+            return;
+        }
+        messageFileStore.delete(failedMessage.clientMsgID);
+        messageFileStore.set(newPayload.clientMsgID, storedFiles);
+        const conversationID = (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) || "";
+        await DChatSDK.deleteMessageFromLocalStorage({
+            conversationID,
+            clientMsgID: failedMessage.clientMsgID,
+        });
+        removeOneMessage(failedMessage.clientMsgID);
+        await sendMessage(Object.assign(Object.assign({}, newPayload), { ex: failedMessage.ex }));
+    }, [sendMessage]);
+    const sendCustomMessage = useCallback(async (payload, sendOptions) => {
+        if (!conversationData || (!recvID && !groupID))
+            return false;
+        const customMessage = await createCustomMessage(payload);
+        if (!customMessage)
+            return false;
+        const extendMessageInfo = generateExtendMessageInfo({
+            currentSession: sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.currentSession,
+        });
+        return sendMessage(Object.assign(Object.assign({}, customMessage), { ex: JSON.stringify(extendMessageInfo) || "{}", isInternal: false }), sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.currentSession);
+    }, [conversationData, recvID, groupID, sendMessage]);
+    const sendMergeMessage = useCallback(async ({ richText, plainText, files = [], currentSession, isInternal, urlMetadata, flow, customMessage, }) => {
+        if (!conversationData || (!recvID && !groupID))
+            return false;
+        const messageList = [];
+        const imageFileWrappers = files.filter((f) => { var _a; return (_a = f.originFileObj) === null || _a === void 0 ? void 0 : _a.type.startsWith("image/"); });
+        const videoFileWrappers = files.filter((f) => { var _a; return (_a = f.originFileObj) === null || _a === void 0 ? void 0 : _a.type.startsWith("video/"); });
+        const documentFileWrappers = files.filter((f) => { var _a; return (_a = f.originFileObj) === null || _a === void 0 ? void 0 : _a.type.startsWith("application/"); });
+        const imageMessages = [];
+        for (const fileWrapper of imageFileWrappers) {
+            const file = fileWrapper.originFileObj;
+            if (!file)
+                continue;
+            try {
+                const picInfo = await createPicBaseInfoFromFile(file);
+                const baseInfo = {
+                    uuid: uuidv4(),
+                    type: file.type,
+                    size: file.size,
+                    width: picInfo.width,
+                    height: picInfo.height,
+                    url: URL.createObjectURL(file),
+                };
+                const imageMessage = await createImageMessageByFile({
+                    sourcePicture: baseInfo,
+                    bigPicture: baseInfo,
+                    snapshotPicture: baseInfo,
+                    sourcePath: "",
+                    file,
+                });
+                if (!imageMessage)
+                    continue;
+                imageMessages.push(imageMessage);
+            }
+            catch (err) {
+                console.error("Lỗi xử lý ảnh:", err);
+            }
+        }
+        if (imageMessages.length === 1) {
+            messageFileStore.set(imageMessages[0].clientMsgID, {
+                type: "image",
+                file: imageFileWrappers[0].originFileObj,
+            });
+            messageList.push(imageMessages[0]);
+        }
+        else if (imageMessages.length > 1) {
+            imageMessages.forEach((imageMsg, index) => {
+                messageFileStore.set(imageMsg.clientMsgID, {
+                    type: "image",
+                    file: imageFileWrappers[index].originFileObj,
+                });
+            });
+            const mergeMsg = await createMergerMessage({
+                messageList: imageMessages,
+                title: "Album ảnh",
+                summaryList: imageMessages.map(() => "[Hình ảnh]"),
+            });
+            if (mergeMsg)
+                messageList.push(mergeMsg);
+        }
+        for (const fileWrapper of videoFileWrappers) {
+            const file = fileWrapper.originFileObj;
+            if (!file)
+                continue;
+            try {
+                const videoBaseInfo = await createVideoInfoWithThumbnail(file);
+                const thumbFile = new File([videoBaseInfo.thumbnail], file.name + "-thumb.jpg", { type: "image/jpeg" });
+                const videoMessage = await createVideoMessageByFile({
+                    videoPath: "",
+                    duration: videoBaseInfo.duration,
+                    videoType: file.type,
+                    snapshotPath: "",
+                    videoUUID: uuidv4(),
+                    videoUrl: URL.createObjectURL(file),
+                    videoSize: file.size,
+                    snapshotUUID: "",
+                    snapshotSize: file.size,
+                    snapshotUrl: URL.createObjectURL(thumbFile),
+                    snapshotWidth: videoBaseInfo.width,
+                    snapshotHeight: videoBaseInfo.height,
+                    snapShotType: file.type,
+                    videoFile: file,
+                    snapshotFile: thumbFile,
+                });
+                if (!videoMessage)
+                    continue;
+                messageFileStore.set(videoMessage.clientMsgID, {
+                    type: "video",
+                    videoFile: file,
+                    snapshotFile: thumbFile,
+                });
+                messageList.push(videoMessage);
+            }
+            catch (err) {
+                console.error("Lỗi xử lý video:", err);
+            }
+        }
+        for (const fileWrapper of documentFileWrappers) {
+            const file = fileWrapper.originFileObj;
+            if (!file)
+                continue;
+            try {
+                const fileParams = {
+                    filePath: "",
+                    fileName: file.name,
+                    uuid: uuidv4(),
+                    sourceUrl: URL.createObjectURL(file),
+                    fileSize: file.size,
+                    fileType: file.type,
+                    file: file,
+                };
+                const fileMessage = await createFileMessageByFile(fileParams);
+                if (!fileMessage)
+                    continue;
+                messageFileStore.set(fileMessage.clientMsgID, {
+                    type: "file",
+                    file: file,
+                });
+                messageList.push(fileMessage);
+            }
+            catch (err) {
+                console.error("Lỗi xử lý tin nhắn:", err);
+            }
+        }
+        if (!!plainText && plainText.trim() !== "") {
+            const urls = extractLinkUrls(plainText);
+            let textMessage = null;
+            if (quotedMessage === null || quotedMessage === void 0 ? void 0 : quotedMessage.clientMsgID) {
+                textMessage = await createQuoteMessage(plainText, quotedMessage);
+                setQuotedMessage(null);
+            }
+            else if (urls.length > 0) {
+                textMessage = await createUrlTextMessage(plainText, urls);
+            }
+            else {
+                textMessage = await createTextMessage(plainText);
+            }
+            if (!textMessage)
+                return false;
+            messageList.push(textMessage);
+        }
+        if (customMessage) {
+            const customMessageItem = await createCustomMessage(customMessage);
+            if (!customMessageItem)
+                return false;
+            messageList.push(customMessageItem);
+        }
+        for (const message of messageList) {
+            const isTextLikeMessage = (message === null || message === void 0 ? void 0 : message.contentType) === MessageType.TextMessage ||
+                (message === null || message === void 0 ? void 0 : message.contentType) === MessageType.UrlTextMessage ||
+                (message === null || message === void 0 ? void 0 : message.contentType) === MessageType.QuoteMessage;
+            const extendMessageInfo = generateExtendMessageInfo({
+                richText: isTextLikeMessage ? richText : "",
+                urlMetadata: (message === null || message === void 0 ? void 0 : message.contentType) === MessageType.UrlTextMessage
+                    ? urlMetadata
+                    : undefined,
+                currentSession,
+                flow: isTextLikeMessage ? flow : undefined,
+            });
+            const mMessage = Object.assign(Object.assign({}, message), { ex: JSON.stringify(extendMessageInfo) || "{}", isInternal });
+            await sendMessage(mMessage, currentSession);
+        }
+        return true;
+    }, [
+        conversationData,
+        recvID,
+        groupID,
+        sendMessage,
+        quotedMessage,
+        setQuotedMessage,
+    ]);
+    return {
+        sendMergeMessage,
+        sendCustomMessage,
+        resendMessage,
+    };
+};
+export const generateExtendMessageInfo = ({ richText, urlMetadata, currentSession, flow, }) => {
+    const extendMessageInfo = {
+        sessionId: (currentSession === null || currentSession === void 0 ? void 0 : currentSession.id) || "",
+        applicationType: useAuthStore.getState().applicationType,
+    };
+    if (flow) {
+        extendMessageInfo.flow = flow;
+    }
+    const trimmedRichText = richText === null || richText === void 0 ? void 0 : richText.trim();
+    if (trimmedRichText) {
+        extendMessageInfo.messageInfo = {
+            type: "MESSAGE_INFO",
+            data: {
+                type: "rich_text",
+                content: trimmedRichText,
+            },
+        };
+    }
+    if (urlMetadata &&
+        (urlMetadata.title || urlMetadata.description || urlMetadata.image)) {
+        extendMessageInfo.urlMetadata = urlMetadata;
+    }
+    return extendMessageInfo;
+};
+const createPicBaseInfoFromFile = (file) => new Promise((resolve, reject) => {
+    const _URL = window.URL || window.webkitURL;
+    const img = new Image();
+    img.onload = function () {
+        resolve(img);
+    };
+    img.src = _URL.createObjectURL(file);
+});
+function createVideoInfoWithThumbnail(file) {
+    return new Promise((resolve, reject) => {
+        try {
+            const video = document.createElement("video");
+            video.preload = "metadata";
+            video.src = URL.createObjectURL(file);
+            video.onloadedmetadata = () => {
+                const duration = Math.floor(video.duration * 1000);
+                const width = video.videoWidth;
+                const height = video.videoHeight;
+                // Seek tới giây 1 (nếu video dài hơn 1s) để lấy frame đẹp hơn
+                video.currentTime = Math.min(1, video.duration / 2);
+            };
+            video.onseeked = () => {
+                const canvas = document.createElement("canvas");
+                canvas.width = video.videoWidth;
+                canvas.height = video.videoHeight;
+                const ctx = canvas.getContext("2d");
+                if (!ctx)
+                    return reject("Canvas not supported");
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                canvas.toBlob((blob) => {
+                    if (!blob)
+                        return reject("Thumbnail capture failed");
+                    resolve({
+                        duration: Math.floor(video.duration * 1000),
+                        width: video.videoWidth,
+                        height: video.videoHeight,
+                        thumbnail: blob,
+                    });
+                }, "image/jpeg", 0.85);
+            };
+            video.onerror = (err) => reject(err);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}