object_message_ko

src/pages/chat/chat.ts

@@ -6,8 +6,6 @@ declare global {
     }
 }
 
-import { groupsMock } from '../../mocks/mock-signature/groupsMock';
-import { messagesMock as initialMessagesMock, messagesMock } from '../../mocks/mock-signature/messagesMock';
 import { membersMock } from '../../mocks/mock-signature/membersMocks';
 import { ApiReturn, Device, Member } from '../../../pkg/sdk_client';
 import { 
@@ -289,7 +287,7 @@ class ChatElement extends HTMLElement {
         }
 
         const currentProcessId = this.getAttribute('process-id');
-        console.log('<EFBFBD><EFBFBD> Current Process ID:', currentProcessId);
+        console.log('🔍 Current Process ID:', currentProcessId);
 
         if (!currentProcessId) {
             throw new Error('No process ID found');
@@ -352,15 +350,6 @@ class ChatElement extends HTMLElement {
                 data: storedProcess
             });
 
-            if (!storedProcess) {
-                console.log('⚠️ Process non trouvé dans IndexedDB, ajout manuel...');
-                await db.addObject({
-                    storeName: processStore,
-                    key: (result as any).process_id,
-                    object: result
-                });
-            }
-
             return result;
         } catch (e) {
             console.error('❌ Erreur:', e);
@@ -401,50 +390,63 @@ class ChatElement extends HTMLElement {
 
 // Send a messsage
     private async sendMessage() {
-        console.log('🚀 Début sendMessage');
-        
         const messageInput = this.shadowRoot?.querySelector('#message-input') as HTMLInputElement;
-        if (!messageInput || !this.selectedMemberId) {
+        if (!messageInput || !this.selectedMemberId) return;
-            console.log('❌ Message input ou selectedMemberId manquant');
-            return;
-        }
         
         const messageText = messageInput.value.trim();
-        if (messageText === '') {
+        if (messageText === '') return;
-            console.log('❌ Message vide');
-            return;
-        }
 
         try {
             const myAddresses = await this.getMemberFromDevice();
-            if (!myAddresses) {
+            if (!myAddresses) throw new Error('No paired member found');
-                throw new Error('No paired member found');
-            }
 
-            // On récupère le processus existant
-            const existingProcess = await this.getExistingConversationProcess(this.selectedMemberId);
             
-            if (!existingProcess) {
+            const messageProcess = await this.getExistingMessageProcess(
-                console.error('❌ Aucun processus de message trouvé');
+                this.getAttribute('process-id') || '',
+                [this.selectedMemberId]
+            );
+
+            if (!messageProcess) {
+                console.error('❌ Processus message non trouvé');
                 return;
             }
 
-            const messageContent = {
+            const recipientRole = Object.entries(messageProcess.roles).find(([_, roleData]: [string, any]) => 
-                text: messageText,
+                roleData.members?.some((member: any) => 
-                timestamp: Date.now(),
+                    member.sp_addresses.includes(this.selectedMemberId)
-                sender: myAddresses[0],
+                )
-                type: 'text'
+            )?.[0] || 'default';
+
+            const messageTemplate = {
+                messaging_id: messageProcess.process_id,
+                description: 'message_content',
+                state: 'sent',
+                content: {
+                    text: messageText,
+                    timestamp: Date.now(),
+                    sender: myAddresses[0],
+                    recipient: this.selectedMemberId
+                },
+                roles: {
+                    [recipientRole]: messageProcess.roles[recipientRole]
+                }
             };
 
-            // Mise à jour du processus existant avec le nouveau message
+            console.log('📝 Template message:', messageTemplate);
-            await this.updateProcessWithNewMessage(existingProcess.process_id, messageContent);
-            console.log('✅ Message ajouté au processus existant:', existingProcess.process_id);
 
+            const result = await this.sdkClient.create_new_process(
+                JSON.stringify(messageTemplate),
+                messageProcess.process_id,
+                'relay_address',
+                1
+            );
+
+            console.log('✅ Message créé:', result);
             messageInput.value = '';
-            this.loadMemberChat(this.selectedMemberId);
+            
-
+            await this.loadMemberChat(this.selectedMemberId);
         } catch (error) {
-            console.error('❌ Erreur lors de l\'envoi du message:', error);
+            console.error('❌ Erreur envoi message:', error);
         }
     }
 
@@ -530,7 +532,6 @@ class ChatElement extends HTMLElement {
                 memberItem.onclick = async (event) => {
                     event.stopPropagation();
                     try {
-                        // Récupérer le processId du chat parent
                         const parentProcessId = this.getAttribute('process-id');
                         console.log('🔍 Parent Process ID:', parentProcessId);
 
@@ -538,7 +539,6 @@ class ChatElement extends HTMLElement {
                             throw new Error('No parent process ID found');
                         }
 
-                        // Vérifier si un processus de message existe déjà pour cet utilisateur
                         const db = await Database.getInstance();
                         const processes = await db.getObject('processes', parentProcessId);
                         console.log('💾 Processus trouvé:', processes);
@@ -637,7 +637,7 @@ class ChatElement extends HTMLElement {
 
 
     private async loadGroupList(processId: string): Promise<void> {
-        console.log('🔍 Loading group list with processId:', processId);
+        console.log('Loading group list with processId:', processId);
         const groupList = this.shadowRoot?.querySelector('#group-list');
         if (!groupList) return;
 
@@ -986,7 +986,7 @@ class ChatElement extends HTMLElement {
         }
 
         // Vérification que le processId est bien stocké
-        console.log('🔍 Vérification this.processId après stockage:', this.processId);
+        console.log('Vérification this.processId après stockage:', this.processId);
 
         const existingProcess = groupList.querySelector(`[data-process-id="${processId}"]`);
         if (existingProcess) {
@@ -1086,42 +1086,6 @@ class ChatElement extends HTMLElement {
         }
     }
 
-    private async updateProcessWithNewMessage(processId: string, messageContent: any) {
-        const db = await Database.getInstance();
-        try {
-            const process = await db.getObject('processes', processId);
-            if (process) {
-                process.messages.object.content.push(messageContent);
-                process.messages.object.metadata.last_updated = Date.now();
-                
-                await db.addObject({
-                    storeName: 'processes',
-                    key: processId,
-                    object: process
-                });
-            }
-        } catch (error) {
-            console.error('Error updating process with new message:', error);
-        }
-    }
-
-    private async saveConversationProcessRef(memberId: string, processId: string) {
-        const db = await Database.getInstance();
-        try {
-            await db.addObject({
-                storeName: 'conversation_refs',
-                key: memberId,
-                object: {
-                    memberId,
-                    processId,
-                    timestamp: Date.now()
-                }
-            });
-        } catch (error) {
-            console.error('Error saving conversation reference:', error);
-        }
-    }
-
     async getProcessFromDB(processId: string) {
         const db = await Database.getInstance();
         const processStore = 'processes';
@@ -1136,30 +1100,52 @@ class ChatElement extends HTMLElement {
 
     private async getExistingMessageProcess(parentId: string, spAddresses: string[]): Promise<any> {
         try {
+            console.log('🔍 Recherche du processus message');
+            console.log('Parent ID:', parentId);
+            console.log('SP Addresses:', spAddresses);
+
             const db = await Database.getInstance();
             const processStore = 'processes';
             
-            // Utiliser une clé valide pour la recherche
+            // Récupérer le processus parent
-            const process = await db.getObject(processStore, parentId);
+            const parentProcess = await db.getObject(processStore, parentId);
-            console.log('🔍 Processus trouvé:', process);
+            console.log('📂 Process parent trouvé dans IndexedDB:', {
+                store: processStore,
+                processId: parentId,
+                data: parentProcess
+            });
 
-            if (!process) {
+            // Afficher la structure détaillée
-                console.log('❌ Aucun processus trouvé avec l\'ID:', parentId);
+            if (parentProcess?.states) {
-                return null;
+                console.log('📝 States:', parentProcess.states);
+                console.log('🔐 Encrypted PCD:', parentProcess.states[0]?.encrypted_pcd);
+                console.log('🔄 Processes:', parentProcess.states[0]?.encrypted_pcd?.processes);
             }
 
-            // Vérifier si c'est le bon processus
+            // Chercher dans les states[0].encrypted_pcd.roles
-            if (process.parent_id === parentId && 
+            const roles = parentProcess?.states?.[0]?.encrypted_pcd?.roles;
-                process.roles?.owner?.members?.some((member: any) => 
+            console.log('👥 Roles trouvés:', roles);
+
+            // Chercher le processus message dans les rôles
+            for (const role in roles) {
+                console.log(`🔍 Vérification du rôle: ${role}`);
+                const members = roles[role].members;
+                if (members?.some((member: any) => 
                     spAddresses.includes(member.sp_addresses[0])
                 )) {
-                console.log('✅ Processus correspondant trouvé');
+                    console.log('✅ Membre trouvé dans le rôle:', role);
-                return process;
+                    return {
+                        description: 'messaging',
+                        parent_id: parentId,
+                        roles: roles
+                    };
+                }
             }
 
+            console.log('❌ Aucun processus message correspondant trouvé');
             return null;
         } catch (error) {
-            console.error('❌ Erreur lors de la recherche du processus:', error);
+            console.error('❌ Erreur recherche processus:', error);
             return null;
         }
     }