mirror of
https://code.equilibrium.co.ao/ITO/doneit-web.git
synced 2026-04-18 20:47:54 +00:00
Peter Maquiran
1491 lines
49 KiB
TypeScript
1491 lines
49 KiB
TypeScript
import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';
|
|
import { PublicationsService } from 'src/app/services/publications.service';
|
|
import { Publication } from 'src/app/models/publication';
|
|
import { PhotoService } from 'src/app/services/photo.service';
|
|
import { ToastService } from 'src/app/services/toast.service';
|
|
import { FormControl, FormGroup, Validators } from '@angular/forms';
|
|
import { ThemeService } from 'src/app/services/theme.service';
|
|
import { Camera, CameraResultType, CameraSource } from '@capacitor/camera';
|
|
import { HttpErrorHandle } from 'src/app/services/http-error-handle.service';
|
|
import { PublicationFolderService } from 'src/app/store/publication-folder.service';
|
|
import { FilePicker } from '@capawesome/capacitor-file-picker';
|
|
import { checkFileTypeService } from 'src/app/services/checkFileType.service';
|
|
import { FileValidatorService } from "src/app/services/file/file-validator.service";
|
|
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 { ObjectMergeNotification, SocketConnectionMCRService } from "src/app/services/socket-connection-mcr.service"
|
|
import { CMAPIService } from '../../repository/CMAPI/cmapi.service';
|
|
import { environment } from 'src/environments/environment';
|
|
import { CaptureError, CaptureImageOptions, MediaCapture, MediaFile } from '@awesome-cordova-plugins/media-capture/ngx';
|
|
import { Filesystem, Directory, Encoding, FilesystemDirectory } from '@capacitor/filesystem';
|
|
import { Platform } from '@ionic/angular';
|
|
import { Capacitor } from '@capacitor/core';
|
|
|
|
|
|
enum ActionType {
|
|
newRapid = "1",
|
|
new = "2",
|
|
edit = "3"
|
|
}
|
|
|
|
@Component({
|
|
selector: 'app-new-publication',
|
|
templateUrl: './new-publication.page.html',
|
|
styleUrls: ['./new-publication.page.scss'],
|
|
})
|
|
export class NewPublicationPage implements OnInit {
|
|
showLoader: boolean;
|
|
pub: Publication = new Publication();
|
|
|
|
publicationTitle: string;
|
|
imgUrl: any;
|
|
|
|
Defaultimage: any = '';
|
|
|
|
Form: FormGroup;
|
|
validateFrom = false
|
|
|
|
@Input() publication!: Publication;
|
|
@Input() publicationType: string;
|
|
@Input() folderId: string;
|
|
@Input() documentId: string;
|
|
|
|
@Output() closeDesktopComponent = new EventEmitter<any>();
|
|
@Output() openPublicationDetails = new EventEmitter<any>();
|
|
@Output() goBackToViewPublications = new EventEmitter<any>();
|
|
@Output() goBacktoPublicationDetails = new EventEmitter<any>();
|
|
|
|
guestPicture: any;
|
|
|
|
capturedImage: any = '';
|
|
capturedImageTitle: any = '';
|
|
fileType: string;
|
|
filecontent: boolean;
|
|
captureContent: any;
|
|
seletedContent: PublicationAttachmentEntity[] = []
|
|
displayLimit = 4;
|
|
filesSizeSum = 0;
|
|
photoOrVideo: boolean = false;
|
|
video: any;
|
|
|
|
|
|
publicationFormMV = new PublicationFormMV()
|
|
|
|
constructor(
|
|
public photoService: PhotoService,
|
|
private publications: PublicationsService,
|
|
private toastService: ToastService,
|
|
public ThemeService: ThemeService,
|
|
private httpErroHandle: HttpErrorHandle,
|
|
public PublicationFolderService: PublicationFolderService,
|
|
public checkFileType: checkFileTypeService,
|
|
private FileValidatorService: FileValidatorService,
|
|
private MiddlewareServiceService: MiddlewareServiceService,
|
|
private LakefsRepositoryService: LakefsRepositoryService,
|
|
private SocketConnectionMCRService: SocketConnectionMCRService,
|
|
private CMAPIService: CMAPIService,
|
|
private mediaCapture: MediaCapture,
|
|
private httpErrorHandle: HttpErrorHandle,
|
|
private platform: Platform,
|
|
) {
|
|
this.publicationTitle = 'Nova Publicação';
|
|
|
|
if (this.publication) {
|
|
this.seletedContent = this.publication.Files;
|
|
this.filecontent = true;
|
|
}
|
|
|
|
this.SocketConnectionMCRService.connect()
|
|
}
|
|
|
|
ngOnInit() {
|
|
|
|
this.publication = {
|
|
DateIndex: "",
|
|
DocumentId: 0,
|
|
ProcessId: "",
|
|
Title: "",
|
|
Message: "",
|
|
DatePublication: "",
|
|
Files: [],
|
|
OriginalFileName: "",
|
|
}
|
|
this.pub = this.publication;
|
|
|
|
this.setTitle();
|
|
this.setData()
|
|
}
|
|
|
|
setData() {
|
|
if (!this.publicationType) {
|
|
setTimeout(() => {
|
|
this.setData()
|
|
}, 500)
|
|
} else {
|
|
// this.pub = this.publication
|
|
// this.publication = null
|
|
this.getPublicationDetail()
|
|
}
|
|
}
|
|
|
|
getPublicationDetail() {
|
|
console.log('edit 1', this.publicationType)
|
|
if (this.publicationType != ActionType.new) {
|
|
this.showLoader = true;
|
|
this.publications.GetPublicationWithArrayOfFilesById(this.documentId).subscribe(res => {
|
|
this.publication = {
|
|
DateIndex: res.DateIndex,
|
|
DocumentId: res.DocumentId,
|
|
ProcessId: res.ProcessId,
|
|
Title: res.Title,
|
|
Message: res.Message,
|
|
DatePublication: res.DatePublication,
|
|
Files: res.Files,
|
|
OriginalFileName: res.OriginalFileName,
|
|
FileExtension: res.FileExtension,
|
|
}
|
|
console.log('edit', this.publication)
|
|
this.pub = this.publication;
|
|
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)
|
|
}
|
|
)
|
|
})
|
|
this.showLoader = false;
|
|
}, (error) => {
|
|
console.log(error)
|
|
this.showLoader = false;
|
|
this.goBack()
|
|
});
|
|
}
|
|
}
|
|
|
|
async takePicture() {
|
|
const capturedImage = await Camera.getPhoto({
|
|
quality: 50,
|
|
// allowEditing: true,
|
|
resultType: CameraResultType.Base64,
|
|
source: CameraSource.Camera
|
|
});
|
|
|
|
this.capturedImage = 'data:image/jpeg;base64,' + capturedImage.base64String;
|
|
this.capturedImageTitle = 'foto';
|
|
|
|
/* if(validation.isOk) { */
|
|
const compressedImage = await this.compressImageBase64(
|
|
this.capturedImage,
|
|
800, // maxWidth
|
|
800, // maxHeight
|
|
0.9 // quality
|
|
).then((picture) => {
|
|
this.photoOrVideo = false;
|
|
let fileObject = {
|
|
FileBase64: picture,
|
|
FileExtension: this.removeTextBeforeSlash('jpeg', '/'),
|
|
OriginalFileName: 'imagem'
|
|
}
|
|
|
|
const FileExtension = this.removeTextBeforeSlash('jpeg', '/')
|
|
|
|
const newAttachment = new PublicationAttachmentEntity(
|
|
{
|
|
base64: picture,
|
|
extension: FileExtension,
|
|
OriginalFileName: "foto",
|
|
FileType: 'image'
|
|
}
|
|
)
|
|
|
|
newAttachment.needUpload()
|
|
|
|
this.seletedContent.push(newAttachment)
|
|
|
|
});
|
|
/* } else {
|
|
this.toastService._badRequest("Imagem inválida")
|
|
} */
|
|
}
|
|
|
|
async laodPicture() {
|
|
const capturedImage = await Camera.getPhoto({
|
|
quality: 90,
|
|
resultType: CameraResultType.Base64,
|
|
source: CameraSource.Photos
|
|
});
|
|
|
|
this.fileType = capturedImage.format
|
|
console.log(this.fileType)
|
|
this.capturedImage = 'data:image/jpeg;base64,' + capturedImage.base64String;
|
|
this.capturedImageTitle = 'foto';
|
|
|
|
const compressedImage = await this.compressImageBase64(
|
|
this.capturedImage,
|
|
800, // maxWidth
|
|
800, // maxHeight
|
|
0.9 // quality
|
|
).then((picture) => {
|
|
let fileObject = {
|
|
FileBase64: picture,
|
|
FileExtension: this.removeTextBeforeSlash('jpeg', '/'),
|
|
OriginalFileName: 'image'
|
|
}
|
|
|
|
const FileExtension = this.removeTextBeforeSlash('jpeg', '/')
|
|
|
|
const newAttachment = new PublicationAttachmentEntity(
|
|
{
|
|
base64: picture,
|
|
extension: FileExtension,
|
|
OriginalFileName: "foto",
|
|
FileType: 'image'
|
|
}
|
|
)
|
|
|
|
newAttachment.needUpload();
|
|
this.seletedContent.push(newAttachment)
|
|
});
|
|
|
|
}
|
|
|
|
async loadVideo() {
|
|
|
|
const result = await FilePicker.pickMedia
|
|
({
|
|
multiple: true,
|
|
});
|
|
|
|
console.log(result)
|
|
|
|
result.files.forEach(async blobFile => {
|
|
console.log(blobFile)
|
|
if (this.checkFileType.checkFileType(blobFile.mimeType) == 'image' || this.checkFileType.checkFileType(blobFile.mimeType) == 'video') {
|
|
/* console.log('converte new way',this.getBase64(blobFile)) */
|
|
|
|
/* const blob = await fetch(
|
|
Capacitor.convertFileSrc(blobFile.path)
|
|
).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) => {
|
|
|
|
console.log(value)
|
|
|
|
this.filesSizeSum = this.filesSizeSum + blobFile.size
|
|
if (this.fileSizeToMB(this.filesSizeSum) <= 20) {
|
|
|
|
const FileExtension = this.removeTextBeforeSlash(blobFile.mimeType, '/')
|
|
|
|
const file = new File([blobFile.blob], blobFile.name);
|
|
|
|
const newAttachment = new PublicationAttachmentEntity(
|
|
{
|
|
base64: value,
|
|
extension: FileExtension,
|
|
blobFile: file,
|
|
FileType: this.checkFileType.checkFileType(FileExtension)
|
|
}
|
|
)
|
|
|
|
newAttachment.needUpload()
|
|
|
|
this.seletedContent.push(newAttachment)
|
|
console.log(this.seletedContent)
|
|
this.filecontent = true;
|
|
} else {
|
|
if (this.seletedContent.length === 0)
|
|
this.filesSizeSum = 0
|
|
|
|
this.httpErroHandle.validationMessagge('filessize');
|
|
}
|
|
}).catch((erro) => {
|
|
console.log(erro)
|
|
})
|
|
} else {
|
|
this.httpErroHandle.validationMessagge('filetype');
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
/* this.capturedImage = 'data:image/jpeg;base64,' +capturedImage.base64String;
|
|
this.capturedImageTitle = 'foto';
|
|
|
|
|
|
const validation = await this.FileValidatorService.ValidateImage(this.capturedImage)
|
|
|
|
if(validation.isOk) {
|
|
|
|
const compressedImage = await this.compressImageBase64(
|
|
this.capturedImage,
|
|
800, // maxWidth
|
|
800, // maxHeight
|
|
0.9 // quality
|
|
).then((picture) => {
|
|
console.log('Selected: ', picture)
|
|
this.capturedImage = picture
|
|
});
|
|
} else {
|
|
this.toastService._badRequest("Imagem inválida")
|
|
} */
|
|
|
|
};
|
|
|
|
async loadVideoTablet() {
|
|
|
|
const result = await FilePicker.pickMedia
|
|
({
|
|
multiple: true,
|
|
});
|
|
console.log(result.files)
|
|
result.files.forEach(element => {
|
|
|
|
this.filesSizeSum = this.filesSizeSum + element.size
|
|
if (this.fileSizeToMB(this.filesSizeSum) <= 20) {
|
|
if (this.checkFileType.checkFileType(element.mimeType) == 'image' || this.checkFileType.checkFileType(element.mimeType) == 'video') {
|
|
let resultUrl = decodeURIComponent(element.path);
|
|
try {
|
|
Filesystem.readFile({ path: resultUrl })
|
|
|
|
.then(async (content) => {
|
|
console.log(result)
|
|
console.log('load video tablet base64',content)
|
|
this.filecontent = true;
|
|
let fileObject = new PublicationAttachmentEntity ({
|
|
base64: content.data,
|
|
extension: this.removeTextBeforeSlash(element.mimeType, '/'),
|
|
OriginalFileName: 'video',
|
|
FileType: this.checkFileType.checkFileType( this.removeTextBeforeSlash(element.mimeType, '/'))
|
|
})
|
|
this.seletedContent.push(fileObject)
|
|
})
|
|
.catch((err) => console.error(err));
|
|
} catch (error) {
|
|
console.log('upload video error: ', error)
|
|
}
|
|
|
|
}
|
|
} else {
|
|
if (this.seletedContent.length === 0)
|
|
this.filesSizeSum = 0
|
|
|
|
this.httpErrorHandle.validationMessagge('filessize')
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
runValidation() {
|
|
this.validateFrom = true
|
|
}
|
|
|
|
injectValidation() {
|
|
|
|
this.Form = new FormGroup({
|
|
Subject: new FormControl(this.pub.Title, [
|
|
Validators.required,
|
|
// Validators.minLength(4)
|
|
]),
|
|
Message: new FormControl(this.pub.Message, [
|
|
Validators.required,
|
|
Validators.maxLength(1000)
|
|
])
|
|
})
|
|
}
|
|
|
|
|
|
async save() {
|
|
|
|
this.injectValidation()
|
|
this.runValidation()
|
|
|
|
if (this.Form.invalid) {
|
|
return false
|
|
} else {
|
|
|
|
}
|
|
|
|
|
|
if (this.seletedContent.length == 0) {
|
|
|
|
const newAttachment = new PublicationAttachmentEntity(
|
|
{
|
|
base64: "data:image/png;base64,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",
|
|
extension: "png",
|
|
OriginalFileName: "foto",
|
|
FileType: 'image'
|
|
}
|
|
)
|
|
|
|
this.seletedContent.push(newAttachment)
|
|
}
|
|
|
|
|
|
if (this.publicationType == ActionType.edit) {
|
|
|
|
|
|
|
|
if (this.seletedContent.length >= 1) {
|
|
const loader = this.toastService.loading()
|
|
|
|
this.publication = {
|
|
DateIndex: this.publication.DateIndex,
|
|
DocumentId: this.publication.DocumentId,
|
|
ProcessId: this.publication.ProcessId,
|
|
Title: this.pub.Title,
|
|
Message: this.pub.Message,
|
|
DatePublication: this.publication.DatePublication,
|
|
Files: this.seletedContent,
|
|
}
|
|
|
|
|
|
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,
|
|
OriginalFileName: 'foto'
|
|
}))
|
|
|
|
try {
|
|
|
|
const response = await this.publications.UpdatePublication(this.publication.ProcessId, this.publication).toPromise()
|
|
|
|
this.httpErroHandle.httpsSucessMessagge('Editar publicação')
|
|
|
|
this.goBack();
|
|
|
|
} catch (error) {
|
|
this.httpErroHandle.httpStatusHandle(error)
|
|
if (error.status == 404) {
|
|
this.PublicationFolderService.deletePost(this.publication.ProcessId, this.publication.DocumentId)
|
|
this.goBack();
|
|
}
|
|
} finally {
|
|
loader.remove()
|
|
}
|
|
|
|
|
|
} else {
|
|
this.toastService._badRequest("É necessário adicionar uma imagem ou vídeo")
|
|
}
|
|
|
|
|
|
}
|
|
else {
|
|
let time = new Date()
|
|
if (this.seletedContent.length >= 1) {
|
|
this.publication = {
|
|
DateIndex: time,
|
|
DocumentId: null,
|
|
ProcessId: this.folderId,
|
|
Title: this.pub.Title,
|
|
Message: this.pub.Message,
|
|
DatePublication: time,
|
|
OriginalFileName: this.capturedImageTitle || 'foto',
|
|
Files: this.seletedContent,
|
|
}
|
|
|
|
|
|
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,
|
|
OriginalFileName: 'foto'
|
|
}))
|
|
|
|
|
|
|
|
|
|
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()
|
|
}
|
|
|
|
|
|
} else {
|
|
this.toastService._badRequest("É necessário adicionar uma imagem ou vídeo")
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
close() {
|
|
this.goBack();
|
|
}
|
|
|
|
clear() {
|
|
this.capturedImageTitle = '';
|
|
this.seletedContent = [];
|
|
}
|
|
|
|
deletePublicationImage() {
|
|
|
|
this.publication.Files = []
|
|
}
|
|
|
|
setTitle() {
|
|
if (this.publicationType == ActionType.newRapid) {
|
|
this.publicationTitle = 'Nova Publicação Rápida';
|
|
}
|
|
else if (this.publicationType == ActionType.new) {
|
|
this.publicationTitle = 'Nova Publicação';
|
|
}
|
|
else if (this.publicationType == ActionType.edit) {
|
|
this.publicationTitle = 'Editar Publicação';
|
|
this.pub = this.publication;
|
|
}
|
|
}
|
|
|
|
async goBack() {
|
|
|
|
if (this.publicationType == ActionType.new) {
|
|
this.goBackToViewPublications.emit();
|
|
} else {
|
|
this.goBackToViewPublications.emit();
|
|
//this.goBacktoPublicationDetails.emit();
|
|
}
|
|
|
|
}
|
|
|
|
async compressImageBase64(base64String: string, maxWidth: number, maxHeight: number, quality: number): Promise<string> {
|
|
return new Promise((resolve, reject) => {
|
|
const image = new (window as any).Image();
|
|
image.src = base64String;
|
|
|
|
image.onload = async () => {
|
|
const canvas = document.createElement('canvas');
|
|
let newWidth = image.width;
|
|
let newHeight = image.height;
|
|
|
|
if (newWidth > maxWidth) {
|
|
newHeight *= maxWidth / newWidth;
|
|
newWidth = maxWidth;
|
|
}
|
|
|
|
if (newHeight > maxHeight) {
|
|
newWidth *= maxHeight / newHeight;
|
|
newHeight = maxHeight;
|
|
}
|
|
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
|
|
const context = canvas.getContext('2d');
|
|
context?.drawImage(image, 0, 0, newWidth, newHeight);
|
|
|
|
const compressedBase64 = canvas.toDataURL('image/jpeg', quality);
|
|
resolve(compressedBase64);
|
|
};
|
|
|
|
image.onerror = (error) => {
|
|
reject(error);
|
|
};
|
|
});
|
|
}
|
|
|
|
convertBlobToBase64(blob: Blob) {
|
|
console.log('Convert blob ',blob)
|
|
return new Promise((resolve, reject) => {
|
|
const reader = new FileReader;
|
|
reader.onerror = reject;
|
|
reader.onload = () => {
|
|
resolve(reader.result)
|
|
}
|
|
reader.readAsDataURL(blob)
|
|
},)
|
|
}
|
|
|
|
getBase64(file) {
|
|
return new Promise((resolve, reject) => {
|
|
const reader = new FileReader();
|
|
reader.readAsDataURL(file);
|
|
reader.onload = () => resolve(reader.result);
|
|
reader.onerror = error => reject(error);
|
|
});
|
|
}
|
|
|
|
removeTextBeforeSlash(inputString, mark) {
|
|
if (inputString.includes(mark)) {
|
|
const parts = inputString.split(mark);
|
|
return parts.length > 1 ? parts[1] : inputString;
|
|
} else {
|
|
return inputString;
|
|
}
|
|
}
|
|
|
|
async compressVideoBase64(base64String: string, maxWidth: number, maxHeight: number, quality: number): Promise<string> {
|
|
console.log(base64String)
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
// Decode the base64 video string to an ArrayBuffer
|
|
const trimmedBase64 = base64String.trim();
|
|
const videoBuffer = this.base64ToArrayBuffer(this.removeTextBeforeSlash(trimmedBase64, ','));
|
|
|
|
// Create a Blob from the ArrayBuffer
|
|
const videoBlob = new Blob([videoBuffer], { type: 'video/mp4' });
|
|
|
|
// Create an object URL from the Blob
|
|
const videoObjectUrl = URL.createObjectURL(videoBlob);
|
|
|
|
// Create a video element
|
|
const video = document.createElement('video');
|
|
video.src = videoObjectUrl;
|
|
|
|
// Wait for the video to load metadata
|
|
video.addEventListener('loadedmetadata', async () => {
|
|
const canvas = document.createElement('canvas');
|
|
let newWidth = video.videoWidth;
|
|
let newHeight = video.videoHeight;
|
|
|
|
if (newWidth > maxWidth) {
|
|
newHeight *= maxWidth / newWidth;
|
|
newWidth = maxWidth;
|
|
}
|
|
|
|
if (newHeight > maxHeight) {
|
|
newWidth *= maxHeight / newHeight;
|
|
newHeight = maxHeight;
|
|
}
|
|
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
|
|
const context = canvas.getContext('2d');
|
|
|
|
// Start continuous rendering
|
|
function render() {
|
|
context?.drawImage(video, 0, 0, newWidth, newHeight);
|
|
requestAnimationFrame(render);
|
|
}
|
|
|
|
render();
|
|
|
|
// Convert the canvas to a Blob
|
|
canvas.toBlob(async (blob) => {
|
|
if (blob) {
|
|
// Read the Blob as an ArrayBuffer
|
|
const compressedVideoBuffer = await this.readBlobAsArrayBuffer(blob);
|
|
|
|
// Convert the ArrayBuffer back to base64
|
|
const compressedBase64 = this.arrayBufferToBase64(compressedVideoBuffer);
|
|
|
|
resolve(compressedBase64);
|
|
} else {
|
|
reject('Error creating compressed video blob.');
|
|
}
|
|
}, 'video/mp4', 0.5);
|
|
});
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
/* async compressVideoBase64(base64String: string, maxWidth: number, maxHeight: number, quality: number): Promise<string> {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
// Decode the base64 video string to an ArrayBuffer
|
|
const videoBuffer = this.base64ToArrayBuffer(this.removeTextBeforeSlash(base64String,','));
|
|
|
|
// Create a Blob from the ArrayBuffer
|
|
const videoBlob = new Blob([videoBuffer], { type: 'video/mp4' });
|
|
|
|
// Create an object URL from the Blob
|
|
const videoObjectUrl = URL.createObjectURL(videoBlob);
|
|
|
|
// Create a video element
|
|
const video = document.createElement('video');
|
|
|
|
// Create a source element and set its type attribute
|
|
const source = document.createElement('source');
|
|
source.type = 'video/mp4';
|
|
|
|
// Set the source URL
|
|
source.src = videoObjectUrl;
|
|
|
|
// Append the source element to the video element
|
|
video.appendChild(source);
|
|
|
|
// Wait for the video to load
|
|
video.addEventListener('loadedmetadata', async () => {
|
|
const canvas = document.createElement('canvas');
|
|
let newWidth = video.videoWidth;
|
|
let newHeight = video.videoHeight;
|
|
|
|
if (newWidth > maxWidth) {
|
|
newHeight *= maxWidth / newWidth;
|
|
newWidth = maxWidth;
|
|
}
|
|
|
|
if (newHeight > maxHeight) {
|
|
newWidth *= maxHeight / newHeight;
|
|
newHeight = maxHeight;
|
|
}
|
|
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
|
|
const context = canvas.getContext('2d');
|
|
|
|
// Create a function to draw each video frame onto the canvas
|
|
const drawFrame = () => {
|
|
context?.drawImage(video, 0, 0, newWidth, newHeight);
|
|
|
|
// Convert the canvas to a Blob with the correct MIME type
|
|
canvas.toBlob(async (blob) => {
|
|
if (blob) {
|
|
// Read the Blob as an ArrayBuffer
|
|
const compressedVideoBuffer = await this.readBlobAsArrayBuffer(blob);
|
|
|
|
// Convert the ArrayBuffer back to base64
|
|
const compressedBase64 = this.arrayBufferToBase64(compressedVideoBuffer);
|
|
|
|
resolve(compressedBase64);
|
|
} else {
|
|
reject('Error creating compressed video blob.');
|
|
}
|
|
}, 'video/mp4', quality);
|
|
|
|
// Request the next video frame
|
|
requestAnimationFrame(drawFrame);
|
|
};
|
|
|
|
// Start drawing frames
|
|
drawFrame();
|
|
|
|
// Start playing the video
|
|
video.play();
|
|
});
|
|
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
} */
|
|
|
|
|
|
|
|
|
|
/* async compressVideoBase64(base64String: string, maxWidth: number, maxHeight: number, quality: number): Promise<string> {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
// Decode the base64 video string to an ArrayBuffer
|
|
const videoBuffer = this.base64ToArrayBuffer(this.removeTextBeforeSlash(base64String,','));
|
|
|
|
// Create a Blob from the ArrayBuffer
|
|
const videoBlob = new Blob([videoBuffer], { type: 'video/mp4' });
|
|
|
|
// Create an object URL from the Blob
|
|
const videoObjectUrl = URL.createObjectURL(videoBlob);
|
|
|
|
// Create a video element
|
|
const video = document.createElement('video');
|
|
video.src = videoObjectUrl;
|
|
|
|
// Wait for the video to load metadata
|
|
video.addEventListener('loadedmetadata', async () => {
|
|
const canvas = document.createElement('canvas');
|
|
let newWidth = video.videoWidth;
|
|
let newHeight = video.videoHeight;
|
|
|
|
if (newWidth > maxWidth) {
|
|
newHeight *= maxWidth / newWidth;
|
|
newWidth = maxWidth;
|
|
}
|
|
|
|
if (newHeight > maxHeight) {
|
|
newWidth *= maxHeight / newHeight;
|
|
newHeight = maxHeight;
|
|
}
|
|
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
|
|
const context = canvas.getContext('2d');
|
|
context?.drawImage(video, 0, 0, newWidth, newHeight);
|
|
|
|
// Convert the canvas to a Blob with the correct MIME type
|
|
canvas.toBlob(async (blob) => {
|
|
if (blob) {
|
|
// Read the Blob as an ArrayBuffer
|
|
const compressedVideoBuffer = await this.readBlobAsArrayBuffer(blob);
|
|
|
|
// Convert the ArrayBuffer back to base64
|
|
const compressedBase64 = this.arrayBufferToBase64(compressedVideoBuffer);
|
|
|
|
resolve(compressedBase64);
|
|
} else {
|
|
reject('Error creating compressed video blob.');
|
|
}
|
|
}, 'video/mp4', quality);
|
|
|
|
});
|
|
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
} */
|
|
|
|
|
|
/* async compressVideoBase64(base64String: string, maxWidth: number, maxHeight: number, quality: number): Promise<string> {
|
|
return new Promise(async (resolve, reject) => {
|
|
try {
|
|
// Decode the base64 video string to an ArrayBuffer
|
|
|
|
const trimmedBase64 = base64String.trim();
|
|
console.log(this.removeTextBeforeSlash(trimmedBase64,','))
|
|
const videoBuffer = this.base64ToArrayBuffer(this.removeTextBeforeSlash(trimmedBase64,','));
|
|
|
|
// Create a Blob from the ArrayBuffer
|
|
const videoBlob = new Blob([videoBuffer], { type: 'video/mp4' });
|
|
|
|
// Create an object URL from the Blob
|
|
const videoObjectUrl = URL.createObjectURL(videoBlob);
|
|
|
|
// Create a video element
|
|
const video = document.createElement('video');
|
|
video.src = videoObjectUrl;
|
|
|
|
// Wait for the video to load metadata
|
|
video.addEventListener('loadedmetadata', async () => {
|
|
const canvas = document.createElement('canvas');
|
|
let newWidth = video.videoWidth;
|
|
let newHeight = video.videoHeight;
|
|
|
|
if (newWidth > maxWidth) {
|
|
newHeight *= maxWidth / newWidth;
|
|
newWidth = maxWidth;
|
|
}
|
|
|
|
if (newHeight > maxHeight) {
|
|
newWidth *= maxHeight / newHeight;
|
|
newHeight = maxHeight;
|
|
}
|
|
|
|
canvas.width = newWidth;
|
|
canvas.height = newHeight;
|
|
|
|
const context = canvas.getContext('2d');
|
|
context?.drawImage(video, 0, 0, newWidth, newHeight);
|
|
|
|
// Convert the canvas to a Blob
|
|
canvas.toBlob(async (blob) => {
|
|
if (blob) {
|
|
// Read the Blob as an ArrayBuffer
|
|
const compressedVideoBuffer = await this.readBlobAsArrayBuffer(blob);
|
|
|
|
// Convert the ArrayBuffer back to base64
|
|
const compressedBase64 = this.arrayBufferToBase64(compressedVideoBuffer);
|
|
|
|
resolve(compressedBase64);
|
|
} else {
|
|
reject('Error creating compressed video blob.');
|
|
}
|
|
}, 'video/mp4', quality);
|
|
|
|
});
|
|
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
} */
|
|
|
|
private base64ToArrayBuffer(base64: string): ArrayBuffer {
|
|
const binaryString = window.atob(base64);
|
|
const len = binaryString.length;
|
|
const bytes = new Uint8Array(len);
|
|
for (let i = 0; i < len; ++i) {
|
|
bytes[i] = binaryString.charCodeAt(i);
|
|
}
|
|
return bytes.buffer;
|
|
}
|
|
|
|
private async readBlobAsArrayBuffer(blob: Blob): Promise<ArrayBuffer> {
|
|
return new Promise((resolve, reject) => {
|
|
const reader = new FileReader();
|
|
reader.onloadend = () => {
|
|
if (reader.result instanceof ArrayBuffer) {
|
|
resolve(reader.result);
|
|
} else {
|
|
reject('Error reading blob as ArrayBuffer.');
|
|
}
|
|
};
|
|
reader.readAsArrayBuffer(blob);
|
|
});
|
|
}
|
|
|
|
private arrayBufferToBase64(buffer: ArrayBuffer): string {
|
|
const binary = String.fromCharCode(...new Uint8Array(buffer));
|
|
return btoa(binary);
|
|
}
|
|
|
|
|
|
fileSizeToMB(sizeInBytes) {
|
|
var sizeInMB = (sizeInBytes / (1024 * 1024)).toFixed(2);
|
|
console.log(sizeInMB + 'MB');
|
|
return parseInt(sizeInMB)
|
|
}
|
|
|
|
deleteFromSeletedContent(index) {
|
|
this.seletedContent.splice(index, 1)
|
|
}
|
|
|
|
|
|
|
|
async uploadChunk() {
|
|
let time = new Date()
|
|
|
|
this.publication = {
|
|
DateIndex: time,
|
|
DocumentId: null,
|
|
ProcessId: this.folderId,
|
|
Title: this.pub.Title,
|
|
Message: this.pub.Message,
|
|
DatePublication: time,
|
|
OriginalFileName: this.capturedImageTitle || 'foto',
|
|
Files: this.seletedContent,
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
chossePhotoOrVideo() {
|
|
this.photoOrVideo = !this.photoOrVideo
|
|
}
|
|
|
|
async startVideoRecording() {
|
|
try {
|
|
let options: CaptureImageOptions = { limit: 1 }
|
|
const data: any = await this.mediaCapture.captureVideo(options)
|
|
this.video = data[0];
|
|
console.log(data)
|
|
data.forEach(async element => {
|
|
this.filesSizeSum = this.filesSizeSum + element.size
|
|
if (this.fileSizeToMB(this.filesSizeSum) <= 20) {
|
|
const savedFile = await Filesystem.copy({
|
|
from: element.fullPath, // directory prop removed, Capacitor parses filename for us
|
|
to: "video.mp4",
|
|
toDirectory: FilesystemDirectory.Data
|
|
});
|
|
console.log(savedFile.uri)
|
|
Filesystem.readFile({ path: savedFile.uri })
|
|
|
|
.then(async (content) => {
|
|
this.filecontent = true;
|
|
console.log('',content)
|
|
let fileObject = new PublicationAttachmentEntity({
|
|
base64: content.data,
|
|
extension: 'mp4',
|
|
OriginalFileName: 'record',
|
|
FileType: 'video'
|
|
|
|
}
|
|
)
|
|
this.seletedContent.push(fileObject)
|
|
})
|
|
.catch((err) => console.error(err));
|
|
} else {
|
|
if (this.seletedContent.length === 0)
|
|
this.filesSizeSum = 0
|
|
|
|
this.httpErrorHandle.validationMessagge('filessize')
|
|
}
|
|
|
|
});
|
|
} catch (error) {
|
|
console.log('record video error: ', error)
|
|
}
|
|
}
|
|
|
|
checkTableDivice() {
|
|
if (!this.platform.is('desktop'))
|
|
return true;
|
|
}
|
|
|
|
checkDesktop() {
|
|
if (this.platform.is('desktop'))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
class UploadFileUseCase {
|
|
CMAPIService: CMAPIService = window["CMAPIAPIRepository"]
|
|
constructor() {}
|
|
async execute(PublicationAttachmentEntity: PublicationAttachmentEntity): Promise<Result<PublicationAttachmentEntity, PublicationAttachmentEntity>> {
|
|
return new Promise(async (resolve, reject) => {
|
|
|
|
|
|
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 await 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 {
|
|
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()) {
|
|
const pingRequest = await this.CMAPIService.ping()
|
|
if( pingRequest.isErr()) {
|
|
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
|
|
|
|
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) {
|
|
|
|
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
|
|
}
|
|
}
|