From 2605d73baa0b760868bc7d041a25df04747d9cd5 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Mon, 29 Jan 2024 13:49:53 +0100
Subject: [PATCH 01/16] video uploader

---
 src/app/models/publication.ts                 |   2 +-
 .../services/socket-connection-mcr.service.ts | 330 +++++++++++++-
 .../API/CMAPI/cmapi-api.service.spec.ts       |  16 +
 src/app/shared/API/CMAPI/cmapi-api.service.ts |  18 +
 .../shared/API/CMAPI/cmapi.service.spec.ts    |  16 +
 src/app/shared/API/CMAPI/cmapi.service.ts     |  21 +
 .../middleware/middleware-service.service.ts  |  38 +-
 .../new-publication/new-publication.page.html |  18 +-
 .../new-publication/new-publication.page.ts   | 422 +++++++++++-------
 .../view-publications.page.ts                 |  19 +-
 .../shared/repository/CMAPI/cmapi.service.ts  |  36 +-
 11 files changed, 757 insertions(+), 179 deletions(-)
 create mode 100644 src/app/shared/API/CMAPI/cmapi-api.service.spec.ts
 create mode 100644 src/app/shared/API/CMAPI/cmapi-api.service.ts
 create mode 100644 src/app/shared/API/CMAPI/cmapi.service.spec.ts
 create mode 100644 src/app/shared/API/CMAPI/cmapi.service.ts

diff --git a/src/app/models/publication.ts b/src/app/models/publication.ts
index 64c328a1c..3e48e5214 100644
--- a/src/app/models/publication.ts
+++ b/src/app/models/publication.ts
@@ -11,4 +11,4 @@ export class Publication{
     Files:any = [];
     FileExtension?: string;
     OrganicEntityId?: number;
-}
\ No newline at end of file
+}
diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index 9d8e440c7..2028c3b52 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -1,24 +1,31 @@
 import { Injectable } from '@angular/core';
 import * as signalR  from "@microsoft/signalr"
 import { SessionStore } from '../store/session.service';
-
+import { v4 as uuidv4 } from 'uuid'
+import { HttpClient, HttpHeaders, HttpEventType } from '@angular/common/http';
+import { CMAPIService } from '../shared/repository/CMAPI/cmapi.service';
+import { HubConnectionBuilder } from '@microsoft/signalr';
 
 @Injectable({
   providedIn: 'root'
 })
 export class SocketConnectionMCRService {
+  private  callbacks: Function[] = []
+  private  onDisconnect: Function[] = []
+  private  onConnect: Function[] = []
 
-  constructor() { }
+  constructor(private http: HttpClient,) {
+    window["http"] = this.http
+  }
 
   connect() {
 
     var connection = new signalR.HubConnectionBuilder()
     .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
-        accessTokenFactory: () => SessionStore.user.Authorization
+      accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
     }).configureLogging(signalR.LogLevel.Information)
     .build();
 
-
     connection.on("ReceiveMessage", (message) => {
       console.log("ReceiveMessage", message)
     })
@@ -43,4 +50,319 @@ export class SocketConnectionMCRService {
 
   }
 
+  subscribe(callback) {
+    this.callbacks.push(callback);
+  }
+
+  unsubscribe(callback) {
+    this.callbacks = this.callbacks.filter(cb => cb !== callback);
+  }
+
+  onDisconnectCallback(callback) {
+    this.onDisconnect.push(callback)
+  }
+  onConnectCallback(callback) {
+    this.onConnect.push(callback)
+  }
+
+}
+
+class ReconnectingWebSocketSignalR {
+
+  private connection: any
+  isOpen: boolean
+  private  callbacks: Function[] = []
+  private  onDisconnect: Function[] = []
+  private  onConnect: Function[] = []
+
+  constructor() {
+    this.isOpen = false;
+    this.connect();
+  }
+
+  connect() {
+    this.connection = new signalR.HubConnectionBuilder()
+    .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
+      accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
+    }).configureLogging(signalR.LogLevel.Information)
+    .build();
+
+
+    this.connection.start()
+    .then(() => {
+      this.isOpen = true;
+      console.log('WebSocket connection established');
+
+
+      this.onConnect.forEach(callback => callback());
+        console.log("SignalR connection started.");
+    })
+    .catch((error) => {
+        console.error("Error starting SignalR connection:", error);
+    });
+
+
+    this.connection.on("ReceiveMessage", (message) => {
+      const data: any = JSON.parse(message)
+      console.log(data)
+      this.callbacks.forEach(callback => callback(data));
+    })
+
+    this.connection.onclose((error) => {
+      console.log('WebSocket connection closed');
+      this.isOpen = false;
+      this.onDisconnect.forEach(callback => callback());
+      // Attempt to reconnect after a delay
+      setTimeout(() => {
+        this.connect();
+      }, 1000); // Adjust the delay as needed
+    });
+
+
+  }
+
+  subscribe(callback) {
+    this.callbacks.push(callback);
+  }
+
+  unsubscribe(callback) {
+    this.callbacks = this.callbacks.filter(cb => cb !== callback);
+  }
+
+  onDisconnectCallback(callback) {
+    this.onDisconnect.push(callback)
+  }
+  onConnectCallback(callback) {
+    this.onConnect.push(callback)
+  }
+}
+
+interface socketResponse {
+
+  index: string
+  Guid: string
+  isCompleted: Boolean
+}
+class ReconnectingWebSocket {
+
+  private url: string
+  private  socket
+  isOpen: boolean
+  private  callbacks: Function[] = []
+  private  onDisconnect: Function[] = []
+  private  onConnect: Function[] = []
+
+  http: HttpClient = window["http"]
+
+  constructor(url) {
+    this.url = url;
+    this.socket = null;
+    this.isOpen = false;
+    this.connect();
+  }
+
+  connect() {
+    this.socket = new WebSocket(this.url);
+
+    this.socket.addEventListener('open', (event) => {
+      this.isOpen = true;
+      console.log('WebSocket connection established');
+
+      // Example: Send a message to the server
+      this.socket.send('Hello, WebSocket Server!');
+      this.onConnect.forEach(callback => callback());
+    });
+
+    this.socket.addEventListener('message', (event) => {
+      const data: socketResponse = JSON.parse(event.data)
+      this.callbacks.forEach(callback => callback(data));
+    });
+
+    this.socket.addEventListener('close', (event) => {
+      console.log('WebSocket connection closed');
+      this.isOpen = false;
+      this.onDisconnect.forEach(callback => callback());
+      // Attempt to reconnect after a delay
+      setTimeout(() => {
+        this.connect();
+      }, 1000); // Adjust the delay as needed
+    });
+  }
+
+  send(message) {
+    if (this.isOpen) {
+      this.socket.send(message);
+    } else {
+      console.error('WebSocket connection is not open. Unable to send message.');
+    }
+  }
+
+  close() {
+    if (this.isOpen) {
+      this.socket.close();
+    }
+  }
+
+  subscribe(callback) {
+    this.callbacks.push(callback);
+  }
+
+  unsubscribe(callback) {
+    this.callbacks = this.callbacks.filter(cb => cb !== callback);
+  }
+
+  onDisconnectCallback(callback) {
+    this.onDisconnect.push(callback)
+  }
+  onConnectCallback(callback) {
+    this.onConnect.push(callback)
+  }
+}
+
+// export class ObjectMergeNotification{
+
+//   //socket = new ReconnectingWebSocket('ws://localhost:3002');
+//   callbacks: {[GUID: string]: Function} = {}
+//   runWatch =  true
+//   CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
+
+//   constructor() {
+//     // this.socket.onDisconnectCallback(()=> {
+//     //   this.runWatch = true
+//     //   this.watch()
+//     // })
+
+//     // this.socket.onConnectCallback(()=> {
+//     //   this.runWatch = false
+//     // })
+
+//     // this.socket.subscribe((data: socketResponse) => {
+//     //   if(data.isCompleted == true) {
+//     //     this.callbacks[data.Guid](data)
+//     //     delete this.callbacks[data.Guid]
+//     //   }
+//     // })
+
+//     this.watch()
+//   }
+
+//   async watch() {
+//     if(this.runWatch) {
+//       setTimeout(async ()=> {
+//         for(const [key, funx] of Object.entries(this.callbacks)) {
+
+//           const request = await this.CMAPIService.getVideoHeader(key)
+
+//           if(request.isOk()) {
+//             funx()
+//             delete this.callbacks[key]
+//           }
+//         }
+
+//         this.watch()
+//       }, 1000)
+
+
+//     }
+//   }
+
+//   subscribe(GUID, callback:Function) {
+//     this.callbacks[GUID] = callback;
+//   }
+
+//   unsubscribe(GUID) {
+//     delete this.callbacks[GUID]
+//   }
+
+// }
+
+
+export class ObjectMergeNotification{
+
+  socket = new ReconnectingWebSocketSignalR()
+  callbacks: {[GUID: string]: Function} = {}
+  runWatch =  true
+  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
+
+  constructor() {
+    this.socket.onDisconnectCallback(()=> {
+      this.runWatch = true
+      this.watch()
+    })
+
+    this.socket.onConnectCallback(()=> {
+      this.runWatch = false
+    })
+
+    this.socket.subscribe((data: socketResponse) => {
+      if(data.isCompleted == true) {
+        this.callbacks[data.Guid](data)
+        delete this.callbacks[data.Guid]
+      }
+    })
+
+    this.watch()
+  }
+
+
+  connect() {
+
+    var connection = new signalR.HubConnectionBuilder()
+    .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
+        accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
+    }).configureLogging(signalR.LogLevel.Information)
+    .build();
+
+    connection.on("ReceiveMessage", (message) => {
+      console.log("ReceiveMessage", message)
+    })
+
+    connection.onreconnected((connectionId) => {
+      console.assert(connection.state === signalR.HubConnectionState.Connected);
+      console.log(`Reconnected with connectionId: ${connectionId}`);
+    });
+
+    connection.start()
+    .then(() => {
+        console.log("SignalR connection started.");
+    })
+    .catch((error) => {
+        console.error("Error starting SignalR connection:", error);
+    });
+
+    connection.onclose((error) => {
+      connection.start()
+      console.log("SignalR connection closed:", error);
+    });
+
+  }
+
+  async watch() {
+    if(this.runWatch) {
+      setTimeout(async ()=> {
+        for(const [key, funx] of Object.entries(this.callbacks)) {
+
+          const request = await this.CMAPIService.getVideoHeader(key)
+
+          if(request.isOk()) {
+            funx()
+            delete this.callbacks[key]
+          }
+        }
+
+        this.watch()
+      }, 1000)
+
+
+    }
+  }
+
+  subscribe(GUID, callback:Function) {
+    this.callbacks[GUID] = callback;
+  }
+
+  unsubscribe(GUID) {
+    delete this.callbacks[GUID]
+  }
+
 }
diff --git a/src/app/shared/API/CMAPI/cmapi-api.service.spec.ts b/src/app/shared/API/CMAPI/cmapi-api.service.spec.ts
new file mode 100644
index 000000000..b50b8ad56
--- /dev/null
+++ b/src/app/shared/API/CMAPI/cmapi-api.service.spec.ts
@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CMAPIAPIService } from './cmapi-api.service';
+
+describe('CMAPIAPIService', () => {
+  let service: CMAPIAPIService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(CMAPIAPIService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});
diff --git a/src/app/shared/API/CMAPI/cmapi-api.service.ts b/src/app/shared/API/CMAPI/cmapi-api.service.ts
new file mode 100644
index 000000000..289afcb7d
--- /dev/null
+++ b/src/app/shared/API/CMAPI/cmapi-api.service.ts
@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { HttpServiceService } from 'src/app/services/http/http-service.service';
+import { HttpClient, HttpEvent, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CMAPIAPIService {
+
+  constructor(    private HttpServiceService: HttpServiceService,
+    private http: HttpClient,) { }
+
+
+  getVideoHeader(url: string) {
+    return this.http.head('http://localhost:3001/static/'+url, { observe: 'response' })
+  }
+}
diff --git a/src/app/shared/API/CMAPI/cmapi.service.spec.ts b/src/app/shared/API/CMAPI/cmapi.service.spec.ts
new file mode 100644
index 000000000..09602502b
--- /dev/null
+++ b/src/app/shared/API/CMAPI/cmapi.service.spec.ts
@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CMAPIService } from './cmapi.service';
+
+describe('CMAPIService', () => {
+  let service: CMAPIService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(CMAPIService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});
diff --git a/src/app/shared/API/CMAPI/cmapi.service.ts b/src/app/shared/API/CMAPI/cmapi.service.ts
new file mode 100644
index 000000000..e9519cddf
--- /dev/null
+++ b/src/app/shared/API/CMAPI/cmapi.service.ts
@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { HttpServiceService } from 'src/app/services/http/http-service.service';
+import { HttpClient, HttpEvent, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CMAPIService {
+
+  constructor(    private HttpServiceService: HttpServiceService,
+    private http: HttpClient,) {
+      window["CMAPIService"] = this
+    }
+
+  getVideoHeader(url: string): Observable<Boolean> {
+    return this.http.head(url, { observe: 'response' })
+    .map(response => response.status === 200)
+    .catch(() => Observable.of(false));
+  }
+}
diff --git a/src/app/shared/API/middleware/middleware-service.service.ts b/src/app/shared/API/middleware/middleware-service.service.ts
index 4e58739d6..4a0db190c 100644
--- a/src/app/shared/API/middleware/middleware-service.service.ts
+++ b/src/app/shared/API/middleware/middleware-service.service.ts
@@ -158,7 +158,7 @@ export class MiddlewareServiceService {
 
   // ===========================================================================
 
-  CMAPIFileContent({length, path, index, blobFile}) {
+  CMAPIPing() {
     const headers = new HttpHeaders();
     headers.set('Authorization', 'Bearer ' + SessionStore.user.Authorization);
 
@@ -170,6 +170,31 @@ export class MiddlewareServiceService {
     };
 
 
+    const formData = new FormData();
+
+    formData.append("blobFile", "blobFile");
+    formData.append("length", "length");
+    formData.append("index", "index.toString(");
+
+
+    return this.http.post<IuploadFileLK>(`${geturl}`, formData, options)
+  }
+
+
+
+  CMAPIFileContent({length, path, index, blobFile}) {
+    const headers = new HttpHeaders();
+    headers.set('Authorization', 'Bearer ' + SessionStore.user.Authorization);
+
+    // const geturl = 'http://localhost:3001/FileHub';
+    // const geturl = environment.apiURL + 'Tasks/DelegateTask';
+    const geturl = environment.apiPCURL + 'FileContent';
+
+    let options = {
+      headers: headers
+    };
+
+
     const formData = new FormData();
 
     formData.append("blobFile", blobFile);
@@ -182,4 +207,15 @@ export class MiddlewareServiceService {
 
     return this.http.post<IuploadFileLK>(`${geturl}`, formData, options)
   }
+
+
+
+  tryToReachTheServer() {
+    let opts = {
+      headers: {},
+    }
+
+    return this.http.post(environment.apiURL + "UserAuthentication/Login", '', opts)
+  }
+
 }
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 47516404b..d7df35fe8 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -62,13 +62,19 @@
                   <div class="progress-bar" id="myProgressBar"></div>
                 </div> -->
 
-                <!-- <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
+                <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager">
+
+
                   <mat-progress-bar
-                  *ngIf="seleted.chucksManager"
-                  mode="determinate"
-                  style="width: 50%"
-                ></mat-progress-bar>
-                </div> -->
+
+                    mode="determinate"
+                    [style.width]="seleted.chucksManager.uploadPercentage"
+                  ></mat-progress-bar>
+
+
+
+                </div>
+
 
               <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index 652b5ccfd..080810bdc 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -14,8 +14,10 @@ import { FileValidatorService } from "src/app/services/file/file-validator.servi
 import { MiddlewareServiceService } from "src/app/shared/API/middleware/middleware-service.service";
 import { LakefsRepositoryService } from '../../repository/lakefs/lakefs-repository.service';
 import { ok, err, Result } from 'neverthrow';
-import { SocketConnectionMCRService } from "src/app/services/socket-connection-mcr.service"
-import { CMAPIService } from "src/app/shared/repository/CMAPI/cmapi.service";
+import { ObjectMergeNotification, SocketConnectionMCRService } from "src/app/services/socket-connection-mcr.service"
+import { CMAPIService } from '../../repository/CMAPI/cmapi.service';
+import { environment } from 'src/environments/environment';
+
 
 enum  ActionType  {
   newRapid = "1",
@@ -338,6 +340,7 @@ export class NewPublicationPage implements OnInit {
     }
 
 
+
     if(this.seletedContent.length == 0) {
 
       const newAttachment = new PublicationAttachmentEntity(
@@ -356,6 +359,7 @@ export class NewPublicationPage implements OnInit {
     if (this.publicationType == ActionType.edit) {
 
 
+
       if (this.seletedContent.length >= 1) {
         const loader = this.toastService.loading()
 
@@ -370,6 +374,22 @@ export class NewPublicationPage implements OnInit {
         }
 
 
+        this.publicationFormMV.setDataToFrom(this.publication)
+        const upload = await this.publicationFormMV.uploadVideosFiles()
+
+        if(upload) {
+          this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
+            if(e.FileType == 'video') {
+              e.FileBase64 = environment.apiURL + "/ObjectServer/StreamFiles?path="+ e.chucksManager.path
+            }
+
+            return e
+          })
+
+          console.log("this.publication.Files", this.publication.Files)
+        }
+
+
         this.publication.Files = this.publication.Files.map( e => ({
           FileBase64: e.FileBase64,
           FileExtension: e.FileExtension,
@@ -416,6 +436,20 @@ export class NewPublicationPage implements OnInit {
         }
 
 
+        this.publicationFormMV.setDataToFrom(this.publication)
+        const upload = await this.publicationFormMV.uploadVideosFiles()
+
+        if(upload) {
+          this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
+            if(e.FileType == 'video') {
+              e.FileBase64 = environment.apiURL + "/ObjectServer/StreamFiles?path="+ e.chucksManager.path
+            }
+
+            return e
+          })
+
+          console.log("this.publication.Files", this.publication.Files)
+        }
 
         this.publication.Files = this.publication.Files.map( e => ({
           FileBase64: e.FileBase64,
@@ -871,7 +905,7 @@ export class NewPublicationPage implements OnInit {
 
 
 
-  uploadChunk() {
+  async uploadChunk() {
     let time = new Date()
 
     this.publication = {
@@ -886,162 +920,95 @@ export class NewPublicationPage implements OnInit {
     }
 
 
-    this.publicationFormMV.setDataToFrom(this.publication)
-    this.publicationFormMV.uploadVideosFiles()
 
   }
 }
 
-// class UploadFileUseCase {
-//   LakefsRepositoryService:  LakefsRepositoryService = window["LakefsRepositoryService"]
-//   constructor() {}
-//   execute(attachment: PublicationAttachmentEntity) {
-
-//     const file: File = attachment.blob
-
-//     const chunkSize = 1024 * 100; // Adjust the chunk size as needed
-//     const fileSize = file.size;
-//     let uploadedSize = 0
-//     const totalChunks = Math.ceil(fileSize / chunkSize);
-//     let offset = 0;
-//     let i = 1;
-//     let j = 0;
-//     let path;
-
-//     function count () {
-//       j++
-//       return j
-//     }
-
-//     const readAndUploadChunk = async(index: number) => {
-//       return new Promise<void>((resolve, reject) => {
-//         const chunk = file.slice(offset, offset + chunkSize);
-//         const reader = new FileReader();
-
-//         reader.onload = async () => {
-//           const blob = new Blob([reader.result as ArrayBuffer]);
-//           const formData = new FormData();
-//           const file = new File([blob], "test.mp4", { type: blob.type });
-
-//           uploadedSize =+ file.size
-
-//           formData.append("blobFile", file);
-//           formData.append("length", totalChunks.toString());
-//           formData.append("index", index.toString());
-//           formData.append("path", path);
-
-//           try {
-//             const response = await this.LakefsRepositoryService.uploadFile(formData).toPromise()
-
-//             console.log({response})
-
-//             resolve()
-//           } catch (erro) {
-//             reject()
-//           }
-
-//         };
-
-//         reader.readAsArrayBuffer(chunk);
-//         offset += chunkSize;
-//       });
-//     }
-
-//     const  loop = async() => {
-
-//       for (let index = 2; index <= totalChunks; index++) {
-//         await readAndUploadChunk(index);
-//       }
-
-//     }
-
-//      const startUpload = async() => {
-//       const index = count();
-//       const chunk = file.slice(offset, offset + chunkSize);
-//       const reader = new FileReader();
-
-//       reader.onload = async () => {
-//         const blob = new Blob([reader.result as ArrayBuffer]);
-//         const formData = new FormData();
-//         const file = new File([blob], "test.mp4", { type: blob.type });
-//         uploadedSize =+ file.size
-//         formData.append("blobFile", file);
-//         formData.append("length", totalChunks.toString());
-//         formData.append("index", index.toString());
-
-
-//         const response: any = await this.LakefsRepositoryService.uploadFile(formData).toPromise()
-
-//         console.log({ response, index });
-//         if (index === 1) {
-//           path = response.path;
-//         }
-
-//         await loop();
-//       };
-
-//       reader.readAsArrayBuffer(chunk);
-//       offset += chunkSize;
-//     }
-
-//     startUpload();
-
-
-//   }
-// }
-
-
-
 
 class UploadFileUseCase {
-  CMAPIService:  CMAPIService = window["CMAPIService"]
+  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
   constructor() {}
-  async execute(ChucksManager: ChucksManager): Promise<Result<ChucksManager, ChucksManager>> {
+  async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
+    return new Promise(async (resolve, reject) => {
 
-    let path: string;
-    const length = ChucksManager.chunks.totalChunks.toString()
 
-    const readAndUploadChunk = async(index: number) => {
+      let path: string;
+      const length = PublicationAttachmentEntity.chucksManager.chunks.totalChunks.toString()
 
-      const chunk = await ChucksManager.chunks.getChunks(index)
-      const blob = new Blob([chunk]);
-      const blobFile = new File([blob], "test.mp4", { type: blob.type });
+      const readAndUploadChunk = async(index: number) => {
 
-      return await this.CMAPIService.FileContent({length, path: ChucksManager.path, index, blobFile})
-    }
+        const chunk = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
+        const blob = new Blob([chunk]);
+        const blobFile = new File([blob], "test.mp4", { type: blob.type });
 
-    if(!ChucksManager.hasPath()) {
-
-      const initIndex = ChucksManager.uploadsCount + 1
-      const chuck = await ChucksManager.chunks.getChunks(initIndex)
-      const blob = new Blob([chuck]);
-      const blobFile = new File([blob], "test.mp4", { type: blob.type });
-
-      const uploadRequest = await this.CMAPIService.FileContent({length, path:ChucksManager.path, index: initIndex, blobFile})
-
-      if(uploadRequest.isOk()) {
-
-        path = uploadRequest.value.data
-
-        ChucksManager.setPath(path)
-        ChucksManager.setResponse(initIndex, uploadRequest.value as any)
-      } else {
-        return err(ChucksManager)
+        return await this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
       }
-    }
 
-    const indexContinuation = ChucksManager.uploadsCount + 1
-    for (let index = indexContinuation; index <= ChucksManager.chunks.totalChunks; index++) {
-      const uploadRequest = await readAndUploadChunk(index)
+      if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
+        const initIndex = 1
 
+        const uploadRequest = await readAndUploadChunk(initIndex)
+
+        if(uploadRequest.isOk()) {
+
+          path = uploadRequest.value.data
+
+          PublicationAttachmentEntity.chucksManager.setPath(path)
+          PublicationAttachmentEntity.chucksManager.setResponse(initIndex, uploadRequest)
+        } else {
+          reject(err(PublicationAttachmentEntity))
+        }
+      }
+
+      const allRequest: Promise<any>[] = []
+
+      for (let index = 2; index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1; index++) {
+        const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
+
+        if(needUpload) {
+
+          const request = readAndUploadChunk(index).then(async(uploadRequest) => {
+            if(uploadRequest.isErr()) {
+              const pingRequest = await this.CMAPIService.ping()
+              if( pingRequest.isErr()) {
+                reject(err(PublicationAttachmentEntity))
+              }
+            } else {
+              PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
+            }
+          })
+          allRequest.push(request)
+
+          // const request = readAndUploadChunk(index)
+          // const uploadRequest = await request
+
+          // allRequest.push(request)
+          // if(uploadRequest.isErr()) {
+          //   const pingRequest = await this.CMAPIService.ping()
+          //   if( pingRequest.isErr()) {
+          //     reject(err(PublicationAttachmentEntity))
+          //   }
+          // } else {
+          //   PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
+          // }
+        }
+      }
+
+      await Promise.all(allRequest)
+
+      const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
       if(uploadRequest.isErr()) {
-        return err(ChucksManager)
+        const pingRequest = await this.CMAPIService.ping()
+        if( pingRequest.isErr()) {
+          reject(err(PublicationAttachmentEntity))
+        }
       } else {
-        ChucksManager.setResponse(index, uploadRequest.value as any)
+        PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
       }
-    }
 
-    return ok(ChucksManager)
+      PublicationAttachmentEntity.chucksManager.doneChunkUpload()
+      resolve(ok(PublicationAttachmentEntity))
+    })
   }
 }
 
@@ -1084,6 +1051,9 @@ class PublicationAttachmentEntity {
   setChunkManger (chunks: Chunks) {
     this.chucksManager = new ChucksManager({chunks})
   }
+  get hasChunkManger() {
+    return this.chucksManager?.chunks
+  }
 
   get hasChunkManager() {
     return this.chucksManager != null
@@ -1111,8 +1081,14 @@ class PublicationFormModel implements IPublicationFormModelEntity {
   OriginalFileName: string;
   Files: PublicationAttachmentEntity[];
 
+  hasSet = false
+
   setData(data: IPublicationFormModelEntity) {
-    Object.assign(this, data)
+    if(!this.hasSet) {
+      Object.assign(this, data)
+    }
+
+    this.hasSet = true
   }
 }
 
@@ -1120,6 +1096,7 @@ class PublicationFormMV {
 
   private UploadFileUseCase = new UploadFileUseCase()
   private form = new PublicationFormModel()
+  private ObjectMergeNotification = new ObjectMergeNotification()
 
   setDataToFrom(data: IPublicationFormModelEntity) {
     this.form.setData(data)
@@ -1129,30 +1106,76 @@ class PublicationFormMV {
     return this.form.Files.filter( x => x.FileType == 'video')
   }
 
-  private async upload(PublicationAttachmentEntity: PublicationAttachmentEntity) {
+  private upload(PublicationAttachmentEntity: PublicationAttachmentEntity) {
 
-    const fileBlob = PublicationAttachmentEntity.blobFile;
-    const fileChunks = new Chunks({chunkSize: 100 })
-    fileChunks.setFile(fileBlob)
+    return new Promise(async (resolve, reject)=> {
 
-    PublicationAttachmentEntity.setChunkManger(fileChunks)
+      if(!PublicationAttachmentEntity.hasChunkManger) {
+        const fileBlob = PublicationAttachmentEntity.blobFile;
+        const fileChunks = new Chunks({chunkSize: 500 })
+        fileChunks.setFile(fileBlob)
 
-    const ChucksManagers = new ChucksManager({chunks: fileChunks})
+        PublicationAttachmentEntity.setChunkManger(fileChunks)
+
+        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(()=> {
+          const guid = PublicationAttachmentEntity.chucksManager.path
+
+          this.ObjectMergeNotification.subscribe(guid, (data) => {
+            // console.log("data", data)
+            PublicationAttachmentEntity
+            resolve(true)
+          })
+        })
+
+      } else {
+        if(PublicationAttachmentEntity.chucksManager.doneUpload) {
+          return resolve(true)
+        }
+      }
+
+      const result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
+
+      if(result.isErr()) {
+        reject(false)
+      }
+    })
 
-    this.UploadFileUseCase.execute(ChucksManagers)
   }
 
-  uploadVideosFiles() {
+  uploadVideosFiles(): Promise<Boolean> {
+    return new Promise((resolve, reject)=> {
+      const videosFiles = this.getVideoFiles()
 
-    const videosFiles = this.getVideoFiles()
+      const videosFilesToUploads = videosFiles.filter( e => e.toUpload == true)
 
-    const videosFilesToUploads = videosFiles.filter( e => e.toUpload == true)
+      const Promises: Promise<any>[] = []
+
+      for(const file of videosFilesToUploads) {
+        const promise = this.upload(file)
+        Promises.push(promise)
+      }
+
+      // Use Promise.all to wait for all promises to resolve
+      Promise.all(Promises)
+      .then((results) => {
+        // Check if every promise resolved successfully
+        const allPromisesResolvedSuccessfully = results.every((result) => result == true);
+
+        if (allPromisesResolvedSuccessfully) {
+          console.log('All promises resolved successfully.');
+          resolve(true)
+        } else {
+          reject(false)
+          console.log('Some promises failed to resolve successfully.');
+        }
+      })
+      .catch((error) => {
+        reject(false)
+        console.error('An error occurred while resolving promises:', error);
+      });
+    })
 
-    for(const file of videosFilesToUploads) {
-      this.upload(file)
-    }
   }
-
 }
 
 
@@ -1205,7 +1228,7 @@ class Chunks {
 }
 
 interface IUploadResponse {
-  result: Result<string, Error>
+  result: Result<any, Error>
   attemp: number
 }
 
@@ -1213,25 +1236,110 @@ class ChucksManager {
   chunks: Chunks
   uploads: {[key: string]: IUploadResponse } = {}
   path: string = undefined
+  uploadPercentage: string = "0%"
+  merging = false
+  onSetPath: Function[] = []
+  onSetLastChunk: Function[] = []
+  contentReady = false
+
+  getUploadPercentage() {
+    return this.uploadPercentage
+  }
 
   get uploadsCount() {
     return Object.entries(this.uploads).length
   }
 
+  get uploadWithSuccessCount() {
+    const uploadWithSuccess = Object.entries(this.uploads).filter(([index, data])=>  data.result.isOk())
+    return uploadWithSuccess.length
+  }
+
+  get doneUpload() {
+    return this.chunks.totalChunks == this.uploadWithSuccessCount
+  }
+
   uploadFunc: Function
   constructor({chunks}) {
     this.chunks = chunks
   }
 
+  calculatePercentage(): number {
+    /**
+     * Calculate the percentage based on the total and current values.
+     *
+     * @param total - The total value.
+     * @param current - The current value.
+     * @returns The percentage calculated as (current / total) * 100.
+     */
+    const total = this.chunks.totalChunks
+    const current = this.uploadWithSuccessCount
+
+    if (total === 0) {
+        return 0; // To avoid division by zero error
+    }
+
+    const percentage: number = (current / total) * 100;
+    return percentage;
+  }
+
+  setPercentage() {
+    const percentage: number = this.calculatePercentage()
+    console.log({percentage})
+    this.uploadPercentage = percentage.toString()+"%"
+  }
+
   setPath(path: string) {
     this.path = path
+    this.onSetPath.forEach(callback => callback());
+  }
+
+  registerOnSetPath(a: Function) {
+    this.onSetPath.push(a)
+  }
+
+  registerOnLastChunk(a: Function) {
+    this.onSetPath.push(a)
   }
 
   hasPath() {
     return this.path != undefined
   }
 
+  isIndexRegistered(index) {
+    if(!this.uploads[index]) {
+      return false
+    }
+    return true
+  }
+
+  needToUploadChunkIndex(index) {
+    return !this.uploads?.[index]?.result?.isOk()
+  }
+
   setResponse(index, UploadResponse) {
-    this.uploads[index] = UploadResponse
+
+    if(!this.isIndexRegistered(index)) {
+      this.uploads[index] = {
+        attemp: 1,
+        result: UploadResponse
+      }
+      console.log({UploadResponse})
+    } else {
+      this.uploads[index].attemp++;
+      this.uploads[index].result = UploadResponse
+    }
+
+    this.setPercentage()
+  }
+
+  doneChunkUpload() {
+    this.merging = true
+    this.onSetLastChunk.forEach(callback => callback());
+  }
+
+  contentSetReady() {
+    this.merging = false
+    this.contentReady = true
   }
 }
diff --git a/src/app/shared/publication/view-publications/view-publications.page.ts b/src/app/shared/publication/view-publications/view-publications.page.ts
index ec82302c1..723ddab60 100644
--- a/src/app/shared/publication/view-publications/view-publications.page.ts
+++ b/src/app/shared/publication/view-publications/view-publications.page.ts
@@ -371,15 +371,20 @@ export class ViewPublicationsPage implements OnInit {
       video.pause();
     })
 
+    try {
 
-    this.videoElements.forEach(videoElement => {
-      // You can access the native HTML video element using videoElement.nativeElement
-      const video: HTMLVideoElement = videoElement.nativeElement;
+      this.videoElements.forEach(videoElement => {
+        // You can access the native HTML video element using videoElement.nativeElement
+        const video: HTMLVideoElement = videoElement.nativeElement;
+
+        video.pause()
+        // Do something with each video element
+        // console.log(video);
+      });
+    } catch (e) {
+
+    }
 
-      video.pause()
-      // Do something with each video element
-      // console.log(video);
-    });
   }
 
   public onScroll(event): void {
diff --git a/src/app/shared/repository/CMAPI/cmapi.service.ts b/src/app/shared/repository/CMAPI/cmapi.service.ts
index 5335174ab..817437522 100644
--- a/src/app/shared/repository/CMAPI/cmapi.service.ts
+++ b/src/app/shared/repository/CMAPI/cmapi.service.ts
@@ -1,14 +1,18 @@
 import { Injectable } from '@angular/core';
 import { MiddlewareServiceService } from "src/app/shared/API/middleware/middleware-service.service";
+import { CMAPIAPIService } from "src/app/shared/API/CMAPI/cmapi-api.service";
 import { ok, err } from 'neverthrow';
+import { Observable } from 'rxjs';
 
 @Injectable({
   providedIn: 'root'
 })
 export class CMAPIService {
 
-  constructor(public MiddlewareServiceService: MiddlewareServiceService) {
-    window["CMAPIService"] = this
+  constructor(
+    public MiddlewareServiceService: MiddlewareServiceService,
+    private CMAPIAPIService: CMAPIAPIService) {
+    window["CMAPIAPIRepository"] = this
   }
 
   async FileContent({length, path, index, blobFile}) {
@@ -20,7 +24,33 @@ export class CMAPIService {
     } catch (error) {
       return err(error)
     }
-    
+
+  }
+
+  async ping() {
+    try {
+      await this.MiddlewareServiceService.tryToReachTheServer().toPromise();
+      return ok(true)
+
+    } catch (error) {
+
+      if(error.status == 0) {
+        return err(false)
+      }
+
+      return ok(true)
+    }
+
+  }
+
+  async getVideoHeader(url: string) {
+    try {
+      await this.CMAPIAPIService.getVideoHeader(url).toPromise()
+      return ok(true)
+    } catch(error) {
+      return err(false)
+    }
+
   }
 
 }

From 76b0046a224513c2d41e6c43215663cb0ac07a83 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Tue, 30 Jan 2024 11:35:45 +0100
Subject: [PATCH 02/16] file upload

---
 .../pages/publications/publications.page.html |  7 +-
 .../pages/publications/publications.page.ts   | 38 +-------
 src/app/services/stream/stream.service.ts     | 91 -------------------
 src/app/shared/API/CMAPI/cmapi-api.service.ts |  4 +-
 .../new-publication/new-publication.page.html |  4 +-
 .../new-publication/new-publication.page.ts   | 58 ++++++++----
 .../shared/repository/CMAPI/cmapi.service.ts  |  3 +
 src/environments/environment.prod.ts          |  2 +-
 8 files changed, 53 insertions(+), 154 deletions(-)

diff --git a/src/app/pages/publications/publications.page.html b/src/app/pages/publications/publications.page.html
index 60591173b..e2464cccf 100644
--- a/src/app/pages/publications/publications.page.html
+++ b/src/app/pages/publications/publications.page.html
@@ -19,11 +19,8 @@
           <div class="title-content width-100 d-flex justify-space-between">
             <div class="div-title flex-grow-1">
               <ion-label class="title font-25-em">Acções</ion-label>
-              <!-- <div>
-                <input type="file" (change)="onFileSelect($event)" />
-              </div> -->
             </div>
-            
+
             <div *ngIf="!intent" class="div-icon">
               <button *ngIf="p.userPermission([p.permissionList.Actions.create])" title="Adicionar nova ação presidencial" class="btn-no-color" (click)="AddPublicationFolder()">
                 <ion-icon *ngIf="ThemeService.currentTheme == 'default' " slot="icon-only" src='assets/images/icons-add.svg'></ion-icon>
@@ -35,7 +32,7 @@
               </button>
             </div>
             <div *ngIf="intent" class="div-icon">
-              
+
               <button title="Atualizar"  class="btn-no-color" (click)="close()">
                 <ion-icon class=" font-45-em" src="assets/images/icons-search-close.svg"></ion-icon>
               </button>
diff --git a/src/app/pages/publications/publications.page.ts b/src/app/pages/publications/publications.page.ts
index 5ffd706d5..5692a8d4e 100644
--- a/src/app/pages/publications/publications.page.ts
+++ b/src/app/pages/publications/publications.page.ts
@@ -82,7 +82,7 @@ export class PublicationsPage implements OnInit {
     this.months = ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"];
     this.days = ["Domingo", "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-feira", "Sexta-feira", "Sábado"];
     this.intent = window["sharedContent"]
-    
+
   }
 
   ngOnInit() {
@@ -237,42 +237,6 @@ export class PublicationsPage implements OnInit {
 
   async onFileSelect(event: any) {
 
-    const file:File = event.target.files[0];
-
-
-    const chunkSize = 1024 * 1024; // Adjust the chunk size as needed
-    const chunks = [];
-    let offset = 0;
-    let i = 0;
-    let j = 0;
-
-    function count () {
-      j++
-      return j
-    }
-
-    while (offset < file.size) {
-      const chunk = file.slice(offset, offset + chunkSize);
-      const reader = new FileReader();
-
-      reader.onload = async () => {
-
-        const headers = new HttpHeaders()
-        .append('X-File-Name', "fileName")
-        .append('X-File-Extension', "mp4")
-        .append('X-File-Content-Length', i.toString())
-        .append('X-File-Index', count().toString());
-
-        const a = new Uint8Array(reader.result as ArrayBuffer)
-        await this.http.post('http://localhost:3001/upload', a.buffer, { headers, responseType: 'blob' }).toPromise();
-
-
-      };
-      reader.readAsArrayBuffer(chunk);
-      offset += chunkSize;
-      i++;
-    }
-
 
 
   }
diff --git a/src/app/services/stream/stream.service.ts b/src/app/services/stream/stream.service.ts
index f1c12c1ef..d37e653f1 100644
--- a/src/app/services/stream/stream.service.ts
+++ b/src/app/services/stream/stream.service.ts
@@ -12,97 +12,6 @@ export class StreamService {
     window["StreamService"] = this
   }
 
-
-  async uploadFile() {
-    const API_URL = 'http://localhost:3000/upload'; // Replace with your server URL
-    const filePath = 'path/to/large-file.zip'; // Replace with the path to your file
-    const fileName = 'my-file'; // Specify your desired filename
-    const fileExtension = 'zip'; // Specify the file extension
-
-    const headers = new HttpHeaders()
-      .append('X-File-Name', fileName)
-      .append('X-File-Extension', fileExtension);
-
-    const file = await this.readFileInChunks(filePath);
-    const chunkSize = 1024 * 1024; // 1 MB chunk size (adjust as needed)
-
-    for (let offset = 0; offset < file.length; offset += chunkSize) {
-      const chunk = file.slice(offset, offset + chunkSize);
-      // await this.uploadChunk(API_URL, chunk, headers);
-    }
-
-    console.log('Upload completed.');
-  }
-
-  async readFileInChunks(filePath: string): Promise<Uint8Array> {
-    const response = await fetch(filePath);
-    const reader = response.body.getReader();
-    const chunks: Uint8Array[] = [];
-    let done = false;
-
-    while (!done) {
-      const { value, done: isDone } = await reader.read();
-      if (!isDone) {
-        chunks.push(value);
-      }
-      done = isDone;
-    }
-
-    return new Uint8Array([].concat(...chunks.map((chunk) => Array.from(chunk))));
-  }
-
-  async uploadChunk(url: string, chunks: Uint8Array[], fileName, fileExtension): Promise<void> {
-
-    let i = 1
-
-    console.log('123', chunks.length)
-    for(const chunk of chunks) {
-      try {
-
-        console.log("iterate")
-
-        const headers = new HttpHeaders()
-        .append('X-File-Name', fileName)
-        .append('X-File-Extension', fileExtension)
-        .append('X-File-Content-Length',  chunks.length.toString())
-        .append('X-File-Index', i.toString())
-
-        await this.http.post('http://localhost:3001/upload', chunk.buffer, { headers, responseType: 'blob' }).toPromise();
-        i++
-
-      } catch (error) {
-        console.error('Upload error:', error);
-      }
-    }
-
-  }
-
-
-  async uploadChunkNoLoop(url: string, chunk: Uint8Array, fileName, fileExtension, i, length): Promise<void> {
-
-    console.log("iterate")
-
-    const headers = new HttpHeaders()
-    .append('X-File-Name', fileName)
-    .append('X-File-Extension', fileExtension)
-    .append('X-File-Content-Length',  length)
-    .append('X-File-Index', i.toString())
-
-    await this.http.post('http://localhost:3001/upload', chunk.buffer, { headers, responseType: 'blob' }).toPromise();
-
-  }
-
-  uploadChunk1(chunk: Blob, chunkNumber: number, totalChunks: number, filename: string) {
-
-    console.log(chunk)
-
-    const headers = new HttpHeaders()
-    .append('X-File-Name', filename)
-    .append('X-File-Content-Length',  totalChunks.toString())
-    .append('X-File-Index', chunkNumber.toString())
-
-    return this.http.post('http://localhost:3001/upload-chunk', Blob, { headers, responseType: 'blob' });
-  }
 }
 
 // const text = 'Hello, World00120301010asdf1002sdf 0fsdfasf0001230 12300!\n';
diff --git a/src/app/shared/API/CMAPI/cmapi-api.service.ts b/src/app/shared/API/CMAPI/cmapi-api.service.ts
index 289afcb7d..927de3936 100644
--- a/src/app/shared/API/CMAPI/cmapi-api.service.ts
+++ b/src/app/shared/API/CMAPI/cmapi-api.service.ts
@@ -2,6 +2,7 @@ import { Injectable } from '@angular/core';
 import { HttpServiceService } from 'src/app/services/http/http-service.service';
 import { HttpClient, HttpEvent, HttpHeaders, HttpParams } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { environment } from 'src/environments/environment';
 
 @Injectable({
   providedIn: 'root'
@@ -13,6 +14,7 @@ export class CMAPIAPIService {
 
 
   getVideoHeader(url: string) {
-    return this.http.head('http://localhost:3001/static/'+url, { observe: 'response' })
+    // return this.http.head('http://localhost:3001/static/'+url, { observe: 'response' })
+    return this.http.head(environment.apiURL+'ObjectServer/StreamFiles?path='+url, { observe: 'response' })
   }
 }
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 89b589460..40b765508 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -86,7 +86,7 @@
                 <source type="video/mp4" [src]="'data:video/mp4;base64,' +seleted.FileBase64">
               </video>
 
-
+              <ion-icon *ngIf="seleted?.chucksManager?.manualRetry" src="assets/images/retry-svgrepo-com.svg" class="icon-download font-12"> </ion-icon>
 
             </div>
 
@@ -127,7 +127,7 @@
         </div>
       </div>
     </div>
-   
+
     <div *ngIf="photoOrVideo" class="container-multiselect pt-10" style="width: 200px;">
       <button id="container-multiselect" class="multiselect-button" (click)="takePicture()">Fotografia</button>
       <button id="container-multiselect" class="multiselect-button" (click)="startVideoRecording()">Video</button>
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index 1cd4563f8..d62a5523e 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -458,7 +458,8 @@ export class NewPublicationPage implements OnInit {
         if(upload) {
           this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
             if(e.FileType == 'video') {
-              e.FileBase64 = environment.apiURL + "/ObjectServer/StreamFiles?path="+ e.chucksManager.path
+              e.OriginalFileName = e.chucksManager.path
+              e.FileExtension = "mp4"
             }
 
             return e
@@ -520,7 +521,8 @@ export class NewPublicationPage implements OnInit {
         if(upload) {
           this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
             if(e.FileType == 'video') {
-              e.FileBase64 = environment.apiURL + "/ObjectServer/StreamFiles?path="+ e.chucksManager.path
+              e.OriginalFileName = e.chucksManager.path
+              e.FileExtension = "mp4"
             }
 
             return e
@@ -1076,6 +1078,7 @@ class UploadFileUseCase {
   async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
     return new Promise(async (resolve, reject) => {
 
+      PublicationAttachmentEntity.chucksManager.clearManualRetry()
 
       let path: string;
       const length = PublicationAttachmentEntity.chucksManager.chunks.totalChunks.toString()
@@ -1086,7 +1089,7 @@ class UploadFileUseCase {
         const blob = new Blob([chunk]);
         const blobFile = new File([blob], "test.mp4", { type: blob.type });
 
-        return await this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
+        return this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
       }
 
       if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
@@ -1101,13 +1104,15 @@ class UploadFileUseCase {
           PublicationAttachmentEntity.chucksManager.setPath(path)
           PublicationAttachmentEntity.chucksManager.setResponse(initIndex, uploadRequest)
         } else {
-          reject(err(PublicationAttachmentEntity))
+          PublicationAttachmentEntity.chucksManager.setManualRetry()
+          return reject(err(PublicationAttachmentEntity))
         }
       }
 
       const allRequest: Promise<any>[] = []
+      let connection = true
 
-      for (let index = 2; index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1; index++) {
+      for (let index = 2;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1) && connection ); index++) {
         const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
 
         if(needUpload) {
@@ -1116,7 +1121,9 @@ class UploadFileUseCase {
             if(uploadRequest.isErr()) {
               const pingRequest = await this.CMAPIService.ping()
               if( pingRequest.isErr()) {
-                reject(err(PublicationAttachmentEntity))
+                connection = false
+                PublicationAttachmentEntity.chucksManager.setManualRetry()
+                return reject(err(PublicationAttachmentEntity))
               }
             } else {
               PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
@@ -1139,20 +1146,28 @@ class UploadFileUseCase {
         }
       }
 
-      await Promise.all(allRequest)
-
-      const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
-      if(uploadRequest.isErr()) {
-        const pingRequest = await this.CMAPIService.ping()
-        if( pingRequest.isErr()) {
-          reject(err(PublicationAttachmentEntity))
-        }
+      if(!connection) {
+        PublicationAttachmentEntity.chucksManager.setManualRetry()
+        return reject(err(PublicationAttachmentEntity))
       } else {
-        PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
+        await Promise.all(allRequest)
+
+        const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
+        if(uploadRequest.isErr()) {
+          const pingRequest = await this.CMAPIService.ping()
+          if( pingRequest.isErr()) {
+            PublicationAttachmentEntity.chucksManager.setManualRetry()
+            return reject(err(PublicationAttachmentEntity))
+          }
+        } else {
+          PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
+        }
+
+        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
+        resolve(ok(PublicationAttachmentEntity))
       }
 
-      PublicationAttachmentEntity.chucksManager.doneChunkUpload()
-      resolve(ok(PublicationAttachmentEntity))
+
     })
   }
 }
@@ -1386,6 +1401,7 @@ class ChucksManager {
   onSetPath: Function[] = []
   onSetLastChunk: Function[] = []
   contentReady = false
+  manualRetry = false
 
   getUploadPercentage() {
     return this.uploadPercentage
@@ -1428,6 +1444,14 @@ class ChucksManager {
     return percentage;
   }
 
+  setManualRetry() {
+    this.manualRetry = true
+  }
+
+  clearManualRetry() {
+    this.manualRetry = false
+  }
+
   setPercentage() {
     const percentage: number = this.calculatePercentage()
     console.log({percentage})
diff --git a/src/app/shared/repository/CMAPI/cmapi.service.ts b/src/app/shared/repository/CMAPI/cmapi.service.ts
index 817437522..e943c0dd7 100644
--- a/src/app/shared/repository/CMAPI/cmapi.service.ts
+++ b/src/app/shared/repository/CMAPI/cmapi.service.ts
@@ -48,6 +48,9 @@ export class CMAPIService {
       await this.CMAPIAPIService.getVideoHeader(url).toPromise()
       return ok(true)
     } catch(error) {
+      if(error.status == 405) {
+        return ok(true)
+      }
       return err(false)
     }
 
diff --git a/src/environments/environment.prod.ts b/src/environments/environment.prod.ts
index 726ebb13e..a9256d5a8 100644
--- a/src/environments/environment.prod.ts
+++ b/src/environments/environment.prod.ts
@@ -4,4 +4,4 @@ import { doneITProd } from './suport/doneIt'
 import { DevDev } from './suport/dev'
 
 
-export const environment: Environment = oaprProd;
+export const environment: Environment = DevDev;

From 793c861cbfcc302f4f328f7afbaa64c870ffe969 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Wed, 31 Jan 2024 17:12:01 +0100
Subject: [PATCH 03/16] improve socket

---
 .../new-publication/new-publication.page.html |  12 +-
 .../new-publication/new-publication.page.ts   | 125 +++--
 .../pages/publications/publications.page.ts   |   3 +-
 .../services/socket-connection-mcr.service.ts | 282 +++++-----
 src/app/shared/API/CMAPI/cmapi-api.service.ts |   2 +-
 .../new-publication/new-publication.page.html |  16 +-
 .../new-publication/new-publication.page.ts   | 490 +-----------------
 .../upload/upload-streaming.service.spec.ts   |  16 +
 .../upload/upload-streaming.service.ts        | 483 +++++++++++++++++
 9 files changed, 758 insertions(+), 671 deletions(-)
 create mode 100644 src/app/shared/publication/upload/upload-streaming.service.spec.ts
 create mode 100644 src/app/shared/publication/upload/upload-streaming.service.ts

diff --git a/src/app/pages/publications/new-publication/new-publication.page.html b/src/app/pages/publications/new-publication/new-publication.page.html
index fe0e05983..0b29f2dfb 100644
--- a/src/app/pages/publications/new-publication/new-publication.page.html
+++ b/src/app/pages/publications/new-publication/new-publication.page.html
@@ -40,19 +40,23 @@
 
 
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'" [(ngModel)]="capturedImage"
-                name="image" ngDefaultControl [src]="'data:image/jpg;base64,' + seleted.FileBase64"
+                name="image" ngDefaultControl [src]="'data:image/jpg;base64,' + seleted.Base64"
                 (click)="imageSize(capturedImage)"  style="height: 69px;"></ion-img>
 
-              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'" width="70" height="70"
+              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle == ActionType.edit" width="70" height="70"
                 controls="controls" preload="metadata" autoplay="autoplay" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="'data:video/mp4;base64,' + seleted.FileBase64">
+                <source type="video/mp4" [src]="'data:video/mp4;base64,' + seleted.Base64">
               </video>
 
+              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle != ActionType.edit" width="70" height="70"
+                controls="controls" preload="metadata" autoplay="autoplay" webkit-playsinline="webkit-playsinline">
+                <source type="video/mp4" [src]="seleted.url">
+              </video>
 
             </div>
             <!-- Display the blurred image and count if there are more images -->
             <ion-thumbnail *ngIf="seletedContent.length > displayLimit" lot="start">
-              <ion-img [src]="'data:image/jpg;base64,' + seletedContent[displayLimit - 1].base64"
+              <ion-img [src]="'data:image/jpg;base64,' + seletedContent[displayLimit - 1].Base64"
                 style="filter: blur(5px);"></ion-img>
 
                 <p>mais {{ seletedContent.length - displayLimit }}</p>
diff --git a/src/app/pages/publications/new-publication/new-publication.page.ts b/src/app/pages/publications/new-publication/new-publication.page.ts
index 620b320ca..81c4e2ad2 100644
--- a/src/app/pages/publications/new-publication/new-publication.page.ts
+++ b/src/app/pages/publications/new-publication/new-publication.page.ts
@@ -31,6 +31,7 @@ import { File } from '@ionic-native/file/ngx';
 import { Media } from '@ionic-native/media/ngx';
 import { checkFileTypeService } from 'src/app/services/checkFileType.service';
 import { FileValidatorService } from "src/app/services/file/file-validator.service"
+import { PublicationAttachmentEntity } from 'src/app/shared/publication/upload/upload-streaming.service';
 const config = {
   quality: 0.5,
   maxWidth: 800,
@@ -92,6 +93,13 @@ export class NewPublicationPage implements OnInit {
   publicationTitle: string;
   imgUrl: any;
 
+
+  ActionType =  {
+    newRapid : "1",
+    new: "2",
+    edit: "3"
+  }
+
   Defaultimage: any = '';
 
   photo: SafeResourceUrl;
@@ -112,7 +120,7 @@ export class NewPublicationPage implements OnInit {
   photoOrVideo: boolean = false;
   fileType = "";
   filecontent: boolean;
-  seletedContent: any[] = []
+  seletedContent: PublicationAttachmentEntity[] = []
   // Set a limit for the number of images to display
   displayLimit = 4;
   filesSizeSum = 0;
@@ -142,6 +150,18 @@ export class NewPublicationPage implements OnInit {
     if (this.publication) {
       this.seletedContent = this.publication.Files;
       this.filecontent = true;
+
+      this.seletedContent = this.publication.Files.map(e => {
+        return new PublicationAttachmentEntity(
+          {
+            base64: e.FileBase64,
+            extension: e.FileExtension,
+            OriginalFileName: e.OriginalFileName,
+            FileType: this.checkFileType.checkFileType(e.FileExtension) as any
+          }
+        )
+      })
+
     }
     console.log('Edit', this.publication)
     this.publicationTitle = 'Nova Publicação';
@@ -161,12 +181,16 @@ export class NewPublicationPage implements OnInit {
       recursive: true
     });
 
-    document.addEventListener("click", clickOutside, false);
-    function clickOutside(e) {
-      const inside = document.getElementById('container-multiselect').contains(e.target);
-      this.photoOrVideo = false;
-      console.log(this.photoOrVideo)
-    }
+    try {
+      document.addEventListener("click", clickOutside, false);
+      function clickOutside(e) {
+        const inside = document.getElementById('container-multiselect').contains(e.target);
+        this.photoOrVideo = false;
+        console.log(this.photoOrVideo)
+      }
+    } catch (error) {}
+
+
   }
 
   // in use
@@ -193,11 +217,14 @@ export class NewPublicationPage implements OnInit {
         console.log('take picture', this.removeTextBeforeSlash(picture, ','),)
         this.filecontent = true;
         this.photoOrVideo = false;
-        let fileObject = {
-          FileBase64: this.removeTextBeforeSlash(picture, ','),
-          FileExtension: capturedImage.format,
+
+        const fileObject = new PublicationAttachmentEntity({
+          base64: this.removeTextBeforeSlash(picture, ','),
+          extension: capturedImage.format,
+          FileType: 'image',
           OriginalFileName: 'image'
-        }
+        })
+
         this.seletedContent.push(fileObject)
 
 
@@ -251,11 +278,14 @@ export class NewPublicationPage implements OnInit {
 
             .then(async (content) => {
               this.filecontent = true;
-              let fileObject = {
-                FileBase64: 'data:video/mp4;base64,'+content.data,
-                FileExtension: 'mp4',
-                OriginalFileName: 'video'
-              }
+              let fileObject = new PublicationAttachmentEntity({
+                base64: 'data:video/mp4;base64,'+content.data,
+                extension: 'mp4',
+                OriginalFileName: 'record',
+                FileType: 'video'
+
+              })
+
               this.seletedContent.push(fileObject)
             })
             .catch((err) => console.error(err));
@@ -294,19 +324,30 @@ export class NewPublicationPage implements OnInit {
                 this.filecontent = true;
                 let fileObject;
                 if(this.removeTextBeforeSlash(element.mimeType, '/') == "mp4") {
-                   fileObject = {
-                    FileBase64: 'data:video/mp4;base64,'+ content.data,
-                    FileExtension: this.removeTextBeforeSlash(element.mimeType, '/'),
-                    OriginalFileName: 'video'
-                  }
+
+                  const extension = this.removeTextBeforeSlash(element.mimeType, '/')
+
+                  fileObject = new PublicationAttachmentEntity({
+                    base64:  content.data,
+                    extension: extension,
+                    OriginalFileName: 'video',
+                    FileType: 'video'
+                  })
+
                 } else {
-                  fileObject = {
-                    FileBase64: content.data,
-                    FileExtension: this.removeTextBeforeSlash(element.mimeType, '/'),
-                    OriginalFileName: 'image'
-                  }
+
+                  const extension = this.removeTextBeforeSlash(element.mimeType, '/')
+
+                  fileObject = new PublicationAttachmentEntity({
+                    base64:  content.data,
+                    extension: extension,
+                    OriginalFileName: 'image',
+                    FileType: 'image'
+
+                  })
+
                 }
-                
+
                 this.seletedContent.push(fileObject)
               })
               .catch((err) => console.error(err));
@@ -353,24 +394,24 @@ export class NewPublicationPage implements OnInit {
 
   /*   // in use
     async laodPicture() {
-      
+
       const capturedImage = await Camera.getPhoto({
         quality: 90,
         // allowEditing: true,
         resultType: CameraResultType.Uri,
         source: CameraSource.Photos
       });
-  
+
       const response = await fetch(capturedImage.webPath!);
       const blob = await response.blob();
-  
+
       this.convertBlobToBase64Worker.postMessage(blob);
       this.convertBlobToBase64Worker.onmessage = async (oEvent)=> {
         this.capturedImage = oEvent.data
         this.capturedImageTitle = 'foto'
-  
+
       }
-  
+
     } */
 
 
@@ -497,7 +538,7 @@ export class NewPublicationPage implements OnInit {
             OriginalFileName: "video",
           }
         }
-   
+
         return e
       }) */
 
@@ -533,8 +574,6 @@ export class NewPublicationPage implements OnInit {
 
       try {
 
-       
-
         await this.publications.CreatePublication(this.folderId, this.publication).toPromise();
         this.close();
         this.httpErrorHandle.httpsSucessMessagge('Criar publicação')
@@ -740,12 +779,16 @@ export class NewPublicationPage implements OnInit {
         if (this.checkFileType.checkFileType(FileExtension) == 'image' || this.checkFileType.checkFileType(FileExtension) == 'video') {
           let resultUrl = decodeURIComponent(element.url);
           Filesystem.readFile({ path: resultUrl }).then(async (content) => {
-            console.log('shared base', content.data)
-            let fileObject = {
-              FileBase64: this.removeTextBeforeSlash(content.data, ','),
-              FileExtension: FileExtension,
-              OriginalFileName: 'shared',
-            }
+
+            let fileObject = new PublicationAttachmentEntity(
+              {
+                base64: this.removeTextBeforeSlash(content.data, ','),
+                extension: FileExtension,
+                OriginalFileName: "share-content",
+                FileType: this.checkFileType.checkFileType(FileExtension) as any
+              }
+            )
+
             this.seletedContent.push(fileObject)
           })
         } else {
diff --git a/src/app/pages/publications/publications.page.ts b/src/app/pages/publications/publications.page.ts
index 5692a8d4e..33a8e9d02 100644
--- a/src/app/pages/publications/publications.page.ts
+++ b/src/app/pages/publications/publications.page.ts
@@ -98,6 +98,7 @@ export class PublicationsPage implements OnInit {
 
     this.hideRefreshButton();
     this.intent = window["sharedContent"]
+    window["refreshPublication"] = this.refreshing
 
   }
 
@@ -124,7 +125,7 @@ export class PublicationsPage implements OnInit {
     }
   }
 
-  refreshing() {
+  refreshing = () => {
     setTimeout(() => {
       this.getActions();
     }, 1500);
diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index 2028c3b52..9b6374b81 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -10,60 +10,60 @@ import { HubConnectionBuilder } from '@microsoft/signalr';
   providedIn: 'root'
 })
 export class SocketConnectionMCRService {
-  private  callbacks: Function[] = []
-  private  onDisconnect: Function[] = []
-  private  onConnect: Function[] = []
+  // private  callbacks: Function[] = []
+  // private  onDisconnect: Function[] = []
+  // private  onConnect: Function[] = []
 
-  constructor(private http: HttpClient,) {
-    window["http"] = this.http
-  }
+  // constructor(private http: HttpClient,) {
+  //   window["http"] = this.http
+  // }
 
-  connect() {
+  // connect() {
 
-    var connection = new signalR.HubConnectionBuilder()
-    .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
-      accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
-    }).configureLogging(signalR.LogLevel.Information)
-    .build();
+  //   var connection = new signalR.HubConnectionBuilder()
+  //   .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
+  //     accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
+  //   }).configureLogging(signalR.LogLevel.Information)
+  //   .build();
 
-    connection.on("ReceiveMessage", (message) => {
-      console.log("ReceiveMessage", message)
-    })
+  //   connection.on("ReceiveMessage", (message) => {
+  //     console.log("ReceiveMessage", message)
+  //   })
 
-    connection.onreconnected((connectionId) => {
-      console.assert(connection.state === signalR.HubConnectionState.Connected);
-      console.log(`Reconnected with connectionId: ${connectionId}`);
-    });
+  //   connection.onreconnected((connectionId) => {
+  //     console.assert(connection.state === signalR.HubConnectionState.Connected);
+  //     console.log(`Reconnected with connectionId: ${connectionId}`);
+  //   });
 
-    connection.start()
-    .then(() => {
-        console.log("SignalR connection started.");
-    })
-    .catch((error) => {
-        console.error("Error starting SignalR connection:", error);
-    });
+  //   connection.start()
+  //   .then(() => {
+  //       console.log("SignalR connection started.");
+  //   })
+  //   .catch((error) => {
+  //       console.error("Error starting SignalR connection:", error);
+  //   });
 
-    connection.onclose((error) => {
-      connection.start()
-      console.log("SignalR connection closed:", error);
-    });
+  //   connection.onclose((error) => {
+  //     connection.start()
+  //     console.log("SignalR connection closed:", error);
+  //   });
 
-  }
+  // }
 
-  subscribe(callback) {
-    this.callbacks.push(callback);
-  }
+  // subscribe(callback) {
+  //   this.callbacks.push(callback);
+  // }
 
-  unsubscribe(callback) {
-    this.callbacks = this.callbacks.filter(cb => cb !== callback);
-  }
+  // unsubscribe(callback) {
+  //   this.callbacks = this.callbacks.filter(cb => cb !== callback);
+  // }
 
-  onDisconnectCallback(callback) {
-    this.onDisconnect.push(callback)
-  }
-  onConnectCallback(callback) {
-    this.onConnect.push(callback)
-  }
+  // onDisconnectCallback(callback) {
+  //   this.onDisconnect.push(callback)
+  // }
+  // onConnectCallback(callback) {
+  //   this.onConnect.push(callback)
+  // }
 
 }
 
@@ -74,6 +74,7 @@ class ReconnectingWebSocketSignalR {
   private  callbacks: Function[] = []
   private  onDisconnect: Function[] = []
   private  onConnect: Function[] = []
+  private stop = true
 
   constructor() {
     this.isOpen = false;
@@ -81,9 +82,13 @@ class ReconnectingWebSocketSignalR {
   }
 
   connect() {
+    console.log("try to connect=================================")
+    this.stop = false
+
     this.connection = new signalR.HubConnectionBuilder()
     .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
-      accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
+      transport: signalR.HttpTransportType.LongPolling,
+      accessTokenFactory: () => SessionStore.user.Authorization
     }).configureLogging(signalR.LogLevel.Information)
     .build();
 
@@ -95,16 +100,15 @@ class ReconnectingWebSocketSignalR {
 
 
       this.onConnect.forEach(callback => callback());
-        console.log("SignalR connection started.");
     })
     .catch((error) => {
-        console.error("Error starting SignalR connection:", error);
+      console.error("Error starting SignalR connection:", error);
     });
 
 
     this.connection.on("ReceiveMessage", (message) => {
       const data: any = JSON.parse(message)
-      console.log(data)
+      console.log("ReceiveMessage", data)
       this.callbacks.forEach(callback => callback(data));
     })
 
@@ -113,12 +117,27 @@ class ReconnectingWebSocketSignalR {
       this.isOpen = false;
       this.onDisconnect.forEach(callback => callback());
       // Attempt to reconnect after a delay
-      setTimeout(() => {
-        this.connect();
-      }, 1000); // Adjust the delay as needed
+      if(this.stop) {
+        setTimeout(() => {
+          this.connect();
+        }, 1000); // Adjust the delay as needed
+      }
+
     });
+  }
 
-
+  disconnect() {
+    this.stop = true
+    this.connection.stop()
+    .then(() => {
+      console.log('WebSocket connection closed');
+      this.isOpen = false;
+      this.onDisconnect.forEach(callback => callback());
+      console.log("SignalR connection stopped.");
+    })
+    .catch((error) => {
+      console.error("Error stopping SignalR connection:", error);
+    });
   }
 
   subscribe(callback) {
@@ -143,81 +162,81 @@ interface socketResponse {
   Guid: string
   isCompleted: Boolean
 }
-class ReconnectingWebSocket {
+// class ReconnectingWebSocket {
 
-  private url: string
-  private  socket
-  isOpen: boolean
-  private  callbacks: Function[] = []
-  private  onDisconnect: Function[] = []
-  private  onConnect: Function[] = []
+//   private url: string
+//   private  socket
+//   isOpen: boolean
+//   private  callbacks: Function[] = []
+//   private  onDisconnect: Function[] = []
+//   private  onConnect: Function[] = []
 
-  http: HttpClient = window["http"]
+//   http: HttpClient = window["http"]
 
-  constructor(url) {
-    this.url = url;
-    this.socket = null;
-    this.isOpen = false;
-    this.connect();
-  }
+//   constructor(url) {
+//     this.url = url;
+//     this.socket = null;
+//     this.isOpen = false;
+//     this.connect();
+//   }
 
-  connect() {
-    this.socket = new WebSocket(this.url);
+//   connect() {
+//     this.socket = new WebSocket(this.url);
 
-    this.socket.addEventListener('open', (event) => {
-      this.isOpen = true;
-      console.log('WebSocket connection established');
+//     this.socket.addEventListener('open', (event) => {
+//       this.isOpen = true;
+//       console.log('WebSocket connection established');
 
-      // Example: Send a message to the server
-      this.socket.send('Hello, WebSocket Server!');
-      this.onConnect.forEach(callback => callback());
-    });
+//       // Example: Send a message to the server
+//       this.socket.send('Hello, WebSocket Server!');
+//       this.onConnect.forEach(callback => callback());
+//     });
 
-    this.socket.addEventListener('message', (event) => {
-      const data: socketResponse = JSON.parse(event.data)
-      this.callbacks.forEach(callback => callback(data));
-    });
+//     this.socket.addEventListener('message', (event) => {
+//       const data: socketResponse = JSON.parse(event.data)
+//       this.callbacks.forEach(callback => callback(data));
+//     });
 
-    this.socket.addEventListener('close', (event) => {
-      console.log('WebSocket connection closed');
-      this.isOpen = false;
-      this.onDisconnect.forEach(callback => callback());
-      // Attempt to reconnect after a delay
-      setTimeout(() => {
-        this.connect();
-      }, 1000); // Adjust the delay as needed
-    });
-  }
+//     this.socket.addEventListener('close', (event) => {
+//       console.log('WebSocket connection closed');
+//       this.isOpen = false;
+//       this.onDisconnect.forEach(callback => callback());
+//       // Attempt to reconnect after a delay
+//       setTimeout(() => {
+//         this.connect();
+//       }, 1000); // Adjust the delay as needed
+//     });
+//   }
 
-  send(message) {
-    if (this.isOpen) {
-      this.socket.send(message);
-    } else {
-      console.error('WebSocket connection is not open. Unable to send message.');
-    }
-  }
+//   send(message) {
+//     if (this.isOpen) {
+//       this.socket.send(message);
+//     } else {
+//       console.error('WebSocket connection is not open. Unable to send message.');
+//     }
+//   }
 
-  close() {
-    if (this.isOpen) {
-      this.socket.close();
-    }
-  }
+//   close() {
+//     if (this.isOpen) {
+//       this.socket.close();
+//     }
+//   }
 
-  subscribe(callback) {
-    this.callbacks.push(callback);
-  }
+//   subscribe(callback) {
+//     this.callbacks.push(callback);
+//   }
 
-  unsubscribe(callback) {
-    this.callbacks = this.callbacks.filter(cb => cb !== callback);
-  }
+//   unsubscribe(callback) {
+//     this.callbacks = this.callbacks.filter(cb => cb !== callback);
+//   }
 
-  onDisconnectCallback(callback) {
-    this.onDisconnect.push(callback)
-  }
-  onConnectCallback(callback) {
-    this.onConnect.push(callback)
-  }
-}
+//   onDisconnectCallback(callback) {
+//     this.onDisconnect.push(callback)
+//   }
+//   onConnectCallback(callback) {
+//     this.onConnect.push(callback)
+//   }
+// }
 
 // export class ObjectMergeNotification{
 
@@ -293,9 +312,11 @@ export class ObjectMergeNotification{
     this.socket.onConnectCallback(()=> {
       this.runWatch = false
     })
+    
 
     this.socket.subscribe((data: socketResponse) => {
       if(data.isCompleted == true) {
+        console.log("==================!!!====================")
         this.callbacks[data.Guid](data)
         delete this.callbacks[data.Guid]
       }
@@ -305,36 +326,9 @@ export class ObjectMergeNotification{
   }
 
 
-  connect() {
-
-    var connection = new signalR.HubConnectionBuilder()
-    .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
-        accessTokenFactory: () => "Bearer "+SessionStore.user.Authorization
-    }).configureLogging(signalR.LogLevel.Information)
-    .build();
-
-    connection.on("ReceiveMessage", (message) => {
-      console.log("ReceiveMessage", message)
-    })
-
-    connection.onreconnected((connectionId) => {
-      console.assert(connection.state === signalR.HubConnectionState.Connected);
-      console.log(`Reconnected with connectionId: ${connectionId}`);
-    });
-
-    connection.start()
-    .then(() => {
-        console.log("SignalR connection started.");
-    })
-    .catch((error) => {
-        console.error("Error starting SignalR connection:", error);
-    });
-
-    connection.onclose((error) => {
-      connection.start()
-      console.log("SignalR connection closed:", error);
-    });
-
+  close() {
+    console.log("close=============================================")
+    this.socket.disconnect();
   }
 
   async watch() {
@@ -354,6 +348,8 @@ export class ObjectMergeNotification{
       }, 1000)
 
 
+    } else {
+      console.log("end loop============================")
     }
   }
 
diff --git a/src/app/shared/API/CMAPI/cmapi-api.service.ts b/src/app/shared/API/CMAPI/cmapi-api.service.ts
index 927de3936..ae13fb503 100644
--- a/src/app/shared/API/CMAPI/cmapi-api.service.ts
+++ b/src/app/shared/API/CMAPI/cmapi-api.service.ts
@@ -14,7 +14,7 @@ export class CMAPIAPIService {
 
 
   getVideoHeader(url: string) {
-    // return this.http.head('http://localhost:3001/static/'+url, { observe: 'response' })
+    //return this.http.head('http://localhost:3001/static/'+url, { observe: 'response' })
     return this.http.head(environment.apiURL+'ObjectServer/StreamFiles?path='+url, { observe: 'response' })
   }
 }
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 40b765508..4c4b9a21a 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -56,34 +56,24 @@
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'"
                 name="image" ngDefaultControl [src]="seleted.FileBase64" style="height: 69px;"></ion-img>
 
-
-
-                <!-- <div class="progress-container"   *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
-                  <div class="progress-bar" id="myProgressBar"></div>
-                </div> -->
-
                 <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager">
 
-
                   <mat-progress-bar
 
                     mode="determinate"
                     [style.width]="seleted.chucksManager.uploadPercentage"
                   ></mat-progress-bar>
 
-
-
                 </div>
 
-
               <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkDesktop() == true" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="seleted.FileBase64">
+                <source type="video/mp4" [src]="seleted.url">
               </video>
 
               <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkTableDivice() == true" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="'data:video/mp4;base64,' +seleted.FileBase64">
+                <source type="video/mp4" [src]="'data:video/mp4;base64,' +seleted.Base64">
               </video>
 
               <ion-icon *ngIf="seleted?.chucksManager?.manualRetry" src="assets/images/retry-svgrepo-com.svg" class="icon-download font-12"> </ion-icon>
@@ -93,7 +83,7 @@
           </div>
           <!-- Display the blurred image and count if there are more images -->
           <div *ngIf="seletedContent.length > displayLimit" lot="start">
-            <ion-img [src]="'data:image/jpg;base64,' + seletedContent[displayLimit - 1].FileBase64"
+            <ion-img [src]="'data:image/jpg;base64,' + seletedContent[displayLimit - 1].Base64"
               style="filter: blur(5px);"></ion-img>
 
               <p>mais {{ seletedContent.length - displayLimit }}</p>
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index d62a5523e..54cbb977e 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -22,6 +22,7 @@ import { CaptureError, CaptureImageOptions, MediaCapture, MediaFile } from '@awe
 import { Filesystem, Directory, Encoding, FilesystemDirectory } from '@capacitor/filesystem';
 import { Platform } from '@ionic/angular';
 import { Capacitor } from '@capacitor/core';
+import { PublicationAttachmentEntity, PublicationFormMV } from '../upload/upload-streaming.service';
 
 
 enum ActionType {
@@ -70,9 +71,9 @@ export class NewPublicationPage implements OnInit {
   photoOrVideo: boolean = false;
   video: any;
 
-
   publicationFormMV = new PublicationFormMV()
 
+
   constructor(
     public photoService: PhotoService,
     private publications: PublicationsService,
@@ -97,7 +98,6 @@ export class NewPublicationPage implements OnInit {
       this.filecontent = true;
     }
 
-    this.SocketConnectionMCRService.connect()
   }
 
   ngOnInit() {
@@ -148,13 +148,15 @@ export class NewPublicationPage implements OnInit {
         }
         console.log('edit', this.publication)
         this.pub = this.publication;
+
+        console.log("this.publication.Files", this.publication.Files)
         this.seletedContent = this.publication.Files.map(e => {
           return new PublicationAttachmentEntity(
             {
               base64: e.FileBase64,
               extension: e.FileExtension,
               OriginalFileName: e.OriginalFileName,
-              FileType: this.checkFileType.checkFileType(e.FileExtension)
+              FileType: this.checkFileType.checkFileType(e.FileExtension) as any
             }
           )
         })
@@ -186,11 +188,6 @@ export class NewPublicationPage implements OnInit {
       0.9  // quality
     ).then((picture) => {
       this.photoOrVideo = false;
-      let fileObject = {
-        FileBase64: picture,
-        FileExtension: this.removeTextBeforeSlash('jpeg', '/'),
-        OriginalFileName: 'imagem'
-      }
 
       const FileExtension = this.removeTextBeforeSlash('jpeg', '/')
 
@@ -231,11 +228,6 @@ export class NewPublicationPage implements OnInit {
       800, // maxHeight
       0.9  // quality
     ).then((picture) => {
-      let fileObject = {
-        FileBase64: picture,
-        FileExtension: this.removeTextBeforeSlash('jpeg', '/'),
-        OriginalFileName: 'image'
-      }
 
       const FileExtension = this.removeTextBeforeSlash('jpeg', '/')
 
@@ -278,7 +270,7 @@ export class NewPublicationPage implements OnInit {
 
         console.log("base64 :data:video/mp4;base64,",this.arrayBufferToBase64(await blob.arrayBuffer())) */
 
-        this.convertBlobToBase64(blobFile.blob).then((value) => {
+        this.convertBlobToBase64(blobFile.blob).then((value: string) => {
 
           console.log(value)
 
@@ -294,7 +286,8 @@ export class NewPublicationPage implements OnInit {
                 base64: value,
                 extension: FileExtension,
                 blobFile: file,
-                FileType: this.checkFileType.checkFileType(FileExtension)
+                FileType: this.checkFileType.checkFileType(FileExtension) as any,
+                OriginalFileName: 'load video'
               }
             )
 
@@ -368,7 +361,7 @@ export class NewPublicationPage implements OnInit {
                   base64: content.data,
                   extension: this.removeTextBeforeSlash(element.mimeType, '/'),
                   OriginalFileName: 'video',
-                  FileType: this.checkFileType.checkFileType( this.removeTextBeforeSlash(element.mimeType, '/'))
+                  FileType: this.checkFileType.checkFileType( this.removeTextBeforeSlash(element.mimeType, '/')) as any
                 })
                 this.seletedContent.push(fileObject)
               })
@@ -468,11 +461,10 @@ export class NewPublicationPage implements OnInit {
           console.log("this.publication.Files", this.publication.Files)
         }
 
-
-        this.publication.Files = this.publication.Files.map(e => ({
-          FileBase64: e.FileBase64,
+        this.publication.Files = this.publication.Files.map( (e: PublicationAttachmentEntity) => ({
+          FileBase64: e.Base64,
           FileExtension: e.FileExtension,
-          OriginalFileName: 'foto'
+          OriginalFileName: e.OriginalFileName || 'foto'
         }))
 
         try {
@@ -523,23 +515,21 @@ export class NewPublicationPage implements OnInit {
             if(e.FileType == 'video') {
               e.OriginalFileName = e.chucksManager.path
               e.FileExtension = "mp4"
+              e.Base64 = ""
             }
 
             return e
           })
 
-          console.log("this.publication.Files", this.publication.Files)
         }
 
-        this.publication.Files = this.publication.Files.map(e => ({
-          FileBase64: e.FileBase64,
+        this.publication.Files = this.publication.Files.map( (e:PublicationAttachmentEntity) => ({
+          FileBase64: e.Base64,
           FileExtension: e.FileExtension,
-          OriginalFileName: 'foto'
+          OriginalFileName:  e.OriginalFileName || 'foto'
         }))
 
 
-
-
         const loader = this.toastService.loading()
 
         try {
@@ -560,12 +550,17 @@ export class NewPublicationPage implements OnInit {
           loader.remove()
         }
 
-
       } else {
         this.toastService._badRequest("É necessário adicionar uma imagem ou vídeo")
       }
 
     }
+
+    this.publicationFormMV.ObjectMergeNotification.close()
+  }
+
+  ngOnDestroy() {
+    this.publicationFormMV.ObjectMergeNotification.close()
   }
 
   close() {
@@ -1071,444 +1066,3 @@ export class NewPublicationPage implements OnInit {
       return true;
   }
 }
-
-class UploadFileUseCase {
-  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
-  constructor() {}
-  async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
-    return new Promise(async (resolve, reject) => {
-
-      PublicationAttachmentEntity.chucksManager.clearManualRetry()
-
-      let path: string;
-      const length = PublicationAttachmentEntity.chucksManager.chunks.totalChunks.toString()
-
-      const readAndUploadChunk = async(index: number) => {
-
-        const chunk = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
-        const blob = new Blob([chunk]);
-        const blobFile = new File([blob], "test.mp4", { type: blob.type });
-
-        return this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
-      }
-
-      if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
-        const initIndex = 1
-
-        const uploadRequest = await readAndUploadChunk(initIndex)
-
-        if(uploadRequest.isOk()) {
-
-          path = uploadRequest.value.data
-
-          PublicationAttachmentEntity.chucksManager.setPath(path)
-          PublicationAttachmentEntity.chucksManager.setResponse(initIndex, uploadRequest)
-        } else {
-          PublicationAttachmentEntity.chucksManager.setManualRetry()
-          return reject(err(PublicationAttachmentEntity))
-        }
-      }
-
-      const allRequest: Promise<any>[] = []
-      let connection = true
-
-      for (let index = 2;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1) && connection ); index++) {
-        const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
-
-        if(needUpload) {
-
-          const request = readAndUploadChunk(index).then(async(uploadRequest) => {
-            if(uploadRequest.isErr()) {
-              const pingRequest = await this.CMAPIService.ping()
-              if( pingRequest.isErr()) {
-                connection = false
-                PublicationAttachmentEntity.chucksManager.setManualRetry()
-                return reject(err(PublicationAttachmentEntity))
-              }
-            } else {
-              PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
-            }
-          })
-          allRequest.push(request)
-
-          // const request = readAndUploadChunk(index)
-          // const uploadRequest = await request
-
-          // allRequest.push(request)
-          // if(uploadRequest.isErr()) {
-          //   const pingRequest = await this.CMAPIService.ping()
-          //   if( pingRequest.isErr()) {
-          //     reject(err(PublicationAttachmentEntity))
-          //   }
-          // } else {
-          //   PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
-          // }
-        }
-      }
-
-      if(!connection) {
-        PublicationAttachmentEntity.chucksManager.setManualRetry()
-        return reject(err(PublicationAttachmentEntity))
-      } else {
-        await Promise.all(allRequest)
-
-        const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
-        if(uploadRequest.isErr()) {
-          const pingRequest = await this.CMAPIService.ping()
-          if( pingRequest.isErr()) {
-            PublicationAttachmentEntity.chucksManager.setManualRetry()
-            return reject(err(PublicationAttachmentEntity))
-          }
-        } else {
-          PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
-        }
-
-        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
-        resolve(ok(PublicationAttachmentEntity))
-      }
-
-
-    })
-  }
-}
-
-class PublicationAttachmentEntity {
-  FileBase64: string
-  FileExtension: string
-  FileType: 'image' | 'video'
-  OriginalFileName: string
-  blobFile: File
-  toUpload = false;
-  chucksManager : ChucksManager
-
-  constructor({base64, extension, blobFile = null, OriginalFileName = null, FileType}) {
-    this.FileBase64 = base64;
-    this.FileExtension = extension;
-    this.blobFile = blobFile
-    this.OriginalFileName = OriginalFileName
-    this.FileType = FileType
-
-    this.fixFileBase64();
-  }
-
-  fixFileBase64() {
-    if(this.FileType == 'image' ) {
-      if(!this.FileBase64.startsWith('data:')) {
-        this.FileBase64 = 'data:image/jpg;base64,' + this.FileBase64
-      }
-    } else if (this.FileType == 'video' ) {
-      if(!this.FileBase64.startsWith('data:') && !this.FileBase64.startsWith('http')) {
-        this.FileBase64 = 'data:video/mp4;base64,' + this.FileBase64
-      }
-
-    }
-  }
-
-  needUpload() {
-    this.toUpload = true
-  }
-
-  setChunkManger (chunks: Chunks) {
-    this.chucksManager = new ChucksManager({chunks})
-  }
-  get hasChunkManger() {
-    return this.chucksManager?.chunks
-  }
-
-  get hasChunkManager() {
-    return this.chucksManager != null
-  }
-}
-
-interface IPublicationFormModelEntity  {
-  DateIndex: any
-  DocumentId: any
-  ProcessId: any
-  Title: any
-  Message: any
-  DatePublication: any
-  Files: PublicationAttachmentEntity[]
-}
-
-class PublicationFormModel implements IPublicationFormModelEntity {
-  constructor() {}
-  DateIndex: any;
-  DocumentId: any;
-  ProcessId: any;
-  Title: any;
-  Message: any;
-  DatePublication: any;
-  OriginalFileName: string;
-  Files: PublicationAttachmentEntity[];
-
-  hasSet = false
-
-  setData(data: IPublicationFormModelEntity) {
-    if(!this.hasSet) {
-      Object.assign(this, data)
-    }
-
-    this.hasSet = true
-  }
-}
-
-class PublicationFormMV {
-
-  private UploadFileUseCase = new UploadFileUseCase()
-  private form = new PublicationFormModel()
-  private ObjectMergeNotification = new ObjectMergeNotification()
-
-  setDataToFrom(data: IPublicationFormModelEntity) {
-    this.form.setData(data)
-  }
-
-  private getVideoFiles() {
-    return this.form.Files.filter( x => x.FileType == 'video')
-  }
-
-  private upload(PublicationAttachmentEntity: PublicationAttachmentEntity) {
-
-    return new Promise(async (resolve, reject)=> {
-
-      if(!PublicationAttachmentEntity.hasChunkManger) {
-        const fileBlob = PublicationAttachmentEntity.blobFile;
-        const fileChunks = new Chunks({chunkSize: 500 })
-        fileChunks.setFile(fileBlob)
-
-        PublicationAttachmentEntity.setChunkManger(fileChunks)
-
-        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(()=> {
-          const guid = PublicationAttachmentEntity.chucksManager.path
-
-          this.ObjectMergeNotification.subscribe(guid, (data) => {
-            // console.log("data", data)
-            PublicationAttachmentEntity
-            resolve(true)
-          })
-        })
-
-      } else {
-        if(PublicationAttachmentEntity.chucksManager.doneUpload) {
-          return resolve(true)
-        }
-      }
-
-      const result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
-
-      if(result.isErr()) {
-        reject(false)
-      }
-    })
-
-  }
-
-  uploadVideosFiles(): Promise<Boolean> {
-    return new Promise((resolve, reject)=> {
-      const videosFiles = this.getVideoFiles()
-
-      const videosFilesToUploads = videosFiles.filter( e => e.toUpload == true)
-
-      const Promises: Promise<any>[] = []
-
-      for(const file of videosFilesToUploads) {
-        const promise = this.upload(file)
-        Promises.push(promise)
-      }
-
-      // Use Promise.all to wait for all promises to resolve
-      Promise.all(Promises)
-      .then((results) => {
-        // Check if every promise resolved successfully
-        const allPromisesResolvedSuccessfully = results.every((result) => result == true);
-
-        if (allPromisesResolvedSuccessfully) {
-          console.log('All promises resolved successfully.');
-          resolve(true)
-        } else {
-          reject(false)
-          console.log('Some promises failed to resolve successfully.');
-        }
-      })
-      .catch((error) => {
-        reject(false)
-        console.error('An error occurred while resolving promises:', error);
-      });
-    })
-
-  }
-}
-
-
-class Chunks {
-
-  chunkSize: number
-  private file: File
-
-  constructor({chunkSize}) {
-    this.chunkSize = chunkSize * 1024
-  }
-
-  get totalChunks () {
-    return Math.ceil(this.file.size / this.chunkSize);
-  }
-
-  // Function to read a chunk of the file
-  readChunk(start: number, end: number): Promise<ArrayBuffer> {
-    const file =  this.file
-
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        if (reader.result instanceof ArrayBuffer) {
-          resolve(reader.result);
-        } else {
-          reject(new Error("Failed to read chunk"));
-        }
-      };
-
-      reader.readAsArrayBuffer(file.slice(start, end));
-    });
-  }
-
-  setFile(file: File) {
-    this.file = file
-  }
-
-  async getChunks(i: number) {
-    i--
-    if(i < this.totalChunks) {
-      const start = i * this.chunkSize;
-      const end = Math.min(start + this.chunkSize, this.file.size);
-      const chunk = await this.readChunk(start, end);
-
-      return chunk
-    }
-  }
-
-}
-
-interface IUploadResponse {
-  result: Result<any, Error>
-  attemp: number
-}
-
-class ChucksManager {
-  chunks: Chunks
-  uploads: {[key: string]: IUploadResponse } = {}
-  path: string = undefined
-  uploadPercentage: string = "0%"
-  merging = false
-  onSetPath: Function[] = []
-  onSetLastChunk: Function[] = []
-  contentReady = false
-  manualRetry = false
-
-  getUploadPercentage() {
-    return this.uploadPercentage
-  }
-
-  get uploadsCount() {
-    return Object.entries(this.uploads).length
-  }
-
-  get uploadWithSuccessCount() {
-    const uploadWithSuccess = Object.entries(this.uploads).filter(([index, data])=>  data.result.isOk())
-    return uploadWithSuccess.length
-  }
-
-  get doneUpload() {
-    return this.chunks.totalChunks == this.uploadWithSuccessCount
-  }
-
-  uploadFunc: Function
-  constructor({chunks}) {
-    this.chunks = chunks
-  }
-
-  calculatePercentage(): number {
-    /**
-     * Calculate the percentage based on the total and current values.
-     *
-     * @param total - The total value.
-     * @param current - The current value.
-     * @returns The percentage calculated as (current / total) * 100.
-     */
-    const total = this.chunks.totalChunks
-    const current = this.uploadWithSuccessCount
-
-    if (total === 0) {
-        return 0; // To avoid division by zero error
-    }
-
-    const percentage: number = (current / total) * 100;
-    return percentage;
-  }
-
-  setManualRetry() {
-    this.manualRetry = true
-  }
-
-  clearManualRetry() {
-    this.manualRetry = false
-  }
-
-  setPercentage() {
-    const percentage: number = this.calculatePercentage()
-    console.log({percentage})
-    this.uploadPercentage = percentage.toString()+"%"
-  }
-
-  setPath(path: string) {
-    this.path = path
-    this.onSetPath.forEach(callback => callback());
-  }
-
-  registerOnSetPath(a: Function) {
-    this.onSetPath.push(a)
-  }
-
-  registerOnLastChunk(a: Function) {
-    this.onSetPath.push(a)
-  }
-
-  hasPath() {
-    return this.path != undefined
-  }
-
-  isIndexRegistered(index) {
-    if(!this.uploads[index]) {
-      return false
-    }
-    return true
-  }
-
-  needToUploadChunkIndex(index) {
-    return !this.uploads?.[index]?.result?.isOk()
-  }
-
-  setResponse(index, UploadResponse) {
-
-    if(!this.isIndexRegistered(index)) {
-      this.uploads[index] = {
-        attemp: 1,
-        result: UploadResponse
-      }
-      console.log({UploadResponse})
-    } else {
-      this.uploads[index].attemp++;
-      this.uploads[index].result = UploadResponse
-    }
-
-    this.setPercentage()
-  }
-
-  doneChunkUpload() {
-    this.merging = true
-    this.onSetLastChunk.forEach(callback => callback());
-  }
-
-  contentSetReady() {
-    this.merging = false
-    this.contentReady = true
-  }
-}
diff --git a/src/app/shared/publication/upload/upload-streaming.service.spec.ts b/src/app/shared/publication/upload/upload-streaming.service.spec.ts
new file mode 100644
index 000000000..338c21737
--- /dev/null
+++ b/src/app/shared/publication/upload/upload-streaming.service.spec.ts
@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { UploadStreamingService } from './upload-streaming.service';
+
+describe('UploadStreamingService', () => {
+  let service: UploadStreamingService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(UploadStreamingService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
new file mode 100644
index 000000000..aa6b0c1cf
--- /dev/null
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -0,0 +1,483 @@
+import { Injectable } from '@angular/core';
+import { ok, err, Result } from 'neverthrow';
+import { ObjectMergeNotification } from 'src/app/services/socket-connection-mcr.service';
+import { CMAPIService } from "src/app/shared/repository/CMAPI/cmapi.service"
+@Injectable({
+  providedIn: 'root'
+})
+export class UploadStreamingService {
+  constructor(    private CMAPIService: CMAPIService,) { }
+}
+
+
+class UploadFileUseCase {
+  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
+  constructor() {}
+  async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
+    return new Promise(async (resolve, reject) => {
+
+      PublicationAttachmentEntity.chucksManager.clearManualRetry()
+
+      let path: string;
+      const length = PublicationAttachmentEntity.chucksManager.chunks.totalChunks.toString()
+
+      const readAndUploadChunk = async(index: number) => {
+
+        const chunk = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
+        const blob = new Blob([chunk]);
+        const blobFile = new File([blob], "test.mp4", { type: blob.type });
+
+        return this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
+      }
+
+      if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
+        const initIndex = 1
+
+        const uploadRequest = await readAndUploadChunk(initIndex)
+
+        if(uploadRequest.isOk()) {
+
+          path = uploadRequest.value.data
+
+          PublicationAttachmentEntity.chucksManager.setPath(path)
+          PublicationAttachmentEntity.chucksManager.setResponse(initIndex, uploadRequest)
+        } else {
+          PublicationAttachmentEntity.chucksManager.setManualRetry()
+          return reject(err(PublicationAttachmentEntity))
+        }
+      }
+
+      const allRequest: Promise<any>[] = []
+      let connection = true
+
+      for (let index = 2;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1) && connection ); index++) {
+        const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
+
+        if(needUpload) {
+
+          const request = readAndUploadChunk(index).then(async(uploadRequest) => {
+            if(uploadRequest.isErr()) {
+              const pingRequest = await this.CMAPIService.ping()
+              if( pingRequest.isErr()) {
+                connection = false
+                PublicationAttachmentEntity.chucksManager.setManualRetry()
+                return reject(err(PublicationAttachmentEntity))
+              }
+            } else {
+              PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
+            }
+          })
+          allRequest.push(request)
+
+          // const request = readAndUploadChunk(index)
+          // const uploadRequest = await request
+
+          // allRequest.push(request)
+          // if(uploadRequest.isErr()) {
+          //   const pingRequest = await this.CMAPIService.ping()
+          //   if( pingRequest.isErr()) {
+          //     reject(err(PublicationAttachmentEntity))
+          //   }
+          // } else {
+          //   PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
+          // }
+        }
+      }
+
+      if(!connection) {
+        PublicationAttachmentEntity.chucksManager.setManualRetry()
+        return reject(err(PublicationAttachmentEntity))
+      } else {
+        await Promise.all(allRequest)
+
+        const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
+        if(uploadRequest.isErr()) {
+          const pingRequest = await this.CMAPIService.ping()
+          if( pingRequest.isErr()) {
+            PublicationAttachmentEntity.chucksManager.setManualRetry()
+            return reject(err(PublicationAttachmentEntity))
+          }
+        } else {
+          PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
+        }
+
+        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
+        resolve(ok(PublicationAttachmentEntity))
+      }
+
+
+    })
+  }
+}
+
+export class PublicationAttachmentEntity {
+  url: string
+  FileExtension: string
+  FileType: 'image' | 'video'
+  OriginalFileName: string
+  blobFile?: File
+  toUpload = false;
+  chucksManager : ChucksManager
+  Base64: string
+
+  constructor({base64, extension, blobFile, OriginalFileName, FileType}:PublicationAttachmentEntityParams) {
+    this.Base64 = base64;
+    this.FileExtension = extension;
+    this.blobFile = blobFile
+    this.OriginalFileName = OriginalFileName
+    this.FileType = FileType
+
+    this.fixFileBase64();
+  }
+
+  fixFileBase64() {
+    if(this.FileType == 'image' ) {
+      if(!this.Base64.startsWith('data:')) {
+        this.url = 'data:image/jpg;base64,' + this.Base64
+      } else {
+        this.url =  this.Base64
+      }
+    } else if (this.FileType == 'video' ) {
+      if(!this.Base64.startsWith('data:') && !this.Base64.startsWith('http')) {
+        this.url = 'data:video/mp4;base64,' + this.Base64
+      } else {
+        this.url = this.Base64
+      }
+    }
+  }
+
+  needUpload() {
+    this.toUpload = true
+  }
+
+  setChunkManger (chunks: Chunks) {
+    this.chucksManager = new ChucksManager({chunks})
+  }
+  get hasChunkManger() {
+    return this.chucksManager?.chunks
+  }
+
+  get hasChunkManager() {
+    return this.chucksManager != null
+  }
+}
+
+interface IPublicationFormModelEntity  {
+  DateIndex: any
+  DocumentId: any
+  ProcessId: any
+  Title: any
+  Message: any
+  DatePublication: any
+  Files: PublicationAttachmentEntity[]
+}
+
+interface PublicationAttachmentEntityParams {
+  base64: string,
+  blobFile?: File
+  extension: string,
+  OriginalFileName: string,
+  FileType: 'image' | 'video'
+}
+
+export class PublicationFormModel implements IPublicationFormModelEntity {
+  constructor() {}
+  DateIndex: any;
+  DocumentId: any;
+  ProcessId: any;
+  Title: any;
+  Message: any;
+  DatePublication: any;
+  OriginalFileName: string;
+  Files: PublicationAttachmentEntity[];
+
+  hasSet = false
+
+  setData(data: IPublicationFormModelEntity) {
+    if(!this.hasSet) {
+      Object.assign(this, data)
+    }
+
+    this.hasSet = true
+  }
+}
+
+export class PublicationFormMV {
+
+  private UploadFileUseCase = new UploadFileUseCase()
+  private form = new PublicationFormModel()
+  ObjectMergeNotification = new ObjectMergeNotification()
+
+  setDataToFrom(data: IPublicationFormModelEntity) {
+    this.form.setData(data)
+  }
+
+  private getVideoFiles() {
+    return this.form.Files.filter( x => x.FileType == 'video')
+  }
+
+  private upload(PublicationAttachmentEntity: PublicationAttachmentEntity) {
+
+    return new Promise(async (resolve, reject)=> {
+
+      if(!PublicationAttachmentEntity.hasChunkManger) {
+        const fileBlob = PublicationAttachmentEntity.blobFile;
+        const fileChunks = new Chunks({chunkSize: 500 })
+        fileChunks.setFile(fileBlob)
+
+        PublicationAttachmentEntity.setChunkManger(fileChunks)
+
+        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(()=> {
+          const guid = PublicationAttachmentEntity.chucksManager.path
+
+          this.ObjectMergeNotification.subscribe(guid, (data) => {
+            // console.log("data", data)
+            PublicationAttachmentEntity
+            resolve(true)
+          })
+        })
+
+      } else {
+        if(PublicationAttachmentEntity.chucksManager.doneUpload) {
+          return resolve(true)
+        }
+      }
+
+      if( PublicationAttachmentEntity.chucksManager.isUploading == false) {
+        PublicationAttachmentEntity.chucksManager.setUploading()
+        const result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
+        PublicationAttachmentEntity.chucksManager.clearUploading()
+
+        if(result.isErr()) {
+          reject(false)
+        }
+      }
+
+    })
+
+  }
+
+  uploadVideosFiles(): Promise<Boolean> {
+    return new Promise((resolve, reject)=> {
+      const videosFiles = this.getVideoFiles()
+
+      const videosFilesToUploads = videosFiles.filter( e => e.FileType == "video")
+
+      const Promises: Promise<any>[] = []
+
+      for(const file of videosFilesToUploads) {
+        const promise = this.upload(file)
+        Promises.push(promise)
+      }
+
+      // Use Promise.all to wait for all promises to resolve
+      Promise.all(Promises)
+      .then((results) => {
+        // Check if every promise resolved successfully
+        const allPromisesResolvedSuccessfully = results.every((result) => result == true);
+
+        if (allPromisesResolvedSuccessfully) {
+          console.log('All promises resolved successfully.');
+          resolve(true)
+        } else {
+          reject(false)
+          console.log('Some promises failed to resolve successfully.');
+        }
+      })
+      .catch((error) => {
+        reject(false)
+        console.error('An error occurred while resolving promises:', error);
+      });
+    })
+
+  }
+}
+
+
+export class Chunks {
+
+  chunkSize: number
+  private file: File
+
+  constructor({chunkSize}) {
+    this.chunkSize = chunkSize * 1024
+  }
+
+  get totalChunks () {
+    return Math.ceil(this.file.size / this.chunkSize);
+  }
+
+  // Function to read a chunk of the file
+  readChunk(start: number, end: number): Promise<ArrayBuffer> {
+    const file =  this.file
+
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        if (reader.result instanceof ArrayBuffer) {
+          resolve(reader.result);
+        } else {
+          reject(new Error("Failed to read chunk"));
+        }
+      };
+
+      reader.readAsArrayBuffer(file.slice(start, end));
+    });
+  }
+
+  setFile(file: File) {
+    this.file = file
+  }
+
+  async getChunks(i: number) {
+    i--
+    if(i < this.totalChunks) {
+      const start = i * this.chunkSize;
+      const end = Math.min(start + this.chunkSize, this.file.size);
+      const chunk = await this.readChunk(start, end);
+
+      return chunk
+    }
+  }
+
+}
+
+interface IUploadResponse {
+  result: Result<any, Error>
+  attemp: number
+}
+
+export class ChucksManager {
+  chunks: Chunks
+  uploads: {[key: string]: IUploadResponse } = {}
+  path: string = undefined
+  uploadPercentage: string = "0%"
+  merging = false
+  onSetPath: Function[] = []
+  onSetLastChunk: Function[] = []
+  contentReady = false
+  manualRetry = false
+  isUploading = false
+  subscribeToUseCaseResponse: Function[] = []
+
+  getUploadPercentage() {
+    return this.uploadPercentage
+  }
+
+  get uploadsCount() {
+    return Object.entries(this.uploads).length
+  }
+
+  get uploadWithSuccessCount() {
+    const uploadWithSuccess = Object.entries(this.uploads).filter(([index, data])=>  data.result.isOk())
+    return uploadWithSuccess.length
+  }
+
+  get doneUpload() {
+    return this.chunks.totalChunks == this.uploadWithSuccessCount
+  }
+
+  uploadFunc: Function
+  constructor({chunks}) {
+    this.chunks = chunks
+  }
+
+  calculatePercentage(): number {
+    /**
+     * Calculate the percentage based on the total and current values.
+     *
+     * @param total - The total value.
+     * @param current - The current value.
+     * @returns The percentage calculated as (current / total) * 100.
+     */
+    const total = this.chunks.totalChunks
+    const current = this.uploadWithSuccessCount
+
+    if (total === 0) {
+        return 0; // To avoid division by zero error
+    }
+
+    const percentage: number = (current / total) * 100;
+    return percentage;
+  }
+
+  setManualRetry() {
+    this.manualRetry = true
+  }
+
+  clearManualRetry() {
+    this.manualRetry = false
+  }
+
+  setUploading() {
+    this.isUploading = true
+  }
+  clearUploading() {
+    this.isUploading = false
+  }
+
+  setPercentage() {
+    const percentage: number = this.calculatePercentage()
+    console.log({percentage})
+    this.uploadPercentage = percentage.toString()+"%"
+  }
+
+  setPath(path: string) {
+    this.path = path
+    this.onSetPath.forEach(callback => callback());
+  }
+
+  registerOnSetPath(a: Function) {
+    this.onSetPath.push(a)
+  }
+
+  registerOnLastChunk(a: Function) {
+    this.onSetPath.push(a)
+  }
+
+  registerToUseCaseResponse(a: Function) {
+    this.subscribeToUseCaseResponse.push(a)
+  }
+
+
+  hasPath() {
+    return this.path != undefined
+  }
+
+  isIndexRegistered(index) {
+    if(!this.uploads[index]) {
+      return false
+    }
+    return true
+  }
+
+  needToUploadChunkIndex(index) {
+    return !this.uploads?.[index]?.result?.isOk()
+  }
+
+  setResponse(index, UploadResponse) {
+
+    if(!this.isIndexRegistered(index)) {
+      this.uploads[index] = {
+        attemp: 1,
+        result: UploadResponse
+      }
+      console.log({UploadResponse})
+    } else {
+      this.uploads[index].attemp++;
+      this.uploads[index].result = UploadResponse
+    }
+
+    this.setPercentage()
+  }
+
+  doneChunkUpload() {
+    this.merging = true
+    this.onSetLastChunk.forEach(callback => callback());
+  }
+
+  contentSetReady() {
+    this.merging = false
+    this.contentReady = true
+  }
+}

From e21e5da7e5a43d613ae561096afc5ac48a1279f3 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 1 Feb 2024 08:25:31 +0100
Subject: [PATCH 04/16] fix chat and remove guid extension

---
 src/app/interceptors/token.interceptors.ts    | 31 ++++++++++++-------
 src/app/services/chat.service.ts              |  4 +--
 .../new-publication/new-publication.page.ts   |  4 +--
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/app/interceptors/token.interceptors.ts b/src/app/interceptors/token.interceptors.ts
index d087096b8..6d40566b8 100644
--- a/src/app/interceptors/token.interceptors.ts
+++ b/src/app/interceptors/token.interceptors.ts
@@ -22,6 +22,8 @@ export class TokenInterceptor implements HttpInterceptor {
     null
   );
 
+  private excludedDomains = ['Login', environment.apiChatUrl]; // Add the domains you want to exclude
+
   constructor(private http: HttpClient, private router: Router,) { }
 
 
@@ -29,6 +31,11 @@ export class TokenInterceptor implements HttpInterceptor {
     request: HttpRequest<any>,
     next: HttpHandler
   ): Observable<HttpEvent<any>> {
+
+    if (this.shouldExcludeDomain(request)) {
+      return next.handle(request);
+    }
+
     if (SessionStore.user.Authorization) {
       request = this.addToken(request, SessionStore.user.Authorization);
     }
@@ -44,23 +51,24 @@ export class TokenInterceptor implements HttpInterceptor {
     );
   }
 
+  private shouldExcludeDomain(request: HttpRequest<any>): boolean {
+    const url = request.url.toLowerCase();
+    return this.excludedDomains.some((domain) => url.includes(domain.toLowerCase()));
+  }
+
   private addToken(request: HttpRequest<any>, token: string) {
 
-    if(request.url.includes("Login")) {
-      return request.clone({});
-    } else {
-
-      return request.clone({
-        setHeaders: {
-          //'Access-Control-Allow-Origin': '*',
-          Authorization: `Bearer ${token}`,
-        },
-      });
-    }
+    return request.clone({
+      setHeaders: {
+        //'Access-Control-Allow-Origin': '*',
+        Authorization: `Bearer ${token}`,
+      },
+    });
 
   }
 
   private handle401Error(request: HttpRequest<any>, next: HttpHandler) {
+    // if not getting the new token yet
     if (!this.isRefreshing) {
       this.isRefreshing = true;
       this.refreshTokenSubject.next(null);
@@ -73,6 +81,7 @@ export class TokenInterceptor implements HttpInterceptor {
         })
       );
     } else {
+      // get new token
       return this.refreshTokenSubject.pipe(
         filter((token) => token != null),
         take(1),
diff --git a/src/app/services/chat.service.ts b/src/app/services/chat.service.ts
index c650cdf12..236cd2fd0 100644
--- a/src/app/services/chat.service.ts
+++ b/src/app/services/chat.service.ts
@@ -370,7 +370,7 @@ export class ChatService {
 
   async refreshtoken() {
 
- /*    if(this.headers && SessionStore.user.ChatData) {
+    if(this.headers && SessionStore.user.ChatData) {
       this.headers = this.headers.set('Authorization', 'Bearer ' + SessionStore.user.Authorization);
       let options = {
         headers: this.headers
@@ -423,7 +423,7 @@ export class ChatService {
     } else if (!this.headers) {
       this.setheader()
       this.refreshtoken()
-    } */
+    }
 
   }
 
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index 54cbb977e..3a7a15016 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -451,7 +451,7 @@ export class NewPublicationPage implements OnInit {
         if(upload) {
           this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
             if(e.FileType == 'video') {
-              e.OriginalFileName = e.chucksManager.path
+              e.OriginalFileName = e.chucksManager.path.replace(".mp4", "")
               e.FileExtension = "mp4"
             }
 
@@ -513,7 +513,7 @@ export class NewPublicationPage implements OnInit {
         if(upload) {
           this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
             if(e.FileType == 'video') {
-              e.OriginalFileName = e.chucksManager.path
+              e.OriginalFileName = e.chucksManager.path.replace(".mp4", "")
               e.FileExtension = "mp4"
               e.Base64 = ""
             }

From 2d6598edfe80f806482efe00337b53dba553b948 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 1 Feb 2024 11:44:56 +0100
Subject: [PATCH 05/16] fix signalR

---
 .../services/socket-connection-mcr.service.ts | 63 ++++++++++++-------
 .../new-publication/new-publication.page.html |  2 +-
 .../upload/upload-streaming.service.ts        |  2 +-
 3 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index 9b6374b81..b2c71b7fe 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -70,16 +70,13 @@ export class SocketConnectionMCRService {
 class ReconnectingWebSocketSignalR {
 
   private connection: any
-  isOpen: boolean
+  isOpen: boolean = false
   private  callbacks: Function[] = []
   private  onDisconnect: Function[] = []
   private  onConnect: Function[] = []
   private stop = true
 
-  constructor() {
-    this.isOpen = false;
-    this.connect();
-  }
+  constructor() {}
 
   connect() {
     console.log("try to connect=================================")
@@ -113,11 +110,11 @@ class ReconnectingWebSocketSignalR {
     })
 
     this.connection.onclose((error) => {
-      console.log('WebSocket connection closed');
+      console.log('WebSocket connection closed..');
       this.isOpen = false;
       this.onDisconnect.forEach(callback => callback());
       // Attempt to reconnect after a delay
-      if(this.stop) {
+      if(this.stop == false) {
         setTimeout(() => {
           this.connect();
         }, 1000); // Adjust the delay as needed
@@ -128,16 +125,18 @@ class ReconnectingWebSocketSignalR {
 
   disconnect() {
     this.stop = true
-    this.connection.stop()
-    .then(() => {
-      console.log('WebSocket connection closed');
-      this.isOpen = false;
-      this.onDisconnect.forEach(callback => callback());
-      console.log("SignalR connection stopped.");
-    })
-    .catch((error) => {
-      console.error("Error stopping SignalR connection:", error);
-    });
+    if(this.isOpen == true) {
+      this.connection.stop()
+      .then(() => {
+        console.log('WebSocket connection was closed by client');
+        this.isOpen = false;
+        this.onDisconnect.forEach(callback => callback());
+        console.log("SignalR connection stopped.");
+      })
+      .catch((error) => {
+        console.error("Error stopping SignalR connection by client:", error);
+      });
+    }
   }
 
   subscribe(callback) {
@@ -160,7 +159,7 @@ interface socketResponse {
 
   index: string
   Guid: string
-  isCompleted: Boolean
+  IsCompleted: Boolean
 }
 // class ReconnectingWebSocket {
 
@@ -256,7 +255,7 @@ interface socketResponse {
 //     // })
 
 //     // this.socket.subscribe((data: socketResponse) => {
-//     //   if(data.isCompleted == true) {
+//     //   if(data.IsCompleted == true) {
 //     //     this.callbacks[data.Guid](data)
 //     //     delete this.callbacks[data.Guid]
 //     //   }
@@ -302,38 +301,48 @@ export class ObjectMergeNotification{
   callbacks: {[GUID: string]: Function} = {}
   runWatch =  true
   CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
+  watchCount  = 0
 
   constructor() {
     this.socket.onDisconnectCallback(()=> {
+      console.log("run watch")
       this.runWatch = true
       this.watch()
     })
 
     this.socket.onConnectCallback(()=> {
+
+      console.log("open trigger")
       this.runWatch = false
     })
     
-
     this.socket.subscribe((data: socketResponse) => {
-      if(data.isCompleted == true) {
+      if(data.IsCompleted == true) {
         console.log("==================!!!====================")
         this.callbacks[data.Guid](data)
         delete this.callbacks[data.Guid]
+      } else {
+        console.log("else", data)
       }
     })
 
+    this.socket.connect();
     this.watch()
   }
 
 
   close() {
-    console.log("close=============================================")
     this.socket.disconnect();
+    this.watchCount = 0;
+    this.runWatch = false
   }
 
   async watch() {
+
+    this.watchCount = 0;
+
     if(this.runWatch) {
-      setTimeout(async ()=> {
+      setTimeout(async () => {
         for(const [key, funx] of Object.entries(this.callbacks)) {
 
           const request = await this.CMAPIService.getVideoHeader(key)
@@ -344,7 +353,13 @@ export class ObjectMergeNotification{
           }
         }
 
-        this.watch()
+        this.watchCount++
+        if(this.watchCount <= 15) {
+          this.watch()  
+        } else {
+          this.runWatch = false
+        }
+        
       }, 1000)
 
 
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 4c4b9a21a..4af2e6448 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -56,7 +56,7 @@
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'"
                 name="image" ngDefaultControl [src]="seleted.FileBase64" style="height: 69px;"></ion-img>
 
-                <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager">
+                <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager" style="background: #ededed;">
 
                   <mat-progress-bar
 
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index aa6b0c1cf..ee6a8a33e 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -351,7 +351,7 @@ export class ChucksManager {
   chunks: Chunks
   uploads: {[key: string]: IUploadResponse } = {}
   path: string = undefined
-  uploadPercentage: string = "0%"
+  uploadPercentage: string = "1%"
   merging = false
   onSetPath: Function[] = []
   onSetLastChunk: Function[] = []

From 60edd1ca013b8d682192c9ded748e774befaafd3 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Wed, 7 Feb 2024 16:45:53 +0100
Subject: [PATCH 06/16] video merge

---
 gabinete-digital-fo.code-workspace            |   3 -
 package-lock.json                             |  89 +++-
 .../services/socket-connection-mcr.service.ts | 462 ++++++++++--------
 .../middleware/middleware-service.service.ts  |  17 +-
 .../new-publication/new-publication.page.html |  38 +-
 .../new-publication/new-publication.page.ts   |  67 +--
 .../upload/upload-streaming.service.ts        | 260 +++++-----
 .../view-publications.page.html               |  22 +-
 .../view-publications.page.scss               |   7 +
 .../view-publications.page.ts                 |  12 +
 .../shared/repository/CMAPI/cmapi.service.ts  |  30 +-
 11 files changed, 586 insertions(+), 421 deletions(-)

diff --git a/gabinete-digital-fo.code-workspace b/gabinete-digital-fo.code-workspace
index 2730d9669..f1b39c052 100644
--- a/gabinete-digital-fo.code-workspace
+++ b/gabinete-digital-fo.code-workspace
@@ -14,9 +14,6 @@
 		},
 		{
 			"path": "../sih"
-		},
-		{
-			"path": "../Ionic-Video-Capture-Play-main"
 		}
 	],
 	"settings": {
diff --git a/package-lock.json b/package-lock.json
index a0d74e455..b401e08dd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -48,7 +48,9 @@
         "@capacitor/push-notifications": "^5.1.0",
         "@capacitor/share": "^4.1.0",
         "@capacitor/storage": "^1.2.5",
-        "@capawesome/capacitor-file-picker": "^5.1.1",
+        "@capawesome/capacitor-file-picker": "^5.3.0",
+        "@ffmpeg/core": "^0.12.6",
+        "@ffmpeg/ffmpeg": "^0.12.10",
         "@fortawesome/angular-fontawesome": "^0.9.0",
         "@fortawesome/fontawesome-free": "^5.15.3",
         "@fortawesome/fontawesome-svg-core": "^1.2.35",
@@ -153,6 +155,7 @@
         "lite-server": "^2.6.1",
         "minisearch": "^6.0.1",
         "moment": "^2.29.3",
+        "mux.js": "^6.3.0",
         "neverthrow": "^6.1.0",
         "ng-lazyload-image": "^9.1.2",
         "ng2-pdf-viewer": "^3.0.8",
@@ -3615,7 +3618,6 @@
       "version": "7.14.8",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.14.8.tgz",
       "integrity": "sha512-twj3L8Og5SaCRCErB4x4ajbvBIVV77CGeFglHpeg5WC5FF8TZzBWXtTJ4MqaD9QszLYTtr+IsaAL2rEUevb+eg==",
-      "dev": true,
       "dependencies": {
         "regenerator-runtime": "^0.13.4"
       },
@@ -4018,9 +4020,9 @@
       }
     },
     "node_modules/@capawesome/capacitor-file-picker": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/@capawesome/capacitor-file-picker/-/capacitor-file-picker-5.1.1.tgz",
-      "integrity": "sha512-VtWV/er8Kux5Bbb0BtRneAaL8aj7zKoSPSR5sn3QlVBccete+CX+nH3scg6JKrogoitNP35PS33LIoaz9WVZiA==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@capawesome/capacitor-file-picker/-/capacitor-file-picker-5.3.0.tgz",
+      "integrity": "sha512-r+cfD+9FCBXMYtckSovgi7WoMWT5cxzNDaH3SDNuiORiyQklOl+7DExfhW00p1DqsDR+f50nADk/NBb4IsGVYg==",
       "funding": [
         {
           "type": "github",
@@ -4231,6 +4233,33 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@ffmpeg/core": {
+      "version": "0.12.6",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/core/-/core-0.12.6.tgz",
+      "integrity": "sha512-PrjWBTfGn2WVn9T7wGnzfFwChbqWeZc7tM9vvJZVRadYFUDakfzy7W0LpYC0cvvK0xT82qlBsk38lQhJ/Hps5A==",
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
+    "node_modules/@ffmpeg/ffmpeg": {
+      "version": "0.12.10",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/ffmpeg/-/ffmpeg-0.12.10.tgz",
+      "integrity": "sha512-lVtk8PW8e+NUzGZhPTWj2P1J4/NyuCrbDD3O9IGpSeLYtUZKBqZO8CNj1WYGghep/MXoM8e1qVY1GztTkf8YYQ==",
+      "dependencies": {
+        "@ffmpeg/types": "^0.12.2"
+      },
+      "engines": {
+        "node": ">=18.x"
+      }
+    },
+    "node_modules/@ffmpeg/types": {
+      "version": "0.12.2",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/types/-/types-0.12.2.tgz",
+      "integrity": "sha512-NJtxwPoLb60/z1Klv0ueshguWQ/7mNm106qdHkB4HL49LXszjhjCCiL+ldHJGQ9ai2Igx0s4F24ghigy//ERdA==",
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
     "node_modules/@firebase/analytics": {
       "version": "0.6.18",
       "resolved": "https://registry.npmjs.org/@firebase/analytics/-/analytics-0.6.18.tgz",
@@ -26817,6 +26846,22 @@
       "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
       "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="
     },
+    "node_modules/mux.js": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/mux.js/-/mux.js-6.3.0.tgz",
+      "integrity": "sha512-/QTkbSAP2+w1nxV+qTcumSDN5PA98P0tjrADijIzQHe85oBK3Akhy9AHlH0ne/GombLMz1rLyvVsmrgRxoPDrQ==",
+      "dependencies": {
+        "@babel/runtime": "^7.11.2",
+        "global": "^4.4.0"
+      },
+      "bin": {
+        "muxjs-transmux": "bin/transmux.js"
+      },
+      "engines": {
+        "node": ">=8",
+        "npm": ">=5"
+      }
+    },
     "node_modules/nan": {
       "version": "2.17.0",
       "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz",
@@ -46185,7 +46230,6 @@
       "version": "7.14.8",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.14.8.tgz",
       "integrity": "sha512-twj3L8Og5SaCRCErB4x4ajbvBIVV77CGeFglHpeg5WC5FF8TZzBWXtTJ4MqaD9QszLYTtr+IsaAL2rEUevb+eg==",
-      "dev": true,
       "requires": {
         "regenerator-runtime": "^0.13.4"
       }
@@ -46494,9 +46538,9 @@
       "requires": {}
     },
     "@capawesome/capacitor-file-picker": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/@capawesome/capacitor-file-picker/-/capacitor-file-picker-5.1.1.tgz",
-      "integrity": "sha512-VtWV/er8Kux5Bbb0BtRneAaL8aj7zKoSPSR5sn3QlVBccete+CX+nH3scg6JKrogoitNP35PS33LIoaz9WVZiA==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@capawesome/capacitor-file-picker/-/capacitor-file-picker-5.3.0.tgz",
+      "integrity": "sha512-r+cfD+9FCBXMYtckSovgi7WoMWT5cxzNDaH3SDNuiORiyQklOl+7DExfhW00p1DqsDR+f50nADk/NBb4IsGVYg==",
       "requires": {}
     },
     "@cnakazawa/watch": {
@@ -46659,6 +46703,24 @@
       "integrity": "sha512-Fxt+AfXgjMoin2maPIYzFZnQjAXjAL0PHscM5pRTtatFqB+vZxAM9tLp2Optnuw3QOQC40jTNeGYFOMvyf7v9g==",
       "dev": true
     },
+    "@ffmpeg/core": {
+      "version": "0.12.6",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/core/-/core-0.12.6.tgz",
+      "integrity": "sha512-PrjWBTfGn2WVn9T7wGnzfFwChbqWeZc7tM9vvJZVRadYFUDakfzy7W0LpYC0cvvK0xT82qlBsk38lQhJ/Hps5A=="
+    },
+    "@ffmpeg/ffmpeg": {
+      "version": "0.12.10",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/ffmpeg/-/ffmpeg-0.12.10.tgz",
+      "integrity": "sha512-lVtk8PW8e+NUzGZhPTWj2P1J4/NyuCrbDD3O9IGpSeLYtUZKBqZO8CNj1WYGghep/MXoM8e1qVY1GztTkf8YYQ==",
+      "requires": {
+        "@ffmpeg/types": "^0.12.2"
+      }
+    },
+    "@ffmpeg/types": {
+      "version": "0.12.2",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/types/-/types-0.12.2.tgz",
+      "integrity": "sha512-NJtxwPoLb60/z1Klv0ueshguWQ/7mNm106qdHkB4HL49LXszjhjCCiL+ldHJGQ9ai2Igx0s4F24ghigy//ERdA=="
+    },
     "@firebase/analytics": {
       "version": "0.6.18",
       "resolved": "https://registry.npmjs.org/@firebase/analytics/-/analytics-0.6.18.tgz",
@@ -64261,6 +64323,15 @@
       "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
       "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="
     },
+    "mux.js": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/mux.js/-/mux.js-6.3.0.tgz",
+      "integrity": "sha512-/QTkbSAP2+w1nxV+qTcumSDN5PA98P0tjrADijIzQHe85oBK3Akhy9AHlH0ne/GombLMz1rLyvVsmrgRxoPDrQ==",
+      "requires": {
+        "@babel/runtime": "^7.11.2",
+        "global": "^4.4.0"
+      }
+    },
     "nan": {
       "version": "2.17.0",
       "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz",
diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index 57002ee8b..d885b7895 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -14,9 +14,9 @@ export class SocketConnectionMCRService {
   // private  onDisconnect: Function[] = []
   // private  onConnect: Function[] = []
 
-  // constructor(private http: HttpClient,) {
-  //   window["http"] = this.http
-  // }
+  constructor(private http: HttpClient, private _CMAPIService: CMAPIService) {
+    window["http"] = this.http
+  }
 
   // connect() {
 
@@ -67,137 +67,52 @@ export class SocketConnectionMCRService {
 
 }
 
-// class ReconnectingWebSocketSignalR {
+class ReconnectingWebSocketSignalR {
 
-//   private connection: any
-//   isOpen: boolean = false
-//   private  callbacks: Function[] = []
-//   private  onDisconnect: Function[] = []
-//   private  onConnect: Function[] = []
-//   private stop = true
-
-//   constructor() {}
-
-//   connect() {
-//     console.log("try to connect=================================")
-//     this.stop = false
-
-//     this.connection = new signalR.HubConnectionBuilder()
-//     .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
-//       transport: signalR.HttpTransportType.LongPolling,
-//       accessTokenFactory: () => SessionStore.user.Authorization
-//     }).configureLogging(signalR.LogLevel.Information)
-//     .build();
-
-
-//     this.connection.start()
-//     .then(() => {
-//       this.isOpen = true;
-//       console.log('WebSocket connection established');
-
-
-//       this.onConnect.forEach(callback => callback());
-//     })
-//     .catch((error) => {
-//       console.error("Error starting SignalR connection:", error);
-//     });
-
-
-//     this.connection.on("ReceiveMessage", (message) => {
-//       const data: any = JSON.parse(message)
-//       console.log("ReceiveMessage", data)
-//       this.callbacks.forEach(callback => callback(data));
-//     })
-
-//     this.connection.onclose((error) => {
-//       console.log('WebSocket connection closed..');
-//       this.isOpen = false;
-//       this.onDisconnect.forEach(callback => callback());
-//       // Attempt to reconnect after a delay
-//       if(this.stop == false) {
-//         setTimeout(() => {
-//           this.connect();
-//         }, 1000); // Adjust the delay as needed
-//       }
-
-//     });
-//   }
-
-//   disconnect() {
-//     this.stop = true
-//     if(this.isOpen == true) {
-//       this.connection.stop()
-//       .then(() => {
-//         console.log('WebSocket connection was closed by client');
-//         this.isOpen = false;
-//         this.onDisconnect.forEach(callback => callback());
-//         console.log("SignalR connection stopped.");
-//       })
-//       .catch((error) => {
-//         console.error("Error stopping SignalR connection by client:", error);
-//       });
-//     }
-//   }
-
-//   subscribe(callback) {
-//     this.callbacks.push(callback);
-//   }
-
-//   unsubscribe(callback) {
-//     this.callbacks = this.callbacks.filter(cb => cb !== callback);
-//   }
-
-//   onDisconnectCallback(callback) {
-//     this.onDisconnect.push(callback)
-//   }
-//   onConnectCallback(callback) {
-//     this.onConnect.push(callback)
-//   }
-// }
-
-interface socketResponse {
-
-  index: string
-  Guid: string
-  IsCompleted: Boolean
-}
-class ReconnectingWebSocket {
-
-  private url: string
-  private  socket
-  isOpen: boolean
+  private connection: any
+  isOpen: boolean = false
   private  callbacks: Function[] = []
   private  onDisconnect: Function[] = []
   private  onConnect: Function[] = []
+  private whenConnected: Function[] = []
   private stop = true
-  http: HttpClient = window["http"]
 
-  constructor(url) {
-    this.url = url;
-    this.socket = null;
-    this.isOpen = false;
-    this.connect();
-  }
+  constructor() {}
 
   connect() {
-    this.socket = new WebSocket(this.url);
+    console.log("try to connect=================================")
+    this.stop = false
 
-    this.socket.addEventListener('open', (event) => {
+    this.connection = new signalR.HubConnectionBuilder()
+    .withUrl("https://gdcmapi-dev.dyndns.info/FileHub", {
+      transport: signalR.HttpTransportType.LongPolling,
+      accessTokenFactory: () => SessionStore.user.Authorization
+    }).configureLogging(signalR.LogLevel.Information)
+    .build();
+
+
+    this.connection.start()
+    .then(() => {
       this.isOpen = true;
       console.log('WebSocket connection established');
 
-      // Example: Send a message to the server
-      this.socket.send('Hello, WebSocket Server!');
+
       this.onConnect.forEach(callback => callback());
+      this.whenConnected.forEach(callback => callback())
+    })
+    .catch((error) => {
+      console.error("Error starting SignalR connection:", error);
     });
 
-    this.socket.addEventListener('message', (event) => {
-      const data: socketResponse = JSON.parse(event.data)
+
+    this.connection.on("ReceiveMessage", (message) => {
+      const data: any = JSON.parse(message)
+      console.log("ReceiveMessage", data)
       this.callbacks.forEach(callback => callback(data));
-    });
+    })
 
-    this.socket.addEventListener('close', (event) => {
-      console.log('WebSocket connection closed');
+    this.connection.onclose((error) => {
+      console.log('WebSocket connection closed..');
       this.isOpen = false;
       this.onDisconnect.forEach(callback => callback());
       // Attempt to reconnect after a delay
@@ -206,22 +121,27 @@ class ReconnectingWebSocket {
           this.connect();
         }, 1000); // Adjust the delay as needed
       }
+
     });
   }
 
-  send(message) {
-    if (this.isOpen) {
-      this.socket.send(message);
-    } else {
-      console.error('WebSocket connection is not open. Unable to send message.');
-    }
+  commit(path) {
+    this.connection.invoke("CommitUpload", path).catch(err => console.error(err.toString()));
   }
 
   disconnect() {
     this.stop = true
-    if (this.isOpen) {
-      this.isOpen = false;
-      this.socket.close();
+    if(this.isOpen == true) {
+      this.connection.stop()
+      .then(() => {
+        console.log('WebSocket connection was closed by client');
+        this.isOpen = false;
+        this.onDisconnect.forEach(callback => callback());
+        console.log("SignalR connection stopped.");
+      })
+      .catch((error) => {
+        console.error("Error stopping SignalR connection by client:", error);
+      });
     }
   }
 
@@ -239,94 +159,116 @@ class ReconnectingWebSocket {
   onConnectCallback(callback) {
     this.onConnect.push(callback)
   }
-}
-
-export class ObjectMergeNotification{
-
-  socket = new ReconnectingWebSocket('ws://localhost:3002');
-  callbacks: {[GUID: string]: Function} = {}
-  runWatch =  true
-  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
-  watchCount  = 0
-
-  constructor() {
-    this.socket.onDisconnectCallback(()=> {
-      console.log("run watch")
-      this.runWatch = true
-      this.watch()
-    })
-
-    this.socket.onConnectCallback(()=> {
-      console.log("open trigger")
-      this.runWatch = false
-    })
-
-    this.socket.subscribe((data: socketResponse) => {
-      if(data.IsCompleted == true) {
-        console.log("==================!!!====================")
-        try {  
-          this.callbacks[data.Guid](data)
-          delete this.callbacks[data.Guid]
-        } catch (error) {}
-      } else {
-        console.log("else", data)
-      }
-    })
-
-    this.watch()
-  }
-
-  async watch() {
-
-    this.watchCount = 0;
-
-    if(this.runWatch) {
-      setTimeout(async () => {
-        for(const [key, funx] of Object.entries(this.callbacks)) {
-
-          const request = await this.CMAPIService.getVideoHeader(key)
-
-          if(request.isOk()) {
-            funx()
-            delete this.callbacks[key]
-          }
-        }
-
-        this.watchCount++
-        if(this.watchCount <= 15) {
-          this.watch()  
-        } else {
-          this.runWatch = false
-        }
-        
-      }, 1000)
-
 
+  registerWhenConnected(f: Function) {
+    if(this.isOpen) {
+      f();
     } else {
-      console.log("end loop============================")
+      this.whenConnected.push(f);
     }
-  }
 
-  close() {
-    this.socket.disconnect();
-    this.watchCount = 0;
-    this.runWatch = false
   }
-
-  subscribe(GUID, callback:Function) {
-    this.callbacks[GUID] = callback;
-  }
-
-  unsubscribe(GUID) {
-    delete this.callbacks[GUID]
-  }
-
 }
 
+interface socketResponse {
+
+  index: string
+  Guid: string
+  IsCompleted: Boolean
+}
+// class ReconnectingWebSocket {
+
+//   private url: string
+//   private  socket
+//   isOpen: boolean
+//   private  callbacks: Function[] = []
+//   private  onDisconnect: Function[] = []
+//   private  onConnect: Function[] = []
+//   private whenConnected: Function[] = []
+//   private stop = true
+//   http: HttpClient = window["http"]
+
+//   constructor(url) {
+//     this.url = url;
+//     this.socket = null;
+//     this.isOpen = false;
+//   }
+
+//   connect() {
+//     this.socket = new WebSocket(this.url);
+
+//     this.socket.addEventListener('open', (event) => {
+//       this.isOpen = true;
+//       console.log('WebSocket connection established');
+
+//       // Example: Send a message to the server
+//       this.socket.send('Hello, WebSocket Server!');
+//       this.onConnect.forEach(callback => callback());
+//       this.whenConnected.forEach(callback => callback())
+//     });
+
+//     this.socket.addEventListener('message', (event) => {
+//       const data: socketResponse = JSON.parse(event.data)
+//       this.callbacks.forEach(callback => callback(data));
+//     });
+
+//     this.socket.addEventListener('close', (event) => {
+//       console.log('WebSocket connection closed');
+//       this.isOpen = false;
+//       this.onDisconnect.forEach(callback => callback());
+//       // Attempt to reconnect after a delay
+//       if(this.stop == false) {
+//         setTimeout(() => {
+//           this.connect();
+//         }, 1000); // Adjust the delay as needed
+//       }
+//     });
+//   }
+
+//   send(message) {
+//     if (this.isOpen) {
+//       this.socket.send(message);
+//     } else {
+//       console.error('WebSocket connection is not open. Unable to send message.');
+//     }
+//   }
+
+//   disconnect() {
+//     this.stop = true
+//     if (this.isOpen) {
+//       this.isOpen = false;
+//       this.socket.close();
+//     }
+//   }
+
+//   subscribe(callback) {
+//     this.callbacks.push(callback);
+//   }
+
+//   unsubscribe(callback) {
+//     this.callbacks = this.callbacks.filter(cb => cb !== callback);
+//   }
+
+//   onDisconnectCallback(callback) {
+//     this.onDisconnect.push(callback)
+//   }
+//   onConnectCallback(callback) {
+//     this.onConnect.push(callback)
+//   }
+
+//   registerWhenConnected(f: Function) {
+//     if(this.isOpen) {
+//       f();
+//     } else {
+//       this.whenConnected.push(f);
+//     }
+
+//   }
+// }
 
 // export class ObjectMergeNotification{
 
-//   socket = new ReconnectingWebSocketSignalR()
+//   socket = new ReconnectingWebSocket('ws://localhost:3002');
 //   callbacks: {[GUID: string]: Function} = {}
 //   runWatch =  true
 //   CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
@@ -340,15 +282,14 @@ export class ObjectMergeNotification{
 //     })
 
 //     this.socket.onConnectCallback(()=> {
-
 //       console.log("open trigger")
 //       this.runWatch = false
 //     })
-    
+
 //     this.socket.subscribe((data: socketResponse) => {
 //       if(data.IsCompleted == true) {
 //         console.log("==================!!!====================")
-//         try {  
+//         try {
 //           this.callbacks[data.Guid](data)
 //           delete this.callbacks[data.Guid]
 //         } catch (error) {}
@@ -357,15 +298,11 @@ export class ObjectMergeNotification{
 //       }
 //     })
 
-//     this.socket.connect();
 //     this.watch()
 //   }
 
-
-//   close() {
-//     this.socket.disconnect();
-//     this.watchCount = 0;
-//     this.runWatch = false
+//   connect() {
+//     this.socket.connect()
 //   }
 
 //   async watch() {
@@ -386,11 +323,11 @@ export class ObjectMergeNotification{
 
 //         this.watchCount++
 //         if(this.watchCount <= 15) {
-//           this.watch()  
+//           this.watch()
 //         } else {
 //           this.runWatch = false
 //         }
-        
+
 //       }, 1000)
 
 
@@ -399,6 +336,12 @@ export class ObjectMergeNotification{
 //     }
 //   }
 
+//   close() {
+//     this.socket.disconnect();
+//     this.watchCount = 0;
+//     this.runWatch = false
+//   }
+
 //   subscribe(GUID, callback:Function) {
 //     this.callbacks[GUID] = callback;
 //   }
@@ -408,3 +351,92 @@ export class ObjectMergeNotification{
 //   }
 
 // }
+
+
+export class ObjectMergeNotification{
+
+  socket = new ReconnectingWebSocketSignalR()
+  callbacks: {[GUID: string]: Function} = {}
+  runWatch =  true
+  CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
+  watchCount  = 0
+
+  constructor() {
+    this.socket.onDisconnectCallback(()=> {
+      console.log("run watch")
+      this.runWatch = true
+      this.watch()
+    })
+
+    this.socket.onConnectCallback(()=> {
+
+      console.log("open trigger")
+      this.runWatch = false
+    })
+
+    this.socket.subscribe((data: socketResponse) => {
+      if(data.IsCompleted == true) {
+        console.log("==================!!!====================")
+        try {
+          this.callbacks[data.Guid](data)
+          delete this.callbacks[data.Guid]
+        } catch (error) {}
+      } else {
+        console.log("else", data)
+      }
+    })
+
+    this.socket.connect();
+    this.watch()
+  }
+
+  connect() {
+    this.socket.connect();
+  }
+
+  close() {
+    this.socket.disconnect();
+    this.watchCount = 0;
+    this.runWatch = false
+  }
+
+  async watch() {
+
+    // this.watchCount = 0;
+
+    // if(this.runWatch) {
+    //   setTimeout(async () => {
+    //     for(const [key, funx] of Object.entries(this.callbacks)) {
+
+    //       const request = await this.CMAPIService.getVideoHeader(key)
+
+    //       if(request.isOk()) {
+    //         funx()
+    //         delete this.callbacks[key]
+    //       }
+    //     }
+
+    //     this.watchCount++
+    //     if(this.watchCount <= 15) {
+    //       this.watch()
+    //     } else {
+    //       this.runWatch = false
+    //     }
+
+    //   }, 1000)
+
+
+    // } else {
+    //   console.log("end loop============================")
+    // }
+  }
+
+  subscribe(GUID, callback:Function) {
+    this.callbacks[GUID] = callback;
+  }
+
+  unsubscribe(GUID) {
+    delete this.callbacks[GUID]
+  }
+
+}
diff --git a/src/app/shared/API/middleware/middleware-service.service.ts b/src/app/shared/API/middleware/middleware-service.service.ts
index 084a5c1d8..a82bd7cf6 100644
--- a/src/app/shared/API/middleware/middleware-service.service.ts
+++ b/src/app/shared/API/middleware/middleware-service.service.ts
@@ -23,7 +23,7 @@ export class MiddlewareServiceService {
     window["MiddlewareServiceService"] = this
   }
 
-  refreshToken(refreshToken: string){
+  refreshToken(refreshToken: string) {
     const data = {
       refreshToken: refreshToken
     }
@@ -186,15 +186,13 @@ export class MiddlewareServiceService {
     const headers = new HttpHeaders();
     headers.set('Authorization', 'Bearer ' + SessionStore.user.Authorization);
 
-    const geturl = 'http://localhost:3001/FileHub';
-    // const geturl = environment.apiURL + 'Tasks/DelegateTask';
-    // const geturl = environment.apiPCURL + 'FileContent';
+    // const geturl = 'http://localhost:3001/FileHub';
+    const geturl = environment.apiPCURL + 'FileContent/UploadFile';
 
     let options = {
       headers: headers
     };
 
-
     const formData = new FormData();
 
     formData.append("blobFile", blobFile);
@@ -208,6 +206,15 @@ export class MiddlewareServiceService {
     return this.http.post<IuploadFileLK>(`${geturl}`, formData, options)
   }
 
+  CMAPIRequestUpload() {
+    const geturl = environment.apiPCURL + 'FileContent/RequestUpload';
+    return this.http.get<string>(`${geturl}`)
+  }
+
+  CMAPIUploadStatus() {
+    const geturl = environment.apiPCURL + 'FileContent/UploadStatus';
+    return this.http.get<string>(`${geturl}`)
+  }
 
 
   tryToReachTheServer() {
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 8dba39bdf..6fa3b82a5 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -56,33 +56,35 @@
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'"
                 name="image" ngDefaultControl [src]="seleted.FileBase64" style="height: 69px;"></ion-img>
 
-                <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager" style="background: #ededed;">
 
+
+                <!-- <div class="progress-container"   *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
+                  <div class="progress-bar" id="myProgressBar"></div>
+                </div> -->
+
+                <!-- <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
                   <mat-progress-bar
-
-                    mode="determinate"
-                    [style.width]="seleted.chucksManager.uploadPercentage"
-                  ></mat-progress-bar>
-
-                </div>
+                  *ngIf="seleted.chucksManager"
+                  mode="determinate"
+                  style="width: 50%"
+                ></mat-progress-bar>
+                </div> -->
 
               <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkDesktop() == true" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="seleted.url">
+                <source type="video/mp4" [src]="seleted.FileBase64">
               </video>
 
-              <ion-icon *ngIf="seleted?.chucksManager?.manualRetry" src="assets/images/retry-svgrepo-com.svg" class="icon-download font-12"> </ion-icon>
+              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkTableDivice() == true" width="70" height="70"
+                preload="metadata" webkit-playsinline="webkit-playsinline">
+                <source type="video/mp4" [src]="seleted.FileBase64">
+              </video>
+
+
 
             </div>
 
           </div>
-          <!-- Display the blurred image and count if there are more images -->
-          <div *ngIf="seletedContent.length > displayLimit" lot="start">
-            <ion-img [src]="'data:image/jpg;base64,' + seletedContent[displayLimit - 1].Base64"
-              style="filter: blur(5px);"></ion-img>
-
-              <p>mais {{ seletedContent.length - displayLimit }}</p>
-          </div>
 
           <ion-label class="pl-10">
             <p>{{capturedImageTitle}}</p>
@@ -144,6 +146,10 @@
         </div>
       </ion-label>
     </div>
+
+
+
+    <video id="yourVideoElementId" >videoss</video>
   </div>
 
 </ion-content>
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index f377503d4..bb6c32fd5 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -265,9 +265,9 @@ export class NewPublicationPage implements OnInit {
         ).then(r => r.blob()); */
 
         /*  console.log(await blob.arrayBuffer());
-   
-          
-             
+
+
+
            console.log("base64 :data:video/mp4;base64,",this.arrayBufferToBase64(await blob.arrayBuffer())) */
 
         this.convertBlobToBase64(blobFile.blob).then((value: string) => {
@@ -445,7 +445,6 @@ export class NewPublicationPage implements OnInit {
           Files: this.seletedContent,
         }
 
-
         this.publicationFormMV.setDataToFrom(this.publication)
         const upload = await this.publicationFormMV.uploadVideosFiles()
 
@@ -455,10 +454,12 @@ export class NewPublicationPage implements OnInit {
               e.OriginalFileName = e.chucksManager.path.replace(".mp4", "")
               e.FileExtension = "mp4"
             }
+            this.publicationFormMV.ObjectMergeNotification.socket.commit(e.chucksManager.path)
 
             return e
           })
 
+
           console.log("this.publication.Files", this.publication.Files)
         }
 
@@ -480,7 +481,7 @@ export class NewPublicationPage implements OnInit {
           this.httpErroHandle.httpStatusHandle(error)
           if (error.status == 404) {
             this.PublicationFolderService.deletePost(this.publication.ProcessId, this.publication.DocumentId)
-            this.goBack();
+            //this.goBack();
           }
         } finally {
           loader.remove()
@@ -507,7 +508,6 @@ export class NewPublicationPage implements OnInit {
           Files: this.seletedContent,
         }
 
-
         this.publicationFormMV.setDataToFrom(this.publication)
         const upload = await this.publicationFormMV.uploadVideosFiles()
 
@@ -519,49 +519,60 @@ export class NewPublicationPage implements OnInit {
               e.Base64 = ""
             }
 
+            alert("commit")
+            this.publicationFormMV.ObjectMergeNotification.socket.commit(e.chucksManager.path)
+
             return e
           })
 
-        }
-
-        this.publication.Files = this.publication.Files.map( (e:PublicationAttachmentEntity) => ({
-          FileBase64: e.Base64,
-          FileExtension: e.FileExtension,
-          OriginalFileName:  e.OriginalFileName || 'foto'
-        }))
 
 
-        const loader = this.toastService.loading()
 
-        try {
+          this.publication.Files = this.publication.Files.map( (e:PublicationAttachmentEntity) => ({
+            FileBase64: e.Base64,
+            FileExtension: e.FileExtension,
+            OriginalFileName:  e.OriginalFileName || 'foto'
+          }))
 
-          await this.publications.CreatePublication(this.publication.ProcessId, this.publication).toPromise()
-          if (this.publicationTitle == '1') {
 
-          } else if (this.publicationTitle == '2') {
-            this.httpErroHandle.httpsSucessMessagge('Criar publicação')
-          } else if (this.publicationTitle == '3') {
-            this.httpErroHandle.httpsSucessMessagge('Editar publicação')
+
+
+          const loader = this.toastService.loading()
+
+          try {
+
+            await this.publications.CreatePublication(this.publication.ProcessId, this.publication).toPromise()
+            if (this.publicationTitle == '1') {
+
+            } else if (this.publicationTitle == '2') {
+              this.httpErroHandle.httpsSucessMessagge('Criar publicação')
+            } else if (this.publicationTitle == '3') {
+              this.httpErroHandle.httpsSucessMessagge('Editar publicação')
+            }
+
+            //this.goBackToViewPublications.emit();
+          } catch (error) {
+            this.httpErroHandle.httpStatusHandle(error)
+          } finally {
+            loader.remove()
           }
 
-          this.goBackToViewPublications.emit();
-        } catch (error) {
-          this.httpErroHandle.httpStatusHandle(error)
-        } finally {
-          loader.remove()
         }
 
+
+
       } else {
         this.toastService._badRequest("É necessário adicionar uma imagem ou vídeo")
       }
 
     }
 
-    this.publicationFormMV.ObjectMergeNotification.close()
+
+    // this.publicationFormMV.ObjectMergeNotification.close()
   }
 
   ngOnDestroy() {
-    this.publicationFormMV.ObjectMergeNotification.close()
+    // this.publicationFormMV.ObjectMergeNotification.close()
   }
 
   close() {
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 34bd620e2..211df04c9 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -2,6 +2,17 @@ import { Injectable } from '@angular/core';
 import { ok, err, Result } from 'neverthrow';
 import { ObjectMergeNotification } from 'src/app/services/socket-connection-mcr.service';
 import { CMAPIService } from "src/app/shared/repository/CMAPI/cmapi.service"
+
+const objectMergeNotification  = new ObjectMergeNotification()
+
+export enum UploadError {
+  noConnection = 'noConnection',
+  slow = 'slow'
+}
+
+export type IOUploadError = "noConnection" |  "slow"
+
+
 @Injectable({
   providedIn: 'root'
 })
@@ -9,112 +20,85 @@ export class UploadStreamingService {
   constructor(    private CMAPIService: CMAPIService,) { }
 }
 
-
 class UploadFileUseCase {
   CMAPIService:  CMAPIService = window["CMAPIAPIRepository"]
   constructor() {}
-  async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
+  async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<true, IOUploadError >> {
     return new Promise(async (resolve, reject) => {
 
-      PublicationAttachmentEntity.chucksManager.clearManualRetry()
-
       let path: string;
       const length = PublicationAttachmentEntity.chucksManager.chunks.totalChunks.toString()
 
       const readAndUploadChunk = async(index: number) => {
 
-        const chunk = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
-        const blob = new Blob([chunk]);
-        const blobFile = new File([blob], "test.mp4", { type: blob.type });
+        const base64 = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
 
-        return this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile})
-      }
 
-      if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
-        const initIndex = 1
+        if(index == 2) {
+          const base1 = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(2)
 
-        const uploadRequest = await readAndUploadChunk(initIndex)
+          // Get the video element from the DOM
+          const videoElement: any = document.getElementById("yourVideoElementId");
 
-        if(uploadRequest.isOk()) {
+          // Set the src attribute of the video element to the blob URL
+          videoElement.src = "data:video/mp4;base64,"+ base1 + base64 ;
 
-          path = uploadRequest.value.data
-
-          PublicationAttachmentEntity.chucksManager.setPath(path)
-          PublicationAttachmentEntity.chucksManager.setResponse(initIndex, uploadRequest)
-          alert("passs")
-        } else {
-          alert("erro dfsdfsdfsdr")
-          PublicationAttachmentEntity.chucksManager.clearUploading()
-          PublicationAttachmentEntity.chucksManager.setManualRetry()
-          return reject(err(PublicationAttachmentEntity))
+          // Optionally, you can also set other attributes or play the video
+          videoElement.controls = true; // Add controls for play, pause, etc.
+          videoElement.play(); // Auto-play the vid
         }
+
+        const uploadRequest = this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile: base64})
+
+        uploadRequest.then((uploadRequest) => {
+          if(uploadRequest.isOk()) {
+            PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
+          }
+        })
+
+        return uploadRequest;
       }
 
+      // if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
+      //   const guidRequest = await this.CMAPIService.RequestUpload()
+
+      //   if(guidRequest.isOk()) {
+      //     path = guidRequest.value+".mp4"
+      //     PublicationAttachmentEntity.chucksManager.setPath(path)
+      //   } else {
+      //     const pingRequest = await this.CMAPIService.ping()
+      //     if( pingRequest.isErr()) {
+      //       return resolve(err(UploadError.noConnection))
+      //     } else {
+      //       return resolve(err(UploadError.slow))
+      //     }
+      //   }
+      // }
+
       const allRequest: Promise<any>[] = []
       let connection = true
+      let errorMessage: UploadError.noConnection |  UploadError.slow
 
-      for (let index = 2;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks -1) && connection ); index++) {
+      for (let index = 1;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks)  ); index++) {
         const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
 
         if(needUpload) {
 
           const request = readAndUploadChunk(index).then(async(uploadRequest) => {
-            if(uploadRequest.isErr()) {
-              const pingRequest = await this.CMAPIService.ping()
-              if( pingRequest.isErr()) {
-                connection = false
-                return reject(err(PublicationAttachmentEntity))
-              }
-            } else {
-              PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
-            }
+
           })
           allRequest.push(request)
-
-          // const request = readAndUploadChunk(index)
-          // const uploadRequest = await request
-
-          // allRequest.push(request)
-          // if(uploadRequest.isErr()) {
-          //   const pingRequest = await this.CMAPIService.ping()
-          //   if( pingRequest.isErr()) {
-          //     reject(err(PublicationAttachmentEntity))
-          //   }
-          // } else {
-          //   PublicationAttachmentEntity.chucksManager.setResponse(index, uploadRequest)
-          // }
         }
       }
 
+      await Promise.all(allRequest)
+
       if(!connection) {
-        PublicationAttachmentEntity.chucksManager.clearUploading()
-        PublicationAttachmentEntity.chucksManager.setManualRetry()
-        return reject(err(PublicationAttachmentEntity))
-      } else if (PublicationAttachmentEntity.chucksManager.chunks.totalChunks != 1) {
-        await Promise.all(allRequest)
-
-        const uploadRequest = await readAndUploadChunk(PublicationAttachmentEntity.chucksManager.chunks.totalChunks)
-        if(uploadRequest.isErr()) {
-          const pingRequest = await this.CMAPIService.ping()
-          if( pingRequest.isErr()) {
-          }
-
-          PublicationAttachmentEntity.chucksManager.clearUploading()
-          PublicationAttachmentEntity.chucksManager.setManualRetry()
-          return reject(err(PublicationAttachmentEntity))
-        } else {
-          PublicationAttachmentEntity.chucksManager.setResponse(PublicationAttachmentEntity.chucksManager.chunks.totalChunks, uploadRequest)
-          PublicationAttachmentEntity.chucksManager.doneChunkUpload()
-          return resolve(ok(PublicationAttachmentEntity))
-        }
-
+        return resolve(err(errorMessage))
       } else {
-
-        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
-        return resolve(ok(PublicationAttachmentEntity))
+        return resolve(ok(true))
       }
 
-
     })
   }
 }
@@ -215,7 +199,11 @@ export class PublicationFormMV {
 
   private UploadFileUseCase = new UploadFileUseCase()
   private form = new PublicationFormModel()
-  ObjectMergeNotification = new ObjectMergeNotification()
+  ObjectMergeNotification = objectMergeNotification
+
+  constructor() {
+    this.ObjectMergeNotification.connect();
+  }
 
   setDataToFrom(data: IPublicationFormModelEntity) {
     this.form.setData(data)
@@ -231,12 +219,14 @@ export class PublicationFormMV {
 
       if(!PublicationAttachmentEntity.hasChunkManger) {
         const fileBlob = PublicationAttachmentEntity.blobFile;
-        const fileChunks = new Chunks({chunkSize: 2000 })
+        const fileChunks = new Chunks({chunkSize: 70 })
         fileChunks.setFile(fileBlob)
 
         PublicationAttachmentEntity.setChunkManger(fileChunks)
 
-        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(()=> {
+        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(() => {
+
+          console.log("last chunk ===============================================")
           const guid = PublicationAttachmentEntity.chucksManager.path
 
           this.ObjectMergeNotification.subscribe(guid, (data) => {
@@ -246,29 +236,36 @@ export class PublicationFormMV {
           })
         })
 
-      } else {
-        if(PublicationAttachmentEntity.chucksManager.doneUpload) {
-          alert("done")
-          return resolve(true)
-        }
+      } else if(PublicationAttachmentEntity.chucksManager.doneUpload) {
+        return resolve(true)
       }
 
-      if( PublicationAttachmentEntity.chucksManager.isUploading == false) {
-        PublicationAttachmentEntity.chucksManager.setUploading()
-        const result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
-        PublicationAttachmentEntity.chucksManager.clearUploading()
-        PublicationAttachmentEntity.chucksManager.setManualRetry()
+      let attemp  = 0;
+      let result: Result<true, IOUploadError>
 
+      if( PublicationAttachmentEntity.chucksManager.isUploading == false) {
+
+        do {
+          attemp++
+
+          PublicationAttachmentEntity.chucksManager.clearManualRetry()
+          PublicationAttachmentEntity.chucksManager.setUploading()
+          result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
+          PublicationAttachmentEntity.chucksManager.clearUploading()
+
+        } while (attemp<3 && result.isErr() && result?.error == 'slow')
+
+        PublicationAttachmentEntity.chucksManager.setManualRetry()
+        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
 
         if(result.isErr()) {
-          alert("error")
-          
-          reject(false)
+          resolve(false)
         } else {
-          alert("passs")
+          resolve(true)
         }
+
       } else {
-        alert("not")
+
       }
 
     })
@@ -276,36 +273,41 @@ export class PublicationFormMV {
   }
 
   uploadVideosFiles(): Promise<Boolean> {
-    return new Promise((resolve, reject)=> {
-      const videosFiles = this.getVideoFiles()
 
-      const videosFilesToUploads = videosFiles.filter( e => e.FileType == "video")
+    return new Promise((resolve, reject) => {
 
-      const Promises: Promise<any>[] = []
+      // this.ObjectMergeNotification.socket.registerWhenConnected(() => {
+        const videosFiles = this.getVideoFiles()
 
-      for(const file of videosFilesToUploads) {
-        const promise = this.upload(file)
-        Promises.push(promise)
-      }
+        const videosFilesToUploads = videosFiles.filter( e => e.FileType == "video")
 
-      // Use Promise.all to wait for all promises to resolve
-      Promise.all(Promises)
-      .then((results) => {
-        // Check if every promise resolved successfully
-        const allPromisesResolvedSuccessfully = results.every((result) => result == true);
+        const Promises: Promise<any>[] = []
 
-        if (allPromisesResolvedSuccessfully) {
-          console.log('All promises resolved successfully.');
-          resolve(true)
-        } else {
-          reject(false)
-          console.log('Some promises failed to resolve successfully.');
+        for(const file of videosFilesToUploads) {
+          const promise = this.upload(file)
+          Promises.push(promise)
         }
-      })
-      .catch((error) => {
-        reject(false)
-        console.error('An error occurred while resolving promises:', error);
-      });
+
+        // Use Promise.all to wait for all promises to resolve
+        Promise.all(Promises)
+        .then((results) => {
+          // Check if every promise resolved successfully
+          const allPromisesResolvedSuccessfully = results.every((result) => result == true);
+
+          if (allPromisesResolvedSuccessfully) {
+            console.log('All promises resolved successfully.');
+            resolve(true)
+          } else {
+            resolve(false)
+            console.log('Some promises failed to resolve successfully.');
+          }
+        })
+        .catch((error) => {
+          resolve(false)
+          console.error('An error occurred while resolving promises:', error);
+        });
+      //})
+
     })
 
   }
@@ -325,29 +327,22 @@ export class Chunks {
     return Math.ceil(this.file.size / this.chunkSize);
   }
 
-  // Function to read a chunk of the file
-  readChunk(start: number, end: number): Promise<ArrayBuffer> {
-    const file =  this.file
-
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        if (reader.result instanceof ArrayBuffer) {
-          resolve(reader.result);
-        } else {
-          reject(new Error("Failed to read chunk"));
-        }
-      };
-
-      reader.readAsArrayBuffer(file.slice(start, end));
-    });
-  }
-
   setFile(file: File) {
     this.file = file
   }
 
-  async getChunks(i: number) {
+  // Function to read a chunk of the file
+  readChunk(start: number, end: number): any {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (event: any) => resolve(event.target.result.split(',')[1]);
+      reader.onerror = (error) => reject(error);
+      reader.readAsDataURL(this.file.slice(start, end));
+    });
+  }
+
+
+  async getChunks(i: number): Promise<string> {
     i--
     if(i < this.totalChunks) {
       const start = i * this.chunkSize;
@@ -499,3 +494,4 @@ export class ChucksManager {
     this.contentReady = true
   }
 }
+
diff --git a/src/app/shared/publication/view-publications/view-publications.page.html b/src/app/shared/publication/view-publications/view-publications.page.html
index 0df78345c..34f8082b1 100644
--- a/src/app/shared/publication/view-publications/view-publications.page.html
+++ b/src/app/shared/publication/view-publications/view-publications.page.html
@@ -39,23 +39,25 @@
     <p class="item-content-detail">{{publicationFolderService.FolderDetails[folderId].Detail}}</p>
 
 
-
     <ion-card *ngFor="let publication of publicationFolderService.publicationList[folderId] let i = index">
       <ion-card-content>
 
-        <swiper-container [modules]="swiperModules" [speed]=400 navigation="true" [pagination]="{clickable: true, dynamicBullets: true }">
-          <swiper-slide *ngFor="let files of publication.Files let k = index">
-            <div (click)="viewPublicationDetail(publication.DocumentId, publication.ProcessId)">
-              <img  *ngIf="checkFileType.checkFileType(files.FileExtension ) == 'image'" class="post-img cursor-pointer"
-                [lazyLoad]="'data:image/jpg;base64,' + files.FileBase64">
+        <swiper-container [config]="swiperThumbsConfig" [modules]="swiperModules" [speed]=400 navigation="true" [pagination]="{clickable: true, dynamicBullets: true }">
+          <swiper-slide *ngFor="let files of publication.Files let k = index" class="centered-slide">
+            <div class="cool">
+              <div (click)="viewPublicationDetail(publication.DocumentId, publication.ProcessId)">
+                <img  *ngIf="checkFileType.checkFileType(files.FileExtension ) == 'image'" class="post-img cursor-pointer"
+                  [lazyLoad]="'data:image/jpg;base64,' + files.FileBase64">
 
-              <video [appVisibility]="onVisibilityChange" #myVideo #videoElement *ngIf="checkFileType.checkFileType(files.FileExtension ) == 'video'" class="post-video" controls="controls" preload="metadata"
-                webkit-playsinline="webkit-playsinline" class="videoPlayer"  (click)="preventVideoPlay($event)">
-                <source [src]="files.FileBase64" type="video/mp4" >
-              </video>
+                <video [appVisibility]="onVisibilityChange" #myVideo #videoElement *ngIf="checkFileType.checkFileType(files.FileExtension ) == 'video'" class="post-video" controls="controls" preload="metadata"
+                  webkit-playsinline="webkit-playsinline" class="videoPlayer"  (click)="preventVideoPlay($event)">
+                  <source [src]="files.FileBase64" type="video/mp4" >
+                </video>
 
 
+              </div>
             </div>
+
           </swiper-slide>
 
           <!-- <div *ngIf="publication?.Files?.length == 0">
diff --git a/src/app/shared/publication/view-publications/view-publications.page.scss b/src/app/shared/publication/view-publications/view-publications.page.scss
index 974fdafe5..f52ae38b5 100644
--- a/src/app/shared/publication/view-publications/view-publications.page.scss
+++ b/src/app/shared/publication/view-publications/view-publications.page.scss
@@ -292,3 +292,10 @@ swiper-slide video {
   align-items: center;
 
 }
+
+.centered-slide {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+}
diff --git a/src/app/shared/publication/view-publications/view-publications.page.ts b/src/app/shared/publication/view-publications/view-publications.page.ts
index d5573e33e..1901d3b4b 100644
--- a/src/app/shared/publication/view-publications/view-publications.page.ts
+++ b/src/app/shared/publication/view-publications/view-publications.page.ts
@@ -29,6 +29,18 @@ export class ViewPublicationsPage implements OnInit {
   error: any;
   oldpublicationIds = []
 
+  swiperConfig = {
+    spaceBetween: 10,
+    navigation: true,
+  }
+
+  swiperThumbsConfig = {
+    spaceBetween: 10,
+    slidesPerView: 4,
+    freeMode: true,
+    watchSlidesProgress: true,
+  }
+
   @Input() folderId: any;
   @Output() addNewPublication = new EventEmitter<any>();
   @Output() editPublication = new EventEmitter<any>();
diff --git a/src/app/shared/repository/CMAPI/cmapi.service.ts b/src/app/shared/repository/CMAPI/cmapi.service.ts
index e943c0dd7..dc8cda20a 100644
--- a/src/app/shared/repository/CMAPI/cmapi.service.ts
+++ b/src/app/shared/repository/CMAPI/cmapi.service.ts
@@ -1,8 +1,10 @@
 import { Injectable } from '@angular/core';
 import { MiddlewareServiceService } from "src/app/shared/API/middleware/middleware-service.service";
 import { CMAPIAPIService } from "src/app/shared/API/CMAPI/cmapi-api.service";
-import { ok, err } from 'neverthrow';
+import { ok, err, Result } from 'neverthrow';
 import { Observable } from 'rxjs';
+import { environment } from 'src/environments/environment';
+import { IuploadFileLK } from '../../API/middleware/interface';
 
 @Injectable({
   providedIn: 'root'
@@ -15,16 +17,38 @@ export class CMAPIService {
     window["CMAPIAPIRepository"] = this
   }
 
-  async FileContent({length, path, index, blobFile}) {
-
+  async FileContent({length, path, index, blobFile}): Promise<Result<IuploadFileLK, "badRequest" | "other">> {
     try {
       const result = await this.MiddlewareServiceService.CMAPIFileContent({length, path, index, blobFile}).toPromise();
       return ok(result)
+    } catch (error) {
+      if(error.status >= 400 && error.status >= 499) {
+        return err("badRequest")
+      }
+
+      return err("other")
+    }
+  }
+
+
+  async RequestUpload(): Promise<Result<string, any>> {
+    try {
+      const result = await this.MiddlewareServiceService.CMAPIRequestUpload().toPromise();
+      return ok(result)
 
     } catch (error) {
       return err(error)
     }
+  }
 
+  async UploadStatus() {
+    try {
+      const result = await this.MiddlewareServiceService.CMAPIUploadStatus().toPromise();
+      return ok(result)
+
+    } catch (error) {
+      return err(error)
+    }
   }
 
   async ping() {

From 0e383c85a8a23a342734ba3d419cf6e54f81a83f Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 8 Feb 2024 10:14:21 +0100
Subject: [PATCH 07/16] done chunk upload

---
 .../services/socket-connection-mcr.service.ts |  2 +-
 .../middleware/middleware-service.service.ts  | 23 +++------
 .../new-publication/new-publication.page.ts   | 15 ++----
 .../upload/upload-streaming.service.ts        | 48 +++++++------------
 .../shared/repository/CMAPI/cmapi.service.ts  |  4 +-
 5 files changed, 31 insertions(+), 61 deletions(-)

diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index d885b7895..79487258a 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -75,7 +75,7 @@ class ReconnectingWebSocketSignalR {
   private  onDisconnect: Function[] = []
   private  onConnect: Function[] = []
   private whenConnected: Function[] = []
-  private stop = true
+  stop = true
 
   constructor() {}
 
diff --git a/src/app/shared/API/middleware/middleware-service.service.ts b/src/app/shared/API/middleware/middleware-service.service.ts
index a82bd7cf6..afa8c69e2 100644
--- a/src/app/shared/API/middleware/middleware-service.service.ts
+++ b/src/app/shared/API/middleware/middleware-service.service.ts
@@ -182,28 +182,19 @@ export class MiddlewareServiceService {
 
 
 
-  CMAPIFileContent({length, path, index, blobFile}) {
-    const headers = new HttpHeaders();
-    headers.set('Authorization', 'Bearer ' + SessionStore.user.Authorization);
+  CMAPIFileContent({length, path, index, base64}) {
 
     // const geturl = 'http://localhost:3001/FileHub';
     const geturl = environment.apiPCURL + 'FileContent/UploadFile';
 
-    let options = {
-      headers: headers
-    };
-
-    const formData = new FormData();
-
-    formData.append("blobFile", blobFile);
-    formData.append("length", length);
-    formData.append("index", index.toString());
-
-    if(path) {
-      formData.append("path", path);
+    const data = {
+      index,
+      length,
+      base64,
+      path,
     }
 
-    return this.http.post<IuploadFileLK>(`${geturl}`, formData, options)
+    return this.http.post<IuploadFileLK>(`${geturl}`, data)
   }
 
   CMAPIRequestUpload() {
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index bb6c32fd5..bd1ee85d7 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -430,8 +430,6 @@ export class NewPublicationPage implements OnInit {
 
     if (this.publicationType == ActionType.edit) {
 
-
-
       if (this.seletedContent.length >= 1) {
         const loader = this.toastService.loading()
 
@@ -459,8 +457,6 @@ export class NewPublicationPage implements OnInit {
             return e
           })
 
-
-          console.log("this.publication.Files", this.publication.Files)
         }
 
         this.publication.Files = this.publication.Files.map( (e: PublicationAttachmentEntity) => ({
@@ -481,7 +477,7 @@ export class NewPublicationPage implements OnInit {
           this.httpErroHandle.httpStatusHandle(error)
           if (error.status == 404) {
             this.PublicationFolderService.deletePost(this.publication.ProcessId, this.publication.DocumentId)
-            //this.goBack();
+            this.goBack();
           }
         } finally {
           loader.remove()
@@ -512,14 +508,13 @@ export class NewPublicationPage implements OnInit {
         const upload = await this.publicationFormMV.uploadVideosFiles()
 
         if(upload) {
-          this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity)=> {
+          this.publication.Files = this.publication.Files.map((e:PublicationAttachmentEntity) => {
             if(e.FileType == 'video') {
               e.OriginalFileName = e.chucksManager.path.replace(".mp4", "")
               e.FileExtension = "mp4"
               e.Base64 = ""
             }
 
-            alert("commit")
             this.publicationFormMV.ObjectMergeNotification.socket.commit(e.chucksManager.path)
 
             return e
@@ -550,7 +545,7 @@ export class NewPublicationPage implements OnInit {
               this.httpErroHandle.httpsSucessMessagge('Editar publicação')
             }
 
-            //this.goBackToViewPublications.emit();
+            this.goBackToViewPublications.emit();
           } catch (error) {
             this.httpErroHandle.httpStatusHandle(error)
           } finally {
@@ -568,11 +563,11 @@ export class NewPublicationPage implements OnInit {
     }
 
 
-    // this.publicationFormMV.ObjectMergeNotification.close()
+    this.publicationFormMV.ObjectMergeNotification.close()
   }
 
   ngOnDestroy() {
-    // this.publicationFormMV.ObjectMergeNotification.close()
+    this.publicationFormMV.ObjectMergeNotification.close()
   }
 
   close() {
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 211df04c9..1696a803b 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -12,7 +12,6 @@ export enum UploadError {
 
 export type IOUploadError = "noConnection" |  "slow"
 
-
 @Injectable({
   providedIn: 'root'
 })
@@ -34,21 +33,7 @@ class UploadFileUseCase {
         const base64 = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(index)
 
 
-        if(index == 2) {
-          const base1 = await PublicationAttachmentEntity.chucksManager.chunks.getChunks(2)
-
-          // Get the video element from the DOM
-          const videoElement: any = document.getElementById("yourVideoElementId");
-
-          // Set the src attribute of the video element to the blob URL
-          videoElement.src = "data:video/mp4;base64,"+ base1 + base64 ;
-
-          // Optionally, you can also set other attributes or play the video
-          videoElement.controls = true; // Add controls for play, pause, etc.
-          videoElement.play(); // Auto-play the vid
-        }
-
-        const uploadRequest = this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, blobFile: base64})
+        const uploadRequest = this.CMAPIService.FileContent({length, path: PublicationAttachmentEntity.chucksManager.path, index, base64})
 
         uploadRequest.then((uploadRequest) => {
           if(uploadRequest.isOk()) {
@@ -59,21 +44,21 @@ class UploadFileUseCase {
         return uploadRequest;
       }
 
-      // if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
-      //   const guidRequest = await this.CMAPIService.RequestUpload()
+      if(!PublicationAttachmentEntity.chucksManager.hasPath()) {
+        const guidRequest = await this.CMAPIService.RequestUpload()
 
-      //   if(guidRequest.isOk()) {
-      //     path = guidRequest.value+".mp4"
-      //     PublicationAttachmentEntity.chucksManager.setPath(path)
-      //   } else {
-      //     const pingRequest = await this.CMAPIService.ping()
-      //     if( pingRequest.isErr()) {
-      //       return resolve(err(UploadError.noConnection))
-      //     } else {
-      //       return resolve(err(UploadError.slow))
-      //     }
-      //   }
-      // }
+        if(guidRequest.isOk()) {
+          path = guidRequest.value+".mp4"
+          PublicationAttachmentEntity.chucksManager.setPath(path)
+        } else {
+          const pingRequest = await this.CMAPIService.ping()
+          if( pingRequest.isErr()) {
+            return resolve(err(UploadError.noConnection))
+          } else {
+            return resolve(err(UploadError.slow))
+          }
+        }
+      }
 
       const allRequest: Promise<any>[] = []
       let connection = true
@@ -219,14 +204,13 @@ export class PublicationFormMV {
 
       if(!PublicationAttachmentEntity.hasChunkManger) {
         const fileBlob = PublicationAttachmentEntity.blobFile;
-        const fileChunks = new Chunks({chunkSize: 70 })
+        const fileChunks = new Chunks({chunkSize: 1024 })
         fileChunks.setFile(fileBlob)
 
         PublicationAttachmentEntity.setChunkManger(fileChunks)
 
         PublicationAttachmentEntity.chucksManager.registerOnLastChunk(() => {
 
-          console.log("last chunk ===============================================")
           const guid = PublicationAttachmentEntity.chucksManager.path
 
           this.ObjectMergeNotification.subscribe(guid, (data) => {
diff --git a/src/app/shared/repository/CMAPI/cmapi.service.ts b/src/app/shared/repository/CMAPI/cmapi.service.ts
index dc8cda20a..12e3d7715 100644
--- a/src/app/shared/repository/CMAPI/cmapi.service.ts
+++ b/src/app/shared/repository/CMAPI/cmapi.service.ts
@@ -17,9 +17,9 @@ export class CMAPIService {
     window["CMAPIAPIRepository"] = this
   }
 
-  async FileContent({length, path, index, blobFile}): Promise<Result<IuploadFileLK, "badRequest" | "other">> {
+  async FileContent({length, path, index, base64}): Promise<Result<IuploadFileLK, "badRequest" | "other">> {
     try {
-      const result = await this.MiddlewareServiceService.CMAPIFileContent({length, path, index, blobFile}).toPromise();
+      const result = await this.MiddlewareServiceService.CMAPIFileContent({length, path, index, base64}).toPromise();
       return ok(result)
     } catch (error) {
       if(error.status >= 400 && error.status >= 499) {

From 02e1decd51edb004647aa6bb96ac30d568241ff4 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 8 Feb 2024 16:40:12 +0100
Subject: [PATCH 08/16] fix image and video thumbnails

---
 .../view-document/view-document.page.html     |  2 +-
 .../new-publication/new-publication.page.html |  4 ++--
 .../new-publication/new-publication.page.html | 24 ++++---------------
 3 files changed, 8 insertions(+), 22 deletions(-)

diff --git a/src/app/modals/view-document/view-document.page.html b/src/app/modals/view-document/view-document.page.html
index 9c0b9e166..9a7639fbe 100644
--- a/src/app/modals/view-document/view-document.page.html
+++ b/src/app/modals/view-document/view-document.page.html
@@ -5,7 +5,7 @@
         <fa-icon icon="chevron-left" class="menu-icon font-awesome-1"></fa-icon>
       </div>
 
-      <div class="middle add-ellipsis">
+      <div class="middle ">
         {{file.title}}
       </div>
 
diff --git a/src/app/pages/publications/new-publication/new-publication.page.html b/src/app/pages/publications/new-publication/new-publication.page.html
index 0b29f2dfb..f245317e4 100644
--- a/src/app/pages/publications/new-publication/new-publication.page.html
+++ b/src/app/pages/publications/new-publication/new-publication.page.html
@@ -43,12 +43,12 @@
                 name="image" ngDefaultControl [src]="'data:image/jpg;base64,' + seleted.Base64"
                 (click)="imageSize(capturedImage)"  style="height: 69px;"></ion-img>
 
-              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle == ActionType.edit" width="70" height="70"
+              <video class="55" *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle == ActionType.edit" width="70" height="70"
                 controls="controls" preload="metadata" autoplay="autoplay" webkit-playsinline="webkit-playsinline">
                 <source type="video/mp4" [src]="'data:video/mp4;base64,' + seleted.Base64">
               </video>
 
-              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle != ActionType.edit" width="70" height="70"
+              <video class="src" *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && publicationTitle != ActionType.edit" width="70" height="70"
                 controls="controls" preload="metadata" autoplay="autoplay" webkit-playsinline="webkit-playsinline">
                 <source type="video/mp4" [src]="seleted.url">
               </video>
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 6fa3b82a5..3deea11d5 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -54,30 +54,16 @@
               </div>
 
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'"
-                name="image" ngDefaultControl [src]="seleted.FileBase64" style="height: 69px;"></ion-img>
+                name="image" ngDefaultControl [src]="seleted.url" style="height: 69px;"></ion-img>
 
-
-
-                <!-- <div class="progress-container"   *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
-                  <div class="progress-bar" id="myProgressBar"></div>
-                </div> -->
-
-                <!-- <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video'">
-                  <mat-progress-bar
-                  *ngIf="seleted.chucksManager"
-                  mode="determinate"
-                  style="width: 50%"
-                ></mat-progress-bar>
-                </div> -->
-
-              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkDesktop() == true" width="70" height="70"
+              <video class="sdf" *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkDesktop() == true" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="seleted.FileBase64">
+                <source type="video/mp4" [src]="seleted.url">
               </video>
 
-              <video *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkTableDivice() == true" width="70" height="70"
+              <video class="sdfsdf" *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && checkTableDivice() == true" width="70" height="70"
                 preload="metadata" webkit-playsinline="webkit-playsinline">
-                <source type="video/mp4" [src]="seleted.FileBase64">
+                <source type="video/mp4" [src]="'data:video/mp4;base64,' + seleted.Base64">
               </video>
 
 

From 8dca3a64a8456252c1f0af3736f2f04b129da135 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Fri, 9 Feb 2024 09:10:50 +0100
Subject: [PATCH 09/16] serializing url

---
 src/app/pipes/pipes.module.ts                       |  3 ++-
 src/app/pipes/safe.pipe.spec.ts                     |  8 ++++++++
 src/app/pipes/safe.pipe.ts                          | 13 +++++++++++++
 .../new-publication/new-publication.page.html       |  2 --
 .../publication/upload/upload-streaming.service.ts  | 10 +++++++++-
 5 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 src/app/pipes/safe.pipe.spec.ts
 create mode 100644 src/app/pipes/safe.pipe.ts

diff --git a/src/app/pipes/pipes.module.ts b/src/app/pipes/pipes.module.ts
index 2d3ab2605..f5a8d980a 100644
--- a/src/app/pipes/pipes.module.ts
+++ b/src/app/pipes/pipes.module.ts
@@ -8,10 +8,11 @@ import { ExpedienteTaskPipe } from './expediente-task.pipe';
 import { ParticipantsPipe } from './participants.pipe';
 import { SafehtmlPipe } from './safehtml.pipe';
 import { EventoApprovePipe } from './evento-approve.pipe';
+import { SafePipe } from './safe.pipe';
 
 
 @NgModule({
-  declarations: [FilterPipe, SearchDocumentPipe, CustomTaskPipe, EventPipe, PublicationPipe, ExpedienteTaskPipe, ParticipantsPipe, SafehtmlPipe, EventoApprovePipe],
+  declarations: [FilterPipe, SearchDocumentPipe, CustomTaskPipe, EventPipe, PublicationPipe, ExpedienteTaskPipe, ParticipantsPipe, SafehtmlPipe, EventoApprovePipe, SafePipe],
   exports: [FilterPipe, SafehtmlPipe],
   imports: []
 })
diff --git a/src/app/pipes/safe.pipe.spec.ts b/src/app/pipes/safe.pipe.spec.ts
new file mode 100644
index 000000000..49ee0ad14
--- /dev/null
+++ b/src/app/pipes/safe.pipe.spec.ts
@@ -0,0 +1,8 @@
+import { SafePipe } from './safe.pipe';
+
+describe('SafePipe', () => {
+  it('create an instance', () => {
+    const pipe = new SafePipe();
+    expect(pipe).toBeTruthy();
+  });
+});
diff --git a/src/app/pipes/safe.pipe.ts b/src/app/pipes/safe.pipe.ts
new file mode 100644
index 000000000..e3e3e0c18
--- /dev/null
+++ b/src/app/pipes/safe.pipe.ts
@@ -0,0 +1,13 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+
+@Pipe({
+  name: 'safe'
+})
+export class SafePipe implements PipeTransform {
+  constructor(private sanitizer: DomSanitizer) { }
+
+  transform(url: string): SafeUrl {
+    return this.sanitizer.bypassSecurityTrustUrl(url);
+  }
+}
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 3deea11d5..2b418047a 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -66,8 +66,6 @@
                 <source type="video/mp4" [src]="'data:video/mp4;base64,' + seleted.Base64">
               </video>
 
-
-
             </div>
 
           </div>
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 1696a803b..f27414270 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -2,6 +2,7 @@ import { Injectable } from '@angular/core';
 import { ok, err, Result } from 'neverthrow';
 import { ObjectMergeNotification } from 'src/app/services/socket-connection-mcr.service';
 import { CMAPIService } from "src/app/shared/repository/CMAPI/cmapi.service"
+import { DomSanitizer } from '@angular/platform-browser';
 
 const objectMergeNotification  = new ObjectMergeNotification()
 
@@ -16,7 +17,12 @@ export type IOUploadError = "noConnection" |  "slow"
   providedIn: 'root'
 })
 export class UploadStreamingService {
-  constructor(    private CMAPIService: CMAPIService,) { }
+  constructor(
+    private CMAPIService: CMAPIService,
+    private sanitizer: DomSanitizer
+  ) {
+    window["sanitizer"] = this.sanitizer
+  }
 }
 
 class UploadFileUseCase {
@@ -109,6 +115,8 @@ export class PublicationAttachmentEntity {
   }
 
   fixFileBase64() {
+    //const  sanitizer : DomSanitizer = window["sanitizer"]
+
     if(this.FileType == 'image' ) {
       if(!this.Base64.startsWith('data:')) {
         this.url = 'data:image/jpg;base64,' + this.Base64

From da49dd680a4cd037212907107ad8c221fdd2e402 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Fri, 9 Feb 2024 10:33:53 +0100
Subject: [PATCH 10/16] fix commit to hub

---
 .../pages/publications/publications.page.ts   | 45 ++++++++++++++++---
 .../new-publication/new-publication.page.html | 10 +++++
 .../new-publication/new-publication.page.ts   |  6 +--
 .../publication-form-mv.service.spec.ts       | 16 +++++++
 .../upload/publication-form-mv.service.ts     |  9 ++++
 .../upload/upload-streaming.service.ts        | 10 ++---
 6 files changed, 81 insertions(+), 15 deletions(-)
 create mode 100644 src/app/shared/publication/upload/publication-form-mv.service.spec.ts
 create mode 100644 src/app/shared/publication/upload/publication-form-mv.service.ts

diff --git a/src/app/pages/publications/publications.page.ts b/src/app/pages/publications/publications.page.ts
index 7c0d4266f..39f73b349 100644
--- a/src/app/pages/publications/publications.page.ts
+++ b/src/app/pages/publications/publications.page.ts
@@ -238,6 +238,42 @@ export class PublicationsPage implements OnInit {
 
   async onFileSelect(event: any) {
 
+    const file:File = event.target.files[0];
+
+
+    const chunkSize = 1024 * 1024; // Adjust the chunk size as needed
+    const chunks = [];
+    let offset = 0;
+    let i = 0;
+    let j = 0;
+
+    function count () {
+      j++
+      return j
+    }
+
+    while (offset < file.size) {
+      const chunk = file.slice(offset, offset + chunkSize);
+      const reader = new FileReader();
+
+      reader.onload = async () => {
+
+        const headers = new HttpHeaders()
+        .append('X-File-Name', "fileName")
+        .append('X-File-Extension', "mp4")
+        .append('X-File-Content-Length', i.toString())
+        .append('X-File-Index', count().toString());
+
+        const a = new Uint8Array(reader.result as ArrayBuffer)
+        await this.http.post('http://localhost:3001/upload', a.buffer, { headers, responseType: 'blob' }).toPromise();
+
+
+      };
+      reader.readAsArrayBuffer(chunk);
+      offset += chunkSize;
+      i++;
+    }
+
 
 
   }
@@ -265,9 +301,6 @@ export class PublicationsPage implements OnInit {
     const loader = this.toastService.loading();
     try {
       await this.publications.DeletePresidentialAction(id).toPromise();
-      if(window["refreshPublication"]) {
-        window["refreshPublication"]();
-      }
       this.toastService._successMessage()
     } catch (error) {
       if(error.status == 0) {
@@ -316,7 +349,7 @@ export class PublicationsPage implements OnInit {
       componentProps: {
         publicationType: publicationType,
         folderId: folderId,
-        intent: intent
+        intent: window["sharedContent"]
       },
       cssClass: 'new-publication modal modal-desktop',
       backdropDismiss: false
@@ -329,8 +362,8 @@ export class PublicationsPage implements OnInit {
   }
 
   goToPublicationsList(folderId: string) {
-    if(this.intent){
-      this.AddPublication('2',folderId,this.intent)
+    if(window["sharedContent"]){
+      this.AddPublication('2',folderId,window["sharedContent"])
       return
     }
     if (window.innerWidth < 701) {
diff --git a/src/app/shared/publication/new-publication/new-publication.page.html b/src/app/shared/publication/new-publication/new-publication.page.html
index 2b418047a..507ae0b7f 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.html
+++ b/src/app/shared/publication/new-publication/new-publication.page.html
@@ -53,6 +53,16 @@
                 X
               </div>
 
+              <div *ngIf="checkFileType.checkFileType(seleted.FileExtension)  == 'video' && seleted.chucksManager">
+
+                <mat-progress-bar
+
+                  mode="determinate"
+                  [style.width]="seleted.chucksManager.uploadPercentage"
+                ></mat-progress-bar>
+
+              </div>
+
               <ion-img *ngIf="checkFileType.checkFileType(seleted.FileExtension) == 'image'"
                 name="image" ngDefaultControl [src]="seleted.url" style="height: 69px;"></ion-img>
 
diff --git a/src/app/shared/publication/new-publication/new-publication.page.ts b/src/app/shared/publication/new-publication/new-publication.page.ts
index bd1ee85d7..5a926db57 100644
--- a/src/app/shared/publication/new-publication/new-publication.page.ts
+++ b/src/app/shared/publication/new-publication/new-publication.page.ts
@@ -23,7 +23,7 @@ import { Filesystem, Directory, Encoding, FilesystemDirectory } from '@capacitor
 import { Platform } from '@ionic/angular';
 import { Capacitor } from '@capacitor/core';
 import { PublicationAttachmentEntity, PublicationFormMV } from '../upload/upload-streaming.service';
-
+import { PublicationFormMVService } from "src/app/shared/publication/upload/publication-form-mv.service"
 
 enum ActionType {
   newRapid = "1",
@@ -75,6 +75,7 @@ export class NewPublicationPage implements OnInit {
 
 
   constructor(
+    PublicationFormMVService: PublicationFormMVService,
     public photoService: PhotoService,
     private publications: PublicationsService,
     private toastService: ToastService,
@@ -452,8 +453,6 @@ export class NewPublicationPage implements OnInit {
               e.OriginalFileName = e.chucksManager.path.replace(".mp4", "")
               e.FileExtension = "mp4"
             }
-            this.publicationFormMV.ObjectMergeNotification.socket.commit(e.chucksManager.path)
-
             return e
           })
 
@@ -515,7 +514,6 @@ export class NewPublicationPage implements OnInit {
               e.Base64 = ""
             }
 
-            this.publicationFormMV.ObjectMergeNotification.socket.commit(e.chucksManager.path)
 
             return e
           })
diff --git a/src/app/shared/publication/upload/publication-form-mv.service.spec.ts b/src/app/shared/publication/upload/publication-form-mv.service.spec.ts
new file mode 100644
index 000000000..e29f538fa
--- /dev/null
+++ b/src/app/shared/publication/upload/publication-form-mv.service.spec.ts
@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { PublicationFormMVService } from './publication-form-mv.service';
+
+describe('PublicationFormMVService', () => {
+  let service: PublicationFormMVService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(PublicationFormMVService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});
diff --git a/src/app/shared/publication/upload/publication-form-mv.service.ts b/src/app/shared/publication/upload/publication-form-mv.service.ts
new file mode 100644
index 000000000..7fbeee014
--- /dev/null
+++ b/src/app/shared/publication/upload/publication-form-mv.service.ts
@@ -0,0 +1,9 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PublicationFormMVService {
+
+  constructor() { }
+}
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index f27414270..750dcf4f5 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -4,7 +4,7 @@ import { ObjectMergeNotification } from 'src/app/services/socket-connection-mcr.
 import { CMAPIService } from "src/app/shared/repository/CMAPI/cmapi.service"
 import { DomSanitizer } from '@angular/platform-browser';
 
-const objectMergeNotification  = new ObjectMergeNotification()
+
 
 export enum UploadError {
   noConnection = 'noConnection',
@@ -192,10 +192,10 @@ export class PublicationFormMV {
 
   private UploadFileUseCase = new UploadFileUseCase()
   private form = new PublicationFormModel()
-  ObjectMergeNotification = objectMergeNotification
+  ObjectMergeNotification =  new ObjectMergeNotification()
 
   constructor() {
-    this.ObjectMergeNotification.connect();
+    // this.ObjectMergeNotification.connect();
   }
 
   setDataToFrom(data: IPublicationFormModelEntity) {
@@ -218,11 +218,11 @@ export class PublicationFormMV {
         PublicationAttachmentEntity.setChunkManger(fileChunks)
 
         PublicationAttachmentEntity.chucksManager.registerOnLastChunk(() => {
+          this.ObjectMergeNotification.socket.commit(PublicationAttachmentEntity.chucksManager.path)
 
           const guid = PublicationAttachmentEntity.chucksManager.path
 
           this.ObjectMergeNotification.subscribe(guid, (data) => {
-            // console.log("data", data)
             PublicationAttachmentEntity
             resolve(true)
           })
@@ -437,7 +437,7 @@ export class ChucksManager {
   }
 
   registerOnLastChunk(a: Function) {
-    this.onSetPath.push(a)
+    this.onSetLastChunk.push(a)
   }
 
   registerToUseCaseResponse(a: Function) {

From c21802f30b56a5b94609ba6d5c25f7d17b499568 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Fri, 9 Feb 2024 10:57:41 +0100
Subject: [PATCH 11/16] add  sanitizer.bypassSecurityTrustUrl

---
 src/app/app.component.ts                                 | 9 ++++++---
 .../publication/upload/upload-streaming.service.ts       | 4 +++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/app/app.component.ts b/src/app/app.component.ts
index d2564ab3d..e66c38cba 100644
--- a/src/app/app.component.ts
+++ b/src/app/app.component.ts
@@ -11,6 +11,7 @@ import { environment } from 'src/environments/environment';
 import { Storage } from '@ionic/storage';
 import { ChatController } from './controller/chat';
 import { register } from 'swiper/element/bundle';
+import { DomSanitizer } from '@angular/platform-browser';
 
 const CUSTOM_DATE_FORMATS: NgxMatDateFormats = {
   parse: {
@@ -39,13 +40,15 @@ export class AppComponent {
       private statusBar: StatusBar,
       public ThemeService: ThemeService,
       private storage: Storage,
-      private ChatSystemService: ChatSystemService
+      private ChatSystemService: ChatSystemService,
+      private sanitizer: DomSanitizer
   ) {
 
+    window["sanitizer"] = this.sanitizer
     this.initializeApp();
     this.storage.set('version', environment.version).then(() => {})
     ChatController.ChatSystemService = this.ChatSystemService
-    
+
   }
 
 /*   requestPermission() {
@@ -70,7 +73,7 @@ export class AppComponent {
   initializeApp() {
     this.platform.ready().then(() => {
       this.statusBar.styleDefault();
-     
+
       if (this.platform.is("tablet")) {
         window.screen.orientation.unlock();
       } else if( this.platform.is("mobile")) {
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 750dcf4f5..571dfb6b3 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -115,17 +115,19 @@ export class PublicationAttachmentEntity {
   }
 
   fixFileBase64() {
-    //const  sanitizer : DomSanitizer = window["sanitizer"]
+    const  sanitizer : DomSanitizer = window["sanitizer"]
 
     if(this.FileType == 'image' ) {
       if(!this.Base64.startsWith('data:')) {
         this.url = 'data:image/jpg;base64,' + this.Base64
+        // this.url =  sanitizer.bypassSecurityTrustUrl('data:image/jpg;base64,' + this.Base64) as any
       } else {
         this.url =  this.Base64
       }
     } else if (this.FileType == 'video' ) {
       if(!this.Base64.startsWith('data:') && !this.Base64.startsWith('http')) {
         this.url = 'data:video/mp4;base64,' + this.Base64
+        // this.url = sanitizer.bypassSecurityTrustUrl('data:video/mp4;base64,' + this.Base64) as any
       } else {
         this.url = this.Base64
       }

From 8dd02b391fbc263524504494e447aeda058c3e5b Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Fri, 9 Feb 2024 11:26:33 +0100
Subject: [PATCH 12/16] new way to invoke merge

---
 .../services/socket-connection-mcr.service.ts | 14 ++++++++++---
 .../upload/upload-streaming.service.ts        | 21 +++++++------------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/app/services/socket-connection-mcr.service.ts b/src/app/services/socket-connection-mcr.service.ts
index 79487258a..4dbd9ac16 100644
--- a/src/app/services/socket-connection-mcr.service.ts
+++ b/src/app/services/socket-connection-mcr.service.ts
@@ -5,7 +5,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { HttpClient, HttpHeaders, HttpEventType } from '@angular/common/http';
 import { CMAPIService } from '../shared/repository/CMAPI/cmapi.service';
 import { HubConnectionBuilder } from '@microsoft/signalr';
-
+import { ok, err, Result } from 'neverthrow';
 @Injectable({
   providedIn: 'root'
 })
@@ -125,8 +125,16 @@ class ReconnectingWebSocketSignalR {
     });
   }
 
-  commit(path) {
-    this.connection.invoke("CommitUpload", path).catch(err => console.error(err.toString()));
+  commit(path): Promise<Result<true, false>>  {
+    return new Promise((resolve, reject) => {
+      this.connection.invoke("CommitUpload", path).then((e) => {
+        console.log("commit message", e)
+        resolve(ok(true))
+      }).catch(err => {
+        resolve(err(false))
+        console.error(err.toString())
+      });
+    })
   }
 
   disconnect() {
diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 571dfb6b3..352e92c30 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -214,22 +214,11 @@ export class PublicationFormMV {
 
       if(!PublicationAttachmentEntity.hasChunkManger) {
         const fileBlob = PublicationAttachmentEntity.blobFile;
-        const fileChunks = new Chunks({chunkSize: 1024 })
+        const fileChunks = new Chunks({chunkSize: 40 })
         fileChunks.setFile(fileBlob)
 
         PublicationAttachmentEntity.setChunkManger(fileChunks)
 
-        PublicationAttachmentEntity.chucksManager.registerOnLastChunk(() => {
-          this.ObjectMergeNotification.socket.commit(PublicationAttachmentEntity.chucksManager.path)
-
-          const guid = PublicationAttachmentEntity.chucksManager.path
-
-          this.ObjectMergeNotification.subscribe(guid, (data) => {
-            PublicationAttachmentEntity
-            resolve(true)
-          })
-        })
-
       } else if(PublicationAttachmentEntity.chucksManager.doneUpload) {
         return resolve(true)
       }
@@ -250,11 +239,17 @@ export class PublicationFormMV {
         } while (attemp<3 && result.isErr() && result?.error == 'slow')
 
         PublicationAttachmentEntity.chucksManager.setManualRetry()
-        PublicationAttachmentEntity.chucksManager.doneChunkUpload()
 
         if(result.isErr()) {
           resolve(false)
         } else {
+          const guid = PublicationAttachmentEntity.chucksManager.path
+          this.ObjectMergeNotification.subscribe(guid, (data) => {
+            PublicationAttachmentEntity
+            resolve(true)
+          })
+          PublicationAttachmentEntity.chucksManager.doneChunkUpload()
+          this.ObjectMergeNotification.socket.commit(PublicationAttachmentEntity.chucksManager.path)
           resolve(true)
         }
 

From 46fa354542823078ff315b981ef2ea29da074bd7 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 15 Feb 2024 23:18:51 +0100
Subject: [PATCH 13/16] fix return error if chunk failed to upload

---
 .../publication/upload/upload-streaming.service.ts   | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 352e92c30..a8fabe0da 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -70,13 +70,23 @@ class UploadFileUseCase {
       let connection = true
       let errorMessage: UploadError.noConnection |  UploadError.slow
 
-      for (let index = 1;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks)  ); index++) {
+      for (let index = 1;  ( (index <= PublicationAttachmentEntity.chucksManager.chunks.totalChunks) && connection ); index++) {
         const needUpload = PublicationAttachmentEntity.chucksManager.needToUploadChunkIndex(index)
 
         if(needUpload) {
 
           const request = readAndUploadChunk(index).then(async(uploadRequest) => {
 
+            if(uploadRequest.isErr()) {
+              connection = false
+              const pingRequest = await this.CMAPIService.ping()
+              if( pingRequest.isErr()) {
+                errorMessage = UploadError.noConnection
+              } else {
+                errorMessage = UploadError.slow
+              }
+            }
+
           })
           allRequest.push(request)
         }

From 00a638b208b664d4b3ec46fd1050f8e3f486fa8e Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 15 Feb 2024 23:35:12 +0100
Subject: [PATCH 14/16] set manual retry only then chunk upload fails

---
 src/app/shared/publication/upload/upload-streaming.service.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index a8fabe0da..e90625d5e 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -248,9 +248,9 @@ export class PublicationFormMV {
 
         } while (attemp<3 && result.isErr() && result?.error == 'slow')
 
-        PublicationAttachmentEntity.chucksManager.setManualRetry()
 
         if(result.isErr()) {
+          PublicationAttachmentEntity.chucksManager.setManualRetry()
           resolve(false)
         } else {
           const guid = PublicationAttachmentEntity.chucksManager.path

From be7b9f3875e201822cda1b4eaafafd16a5d5bb3c Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Thu, 15 Feb 2024 23:44:57 +0100
Subject: [PATCH 15/16] add done mergin

---
 src/app/shared/publication/upload/upload-streaming.service.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index e90625d5e..99698bb29 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -246,7 +246,7 @@ export class PublicationFormMV {
           result = await this.UploadFileUseCase.execute(PublicationAttachmentEntity)
           PublicationAttachmentEntity.chucksManager.clearUploading()
 
-        } while (attemp<3 && result.isErr() && result?.error == 'slow')
+        } while (attemp<3 && result.isErr() && result.error == 'slow')
 
 
         if(result.isErr()) {
@@ -255,7 +255,7 @@ export class PublicationFormMV {
         } else {
           const guid = PublicationAttachmentEntity.chucksManager.path
           this.ObjectMergeNotification.subscribe(guid, (data) => {
-            PublicationAttachmentEntity
+            PublicationAttachmentEntity.chucksManager.contentSetReady()
             resolve(true)
           })
           PublicationAttachmentEntity.chucksManager.doneChunkUpload()

From 213f32023c67012c6508a90d1baa0b6939e45b16 Mon Sep 17 00:00:00 2001
From: Peter Maquiran <peter.maquiran@equilibrium.local>
Date: Fri, 16 Feb 2024 10:55:29 +0100
Subject: [PATCH 16/16] chunk upload setting change, upload chunk one by one

---
 .../upload/upload-streaming.service.ts        | 38 +++++++++++++------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/app/shared/publication/upload/upload-streaming.service.ts b/src/app/shared/publication/upload/upload-streaming.service.ts
index 99698bb29..555741778 100644
--- a/src/app/shared/publication/upload/upload-streaming.service.ts
+++ b/src/app/shared/publication/upload/upload-streaming.service.ts
@@ -75,20 +75,36 @@ class UploadFileUseCase {
 
         if(needUpload) {
 
-          const request = readAndUploadChunk(index).then(async(uploadRequest) => {
+          // upload every chunk at onces
+          // const request = readAndUploadChunk(index).then(async(uploadRequest) => {
 
-            if(uploadRequest.isErr()) {
-              connection = false
-              const pingRequest = await this.CMAPIService.ping()
-              if( pingRequest.isErr()) {
-                errorMessage = UploadError.noConnection
-              } else {
-                errorMessage = UploadError.slow
-              }
-            }
+          //   if(uploadRequest.isErr()) {
+          //     connection = false
+          //     const pingRequest = await this.CMAPIService.ping()
+          //     if( pingRequest.isErr()) {
+          //       errorMessage = UploadError.noConnection
+          //     } else {
+          //       errorMessage = UploadError.slow
+          //     }
+          //   }
 
-          })
+          // })
+          // allRequest.push(request)
+
+          // one by one chunk upload
+          const request = readAndUploadChunk(index)
           allRequest.push(request)
+          const uploadRequest = await request
+
+          if(uploadRequest.isErr()) {
+            const pingRequest = await this.CMAPIService.ping()
+            if( pingRequest.isErr()) {
+              return resolve(err(UploadError.noConnection))
+            } else {
+              return resolve(err(UploadError.slow))
+            }
+          }
+
         }
       }