@apia/uploader-controller 4.0.44

package/dist/index.d.ts

@@ -0,0 +1,495 @@
+import * as _apia_util from '@apia/util';
+import { EventEmitter, NotificationDefinition, T__LEGACY_SERVER__ApiaLoad, T__LEGACY_SERVER__ApiaFunction } from '@apia/util';
+import * as _apia_api2 from '@apia/api2';
+import { ApiContext } from '@apia/api2';
+
+interface UploadContext extends ApiContext {
+    currentUserLogin: string;
+    docLangs: string;
+    everyoneCanUpdate: boolean;
+    ownerCanUpdate: boolean;
+    readonly: boolean;
+    IN_MONITOR: boolean;
+    WEBDAV_SERVER: string;
+    ITHit: any;
+}
+/**
+ * El comportamiento de esta función se explica por su
+ * nombre.
+ */
+declare function returnExactlyTheSame(defaultParameters: Record<string, unknown>): Record<string, unknown>;
+declare const parseFileDefinition: (context: UploadContext, fileDefinition: TFileUploaded | TUploaderFileInfo, isSignRequired: boolean) => TUploaderFileInfo;
+type TOnUploadProgress = (progress: number) => void;
+declare class UploaderApi extends EventEmitter<{
+    fileUploaded: null;
+}> {
+    props: {
+        context: UploadContext;
+        id: string;
+        type: 'E' | 'P';
+        modalConfig: TModalConfig;
+    };
+    maxFiles: number;
+    modalController: UploaderModalController | null;
+    allowTranslations: boolean;
+    langs: Record<number, string> | undefined;
+    currentConfiguration: TUploaderLoadCurrentFunctionMessages | undefined;
+    state: UploaderState;
+    get filesArray(): TUploaderFileInfo[];
+    constructor(props: {
+        context: UploadContext;
+        id: string;
+        type: 'E' | 'P';
+        modalConfig: TModalConfig;
+    });
+    get context(): UploadContext;
+    init(): Promise<void>;
+    protected buildModalController(conf?: {
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+        versionFile?: TUploaderFileInfo;
+    }): UploaderModalController;
+    onStartUpload(files?: File[]): Promise<void>;
+    onTranslateUpload(conf: {
+        langId: number;
+        translatingFile: TUploaderFileInfo;
+    }, files?: File[]): Promise<void>;
+    onVersionUpload(file: TUploaderFileInfo, conf?: {
+        newFiles?: File[];
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+    }): Promise<void>;
+    autoLock(): Promise<boolean>;
+    notify(notification: NotificationDefinition): void;
+    protected getAjaxUrl(): string;
+    getDocTypes(): TDocType[];
+    getCurrentDocTypeId(): string;
+    getCurrentDocType(): TDocType | undefined;
+    getInProgressFiles(): File[];
+    getHiddenFiles(): File[];
+    getExistingFiles(): Record<string, TUploaderFileInfo>;
+    getProgress(): number;
+    getHasAllDocTypes(): boolean | undefined;
+    getDocumentInfo({ docId: apiId, downloadDocId: docId, }: TRequireOnlyOne<{
+        docId: string;
+        downloadDocId: string;
+    }>, newElem?: boolean): Promise<({
+        canClose: boolean;
+        type: string;
+    } & {
+        function: {
+            name: string;
+        } & {
+            data: {
+                onClose: string;
+                general: TApiaDocumentDefinition;
+                permissions: {
+                    pool: TDocumentPermission | TDocumentPermission[];
+                    user: TDocumentPermission | TDocumentPermission[];
+                };
+                versions: {
+                    version: TDocumentVersion | TDocumentVersion[];
+                };
+            };
+            currentUsrPems: {
+                usrCanModify: boolean;
+            };
+            metadatas: {
+                metadata: TDocumentMetadata | TDocumentMetadata[];
+            };
+            docDownHistory: {
+                docHistory: TDocumentDownloadHistory | TDocumentDownloadHistory[];
+            };
+        };
+    } & _apia_util.T__LEGACY_SERVER__MessagesPayload) | null>;
+    /**
+     * This method searches for the provided id in several places:
+     *
+     * If it's found in the current files, returns it.
+     * If not, it searches the provided docId in the translations map of each uploaded file.
+     */
+    getDocument(docId: string): TUploaderFileInfo | undefined;
+    protected updateDocument(docId: string, newValue: TUploaderFileInfo): void;
+    protected deleteDocument(docId: string): void;
+    clearFile(name: string): void;
+    clearFiles(): void;
+    clearState(): void;
+    checkLockDocument(id: string, shouldNotifyUnlocked?: boolean): Promise<string | boolean>;
+    setCurrentDocTypeId(docTypeId: string): void;
+    ajaxUploadStart(newFiles?: File[]): Promise<boolean | undefined>;
+    reloadMetadata(props?: Partial<{
+        docId: string;
+        docTypeId: number | string;
+    }>, additionalProps?: Record<string, unknown>): Promise<void>;
+    saveDroppedFiles(unprocessedFiles: File[], conf?: TSaveDroppedFilesConf): Promise<boolean>;
+    checkWebDavLock(docId: string): Promise<unknown>;
+    checkSignature(file: TUploaderFileInfo): Promise<_apia_api2.TApiaApiAxiosResponse<({
+        markedToSign: boolean;
+    } & _apia_util.T__LEGACY_SERVER__MessagesPayload) | null> | null>;
+    editDocument(id: string): Promise<void>;
+    downloadVersion(fileId: string, version?: string): Promise<void>;
+    downloadDocument(id: string, version?: string): Promise<void>;
+    ajaxDeleteDocument(id: string, langId?: number): Promise<void>;
+    version(file: TUploaderFileInfo, conf?: {
+        newFiles?: File[];
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+    }): Promise<void>;
+    versionFileInfo(file: TUploaderFileInfo): Promise<void>;
+    pickFileById(id: string): Promise<void>;
+    markFileToSign(id: string, langId?: string): Promise<void>;
+    /**
+     * Por el momento realiza la descarga de todos los archivos
+     * que estén subidos.
+     */
+    downloadMultipleDocuments(): void;
+    confirmDropModal(conf?: {
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+    }): Promise<boolean>;
+    loadCurrentDocuments(): Promise<void>;
+    lockDocument(id: string): Promise<void>;
+    protected evaluateDeleteDocumentResult(result: unknown): boolean;
+    setTranslationFile(file: TUploaderFileInfo, docId: string, langId: number): void;
+    protected getCheckSignatureParameters: typeof returnExactlyTheSame;
+    protected getAjaxUploadFileStatusParameters: typeof returnExactlyTheSame;
+    protected getAjaxUploadStartParameters: typeof returnExactlyTheSame;
+    protected getConfirmDropModalParameters: typeof returnExactlyTheSame;
+    protected getCheckLockDocumentParameters: typeof returnExactlyTheSame;
+    protected getCheckWebDavLockParameters: typeof returnExactlyTheSame;
+    protected getConfirmDropModalPostdata: typeof returnExactlyTheSame;
+    protected getConfirmDropModalMetadataString: ({ metadata, }: {
+        metadata: TDocumentMetadata[];
+    }) => string;
+    protected getConfirmDropModalPermissionsString: ({ poolsPermissions, usersPermissions, }: {
+        poolsPermissions: IPoolsPermissions[];
+        usersPermissions: IUsersPermissions[];
+    }) => string;
+    protected getConfirmDropModalAdditionalMetadataString: (additionalMetadata: TDocumentMetadata[] | []) => string;
+    protected getDeleteDocumentParameters: typeof returnExactlyTheSame;
+    protected getClearTempFilesParameters: typeof returnExactlyTheSame;
+    protected getDocumentInfoParameters: typeof returnExactlyTheSame;
+    protected getDownloadMultipleDocumentsParameters: typeof returnExactlyTheSame;
+    protected getEditDocumentParameters: typeof returnExactlyTheSame;
+    protected getLockDocumentParameters: typeof returnExactlyTheSame;
+    protected getMarkFileToSignParameters: typeof returnExactlyTheSame;
+    protected getProcessDroppedFilesParameters: typeof returnExactlyTheSame;
+    protected getProcessDroppedFilesPostdata: typeof returnExactlyTheSame;
+    protected getReloadMetadataParameters: typeof returnExactlyTheSame;
+    protected getSaveDroppedFilesParameters: typeof returnExactlyTheSame;
+    protected filterAlreadyUploadedFiles(files: File[], conf?: TSaveDroppedFilesConf): File[];
+    protected filterByFilesAmountLimit(files: File[]): File[];
+    protected filterAcceptedFiles(files: File[], shouldNotify?: boolean, docTypeId?: string | TDocType): File[];
+    protected filterExistingFiles(files: File[], conf?: TSaveDroppedFilesConf): File[];
+    protected filterVersioningFiles(files: File[], conf?: {
+        langId?: number;
+        strictMode?: boolean;
+        translatingFile?: TUploaderFileInfo;
+        shouldReset?: boolean;
+    }): File[];
+    parseFileDefinition: (file: TFileUploaded) => TUploaderFileInfo;
+    getLoadFileSystemStructureTree(): Record<string, unknown>;
+    getLoadFilesForFolderParameters(): Record<string, unknown>;
+}
+
+declare class UploaderModalController {
+    api: UploaderApi;
+    modalConfig: TModalConfig;
+    conf?: {
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+        versionFile?: TUploaderFileInfo;
+    } | undefined;
+    state: UploaderModalState;
+    constructor(api: UploaderApi, modalConfig: TModalConfig, conf?: {
+        langId?: number;
+        translatingFile?: TUploaderFileInfo;
+        versionFile?: TUploaderFileInfo;
+    } | undefined);
+    get allMetadata(): TDocumentMetadata[];
+    get allowAllType(): "" | "M" | "R";
+    get description(): string;
+    get docFolder(): number | undefined;
+    get docExpDate(): string | undefined;
+    get docTypes(): TDocType[];
+    get freeMetadata(): TDocumentMetadata[];
+    get exitingFiles(): Record<string, TUploaderFileInfo>;
+    get inProgressFiles(): File[];
+    get hiddenFiles(): File[];
+    get progress(): number;
+    get metadata(): TDocumentMetadata[];
+    get selectedDocTypeId(): string;
+    get selectedDocType(): TDocType | undefined;
+    addMetadata(): void;
+    addFiles(files: File[]): void;
+    addDirectoryFile(file: TApiaDocumentDefinition): void;
+    changeDocType(docTypeId: string): Promise<void>;
+    clearDirectoryFile(): void;
+    clearFile(name: string): void;
+    clearFiles(): void;
+    clearState(): void;
+    clearPartialState(): void;
+    onCloseModal(): void;
+    confirm(): Promise<boolean>;
+    deleteMetadata(indices: number[]): void;
+    deletePermission(item: IPoolsPermissions | IUsersPermissions): void;
+    protected onChangeExtension(): void;
+    openModal(): Promise<void>;
+    setDescription(desc: string): void;
+    protected resetMetadata(): Promise<void>;
+    validate(): boolean;
+}
+
+type TUploadModalOpener = (controller: UploaderModalController) => void;
+type UploaderModalState = {
+    fileReqError: boolean;
+    metadata: {
+        metadataArray: TDocumentMetadata[];
+        isFreeMetadata: boolean;
+        freeMetadataArray: TDocumentMetadata[];
+    };
+    fromDirectoryFile: TApiaDocumentDefinition | null;
+    docFolder?: number;
+    docPath?: string;
+    docExpDate?: string;
+    description: string;
+    isReadonly?: boolean;
+    permissions: {
+        allowAllType: 'M' | 'R' | '';
+        users: IUsersPermissions[];
+        pools: IPoolsPermissions[];
+    };
+};
+type UploaderState = {
+    progress: number;
+    allowedTypes: TDocType[];
+    selectedDocTypeId: string;
+    versioningFile: TUploaderFileInfo | null;
+    inProgressFiles: File[];
+    hiddenFiles: File[];
+    files: Record<string, TUploaderFileInfo>;
+    translatedFiles: Map<string, Map<number, TUploaderFileInfo>>;
+    hasAllDocTypes?: boolean;
+    selectedFiles: string[];
+};
+interface IUsersPermissions {
+    userId: string;
+    userLogin: string;
+    canUpdate: boolean;
+}
+interface IPoolsPermissions {
+    poolId: string;
+    poolName: string;
+    canUpdate: boolean;
+}
+type TUploaderFileInfo = Omit<TFileUploaded, 'locked' | 'userLocking'> & {
+    canEdit?: boolean;
+    canRead?: boolean;
+    isLocked: boolean;
+    locked?: boolean;
+    isLockedByMe: boolean;
+    isVirtual: boolean;
+    lockingUser: string;
+};
+type TFileUploaded = {
+    canEdit?: boolean;
+    canWrite?: boolean;
+    canRead?: boolean;
+    description?: string;
+    docDescription?: string;
+    docId: string;
+    docLang?: string;
+    docLangGroup?: string;
+    docName?: string;
+    docSize?: string;
+    docTypeFreeMetadata?: boolean;
+    docTypeId?: string;
+    docTypeLabel?: string;
+    docTypeTitle: string;
+    downloadDocId: string;
+    isMarkedToSign: boolean;
+    markedToSign: boolean;
+    lock?: string | boolean;
+    isLocked?: string | boolean;
+    lockedBy?: string;
+    name?: string;
+    onlyInformation: boolean;
+    prefix: string;
+    preview: string;
+    sign?: string | boolean;
+    size?: string;
+    userLocking: string;
+    virtualDoc?: boolean;
+    locked?: boolean;
+};
+type TAjaxUploadStart = T__LEGACY_SERVER__ApiaLoad<T__LEGACY_SERVER__ApiaFunction<{
+    general: {
+        isDocTypeDisabled: boolean;
+        useDocTypePermitted: boolean;
+        createMode: boolean;
+        allowAllTypes: string;
+        allDocTypes: boolean;
+    };
+    docTypes: {
+        docType: TDocType | TDocType[];
+    };
+    metadatas: {
+        metadata: TDocumentMetadata | TDocumentMetadata[];
+    };
+}, false>>;
+type TDocType = {
+    docExts: string;
+    maxSize: number;
+    id: string;
+    title: string;
+    free: boolean;
+    selected: boolean;
+};
+type TDocumentMetadata = {
+    free: string;
+    id: string;
+    name: string;
+    required: 'Y' | 'N';
+    title: string;
+    type: 'S' | 'N' | 'D';
+    value: string;
+    errorMessage: string;
+    labelErrorMessage: string;
+};
+type TModalConfig = {
+    allowDocumentsMonitor: boolean;
+    allowPickFromDirectories: boolean;
+    collapsePermissions: boolean;
+    collapseDirectories: boolean;
+    collapseMetadata: boolean;
+    defaultDirectory?: number;
+    monitorId?: number;
+    oneClickUpload: boolean;
+    rootFolder?: string;
+    showDirectoriesStructure: boolean;
+    showExpDate: boolean;
+    showPermissions: boolean;
+    showMetadata: boolean;
+    translationId?: string;
+};
+type TUploaderLoadCurrentFunctionMessages = {
+    allowSign: boolean;
+    allowLock: boolean;
+    allowMultiple: boolean;
+    readOnly: boolean;
+};
+type TSaveDroppedFilesConf = {
+    langId?: number;
+    strictMode?: boolean;
+    translatingFile?: TUploaderFileInfo;
+    shouldReset?: boolean;
+};
+type TAjaxUploadFileStatus = T__LEGACY_SERVER__ApiaLoad<T__LEGACY_SERVER__ApiaFunction<{
+    message: {
+        label: string;
+        name: string;
+    }[];
+}>>;
+type TProcessDroppedFiles = T__LEGACY_SERVER__ApiaLoad<T__LEGACY_SERVER__ApiaFunction<{
+    principal: {
+        docInfo: TDocInfo | TDocInfo[];
+        docTypes: {
+            'data-free': boolean;
+            docTypeExtensions: string;
+            docTypeId: string;
+            docTypeMaxSize: number;
+            docTypeName: string;
+        };
+        elemInfo: {
+            elemId: string;
+            elemType: string;
+        };
+    };
+}, false>>;
+type TDocInfo = {
+    docInfoName: string;
+    docInfoSize: string;
+    docInfoTmpId: string;
+    docInfoType: string;
+};
+type TConfirmDropModal = T__LEGACY_SERVER__ApiaLoad<T__LEGACY_SERVER__ApiaFunction<{
+    general: TFileUploaded | TFileUploaded[];
+    fromForm: {
+        fromForm: {
+            fromForm: boolean;
+        }[];
+    };
+}, false>>;
+type TApiaDocumentDefinition = {
+    docDesc: string;
+    docTypeLabel: string;
+    docId: string;
+    prefix: string;
+    docSize: string;
+    docDate: string;
+    docDwnExternal: string;
+    docExpDate: string;
+    docFolder: string;
+    docFolderPath: string;
+    docUsu: string;
+    docAllPoolPerm: 'M' | 'R' | '';
+    docName: string;
+    docTypeId: string;
+    locked: boolean;
+    downloadDocId: string;
+};
+type TUploaderLoadCurrentFunction = {
+    general?: TFileUploaded | TFileUploaded[];
+    messages: {
+        message: {
+            name: keyof TUploaderLoadCurrentFunctionMessages;
+            label: boolean;
+        } | {
+            name: keyof TUploaderLoadCurrentFunctionMessages;
+            label: boolean;
+        }[];
+    };
+};
+type TDocumentInformation = T__LEGACY_SERVER__ApiaLoad<T__LEGACY_SERVER__ApiaFunction<{
+    data: {
+        onClose: string;
+        general: TApiaDocumentDefinition;
+        permissions: {
+            pool: TDocumentPermission | TDocumentPermission[];
+            user: TDocumentPermission | TDocumentPermission[];
+        };
+        versions: {
+            version: TDocumentVersion | TDocumentVersion[];
+        };
+    };
+    currentUsrPems: {
+        usrCanModify: boolean;
+    };
+    metadatas: {
+        metadata: TDocumentMetadata | TDocumentMetadata[];
+    };
+    docDownHistory: {
+        docHistory: TDocumentDownloadHistory | TDocumentDownloadHistory[];
+    };
+}, false>>;
+type TDocumentPermission = {
+    id: string;
+    name: string;
+    permType: 'R' | 'M';
+};
+type TDocumentDownloadHistory = {
+    hisDwn: string;
+    hisUsr: string;
+    hisVer: string;
+};
+type TDocumentVersion = {
+    verUser: string;
+    verNumber: string;
+    verDate: string;
+};
+type TRequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+
+export { type IPoolsPermissions, type IUsersPermissions, type TAjaxUploadFileStatus, type TAjaxUploadStart, type TApiaDocumentDefinition, type TConfirmDropModal, type TDocInfo, type TDocType, type TDocumentDownloadHistory, type TDocumentInformation, type TDocumentMetadata, type TDocumentPermission, type TDocumentVersion, type TFileUploaded, type TModalConfig, type TOnUploadProgress, type TProcessDroppedFiles, type TRequireOnlyOne, type TSaveDroppedFilesConf, type TUploadModalOpener, type TUploaderFileInfo, type TUploaderLoadCurrentFunction, type TUploaderLoadCurrentFunctionMessages, type UploadContext, UploaderApi, UploaderModalController, type UploaderModalState, type UploaderState, parseFileDefinition, returnExactlyTheSame };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}