@droppii-org/chat-mobile 0.2.6 → 0.2.8

package/src/services/endpoints.ts

@@ -1,5 +1,28 @@
+/**
+ * @deprecated Use config/api-endpoints.ts instead
+ * This file is kept for backward compatibility only.
+ * All endpoints should be managed through config/api-endpoints.ts
+ */
+
+import {
+  getApiEndpoint,
+  setApiEndpoint,
+  getAllApiEndpoints,
+} from '../config/api-endpoints';
+
+// Legacy interface - use api-endpoints.ts directly
 export const ENDPOINTS = {
   chatService: {
-    urlMetadata: '/chat-service/v1/utils/url-metadata',
+    get urlMetadata() {
+      return getApiEndpoint('urlMetadata');
+    },
+  },
+  uploaderService: {
+    get uploadImage() {
+      return getApiEndpoint('imageUpload');
+    },
   },
 };
+
+// Re-export proper API for new code
+export { getApiEndpoint, setApiEndpoint, getAllApiEndpoints };

package/src/services/imageUpload.ts

@@ -0,0 +1,162 @@
+import ReactNativeBlobUtil from 'react-native-blob-util';
+import RNFS from 'react-native-fs';
+import { getImageUploadEndpoint, getMimeType } from '../utils/imageUtils';
+import { getAuthToken } from './auth';
+import { getApiEndpoint } from '../config/api-endpoints';
+import { getBaseUrl } from '../config/configuration';
+import type {
+  ImageFile,
+  UploadedImage,
+  ImageUploadConfig,
+} from '../types/imageUpload';
+
+export namespace ImageUploadAPI {
+  export const uploadImageFile = async (
+    file: ImageFile,
+    onProgress?: (progress: number) => void
+  ): Promise<UploadedImage> => {
+    let token: string;
+    let uploadUrl: string;
+
+    try {
+      token = getAuthToken();
+      const relativePath = getApiEndpoint('imageUpload');
+      const baseUrl = getBaseUrl();
+
+      if (!baseUrl) {
+        throw new Error(
+          'Image upload base URL not configured. Call initChatSdk() with apiBaseUrl during app initialization.'
+        );
+      }
+
+      // Construct absolute URL for ReactNativeBlobUtil.fetch()
+      uploadUrl = getImageUploadEndpoint(`${baseUrl}${relativePath}`);
+    } catch (e) {
+      if (__DEV__) console.error('[ImageUploadAPI] Auth error:', e);
+      throw e;
+    }
+
+    return new Promise((resolve, reject) => {
+      ReactNativeBlobUtil.fetch(
+        'POST',
+        uploadUrl,
+        {
+          Authorization: `Bearer ${token}`,
+        },
+        [
+          {
+            name: 'files',
+            filename: file.filename,
+            data: ReactNativeBlobUtil.wrap(file.path),
+            type: getMimeType(file.filename),
+          },
+        ]
+      )
+        .uploadProgress((written, total) => {
+          const progress = Math.round((written / total) * 100);
+          onProgress?.(progress);
+        })
+        .then((response) => {
+          // Check for HTTP error status
+          const status = response.respInfo?.status;
+          if (status && status >= 400) {
+            if (__DEV__)
+              console.error('[ImageUploadAPI] Server error response', {
+                status,
+                data: response.data,
+              });
+            reject(new Error(`Upload failed with status ${status}`));
+            return;
+          }
+
+          if (!response.data || response.data.length === 0) {
+            if (__DEV__)
+              console.error('[ImageUploadAPI] Empty response', {
+                dataType: typeof response.data,
+                data: response.data,
+              });
+            reject(new Error('Empty response from server'));
+            return;
+          }
+
+          try {
+            const json = JSON.parse(response.data);
+            const uploaded = json.data?.[0] || json.files?.[0];
+            const imageUrl =
+              uploaded?.publicUrl || uploaded?.url || uploaded?.data;
+            if (imageUrl) {
+              resolve({
+                url: imageUrl,
+                name: uploaded?.fileName,
+                width: file.width,
+                height: file.height,
+                size: file.size,
+              });
+            } else {
+              if (__DEV__)
+                console.error('[ImageUploadAPI] No URL in response:', json);
+              reject(new Error('No URL in response'));
+            }
+          } catch (err) {
+            if (__DEV__) console.error('[ImageUploadAPI] Parse error:', err);
+            reject(new Error('Invalid response format'));
+          }
+        })
+        .catch((error) => {
+          if (__DEV__) console.error('[ImageUploadAPI] Fetch error:', error);
+          reject(error);
+        });
+    });
+  };
+
+  export const uploadImageQueue = async (
+    files: ImageFile[],
+    config: ImageUploadConfig = {},
+    onProgress?: (completed: number, total: number) => void
+  ): Promise<UploadedImage[]> => {
+    const { maxConcurrent = 2 } = config;
+    const results: UploadedImage[] = [];
+    const queue = [...files];
+    let activeCount = 0;
+
+    return new Promise((resolve, _reject) => {
+      const processNext = async () => {
+        if (queue.length === 0 && activeCount === 0) {
+          resolve(results);
+          return;
+        }
+
+        if (queue.length > 0 && activeCount < maxConcurrent) {
+          const file = queue.shift();
+          if (!file) return;
+
+          activeCount++;
+
+          try {
+            const result = await uploadImageFile(file);
+            results.push(result);
+            onProgress?.(results.length, files.length);
+          } catch (error) {
+            if (__DEV__)
+              console.error(`Failed to upload ${file.filename}:`, error);
+          } finally {
+            activeCount--;
+            processNext();
+          }
+        }
+      };
+
+      for (let i = 0; i < maxConcurrent && queue.length > 0; i++) {
+        processNext();
+      }
+    });
+  };
+
+  export const cleanupImageFile = async (filePath: string): Promise<void> => {
+    try {
+      await RNFS.unlink(filePath);
+    } catch (err) {
+      if (__DEV__) console.warn('Cleanup failed:', err);
+    }
+  };
+}

package/src/store/conversation.ts

@@ -48,7 +48,7 @@ export const useConversationStore = create<ConversationStore>()((set, get) => ({
       sortConversation(
         conversations.reduce(
           (pre, curr) => {
-            pre[curr.conversationId] = curr;
+            pre[curr.conversationID] = curr;
             return pre;
           },
           { ...get().map }

package/src/store/message.ts

@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+import type { MessageItem } from '@droppii/openim-rn-client-sdk';
+import type { DMessageItem, MessageStore } from '../types/chat';
+import { mergeMessages } from '../utils/message';
+
+export const useMessageStore = create<MessageStore>()((set, get) => ({
+  messages: [],
+  hasMoreEarlier: false,
+  hasMoreNewer: false,
+
+  setMessages: (messages, hasMore) => {
+    set({ messages, hasMoreEarlier: hasMore });
+  },
+
+  pushNewMessage: (message: MessageItem) => {
+    set((state) => ({
+      messages: mergeMessages(state.messages, [message as DMessageItem]),
+    }));
+  },
+
+  updateOneMessage: (message: MessageItem) => {
+    const tmpList = [...get().messages];
+    const idx = tmpList.findIndex(
+      (msg) => msg.clientMsgID === message.clientMsgID
+    );
+    if (idx < 0) return;
+    tmpList[idx] = { ...tmpList[idx]!, ...message } as DMessageItem;
+    set({ messages: tmpList });
+  },
+
+  deleteOneMessage: (clientMsgID: string) => {
+    set((state) => ({
+      messages: state.messages.filter((msg) => msg.clientMsgID !== clientMsgID),
+    }));
+  },
+
+  reset: () => {
+    set({
+      messages: [],
+      hasMoreEarlier: false,
+      hasMoreNewer: false,
+    });
+  },
+}));

package/src/translation/resources/i18n.ts

@@ -1,6 +1,26 @@
 const i18nKey: Record<string, string> = {
-  thread_card_bot_crm_name: 'Droppii Hỗ Trợ',
-  thread_card_fallback_name: 'Người dùng',
+  'thread_card_bot_crm_name': 'Droppii Hỗ Trợ',
+  'thread_card_fallback_name': 'Người dùng',
+  'chat:image_preview': 'Xem trước ảnh',
+  'chat:image_too_large': 'Ảnh quá lớn. Tối đa 5MB',
+  'chat:image_sent': 'Đã gửi ảnh',
+  'chat:image_upload_failed': 'Lỗi tải ảnh',
+  'chat:failed_to_send_message': 'Không thể gửi tin nhắn. Thử lại?',
+  'chat:filename': 'Tên tệp',
+  'chat:file_size': 'Kích thước',
+  'chat:dimensions': 'Kích cỡ',
+  'chat:send': 'Gửi',
+  'chat:retry': 'Thử lại',
+  'chat:retry_failed_no_data': 'Không có dữ liệu để thử lại',
+  'chat:retry_failed': 'Thử lại thất bại',
+  'chat:upload_in_progress': 'Đang tải ảnh lên',
+  'chat:wait_or_cancel': 'Vui lòng chờ hoặc hủy bỏ',
+  'msg_type_image': '[Hình ảnh]',
+  'msg_type_voice': '[Tin nhắn thoại]',
+  'msg_type_video': '[Video]',
+  'msg_type_file': '[File đính kèm]',
+  'msg_type_link': '[Liên kết]',
+  'msg_type_revoke': 'Đã thu hồi tin nhắn',
 };
 
 export default {

package/src/types/attachment.ts

@@ -0,0 +1,85 @@
+export type AttachmentType = 'image' | 'video' | 'file' | 'audio';
+
+export interface BaseAttachment {
+  id: string;
+  type: AttachmentType;
+  sourceFile: {
+    path: string;
+    filename: string;
+    size: number;
+    mimeType: string;
+  };
+}
+
+export interface ImageAttachment extends BaseAttachment {
+  type: 'image';
+  metadata: {
+    width: number;
+    height: number;
+    orientation?: 'portrait' | 'landscape' | 'square';
+  };
+}
+
+export interface VideoAttachment extends BaseAttachment {
+  type: 'video';
+  metadata: {
+    width: number;
+    height: number;
+    duration: number;
+    thumbnail?: {
+      url: string;
+      width: number;
+      height: number;
+      size?: number;
+    };
+  };
+}
+
+export interface FileAttachment extends BaseAttachment {
+  type: 'file';
+  metadata: {
+    extension: string;
+    category: 'document' | 'spreadsheet' | 'presentation' | 'other';
+  };
+}
+
+export interface AudioAttachment extends BaseAttachment {
+  type: 'audio';
+  metadata: {
+    duration: number;
+    bitrate?: number;
+  };
+}
+
+export type Attachment =
+  | ImageAttachment
+  | VideoAttachment
+  | FileAttachment
+  | AudioAttachment;
+
+export interface AttachmentUploadStatus {
+  attachmentId: string;
+  state: 'pending' | 'uploading' | 'uploaded' | 'failed' | 'cancelled';
+  progress: number;
+  uploadedUrl?: string;
+  error?: string;
+  uploadedAt?: number;
+}
+
+export type BatchStrategy = 'individual' | 'merged' | 'grouped';
+
+export interface AttachmentSendOptions {
+  strategy: BatchStrategy;
+  includeCaption?: string;
+  uploadConcurrency?: number;
+  retryFailedUploads?: boolean;
+  maxRetries?: number;
+}
+
+export interface AttachmentSendResult {
+  success: boolean;
+  sentAttachmentIds: string[];
+  failedAttachmentIds: string[];
+  mergedMessageId?: string;
+  errors: Record<string, string>;
+}

package/src/types/attachmentHandler.ts

@@ -0,0 +1,31 @@
+import type { Attachment } from './attachment';
+// Imported from handlers to provide dispatch
+import { ImageAttachmentHandler } from '../services/attachmentHandlers/imageAttachmentHandler';
+import VideoAttachmentHandlerDefault from '../services/attachmentHandlers/videoAttachmentHandler';
+import FileAttachmentHandlerDefault from '../services/attachmentHandlers/fileAttachmentHandler';
+
+export interface IAttachmentHandler {
+  validate(
+    attachment: Attachment
+  ): { valid: true } | { valid: false; reason: string };
+
+  prepare?(attachment: Attachment): Promise<Attachment>;
+
+  buildPayload(attachment: Attachment, uploadedUrl: string): Promise<unknown>;
+}
+
+export function getAttachmentHandler(
+  type: Attachment['type']
+): IAttachmentHandler {
+  console.log('[getAttachmentHandler] Getting handler for type:', type);
+  switch (type) {
+    case 'image':
+      return ImageAttachmentHandler;
+    case 'video':
+      return VideoAttachmentHandlerDefault;
+    case 'file':
+      return FileAttachmentHandlerDefault;
+    default:
+      throw new Error(`No handler for attachment type: ${type}`);
+  }
+}

package/src/types/chat.ts

@@ -1,10 +1,10 @@
 import {
   type MessageItem,
-  type SessionType,
-  type MessageReceiveOptType,
-  type GroupAtType,
+  type ConversationItem,
+  PeerType,
 } from '@droppii/openim-rn-client-sdk';
 import type { PropsWithChildren } from 'react';
+import type { IUrlMetadata } from './common';
 
 export const EventProvider = {
   ga: 'ga',
@@ -20,16 +20,17 @@ type LogGA = (
 
 export interface ChatContextType {
   logGA?: LogGA;
+  applicationType: DChatApplicationType;
 }
 
 export type ChatProviderProps = PropsWithChildren<{
-  enabled?: boolean;
   logGA?: LogGA;
+  applicationType: DChatApplicationType;
 }>;
 
 export enum DChatApplicationType {
-  BIZ = 'BIZ',
-  MALL = 'MALL',
+  DROPPII = 'DROPPII',
+  OBEFE = 'OBEFE',
 }
 
 export enum DChatCategory {
@@ -40,11 +41,6 @@ export enum DChatCategory {
   BIZ_BOT_CRM = 'BIZ_BOT_CRM',
 }
 
-export enum DChatType {
-  SINGLE = 'SINGLE',
-  GROUP = 'GROUP',
-}
-
 export enum DMemberRole {
   AGENT = 'AGENT',
   MEMBER = 'MEMBER',
@@ -65,11 +61,11 @@ export interface DConversationPeer {
   group: null; // to be defined when group is implemented
 }
 
-export interface DConversationItem {
+export interface DConversationItem extends ConversationItem {
   // Droppii API fields
   conversationId: string;
   chatCategory: DChatCategory;
-  chatType: DChatType;
+  chatType: PeerType;
   applicationType: string;
   memberRole: DMemberRole;
   pinnedAt: string | null;
@@ -77,23 +73,6 @@ export interface DConversationItem {
   peer: DConversationPeerUser;
   // Merged from OpenIM (available after getConversationListSplit merge)
   lastMessage?: DMessageItem;
-  unreadCount?: number;
-  conversationType?: SessionType;
-  userID?: string;
-  groupID?: string;
-  showName?: string;
-  faceURL?: string;
-  recvMsgOpt?: MessageReceiveOptType;
-  groupAtType?: GroupAtType;
-  latestMsgSendTime?: number;
-  draftText?: string;
-  draftTextTime?: number;
-  isPinned?: boolean;
-  isNotInGroup?: boolean;
-  isPrivateChat?: boolean;
-  isMsgDestruct?: boolean;
-  attachedInfo?: string;
-  ex?: string;
 }
 
 export interface DConversationQueryParams {
@@ -134,3 +113,25 @@ export interface DMessagePushInfoEx {
   title: string;
   desc: string;
 }
+
+export interface IMessageItemEx {
+  applicationType: DChatApplicationType;
+  sessionId?: string;
+  messageInfo?: {
+    type: 'MESSAGE_INFO';
+    data: 'rich_text';
+    content: string;
+  };
+  urlMetadata?: IUrlMetadata;
+}
+
+export interface MessageStore {
+  messages: DMessageItem[];
+  hasMoreEarlier: boolean;
+  hasMoreNewer: boolean;
+  setMessages: (messages: DMessageItem[], hasMore: boolean) => void;
+  pushNewMessage: (message: MessageItem) => void;
+  updateOneMessage: (message: MessageItem) => void;
+  deleteOneMessage: (clientMsgID: string) => void;
+  reset: () => void;
+}

package/src/types/common.ts

@@ -2,4 +2,5 @@ export interface IUrlMetadata {
   title?: string;
   description?: string;
   image?: string;
+  url?: string;
 }

package/src/types/imageUpload.ts

@@ -0,0 +1,28 @@
+export interface ImageFile {
+  path: string;
+  filename: string;
+  size: number;
+  width: number;
+  height: number;
+  mime: string;
+}
+
+export interface UploadedImage {
+  url: string;
+  name: string;
+  width: number;
+  height: number;
+  size: number;
+}
+
+export interface ImageUploadConfig {
+  maxConcurrent?: number;
+  timeout?: number;
+  retryAttempts?: number;
+}
+
+export interface UploadProgress {
+  completed: number;
+  total: number;
+  percentage: number;
+}

package/src/types/message.ts

@@ -4,6 +4,7 @@ export const DChatMessageType = {
   Image: 'IMAGE',
   Video: 'VIDEO',
   File: 'FILE',
+  Merged: 'MERGED',
   Order: 'ORDER',
   Unsupported: 'UNSUPPORTED',
 } as const;