sync message on recoonect on ui

src/app/infra/database/dexie/instance/chat/schema/message.ts

@@ -18,7 +18,7 @@ export const MessageTableSchema = z.object({
     wxUserId: z.number(),
     wxFullName: z.string(),
     wxeMail: z.string(),
-    userPhoto: z.string(),
+    userPhoto: z.string().nullable().optional(),
   }),
   receiverId: z.number().optional(),
   sending: z.boolean().optional(),

src/app/infra/http/adapter.ts

@@ -0,0 +1,14 @@
+import { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { HttpResult } from './type';
+import { Result } from 'neverthrow';
+import { Observable } from 'rxjs';
+
+
+export abstract  class HttpAdapter {
+  abstract post<T>(url: string, body: any): Promise<Result<HttpResult<T>, HttpErrorResponse>>
+  abstract get<T>(url: string, options?: Object): Promise<Result<HttpResult<T>, HttpErrorResponse>>
+  abstract put<T>(url: string, body: any): Promise<Result<HttpResult<T>, HttpErrorResponse>>
+  abstract patch<T>(url: string, body?: Object): Promise<Result<HttpResult<T>, HttpErrorResponse>> 
+  abstract delete<T>(url: string, body?: Object): Promise<Result<HttpResult<T>, HttpErrorResponse>>
+  abstract listen():Observable<Result<HttpResult<any>, HttpErrorResponse>>
+}

src/app/infra/http/http.module.ts

@@ -0,0 +1,17 @@
+import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { HttpAdapter } from './adapter';
+import { HttpService } from './http.service';
+
+@NgModule({
+  imports: [],
+  declarations: [],
+  schemas: [],
+  providers: [
+    {
+      provide: HttpAdapter,
+      useClass: HttpService, // or MockDataService
+    }
+  ],
+  entryComponents: []
+})
+export class HttpModule {}

src/app/infra/http/http.service.ts

@@ -0,0 +1,123 @@
+import { HttpErrorResponse, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ok, err, Result } from 'neverthrow';
+import { HttpResult } from './type';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HttpService {
+
+  private responseSubject = new BehaviorSubject<Result<HttpResult<any>, HttpErrorResponse>>(null);
+  
+  constructor(private http: HttpClient) { }
+
+  async post<T>(url: string, body: any): Promise<Result<HttpResult<T>, HttpErrorResponse>> {
+    try {
+      const response = await this.http.post<T>(url, body, { observe: 'response' }).toPromise();
+      const data = {
+        data: response.body,
+        status: response.status,
+        headers: response.headers,
+        url: response.url || url
+      }
+      this.responseSubject.next(ok(data))
+      return ok(data);
+    } catch (e) {
+      this.responseSubject.next(err(e))
+      return err(e as HttpErrorResponse);
+    }
+  }
+
+  async get<T>(url: string, options = {}): Promise<Result<HttpResult<T>, HttpErrorResponse>> {
+    try {
+      const response = await this.http.get<T>(url, { ...options, observe: 'response' }).toPromise();
+
+      const data = {
+        data: response.body,
+        status: response.status,
+        headers: response.headers,
+        url: response.url || url
+      }
+
+      this.responseSubject.next(ok(data))
+      return ok(data);
+    } catch (e) {
+      this.responseSubject.next(err(e))
+      return err(e as HttpErrorResponse);
+    }
+  }
+
+  async put<T>(url: string, body: any): Promise<Result<HttpResult<T>, HttpErrorResponse>> {
+    try {
+      const response = await this.http.put<T>(url, body, { observe: 'response' }).toPromise();
+
+      const data = {
+        data: response.body,
+        status: response.status,
+        headers: response.headers,
+        url: response.url || url
+      }
+
+      this.responseSubject.next(ok(data))
+      return ok(data);
+    } catch (e) {
+      this.responseSubject.next(err(e))
+      return err(e as HttpErrorResponse);
+    }
+  }
+
+  async patch<T>(url: string, body: any = {}): Promise<Result<HttpResult<T>, HttpErrorResponse>> {
+    try {
+      const response = await this.http.patch<T>(url, body, { observe: 'response' }).toPromise();
+
+      const data = {
+        data: response.body,
+        status: response.status,
+        headers: response.headers,
+        url: response.url || url
+      }
+
+      this.responseSubject.next(ok(data))
+      return ok(data);
+    } catch (e) {
+      this.responseSubject.next(err(e))
+      return err(e as HttpErrorResponse);
+    }
+  }
+
+  async delete<T>(url: string, body = {}): Promise<Result<HttpResult<T>, HttpErrorResponse>> {
+    const options = {
+      body: body, // Pass payload as the body of the request
+      observe: 'response' as 'body'
+    };
+
+    try {
+      const response: any = await this.http.delete<T>(url, options).toPromise();
+
+      const data = {
+        data: response?.body,
+        status: response?.status,
+        headers: response?.headers,
+        url: response?.url || url
+      }
+
+      this.responseSubject.next(ok(data))
+      return ok(data as any);
+    } catch (e) {
+      this.responseSubject.next(err(e))
+      return err(e as HttpErrorResponse);
+    }
+  }
+
+  listen() {
+    return this.responseSubject.asObservable()
+  }
+}
+
+export function isHttpResponse(data: any): data is HttpResponse<any> {
+  return typeof data.status == 'number';
+}
+

src/app/infra/http/type.ts

@@ -0,0 +1,13 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+
+export interface Options {
+  headers?: HttpHeaders
+  params?: HttpParams
+}
+
+export interface HttpResult<T> {
+  data: T | null;
+  status: number;
+  headers: HttpHeaders;
+  url: string;
+}

src/app/infra/socket/adapter.ts

@@ -9,5 +9,6 @@ export abstract class ISignalRService {
   abstract join(): void;
   abstract getData<T>(): Observable<{ method: string; data: T }>;
   abstract getConnectionState(): Observable<boolean>;
+  abstract onReconnect(): Observable<boolean>;
   abstract newConnection(): void;
 }

src/app/infra/socket/signalR/signal-r.service.ts

@@ -3,8 +3,7 @@ import { BehaviorSubject, Observable, Subject, timer } from 'rxjs';
 import { Platform } from '@ionic/angular';
 import { SignalRConnection, SocketMessage } from './signalR';
 import { Plugins } from '@capacitor/core';
-import { z } from 'zod';
-import { filter, map, switchMap } from 'rxjs/operators';
+import { filter, map, skip, switchMap } from 'rxjs/operators';
 import { Result } from 'neverthrow';
 import { HubConnection } from '@microsoft/signalr';
 import { MessageOutPutDataDTO } from 'src/app/module/chat/data/dto/message/messageOutputDTO';
@@ -127,9 +126,17 @@ export class SignalRService {
     return this.connection.join()
   }
 
+  // onReconnect() {
+  //   const connection = this.getConnectionState()
+  //   return connection.pipe(
+  //     skip(1) // Skip the first value
+  //   )
+  // }
+
   getData<T>() {
     return this.sendDataSubject.asObservable() as BehaviorSubject<{method: string, data: T}>
   }
+
   public getConnectionState(): Observable<boolean> {
     return this.connectingSubject.asObservable();
   }

src/app/infra/socket/signalR/signalR.ts

@@ -58,8 +58,6 @@ export class SignalRConnection {
       })
       .catch(error => {
         console.log('Error while starting connection: ' + error);
-        this.connectionStateSubject.next(false);
-
         if(this.hasConnectOnce) {
           setTimeout(()=> {
             this.attempReconnect();