Merge branch 'dev' into feature/bugfix
Conflicts resolved in: - src/app/clients/clients-view/ckyc-tab/ckyc-tab.component.html - src/app/clients/clients-view/ckyc-tab/ckyc-tab.component.ts Kept dev's CKYC architecture (upload dialog, real per-artefact endpoints) and layered feature/bugfix's fixes on top: upload file validation, missing-file badge, silent preview download, and image/PDF view button. Also includes the CKYC "Image of Client" upload-state fix and the client-change state-leak fix in the same component. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5
@@ -9,52 +9,41 @@
|
||||
/** Angular Imports */
|
||||
import { Component, OnInit, OnDestroy, inject } from '@angular/core';
|
||||
import { ActivatedRoute } from '@angular/router';
|
||||
import { Subject, takeUntil, catchError, of } from 'rxjs';
|
||||
import { Subject, Observable, takeUntil, catchError, of, forkJoin } from 'rxjs';
|
||||
|
||||
/** Custom Services */
|
||||
import { ClientsService } from '../../clients.service';
|
||||
import { AlertService } from 'app/core/alert/alert.service';
|
||||
import { MatIcon } from '@angular/material/icon';
|
||||
import { MatProgressSpinner } from '@angular/material/progress-spinner';
|
||||
import { MatDialog } from '@angular/material/dialog';
|
||||
import { FaIconComponent } from '@fortawesome/angular-fontawesome';
|
||||
import { STANDALONE_SHARED_IMPORTS } from 'app/standalone-shared.module';
|
||||
import { Dates } from 'app/core/utils/dates';
|
||||
import { ProofType, normalizeProofType } from '../../shared/kyc-proof-types';
|
||||
import { CkycUploadDialogComponent, CkycUploadDialogResult } from './ckyc-upload-dialog/ckyc-upload-dialog.component';
|
||||
|
||||
interface ExistingArtefact {
|
||||
present: boolean;
|
||||
name?: string;
|
||||
source?: string;
|
||||
previewUrl?: string;
|
||||
previewUrlBack?: string;
|
||||
documentId?: string;
|
||||
documentTypeId?: string;
|
||||
documentKey?: string;
|
||||
/** "Issue date: yyyy-MM-dd, Expiry date: yyyy-MM-dd" — same convention client-india-address-step
|
||||
* already writes/reads for address proof; now shared by the photo/identity proof too. */
|
||||
description?: string;
|
||||
fileCount?: number;
|
||||
expanded?: boolean;
|
||||
/** Set when the stored file could not be fetched - the row exists but its content is gone. */
|
||||
previewUnavailable?: boolean;
|
||||
/** Stored MIME type, so the card knows whether it can render an inline thumbnail. */
|
||||
mimeType?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Multipart `name` / `description` sent for each CKYC artefact type.
|
||||
*
|
||||
* The platform has no CKYC-specific document API; these are stored through the generic
|
||||
* DocumentApiResource, whose contract carries no document-type field. The artefact type therefore
|
||||
* travels in `name`, which is the same mechanism the client signature already uses - so
|
||||
* `CLIENT_SIGNATURE` deliberately reuses the existing `clientSignature` value that
|
||||
* loadExistingArtefacts() (and uploadClientSignatureImage()) match on. Changing that string would
|
||||
* orphan every previously uploaded signature.
|
||||
*/
|
||||
export type CkycDocumentType = 'ID_PROOF' | 'ADDRESS_PROOF' | 'PHOTO_PROOF' | 'CLIENT_IMAGE' | 'CLIENT_SIGNATURE';
|
||||
|
||||
const CKYC_DOCUMENT_META: Record<CkycDocumentType, { name: string; description: string }> = {
|
||||
ID_PROOF: { name: 'ckycIdProof', description: 'CKYC ID proof' },
|
||||
ADDRESS_PROOF: { name: 'ckycAddressProof', description: 'CKYC address proof' },
|
||||
PHOTO_PROOF: { name: 'ckycPhotoProof', description: 'CKYC photo proof' },
|
||||
CLIENT_IMAGE: { name: 'ckycClientImage', description: 'CKYC client photograph' },
|
||||
CLIENT_SIGNATURE: { name: 'clientSignature', description: 'Client signature' }
|
||||
};
|
||||
|
||||
const CKYC_DOCUMENT_TYPES = Object.keys(CKYC_DOCUMENT_META) as CkycDocumentType[];
|
||||
type ProofKind = 'ADDRESS_PROOF' | 'PHOTO_PROOF';
|
||||
type CkycDocKind = ProofKind | 'CLIENT_IMAGE' | 'CLIENT_SIGNATURE';
|
||||
|
||||
/**
|
||||
* Client-side upload guards, kept deliberately in step with the backend so a file that passes here
|
||||
@@ -62,8 +51,8 @@ const CKYC_DOCUMENT_TYPES = Object.keys(CKYC_DOCUMENT_META) as CkycDocumentType[
|
||||
* - 5 MB matches `spring.servlet.multipart.max-file-size`
|
||||
* - the extension list is the intersection of the backend `fineract.content.regex-whitelist`
|
||||
* with what these cards can actually render.
|
||||
* `accept=` on the input is only a file-picker hint and is trivially bypassed, so the real check
|
||||
* lives in onFileSelect().
|
||||
* The dialog's `accept=` is only a file-picker hint and is trivially bypassed, so the real check
|
||||
* runs here, on the file the dialog hands back, before anything is sent.
|
||||
*/
|
||||
const MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
|
||||
const IMAGE_EXTENSIONS = [
|
||||
@@ -76,8 +65,8 @@ const DOCUMENT_EXTENSIONS = [
|
||||
'pdf'
|
||||
];
|
||||
|
||||
/** Types whose card renders an inline <img> preview, so a PDF would not display. */
|
||||
const IMAGE_ONLY_TYPES: CkycDocumentType[] = [
|
||||
/** Cards that render an inline <img>, so a PDF would not display in them. */
|
||||
const IMAGE_ONLY_KINDS: CkycDocKind[] = [
|
||||
'CLIENT_IMAGE',
|
||||
'CLIENT_SIGNATURE'
|
||||
];
|
||||
@@ -98,6 +87,8 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
private route = inject(ActivatedRoute);
|
||||
private clientsService = inject(ClientsService);
|
||||
private alertService = inject(AlertService);
|
||||
private dialog = inject(MatDialog);
|
||||
private dates = inject(Dates);
|
||||
|
||||
private destroy$ = new Subject<void>();
|
||||
|
||||
@@ -131,37 +122,55 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
return this.panVerified && this.aadhaarVerified;
|
||||
}
|
||||
|
||||
/** CKYC artefacts already uploaded for this client, keyed by artefact type. */
|
||||
existing: Record<CkycDocumentType, ExistingArtefact> = {
|
||||
ID_PROOF: { present: false },
|
||||
/** Pre-existing artefacts detected from client data */
|
||||
existing: Record<CkycDocKind, ExistingArtefact> = {
|
||||
ADDRESS_PROOF: { present: false },
|
||||
PHOTO_PROOF: { present: false },
|
||||
CLIENT_IMAGE: { present: false },
|
||||
CLIENT_SIGNATURE: { present: false }
|
||||
};
|
||||
|
||||
/** Document-type options for the proof pickers, fetched once from /kyc/proof-types */
|
||||
addressProofOptions: ProofType[] = [];
|
||||
idProofOptions: ProofType[] = [];
|
||||
|
||||
/** Document type currently selected in each proof card's picker */
|
||||
selectedProofType: Record<ProofKind, ProofType | null> = {
|
||||
ADDRESS_PROOF: null,
|
||||
PHOTO_PROOF: null
|
||||
};
|
||||
|
||||
/** Front/back files staged for the two proof cards; other cards keep a single file each */
|
||||
docFiles: Record<ProofKind, { front: File | null; back: File | null }> = {
|
||||
ADDRESS_PROOF: { front: null, back: null },
|
||||
PHOTO_PROOF: { front: null, back: null }
|
||||
};
|
||||
|
||||
/** Document number + issue/expiry dates staged from the upload dialog, same fields client
|
||||
* creation collects for a KYC/address proof — persisted onto the identifier's documentKey
|
||||
* and description ("Issue date: yyyy-MM-dd, Expiry date: yyyy-MM-dd"). */
|
||||
private documentDetails: Record<
|
||||
ProofKind,
|
||||
{ documentKey: string; issueDate: string | null; expiryDate: string | null }
|
||||
> = {
|
||||
ADDRESS_PROOF: { documentKey: '', issueDate: null, expiryDate: null },
|
||||
PHOTO_PROOF: { documentKey: '', issueDate: null, expiryDate: null }
|
||||
};
|
||||
|
||||
/** File references */
|
||||
idProofFile: File | null = null;
|
||||
addressProofFile: File | null = null;
|
||||
photoProofFile: File | null = null;
|
||||
clientImageFile: File | null = null;
|
||||
clientSignatureFile: File | null = null;
|
||||
|
||||
/** Per-document upload state */
|
||||
uploading: { [key: string]: boolean } = {
|
||||
ID_PROOF: false,
|
||||
ADDRESS_PROOF: false,
|
||||
PHOTO_PROOF: false,
|
||||
CLIENT_IMAGE: false,
|
||||
CLIENT_SIGNATURE: false
|
||||
};
|
||||
|
||||
/** Per-document upload response */
|
||||
uploadResponses: { [key: string]: any } = {};
|
||||
|
||||
/** Per-document error messages */
|
||||
uploadErrors: { [key: string]: string | null } = {
|
||||
ID_PROOF: null,
|
||||
ADDRESS_PROOF: null,
|
||||
PHOTO_PROOF: null,
|
||||
CLIENT_IMAGE: null,
|
||||
@@ -171,6 +180,11 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
ngOnInit(): void {
|
||||
this.route.parent.params.subscribe((params: any) => {
|
||||
this.clientId = params['clientId'];
|
||||
// Angular reuses this component when only the clientId in the route changes, and
|
||||
// loadExistingArtefacts() only ever *assigns* what it finds - it has no "not found" branch.
|
||||
// Without clearing first, a client with no photo (or no signature, or no proof) keeps showing
|
||||
// the previous client's card.
|
||||
this.resetArtefactState();
|
||||
this.loadClientInfo();
|
||||
this.loadAccounts();
|
||||
this.loadCkycData();
|
||||
@@ -178,6 +192,46 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns every per-client card to its empty state, so nothing from the client just viewed can
|
||||
* survive into the next one. Covers all four cards plus the details staged for an upload - a file
|
||||
* or document number left over from another client must never be submitted against this one.
|
||||
*/
|
||||
private resetArtefactState(): void {
|
||||
this.revokePreviewUrls();
|
||||
this.existing = {
|
||||
ADDRESS_PROOF: { present: false },
|
||||
PHOTO_PROOF: { present: false },
|
||||
CLIENT_IMAGE: { present: false },
|
||||
CLIENT_SIGNATURE: { present: false }
|
||||
};
|
||||
this.selectedProofType = { ADDRESS_PROOF: null, PHOTO_PROOF: null };
|
||||
this.docFiles = {
|
||||
ADDRESS_PROOF: { front: null, back: null },
|
||||
PHOTO_PROOF: { front: null, back: null }
|
||||
};
|
||||
this.documentDetails = {
|
||||
ADDRESS_PROOF: { documentKey: '', issueDate: null, expiryDate: null },
|
||||
PHOTO_PROOF: { documentKey: '', issueDate: null, expiryDate: null }
|
||||
};
|
||||
this.clientImageFile = null;
|
||||
this.clientSignatureFile = null;
|
||||
this.uploadErrors = {
|
||||
ADDRESS_PROOF: null,
|
||||
PHOTO_PROOF: null,
|
||||
CLIENT_IMAGE: null,
|
||||
CLIENT_SIGNATURE: null
|
||||
};
|
||||
}
|
||||
|
||||
/** Frees the blob URLs held by the current cards before their references are dropped. */
|
||||
private revokePreviewUrls(): void {
|
||||
Object.values(this.existing).forEach((e) => {
|
||||
if (e.previewUrl?.startsWith('blob:')) URL.revokeObjectURL(e.previewUrl);
|
||||
if (e.previewUrlBack?.startsWith('blob:')) URL.revokeObjectURL(e.previewUrlBack);
|
||||
});
|
||||
}
|
||||
|
||||
private loadClientInfo(): void {
|
||||
this.route.parent.data.subscribe((data: any) => {
|
||||
const cv = data?.clientViewData;
|
||||
@@ -263,123 +317,270 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads every CKYC artefact from the client's documents (`m_document`), which is the single
|
||||
* source of truth for this screen: each card matches the `name` its own upload writes, so what
|
||||
* the checker sees is exactly what CKYC stored.
|
||||
*
|
||||
* Deliberately does NOT read the profile image or client identifiers any more. Those belong to
|
||||
* client registration and the Identities section; reading them here showed artefacts this screen
|
||||
* had never uploaded, and hid the ones it had. Those other screens are untouched.
|
||||
*
|
||||
* A client can accumulate several rows for one artefact (older uploads pre-date replacement, and
|
||||
* the signature is also written by client registration), so the newest row - highest `id` - wins.
|
||||
* Fetch photo (profile image), signature (client document),
|
||||
* ID proof and address proof (client identifiers) so already-uploaded
|
||||
* artefacts are shown here instead of forcing re-upload.
|
||||
*/
|
||||
private loadExistingArtefacts(): void {
|
||||
this.checkingExisting = true;
|
||||
|
||||
forkJoin({
|
||||
photo: this.clientsService.getClientProfileImage(this.clientId).pipe(catchError(() => of(null))),
|
||||
documents: this.clientsService.getClientDocuments(this.clientId).pipe(catchError(() => of([]))),
|
||||
identifiers: this.clientsService.getClientIdentifiers(this.clientId).pipe(catchError(() => of([]))),
|
||||
proofTypes: this.clientsService.getKycProofTypes().pipe(catchError(() => of({ idProofs: [], addressProofs: [] })))
|
||||
})
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe(({ photo, documents, identifiers, proofTypes }) => {
|
||||
this.checkingExisting = false;
|
||||
|
||||
// 1. Photo / image of client — from m_client.image_id
|
||||
if (photo && typeof photo === 'string' && photo.length > 0) {
|
||||
this.existing.CLIENT_IMAGE = {
|
||||
present: true,
|
||||
source: 'Client registration',
|
||||
previewUrl: photo,
|
||||
name: 'Profile photo'
|
||||
};
|
||||
}
|
||||
|
||||
// 2. Signature — client document with name='clientSignature'. Multiple rows can exist
|
||||
// for clients who re-cropped/replaced their signature before uploads became single-slot,
|
||||
// so pick the highest id (latest) rather than the first unordered match.
|
||||
const signatureDoc = (documents as any[])
|
||||
?.filter((d: any) => d?.name === 'clientSignature')
|
||||
?.sort((a: any, b: any) => b.id - a.id)?.[0];
|
||||
if (signatureDoc) {
|
||||
this.existing.CLIENT_SIGNATURE = {
|
||||
present: true,
|
||||
source: 'Client registration',
|
||||
name: signatureDoc.fileName || 'Client signature',
|
||||
documentId: signatureDoc.id,
|
||||
mimeType: signatureDoc.type
|
||||
};
|
||||
// Same endpoint getClientSignatureImage() uses, but opted out of the global error alert:
|
||||
// a m_document row whose file is no longer in the content store returns 500, and the card
|
||||
// below reports that itself. Without `silent` the interceptor pops an "Internal Server
|
||||
// Error" modal on every page load, for a failure the user cannot act on.
|
||||
this.clientsService
|
||||
.downloadClientDocument(this.clientId, String(signatureDoc.id), true)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe({
|
||||
next: (blob: any) => {
|
||||
if (blob && blob.size > 0) {
|
||||
this.existing.CLIENT_SIGNATURE.previewUrl = URL.createObjectURL(blob);
|
||||
} else {
|
||||
// A 200 with an empty body still means there is nothing to show. Without this the
|
||||
// card would claim "Already available" with no thumbnail and no explanation.
|
||||
this.existing.CLIENT_SIGNATURE.previewUnavailable = true;
|
||||
}
|
||||
},
|
||||
error: () => {
|
||||
this.existing.CLIENT_SIGNATURE.previewUnavailable = true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// 3 & 4. ID proof + Address proof — client identifiers classified via proof-types
|
||||
this.idProofOptions = (proofTypes?.idProofs || []).map((p: any) => normalizeProofType(p));
|
||||
this.addressProofOptions = (proofTypes?.addressProofs || []).map((p: any) => normalizeProofType(p));
|
||||
const idProofIds = new Set<string>((proofTypes?.idProofs || []).map((p: any) => String(p.id)));
|
||||
const addressProofIds = new Set<string>((proofTypes?.addressProofs || []).map((p: any) => String(p.id)));
|
||||
|
||||
const idList = Array.isArray(identifiers) ? identifiers : (identifiers as any)?.pageItems || [];
|
||||
|
||||
for (const identity of idList) {
|
||||
const docTypeId = String(identity?.documentType?.id ?? '');
|
||||
const isActive =
|
||||
!identity?.status ||
|
||||
identity?.status?.code === 'clientIdentifierStatusType.active' ||
|
||||
identity?.status === 'clientIdentifierStatusType.active' ||
|
||||
identity?.status === 'Active';
|
||||
if (!isActive) continue;
|
||||
|
||||
const proofName = identity?.documentType?.name || 'Identifier';
|
||||
// Address proof documentKey is auto-generated as "<ProofName> - <clientId>"
|
||||
// in identities-tab; hide it when it's just that synthetic key.
|
||||
const rawKey = identity?.documentKey || '';
|
||||
const isSyntheticKey = rawKey.startsWith(`${proofName} - `);
|
||||
const common = {
|
||||
present: true,
|
||||
source: 'Identities section',
|
||||
name: proofName,
|
||||
documentKey: isSyntheticKey ? '' : rawKey,
|
||||
documentId: identity?.id,
|
||||
documentTypeId: docTypeId,
|
||||
description: identity?.description || '',
|
||||
fileCount: (identity?.documents || []).length
|
||||
};
|
||||
|
||||
if (idProofIds.has(docTypeId) && !this.existing.PHOTO_PROOF.present) {
|
||||
this.existing.PHOTO_PROOF = common;
|
||||
this.selectedProofType.PHOTO_PROOF = this.idProofOptions.find((p) => String(p.id) === docTypeId) || null;
|
||||
this.loadIdentifierDocPreview('PHOTO_PROOF', identity.id);
|
||||
} else if (addressProofIds.has(docTypeId) && !this.existing.ADDRESS_PROOF.present) {
|
||||
this.existing.ADDRESS_PROOF = common;
|
||||
this.selectedProofType.ADDRESS_PROOF =
|
||||
this.addressProofOptions.find((p) => String(p.id) === docTypeId) || null;
|
||||
this.loadIdentifierDocPreview('ADDRESS_PROOF', identity.id);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The scanned ID/address-proof card only showed its file name and key — never the scan
|
||||
* itself, unlike the photo and signature cards right beside it. Mirrors those two: fetch
|
||||
* the identifier's own attached document(s) (m_client_identifier -> m_document, the same
|
||||
* chain the Identities tab and the create-client stepper read) and download the latest for
|
||||
* an inline preview. Two-sided proof types (Aadhaar, Passport, Voter ID, Driving Licence)
|
||||
* store front/back as two separate documents named "<Proof> — Front"/"— Back" (the same
|
||||
* convention the create-client stepper writes), so both are matched and previewed here;
|
||||
* a legacy single upload with no such marker just shows as the one preview.
|
||||
*/
|
||||
private loadIdentifierDocPreview(kind: ProofKind, identifierId: string): void {
|
||||
this.clientsService
|
||||
.getClientDocuments(this.clientId)
|
||||
.getClientIdentificationDocuments(identifierId)
|
||||
.pipe(
|
||||
takeUntil(this.destroy$),
|
||||
catchError(() => of([]))
|
||||
)
|
||||
.subscribe((documents: any) => {
|
||||
this.checkingExisting = false;
|
||||
.subscribe((docs: any) => {
|
||||
const list = Array.isArray(docs) ? docs : [];
|
||||
if (!list.length) return;
|
||||
this.existing[kind].fileCount = list.length;
|
||||
this.existing[kind].previewUnavailable = false;
|
||||
|
||||
const list: any[] = Array.isArray(documents) ? documents : (documents?.pageItems ?? []);
|
||||
const byNewest = (a: any, b: any) => b.id - a.id;
|
||||
const label = (d: any) => (d?.name || d?.fileName || '').toString();
|
||||
const back = [...list].filter((d: any) => /back/i.test(label(d))).sort(byNewest)[0];
|
||||
const front =
|
||||
[...list].filter((d: any) => /front/i.test(label(d))).sort(byNewest)[0] ||
|
||||
[...list].filter((d: any) => d.id !== back?.id).sort(byNewest)[0];
|
||||
|
||||
for (const type of CKYC_DOCUMENT_TYPES) {
|
||||
const expectedName = CKYC_DOCUMENT_META[type].name;
|
||||
|
||||
const doc = list
|
||||
.filter((d: any) => d?.name === expectedName)
|
||||
.sort((a: any, b: any) => (b?.id ?? 0) - (a?.id ?? 0))[0];
|
||||
|
||||
if (!doc) {
|
||||
// No upload yet for this artefact - leave the card in its empty state.
|
||||
this.existing[type] = { present: false };
|
||||
continue;
|
||||
}
|
||||
|
||||
this.existing[type] = {
|
||||
present: true,
|
||||
source: 'CKYC upload',
|
||||
name: doc.fileName || expectedName,
|
||||
documentId: doc.id,
|
||||
mimeType: doc.type
|
||||
};
|
||||
|
||||
this.loadPreview(type, doc.id);
|
||||
}
|
||||
// A proof can be scanned to PDF, which no <img> can render - remember what was stored so the
|
||||
// card offers "View document" instead of a broken thumbnail.
|
||||
if (front) this.existing[kind].mimeType = front.type;
|
||||
if (front) this.downloadIdentifierDocPreview(identifierId, front.id, kind, 'front');
|
||||
if (back && back.id !== front?.id) this.downloadIdentifierDocPreview(identifierId, back.id, kind, 'back');
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetches the stored file so the card can show a thumbnail. A failure here is reported on the
|
||||
* card rather than swallowed: the usual cause is a `m_document` row whose file is no longer in
|
||||
* the content store, and silently showing "Already available" with no image hides that.
|
||||
*/
|
||||
private loadPreview(type: CkycDocumentType, documentId: string | number): void {
|
||||
private downloadIdentifierDocPreview(
|
||||
identifierId: string,
|
||||
documentId: string,
|
||||
kind: ProofKind,
|
||||
slot: 'front' | 'back'
|
||||
): void {
|
||||
this.clientsService
|
||||
// silent: a missing stored file returns 500, and the card below already reports that. Without
|
||||
// this the global error interceptor pops an "Internal Server Error" modal on every page load
|
||||
// and after every upload, for a failure the user cannot act on.
|
||||
.downloadClientDocument(this.clientId, String(documentId), true)
|
||||
.downloadClientIdentificationDocument(identifierId, documentId)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe({
|
||||
next: (blob: any) => {
|
||||
if (blob && blob.size > 0) {
|
||||
this.existing[type].previewUrl = URL.createObjectURL(blob);
|
||||
} else {
|
||||
// A 200 with an empty body still means there is nothing to show. Without this the card
|
||||
// would sit there claiming "Already available" with no thumbnail and no explanation.
|
||||
this.existing[type].previewUnavailable = true;
|
||||
if (!blob || blob.size === 0) {
|
||||
this.existing[kind].previewUnavailable = true;
|
||||
return;
|
||||
}
|
||||
const url = URL.createObjectURL(blob);
|
||||
if (slot === 'front') this.existing[kind].previewUrl = url;
|
||||
else this.existing[kind].previewUrlBack = url;
|
||||
},
|
||||
// The row exists but its file is gone from the content store. Saying so on the card beats
|
||||
// showing "Already available" next to a blank space.
|
||||
error: () => {
|
||||
this.existing[type].previewUnavailable = true;
|
||||
this.existing[kind].previewUnavailable = true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* True when the stored file can be shown as an inline thumbnail. A PDF cannot, so its card falls
|
||||
* back to the "View document" button alone rather than rendering a broken image.
|
||||
*/
|
||||
isImage(documentType: CkycDocumentType): boolean {
|
||||
const entry = this.existing[documentType];
|
||||
if (entry?.mimeType) {
|
||||
return entry.mimeType.startsWith('image/');
|
||||
}
|
||||
// Older rows can have no stored MIME type - fall back to the file extension.
|
||||
const extension = (entry?.name?.split('.').pop() || '').toLowerCase();
|
||||
return IMAGE_EXTENSIONS.includes(extension);
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens the uploaded document full size in a new tab. Uses the blob already fetched for the
|
||||
* thumbnail, so it works for PDFs too and costs no extra request.
|
||||
*/
|
||||
openDocument(documentType: CkycDocumentType): void {
|
||||
const url = this.existing[documentType]?.previewUrl;
|
||||
if (url) {
|
||||
window.open(url, '_blank', 'noopener');
|
||||
}
|
||||
}
|
||||
|
||||
toggleReplace(documentType: string): void {
|
||||
const entry = (this.existing as any)[documentType];
|
||||
if (entry) entry.expanded = !entry.expanded;
|
||||
}
|
||||
|
||||
onAccountSelect(accountNo: string): void {
|
||||
this.selectedAccount = this.allAccounts.find((a) => a.accountNo === accountNo) || null;
|
||||
this.selectedAccountType = this.selectedAccount?.accountType || '';
|
||||
}
|
||||
|
||||
getFile(documentType: string): File | null {
|
||||
switch (documentType) {
|
||||
case 'CLIENT_IMAGE':
|
||||
return this.clientImageFile;
|
||||
case 'CLIENT_SIGNATURE':
|
||||
return this.clientSignatureFile;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static readonly CARD_TITLES: Record<CkycDocKind, string> = {
|
||||
ADDRESS_PROOF: 'Address Proof Document',
|
||||
PHOTO_PROOF: 'Photo Proof Document',
|
||||
CLIENT_IMAGE: 'Image of Client',
|
||||
CLIENT_SIGNATURE: 'Signature of Client'
|
||||
};
|
||||
|
||||
/** Opens the picker/preview popup for one card and, once the user confirms a file there, feeds
|
||||
* the picked type/file(s) into the same upload path the card always used. Picking and preview
|
||||
* now live entirely in the dialog — this screen only stages the result and re-runs upload. */
|
||||
openUploadDialog(kind: CkycDocKind): void {
|
||||
const isProofKind = kind === 'ADDRESS_PROOF' || kind === 'PHOTO_PROOF';
|
||||
const action = this.existing[kind].present ? 'Replace' : 'Upload';
|
||||
const existingDates = isProofKind
|
||||
? this.parseDescriptionDates(this.existing[kind].description)
|
||||
: { issueDate: null, expiryDate: null };
|
||||
|
||||
const ref = this.dialog.open(CkycUploadDialogComponent, {
|
||||
width: '480px',
|
||||
maxWidth: '95vw',
|
||||
data: {
|
||||
title: `${action} ${CkycTabComponent.CARD_TITLES[kind]}`,
|
||||
isProofKind,
|
||||
accept: isProofKind ? '.png,.jpeg,.jpg,.pdf' : '.png,.jpeg,.jpg',
|
||||
proofOptions:
|
||||
kind === 'PHOTO_PROOF'
|
||||
? this.idProofOptions
|
||||
: kind === 'ADDRESS_PROOF'
|
||||
? this.addressProofOptions
|
||||
: undefined,
|
||||
initialProofType: isProofKind ? this.selectedProofType[kind as ProofKind] : undefined,
|
||||
initialDocumentKey: isProofKind ? this.existing[kind].documentKey || '' : undefined,
|
||||
initialIssueDate: existingDates.issueDate,
|
||||
initialExpiryDate: existingDates.expiryDate
|
||||
}
|
||||
});
|
||||
|
||||
ref.afterClosed().subscribe((result: CkycUploadDialogResult | null) => {
|
||||
if (!result) return;
|
||||
|
||||
// The dialog's `accept=` filter is only a hint to the file picker and is trivially bypassed,
|
||||
// so the size/type guard runs here on what actually came back. Catching it now turns a raw
|
||||
// server rejection into a message on the card.
|
||||
const rejection =
|
||||
this.validationError(result.front, kind) ?? (result.back ? this.validationError(result.back, kind) : null);
|
||||
if (rejection) {
|
||||
this.uploadErrors[kind] = rejection;
|
||||
return;
|
||||
}
|
||||
this.uploadErrors[kind] = null;
|
||||
|
||||
if (isProofKind) {
|
||||
const proofKind = kind as ProofKind;
|
||||
this.selectedProofType[proofKind] = result.proofType || null;
|
||||
this.docFiles[proofKind] = { front: result.front, back: result.back || null };
|
||||
this.documentDetails[proofKind] = {
|
||||
documentKey: result.documentKey || '',
|
||||
issueDate: result.issueDate || null,
|
||||
expiryDate: result.expiryDate || null
|
||||
};
|
||||
} else if (kind === 'CLIENT_IMAGE') {
|
||||
this.clientImageFile = result.front;
|
||||
} else {
|
||||
this.clientSignatureFile = result.front;
|
||||
}
|
||||
this.uploadDocument(kind);
|
||||
});
|
||||
}
|
||||
|
||||
/** Extensions a given card can both store and render. */
|
||||
private allowedExtensions(documentType: string): string[] {
|
||||
return IMAGE_ONLY_TYPES.includes(documentType as CkycDocumentType) ? IMAGE_EXTENSIONS : DOCUMENT_EXTENSIONS;
|
||||
private allowedExtensions(kind: CkycDocKind): string[] {
|
||||
return IMAGE_ONLY_KINDS.includes(kind) ? IMAGE_EXTENSIONS : DOCUMENT_EXTENSIONS;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -387,8 +588,11 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
* so the user gets a clear message instead of a raw server error. Returns null when the file is
|
||||
* acceptable.
|
||||
*/
|
||||
private validationError(file: File, documentType: string): string | null {
|
||||
const allowed = this.allowedExtensions(documentType);
|
||||
private validationError(file: File | null | undefined, kind: CkycDocKind): string | null {
|
||||
if (!file) {
|
||||
return null;
|
||||
}
|
||||
const allowed = this.allowedExtensions(kind);
|
||||
const extension = (file.name.split('.').pop() || '').toLowerCase();
|
||||
|
||||
if (!allowed.includes(extension)) {
|
||||
@@ -404,125 +608,279 @@ export class CkycTabComponent implements OnInit, OnDestroy {
|
||||
return null;
|
||||
}
|
||||
|
||||
private setFile(documentType: string, file: File | null): void {
|
||||
switch (documentType) {
|
||||
case 'ID_PROOF':
|
||||
this.idProofFile = file;
|
||||
break;
|
||||
case 'ADDRESS_PROOF':
|
||||
this.addressProofFile = file;
|
||||
break;
|
||||
case 'PHOTO_PROOF':
|
||||
this.photoProofFile = file;
|
||||
break;
|
||||
case 'CLIENT_IMAGE':
|
||||
this.clientImageFile = file;
|
||||
break;
|
||||
case 'CLIENT_SIGNATURE':
|
||||
this.clientSignatureFile = file;
|
||||
break;
|
||||
/**
|
||||
* True when the stored file can be shown as an inline thumbnail. A PDF cannot, so its card falls
|
||||
* back to the "View document" button alone rather than rendering a broken image.
|
||||
*/
|
||||
isImage(kind: CkycDocKind): boolean {
|
||||
const entry = this.existing[kind];
|
||||
// The profile image arrives as a `data:image/...;base64,` URL, which declares its own type -
|
||||
// it has neither a stored MIME type nor a file extension for the checks below to read.
|
||||
if (entry?.previewUrl?.startsWith('data:')) {
|
||||
return entry.previewUrl.startsWith('data:image/');
|
||||
}
|
||||
if (entry?.mimeType) {
|
||||
return entry.mimeType.startsWith('image/');
|
||||
}
|
||||
// Older rows can have no stored MIME type - fall back to the file extension.
|
||||
const extension = (entry?.name?.split('.').pop() || '').toLowerCase();
|
||||
return IMAGE_EXTENSIONS.includes(extension);
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens the uploaded document full size in a new tab. Uses the blob already fetched for the
|
||||
* thumbnail, so it works for PDFs too and costs no extra request.
|
||||
*/
|
||||
openDocument(kind: CkycDocKind): void {
|
||||
const url = this.existing[kind]?.previewUrl;
|
||||
if (url) {
|
||||
window.open(url, '_blank', 'noopener');
|
||||
}
|
||||
}
|
||||
|
||||
onFileSelect(event: any, documentType: string): void {
|
||||
const file = event.target?.files?.[0];
|
||||
if (!file) return;
|
||||
/** Reads back the "Issue date: yyyy-MM-dd, Expiry date: yyyy-MM-dd" convention this tab (and
|
||||
* client-india-address-step, for address proof) writes into the identifier's description. */
|
||||
private parseDescriptionDates(description: string | undefined): { issueDate: Date | null; expiryDate: Date | null } {
|
||||
const issueMatch = (description || '').match(/Issue date:\s*([^,|]+)/i);
|
||||
const expiryMatch = (description || '').match(/Expiry date:\s*([^,|]+)/i);
|
||||
return {
|
||||
issueDate: issueMatch ? this.dates.parseDate(issueMatch[1].trim()) : null,
|
||||
expiryDate: expiryMatch ? this.dates.parseDate(expiryMatch[1].trim()) : null
|
||||
};
|
||||
}
|
||||
|
||||
const error = this.validationError(file, documentType);
|
||||
if (error) {
|
||||
this.setFile(documentType, null);
|
||||
this.uploadErrors[documentType] = error;
|
||||
event.target.value = '';
|
||||
private buildDescription(issueDate: string | null, expiryDate: string | null): string {
|
||||
const parts: string[] = [];
|
||||
if (issueDate) parts.push(`Issue date: ${issueDate}`);
|
||||
if (expiryDate) parts.push(`Expiry date: ${expiryDate}`);
|
||||
return parts.join(', ');
|
||||
}
|
||||
|
||||
/** Issue/expiry date for display on the card, formatted dd-MM-yyyy — parsed from the same
|
||||
* description text the upload dialog writes. */
|
||||
cardDate(kind: ProofKind, which: 'issue' | 'expiry'): string {
|
||||
const parsed = this.parseDescriptionDates(this.existing[kind].description);
|
||||
const value = which === 'issue' ? parsed.issueDate : parsed.expiryDate;
|
||||
return value ? this.dates.formatDate(value, 'dd-MM-yyyy') : '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Routes each card to whichever real endpoint that artefact is actually stored through — there
|
||||
* is no single "/clients/{id}/ckyc/documents" resource on the backend, so posting every card to
|
||||
* one made-up URL 404'd for all four. A photo goes to the image endpoint, a signature to the
|
||||
* client's own documents, and an ID/address proof to the m_client_identifier it already belongs
|
||||
* to (the same one the Identities tab and create-client stepper post to) — never a fresh,
|
||||
* type-less upload, since which identifier a proof belongs to is exactly what makes it that
|
||||
* proof rather than some other file on the client's record.
|
||||
*/
|
||||
uploadDocument(documentType: string): void {
|
||||
if (documentType === 'PHOTO_PROOF' || documentType === 'ADDRESS_PROOF') {
|
||||
this.uploadProofDocument(documentType);
|
||||
return;
|
||||
}
|
||||
|
||||
this.setFile(documentType, file);
|
||||
this.uploadErrors[documentType] = null;
|
||||
}
|
||||
|
||||
getFile(documentType: string): File | null {
|
||||
switch (documentType) {
|
||||
case 'ID_PROOF':
|
||||
return this.idProofFile;
|
||||
case 'ADDRESS_PROOF':
|
||||
return this.addressProofFile;
|
||||
case 'PHOTO_PROOF':
|
||||
return this.photoProofFile;
|
||||
case 'CLIENT_IMAGE':
|
||||
return this.clientImageFile;
|
||||
case 'CLIENT_SIGNATURE':
|
||||
return this.clientSignatureFile;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
uploadDocument(documentType: CkycDocumentType): void {
|
||||
const file = this.getFile(documentType);
|
||||
if (!file) return;
|
||||
|
||||
this.uploading[documentType] = true;
|
||||
this.uploadErrors[documentType] = null;
|
||||
const key = documentType as keyof typeof this.existing;
|
||||
|
||||
// DocumentApiResource consumes multipart/form-data with body parts `file`, `name` and
|
||||
// `description` (file + description mandatory). There is no document-type field in that
|
||||
// contract, so the artefact type is carried in `name` - which is also the key
|
||||
// loadExistingArtefacts() matches on when reading the document back.
|
||||
const meta = CKYC_DOCUMENT_META[documentType];
|
||||
|
||||
const formData = new FormData();
|
||||
formData.append('file', file);
|
||||
formData.append('name', meta.name);
|
||||
formData.append('description', meta.description);
|
||||
|
||||
// Replace in place when this artefact already has a usable document, so a re-upload updates the
|
||||
// existing row (same document id, same content-store location) instead of stacking up another
|
||||
// copy. Falls back to create for the first upload of an artefact.
|
||||
//
|
||||
// Deliberately create instead of replace when the stored file is missing: the backend's update
|
||||
// path writes the new content relative to the row's existing `location` and never calls
|
||||
// setLocation(), so replacing a row whose file is already gone writes the upload to a fresh
|
||||
// folder while the row keeps pointing at the missing one - the artefact would stay broken and
|
||||
// the user would get a success message. Creating a new row repairs the card instead.
|
||||
const entry = this.existing[documentType];
|
||||
const replacing = !!entry?.documentId && !entry?.previewUnavailable;
|
||||
const existingId = entry?.documentId;
|
||||
|
||||
const request$ = replacing
|
||||
? this.clientsService.replaceClientDocument(this.clientId, String(existingId), formData)
|
||||
: this.clientsService.uploadCkycDocument(this.clientId, formData);
|
||||
let request$: Observable<any>;
|
||||
switch (documentType) {
|
||||
case 'CLIENT_IMAGE':
|
||||
request$ = this.clientsService.uploadClientProfileImage(this.clientId, file);
|
||||
break;
|
||||
case 'CLIENT_SIGNATURE':
|
||||
request$ = this.clientsService.uploadClientSignatureImage(this.clientId, file);
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
request$.pipe(takeUntil(this.destroy$)).subscribe({
|
||||
next: (response: any) => {
|
||||
next: () => {
|
||||
this.uploading[documentType] = false;
|
||||
this.uploadResponses[documentType] = response;
|
||||
this.setFile(documentType, null);
|
||||
this.alertService.alert({
|
||||
type: 'success',
|
||||
message:
|
||||
response?.message || (replacing ? 'Document replaced successfully.' : 'Document uploaded successfully.')
|
||||
});
|
||||
// Re-read from m_document so the card reflects what was actually stored, rather than
|
||||
// assuming the write succeeded exactly as sent.
|
||||
this.loadExistingArtefacts();
|
||||
// The card is gated on `present`; without this a successful upload left it reading
|
||||
// "Not uploaded yet". uploadProofDocument() sets the same flag for the proof cards.
|
||||
this.existing[key].present = true;
|
||||
this.existing[key].source = this.existing[key].source || 'CKYC upload';
|
||||
this.alertService.alert({ type: 'success', message: 'Document uploaded successfully.' });
|
||||
this.refreshPreview(documentType);
|
||||
},
|
||||
error: (err: any) => {
|
||||
this.uploading[documentType] = false;
|
||||
this.uploadErrors[documentType] =
|
||||
err?.error?.developerMessage ||
|
||||
err?.error?.defaultUserMessage ||
|
||||
err?.message ||
|
||||
'Failed to upload document.';
|
||||
this.uploadErrors[documentType] = this.extractErrorMessage(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Proof cards work like the create-client KYC step: pick a document type first (its `sides`
|
||||
* decides whether one image or a front+back pair is required), then upload. Reuses the same
|
||||
* identifier the Identities tab manages — updates its documentTypeId if the picked type
|
||||
* changed, or creates a fresh identifier when none exists yet, so this card never depends on
|
||||
* a separate trip to the Identities tab.
|
||||
*/
|
||||
private uploadProofDocument(kind: ProofKind): void {
|
||||
const proof = this.selectedProofType[kind];
|
||||
if (!proof) {
|
||||
this.uploadErrors[kind] = 'Select a document type first.';
|
||||
return;
|
||||
}
|
||||
const files = this.docFiles[kind];
|
||||
if (!files.front || (proof.sides === 2 && !files.back)) {
|
||||
this.uploadErrors[kind] =
|
||||
proof.sides === 2
|
||||
? 'Both front and back images are required for this document type.'
|
||||
: 'Select a file to upload.';
|
||||
return;
|
||||
}
|
||||
|
||||
this.uploading[kind] = true;
|
||||
this.uploadErrors[kind] = null;
|
||||
|
||||
const existingId = this.existing[kind].documentId;
|
||||
const details = this.documentDetails[kind];
|
||||
const documentKey = details.documentKey || `${proof.name} - ${this.clientId}`;
|
||||
const description = this.buildDescription(details.issueDate, details.expiryDate);
|
||||
|
||||
const identifier$: Observable<any> = !existingId
|
||||
? this.clientsService.addClientIdentifier(this.clientId, {
|
||||
documentTypeId: proof.id,
|
||||
status: 'ACTIVE',
|
||||
documentKey,
|
||||
description: description || 'KYC document'
|
||||
})
|
||||
: this.clientsService.updateClientIdentifier(this.clientId, existingId, {
|
||||
documentTypeId: proof.id,
|
||||
status: 'ACTIVE',
|
||||
documentKey,
|
||||
description
|
||||
});
|
||||
|
||||
identifier$.pipe(takeUntil(this.destroy$)).subscribe({
|
||||
next: (res: any) => {
|
||||
const identifierId = existingId || res?.resourceId;
|
||||
const uploads: Observable<any>[] = [];
|
||||
|
||||
const front = new FormData();
|
||||
front.append('name', proof.sides === 2 ? `${proof.name} — Front` : proof.name);
|
||||
front.append('file', files.front!);
|
||||
uploads.push(this.clientsService.uploadClientIdentifierDocument(identifierId, front));
|
||||
|
||||
if (proof.sides === 2 && files.back) {
|
||||
const back = new FormData();
|
||||
back.append('name', `${proof.name} — Back`);
|
||||
back.append('file', files.back);
|
||||
uploads.push(this.clientsService.uploadClientIdentifierDocument(identifierId, back));
|
||||
}
|
||||
|
||||
forkJoin(uploads)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe({
|
||||
next: () => {
|
||||
this.uploading[kind] = false;
|
||||
this.existing[kind].present = true;
|
||||
this.existing[kind].documentId = identifierId;
|
||||
this.existing[kind].documentTypeId = String(proof.id);
|
||||
this.existing[kind].documentKey = details.documentKey || '';
|
||||
this.existing[kind].description = description;
|
||||
this.existing[kind].name = proof.name;
|
||||
this.existing[kind].source = this.existing[kind].source || 'Identities section';
|
||||
this.docFiles[kind] = { front: null, back: null };
|
||||
this.alertService.alert({ type: 'success', message: 'Document uploaded successfully.' });
|
||||
this.refreshPreview(kind);
|
||||
},
|
||||
error: (err: any) => {
|
||||
this.uploading[kind] = false;
|
||||
this.uploadErrors[kind] = this.extractErrorMessage(err);
|
||||
}
|
||||
});
|
||||
},
|
||||
error: (err: any) => {
|
||||
this.uploading[kind] = false;
|
||||
this.uploadErrors[kind] = this.extractErrorMessage(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private extractErrorMessage(err: any): string {
|
||||
return (
|
||||
err?.error?.errors?.[0]?.defaultUserMessage ||
|
||||
err?.error?.developerMessage ||
|
||||
err?.error?.defaultUserMessage ||
|
||||
err?.message ||
|
||||
'Failed to upload document.'
|
||||
);
|
||||
}
|
||||
|
||||
/** Re-fetches whichever artefact was just replaced, so its preview reflects the new file
|
||||
* immediately instead of the one this screen loaded on entry. */
|
||||
private refreshPreview(documentType: string): void {
|
||||
const staleKey = documentType as keyof typeof this.existing;
|
||||
if (this.existing[staleKey].previewUrl?.startsWith('blob:')) {
|
||||
URL.revokeObjectURL(this.existing[staleKey].previewUrl!);
|
||||
}
|
||||
if (this.existing[staleKey].previewUrlBack?.startsWith('blob:')) {
|
||||
URL.revokeObjectURL(this.existing[staleKey].previewUrlBack!);
|
||||
}
|
||||
// The upload that triggered this refresh is what repairs a previously missing file, so the
|
||||
// warning has to be cleared before the re-read - otherwise a fixed card keeps the old badge.
|
||||
this.existing[staleKey].previewUrl = undefined;
|
||||
this.existing[staleKey].previewUrlBack = undefined;
|
||||
this.existing[staleKey].previewUnavailable = false;
|
||||
switch (documentType) {
|
||||
case 'CLIENT_IMAGE':
|
||||
this.clientsService
|
||||
.getClientProfileImage(this.clientId)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe((photo: any) => {
|
||||
if (photo) {
|
||||
this.existing.CLIENT_IMAGE.previewUrl = photo;
|
||||
} else {
|
||||
this.existing.CLIENT_IMAGE.previewUnavailable = true;
|
||||
}
|
||||
});
|
||||
break;
|
||||
case 'CLIENT_SIGNATURE':
|
||||
this.clientsService
|
||||
.getClientDocuments(this.clientId)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe((documents: any) => {
|
||||
const doc = (documents as any[])
|
||||
?.filter((d: any) => d?.name === 'clientSignature')
|
||||
?.sort((a: any, b: any) => b.id - a.id)?.[0];
|
||||
if (!doc) return;
|
||||
this.existing.CLIENT_SIGNATURE.documentId = doc.id;
|
||||
this.existing.CLIENT_SIGNATURE.mimeType = doc.type;
|
||||
this.clientsService
|
||||
.downloadClientDocument(this.clientId, String(doc.id), true)
|
||||
.pipe(takeUntil(this.destroy$))
|
||||
.subscribe({
|
||||
next: (blob: any) => {
|
||||
if (blob && blob.size > 0) {
|
||||
this.existing.CLIENT_SIGNATURE.previewUrl = URL.createObjectURL(blob);
|
||||
} else {
|
||||
this.existing.CLIENT_SIGNATURE.previewUnavailable = true;
|
||||
}
|
||||
},
|
||||
error: () => {
|
||||
this.existing.CLIENT_SIGNATURE.previewUnavailable = true;
|
||||
}
|
||||
});
|
||||
});
|
||||
break;
|
||||
case 'PHOTO_PROOF':
|
||||
case 'ADDRESS_PROOF':
|
||||
this.loadIdentifierDocPreview(documentType, this.existing[documentType].documentId!);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ngOnDestroy(): void {
|
||||
this.destroy$.next();
|
||||
this.destroy$.complete();
|
||||
// Release object URLs
|
||||
Object.values(this.existing).forEach((e) => {
|
||||
if (e.previewUrl?.startsWith('blob:')) URL.revokeObjectURL(e.previewUrl);
|
||||
});
|
||||
this.revokePreviewUrls();
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user