@gsp-svc/formdoc-upload 0.1.31 → 0.1.32

package/esm5/lib/upload/upload.service.js

@@ -182,6 +182,30 @@ var UploadService = /** @class */ (function () {
             return of(error);
         })));
     };
+    /**
+     * @param {?} baseInfo
+     * @return {?}
+     */
+    UploadService.prototype.getSecurityInfoList = /**
+     * @param {?} baseInfo
+     * @return {?}
+     */
+    function (baseInfo) {
+        /** @type {?} */
+        var url = "/api/runtime/dfs/v1.0/storagestrategy/security";
+        url = url + "?id=" + baseInfo.securityId + "&level=" + baseInfo.securityLevel;
+        return this.http.get(url).pipe(tap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        function (res) { })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        function (error) {
+            return of(error);
+        })));
+    };
     /**
      * @param {?} storageInfoList
      * @param {?} rootId
@@ -211,6 +235,42 @@ var UploadService = /** @class */ (function () {
             return of(error);
         })));
     };
+    /**
+     * @param {?} uploadFileInfoList
+     * @param {?} rootId
+     * @return {?}
+     */
+    UploadService.prototype.saveSecurityInfo = /**
+     * @param {?} uploadFileInfoList
+     * @param {?} rootId
+     * @return {?}
+     */
+    function (uploadFileInfoList, rootId) {
+        /** @type {?} */
+        var url = "/api/runtime/dfs/v1.0/doc/exproperty";
+        /** @type {?} */
+        var reqList = [];
+        uploadFileInfoList.forEach((/**
+         * @param {?} element
+         * @return {?}
+         */
+        function (element) {
+            /** @type {?} */
+            var request = { id: element.metadataId, rootId: rootId, exProperty: JSON.stringify(element.securityInfo) };
+            reqList.push(request);
+        }));
+        return this.http.post(url, reqList).pipe(tap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        function (res) { })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        function (error) {
+            return of(error);
+        })));
+    };
     /**
      * @param {?} formId
      * @param {?} rootId
@@ -277,4 +337,4 @@ if (false) {
      */
     UploadService.prototype.http;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.service.js","sourceRoot":"ng://@gsp-svc/formdoc-upload/","sources":["lib/upload/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { GspFormUploadListEntity } from './entity/gspformuploadlistentity';\nimport { HttpService } from '@ecp-caf/caf-common';\nimport { catchError, tap } from 'rxjs/operators';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { GspFormRemoveListEntity } from './entity/gspformremovelistentity';\nimport { of } from 'rxjs/observable/of';\nimport { GspFormDocOperateEntity } from './entity/gspformdocoperateentity';\n\nimport { GspFormUploadEntity } from './entity/gspformuploadentity';\nimport { ExStorageFileInfo } from './entity/extensionstoragefileinfo';\nimport { ChangeInstanceRequest } from './entity/changeinstancerequest';\nimport { OperatingModes } from './entity/operatingmodes';\n\n\n\n@Injectable()\nexport class UploadService {\n\n  constructor(private http: HttpService) { }\n\n  uploadList(docListInfo: GspFormUploadListEntity, rootId: string): Observable<any> {\n    let url;\n    docListInfo.rootId = rootId;\n\n    url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.post(url, docListInfo).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n\n  commit(metadataIdList: string[], rootId: string): Observable<any> {\n    let url;\n    let entity: GspFormDocOperateEntity = new GspFormDocOperateEntity;\n    entity.metadataIdList = metadataIdList;\n    entity.rootId = rootId;\n    url = \"/api/runtime/dfs/v1.0/formdoc/commit\";\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/commit\";\n\n    return this.http.post(url, entity).pipe();\n  }\n\n  cancel(metadataIdList: string[], rootId: string): Observable<any> {\n    let url;\n    let entity: GspFormDocOperateEntity = new GspFormDocOperateEntity;\n    entity.metadataIdList = metadataIdList;\n    entity.rootId = rootId;\n    url = \"/api/runtime/dfs/v1.0/formdoc/cancel\";\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/cancel\";\n    //localStorage.setItem(\"SessionId\",\"huoliang\");\n    return this.http.put(url, entity).pipe();\n  }\n\n  removeList(idList: string[], rootId: string) {\n    let url;\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/list\";\n    url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n    var idListInfo = new GspFormRemoveListEntity;\n    idListInfo.metadataIdList = idList;\n    idListInfo.mode = OperatingModes.Temp;\n    idListInfo.rootId = rootId;\n    return this.http.delete(url, idListInfo).pipe();\n  }\n\n  getFile(metadataId: string, rootId: string) {\n\n    let url;\n    if (rootId == \"\")\n      url = \"/api/runtime/dfs/v1.0/formdoc/file/\" + metadataId;\n    else\n      url = \"/api/runtime/dfs/v1.0/formdoc/file/\" + metadataId + \"/\" + rootId;\n    return this.http.get(url).pipe(tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n\n  }\n\n  uploadFile(docInfo: GspFormUploadEntity): Observable<any> {\n\n    let url = \"/api/runtime/dfs/v1.0/formdoc\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.post(url, docInfo).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n\n  getStorageExtensionInfo(): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/storagestrategy/extension\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  changeStorageInstance(storageInfoList: ExStorageFileInfo[], rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/formdoc/changeinstance\";\n    let request: ChangeInstanceRequest = new ChangeInstanceRequest;\n    request.fileInfoList = storageInfoList;\n    request.rootId = rootId;\n    return this.http.post(url, request).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n\n  getUploadedFileInfoList(formId: string, rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/formdoc/uploadedfile/infolist\" + \"?formid=\" + formId + \"&rootid=\" + rootId;\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  getRootSetting(rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/rootsetting/\" + rootId;\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.service.js","sourceRoot":"ng://@gsp-svc/formdoc-upload/","sources":["lib/upload/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { GspFormUploadListEntity } from './entity/gspformuploadlistentity';\nimport { HttpService } from '@ecp-caf/caf-common';\nimport { catchError, tap } from 'rxjs/operators';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { GspFormRemoveListEntity } from './entity/gspformremovelistentity';\nimport { of } from 'rxjs/observable/of';\nimport { GspFormDocOperateEntity } from './entity/gspformdocoperateentity';\n\nimport { GspFormUploadEntity } from './entity/gspformuploadentity';\nimport { ExStorageFileInfo } from './entity/extensionstoragefileinfo';\nimport { ChangeInstanceRequest } from './entity/changeinstancerequest';\nimport { OperatingModes } from './entity/operatingmodes';\nimport { GspDocSecurityBaseInfo } from './entity/gspdocsecuritynaseinfo';\nimport { UploadFileInfo } from './entity/uploadfileinfo';\nimport { ExPropertyRequest } from './entity/expropertyrequest';\n\n\n\n@Injectable()\nexport class UploadService {\n\n  constructor(private http: HttpService) { }\n\n  uploadList(docListInfo: GspFormUploadListEntity, rootId: string): Observable<any> {\n    let url;\n    docListInfo.rootId = rootId;\n\n    url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.post(url, docListInfo).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n\n  commit(metadataIdList: string[], rootId: string): Observable<any> {\n    let url;\n    let entity: GspFormDocOperateEntity = new GspFormDocOperateEntity;\n    entity.metadataIdList = metadataIdList;\n    entity.rootId = rootId;\n    url = \"/api/runtime/dfs/v1.0/formdoc/commit\";\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/commit\";\n\n    return this.http.post(url, entity).pipe();\n  }\n\n  cancel(metadataIdList: string[], rootId: string): Observable<any> {\n    let url;\n    let entity: GspFormDocOperateEntity = new GspFormDocOperateEntity;\n    entity.metadataIdList = metadataIdList;\n    entity.rootId = rootId;\n    url = \"/api/runtime/dfs/v1.0/formdoc/cancel\";\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/cancel\";\n    //localStorage.setItem(\"SessionId\",\"huoliang\");\n    return this.http.put(url, entity).pipe();\n  }\n\n  removeList(idList: string[], rootId: string) {\n    let url;\n    //url = \"http://localhost:5000/api/runtime/dfs/v1.0/formdoc/list\";\n    url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n    var idListInfo = new GspFormRemoveListEntity;\n    idListInfo.metadataIdList = idList;\n    idListInfo.mode = OperatingModes.Temp;\n    idListInfo.rootId = rootId;\n    return this.http.delete(url, idListInfo).pipe();\n  }\n\n  getFile(metadataId: string, rootId: string) {\n\n    let url;\n    if (rootId == \"\")\n      url = \"/api/runtime/dfs/v1.0/formdoc/file/\" + metadataId;\n    else\n      url = \"/api/runtime/dfs/v1.0/formdoc/file/\" + metadataId + \"/\" + rootId;\n    return this.http.get(url).pipe(tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n\n  }\n\n  uploadFile(docInfo: GspFormUploadEntity): Observable<any> {\n\n    let url = \"/api/runtime/dfs/v1.0/formdoc\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.post(url, docInfo).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n\n  getStorageExtensionInfo(): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/storagestrategy/extension\";\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  getSecurityInfoList(baseInfo: GspDocSecurityBaseInfo): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/storagestrategy/security\";\n    url=url+\"?id=\"+baseInfo.securityId+\"&level=\"+baseInfo.securityLevel;\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  changeStorageInstance(storageInfoList: ExStorageFileInfo[], rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/formdoc/changeinstance\";\n    let request: ChangeInstanceRequest = new ChangeInstanceRequest;\n    request.fileInfoList = storageInfoList;\n    request.rootId = rootId;\n    return this.http.post(url, request).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  saveSecurityInfo(uploadFileInfoList: UploadFileInfo[],rootId:string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/doc/exproperty\";\n    let reqList:ExPropertyRequest[]=[];\n    uploadFileInfoList.forEach(element=>{\n      let request:ExPropertyRequest={id:element.metadataId,rootId:rootId,exProperty:JSON.stringify(element.securityInfo)};\n      reqList.push(request);\n    })\n    return this.http.post(url, reqList).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }))\n  }\n\n\n  getUploadedFileInfoList(formId: string, rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/formdoc/uploadedfile/infolist\" + \"?formid=\" + formId + \"&rootid=\" + rootId;\n    //url = \"/api/runtime/dfs/v1.0/formdoc/list\";\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n  getRootSetting(rootId: string): Observable<any> {\n    let url = \"/api/runtime/dfs/v1.0/rootsetting/\" + rootId;\n\n    return this.http.get(url).pipe(\n      tap(res => { }),\n      catchError((error: HttpErrorResponse) => {\n        return of(error);\n      }));\n  }\n\n}\n"]}

package/esm5/lib/uploaddialog.service.js

@@ -134,6 +134,7 @@ var UploadDialogService = /** @class */ (function () {
             var uploadRef = uploadFactory.create(_this.injector);
             if (limit != null) {
                 uploadRef.instance.fileCount = limit.fileCount;
+                uploadRef.instance.securityInfo = limit.securityInfo;
                 if (limit.fileType != null && limit.fileType != "")
                     uploadRef.instance.fileType = limit.fileType;
             }
@@ -221,4 +222,4 @@ if (false) {
      */
     UploadDialogService.prototype.injector;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploaddialog.service.js","sourceRoot":"ng://@gsp-svc/formdoc-upload/","sources":["lib/uploaddialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, ComponentFactoryResolver, LOCALE_ID } from '@angular/core';\r\nimport { FileUploadComponent } from './upload/file-upload/file-upload.component';\r\nimport { BsModalService, BsModalRef } from '@farris/ui-modal';\r\nimport { UploadFileInfo } from './upload/entity/uploadfileinfo';\r\nimport { Observable, of } from 'rxjs';\r\nimport { UploadLimit } from './upload/entity/uploadlimit';\r\nimport { LocalLangPipe } from './local.pipe';\r\n\r\n\r\n@Injectable()\r\nexport class UploadDialogService {\r\n\r\n    localeid:string;\r\n    localpipe: LocalLangPipe;\r\n    constructor(private modalService: BsModalService, private componentFactoryResolver: ComponentFactoryResolver, private injector: Injector) {\r\n        if(this.injector)\r\n        {\r\n          this.modalService = this.injector.get(BsModalService);\r\n          this.localeid = localStorage.getItem(\"languageCode\") || this.injector.get(LOCALE_ID);\r\n          this.localpipe = new LocalLangPipe(this.localeid);\r\n        } \r\n     }\r\n\r\n    dlg: BsModalRef;\r\n\r\n    fileInfoList: UploadFileInfo[] = [];\r\n\r\n    showDialog(formId: string, rootId: string) {\r\n        let flag = 0;\r\n        return new Promise(resolve => {\r\n            var viewerFactory = this.componentFactoryResolver.resolveComponentFactory(FileUploadComponent);\r\n            var viewerRef = viewerFactory.create(this.injector);\r\n\r\n            viewerRef.instance.rootId = rootId;\r\n            viewerRef.instance.formId = formId;\r\n\r\n            this.dlg = this.modalService.show(viewerRef, {\r\n                title: this.localpipe.transform('uploadFile'),\r\n                width: 950, height: 570,\r\n                buttons: [\r\n                    {\r\n                        text: this.localpipe.transform('save'), cls: 'k-button k-button-icontext k-primary', handle: () => {\r\n                            this.dlg.content.upload().subscribe(\r\n                                res => {\r\n                                    if (res) {\r\n                                        resolve(res);\r\n                                        flag = 1;\r\n                                        this.dlg.close();\r\n                                    }\r\n                                }\r\n                            );\r\n                        }\r\n                    },\r\n                    {\r\n                        text: this.localpipe.transform('close'), cls: 'k-button k-button-icontext', handle: () => {\r\n                            this.dlg.close();\r\n                        }\r\n                    }\r\n                ],\r\n\r\n                showButtons: true,\r\n                showMaxButton: false,\r\n                beforeClose: (): Observable<boolean> => {\r\n                    if (flag == 0)\r\n                        this.dlg.content.cancel();\r\n                    return of(true);\r\n                }\r\n            });\r\n        })\r\n    }\r\n\r\n    uploadFile(formId: string, rootId: string,oldIdList: string[]=[]) { \r\n        return this.uploadFileWithLimit(formId, rootId, null, oldIdList);\r\n    }\r\n\r\n\r\n    uploadFileWithLimit(formId: string, rootId: string, limit: UploadLimit, oldIdList: string[]=[]) {\r\n        let flag = 0;\r\n        return new Promise(resolve => {\r\n            var uploadFactory = this.componentFactoryResolver.resolveComponentFactory(FileUploadComponent);\r\n            var uploadRef = uploadFactory.create(this.injector);\r\n            if (limit != null) {\r\n                uploadRef.instance.fileCount = limit.fileCount;\r\n                if (limit.fileType != null && limit.fileType != \"\")\r\n                    uploadRef.instance.fileType = limit.fileType\r\n            }\r\n\r\n            uploadRef.instance.rootId = rootId;\r\n            uploadRef.instance.formId = formId;\r\n            uploadRef.instance.oldIdList=oldIdList;\r\n\r\n            this.dlg = this.modalService.show(uploadRef, {\r\n                title: this.localpipe.transform('uploadFile'),\r\n                width: 950, height: 570,\r\n                buttons: [\r\n                    {\r\n\r\n                        text: this.localpipe.transform('save'), cls: 'k-button k-button-icontext k-primary', handle: () => {\r\n                            this.dlg.content.upload().subscribe(\r\n                                res => {\r\n                                    if (res) {\r\n                                        resolve(res);\r\n                                        flag = 1;\r\n                                        this.dlg.close();\r\n                                    }\r\n                                }\r\n                            );\r\n                        }\r\n                    },\r\n                    {\r\n                        text: this.localpipe.transform('close'), cls: 'k-button k-button-icontext', handle: () => {\r\n                            this.dlg.close();\r\n                        }\r\n                    }\r\n                ],\r\n\r\n                showButtons: true,\r\n                showMaxButton: false,\r\n                beforeClose: (): Observable<boolean> => {\r\n                    if (flag == 0)\r\n                        this.dlg.content.cancel();\r\n                    return of(true);\r\n                }\r\n            });\r\n        })\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploaddialog.service.js","sourceRoot":"ng://@gsp-svc/formdoc-upload/","sources":["lib/uploaddialog.service.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,cAAc,EAAc,MAAM,kBAAkB,CAAC;AAE9D,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C;IAKI,6BAAoB,YAA4B,EAAU,wBAAkD,EAAU,QAAkB;QAApH,iBAAY,GAAZ,YAAY,CAAgB;QAAU,6BAAwB,GAAxB,wBAAwB,CAA0B;QAAU,aAAQ,GAAR,QAAQ,CAAU;QAUxI,iBAAY,GAAqB,EAAE,CAAC;QAThC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YACtD,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACrF,IAAI,CAAC,SAAS,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACrD;IACL,CAAC;;;;;;IAMD,wCAAU;;;;;IAAV,UAAW,MAAc,EAAE,MAAc;QAAzC,iBA0CC;;YAzCO,IAAI,GAAG,CAAC;QACZ,OAAO,IAAI,OAAO;;;;QAAC,UAAA,OAAO;;gBAClB,aAAa,GAAG,KAAI,CAAC,wBAAwB,CAAC,uBAAuB,CAAC,mBAAmB,CAAC;;gBAC1F,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,KAAI,CAAC,QAAQ,CAAC;YAEnD,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;YACnC,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;YAEnC,KAAI,CAAC,GAAG,GAAG,KAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE;gBACzC,KAAK,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC;gBAC7C,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG;gBACvB,OAAO,EAAE;oBACL;wBACI,IAAI,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,sCAAsC,EAAE,MAAM;;;wBAAE;4BACzF,KAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,SAAS;;;;4BAC/B,UAAA,GAAG;gCACC,IAAI,GAAG,EAAE;oCACL,OAAO,CAAC,GAAG,CAAC,CAAC;oCACb,IAAI,GAAG,CAAC,CAAC;oCACT,KAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;iCACpB;4BACL,CAAC,EACJ,CAAC;wBACN,CAAC,CAAA;qBACJ;oBACD;wBACI,IAAI,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,4BAA4B,EAAE,MAAM;;;wBAAE;4BAChF,KAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;wBACrB,CAAC,CAAA;qBACJ;iBACJ;gBAED,WAAW,EAAE,IAAI;gBACjB,aAAa,EAAE,KAAK;gBACpB,WAAW;;;gBAAE;oBACT,IAAI,IAAI,IAAI,CAAC;wBACT,KAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBAC9B,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;gBACpB,CAAC,CAAA;aACJ,CAAC,CAAC;QACP,CAAC,EAAC,CAAA;IACN,CAAC;;;;;;;IAED,wCAAU;;;;;;IAAV,UAAW,MAAc,EAAE,MAAc,EAAE,SAAwB;QAAxB,0BAAA,EAAA,cAAwB;QAC/D,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IACrE,CAAC;;;;;;;;IAGD,iDAAmB;;;;;;;IAAnB,UAAoB,MAAc,EAAE,MAAc,EAAE,KAAkB,EAAE,SAAwB;QAAhG,iBAkDC;QAlDuE,0BAAA,EAAA,cAAwB;;YACxF,IAAI,GAAG,CAAC;QACZ,OAAO,IAAI,OAAO;;;;QAAC,UAAA,OAAO;;gBAClB,aAAa,GAAG,KAAI,CAAC,wBAAwB,CAAC,uBAAuB,CAAC,mBAAmB,CAAC;;gBAC1F,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,KAAI,CAAC,QAAQ,CAAC;YACnD,IAAI,KAAK,IAAI,IAAI,EAAE;gBACf,SAAS,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;gBAC/C,SAAS,CAAC,QAAQ,CAAC,YAAY,GAAC,KAAK,CAAC,YAAY,CAAC;gBACnD,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,IAAI,KAAK,CAAC,QAAQ,IAAI,EAAE;oBAC9C,SAAS,CAAC,QAAQ,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAA;aACnD;YAED,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;YACnC,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;YACnC,SAAS,CAAC,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC;YAEzC,KAAI,CAAC,GAAG,GAAG,KAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE;gBACzC,KAAK,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC;gBAC7C,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG;gBACvB,OAAO,EAAE;oBACL;wBAEI,IAAI,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,sCAAsC,EAAE,MAAM;;;wBAAE;4BACzF,KAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,SAAS;;;;4BAC/B,UAAA,GAAG;gCACC,IAAI,GAAG,EAAE;oCACL,OAAO,CAAC,GAAG,CAAC,CAAC;oCACb,IAAI,GAAG,CAAC,CAAC;oCACT,KAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;iCACpB;4BACL,CAAC,EACJ,CAAC;wBACN,CAAC,CAAA;qBACJ;oBACD;wBACI,IAAI,EAAE,KAAI,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,4BAA4B,EAAE,MAAM;;;wBAAE;4BAChF,KAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;wBACrB,CAAC,CAAA;qBACJ;iBACJ;gBAED,WAAW,EAAE,IAAI;gBACjB,aAAa,EAAE,KAAK;gBACpB,WAAW;;;gBAAE;oBACT,IAAI,IAAI,IAAI,CAAC;wBACT,KAAI,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBAC9B,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;gBACpB,CAAC,CAAA;aACJ,CAAC,CAAC;QACP,CAAC,EAAC,CAAA;IACN,CAAC;;gBApHJ,UAAU;;;;gBAPF,cAAc;gBAFQ,wBAAwB;gBAAlC,QAAQ;;IA8H7B,0BAAC;CAAA,AArHD,IAqHC;SApHY,mBAAmB;;;IAE5B,uCAAiB;;IACjB,wCAAyB;;IASzB,kCAAgB;;IAEhB,2CAAoC;;;;;IAVxB,2CAAoC;;;;;IAAE,uDAA0D;;;;;IAAE,uCAA0B","sourcesContent":["import { Injectable, Injector, ComponentFactoryResolver, LOCALE_ID } from '@angular/core';\r\nimport { FileUploadComponent } from './upload/file-upload/file-upload.component';\r\nimport { BsModalService, BsModalRef } from '@farris/ui-modal';\r\nimport { UploadFileInfo } from './upload/entity/uploadfileinfo';\r\nimport { Observable, of } from 'rxjs';\r\nimport { UploadLimit } from './upload/entity/uploadlimit';\r\nimport { LocalLangPipe } from './local.pipe';\r\n\r\n\r\n@Injectable()\r\nexport class UploadDialogService {\r\n\r\n    localeid: string;\r\n    localpipe: LocalLangPipe;\r\n    constructor(private modalService: BsModalService, private componentFactoryResolver: ComponentFactoryResolver, private injector: Injector) {\r\n        if (this.injector) {\r\n            this.modalService = this.injector.get(BsModalService);\r\n            this.localeid = localStorage.getItem(\"languageCode\") || this.injector.get(LOCALE_ID);\r\n            this.localpipe = new LocalLangPipe(this.localeid);\r\n        }\r\n    }\r\n\r\n    dlg: BsModalRef;\r\n\r\n    fileInfoList: UploadFileInfo[] = [];\r\n\r\n    showDialog(formId: string, rootId: string) {\r\n        let flag = 0;\r\n        return new Promise(resolve => {\r\n            var viewerFactory = this.componentFactoryResolver.resolveComponentFactory(FileUploadComponent);\r\n            var viewerRef = viewerFactory.create(this.injector);\r\n\r\n            viewerRef.instance.rootId = rootId;\r\n            viewerRef.instance.formId = formId;\r\n\r\n            this.dlg = this.modalService.show(viewerRef, {\r\n                title: this.localpipe.transform('uploadFile'),\r\n                width: 950, height: 570,\r\n                buttons: [\r\n                    {\r\n                        text: this.localpipe.transform('save'), cls: 'k-button k-button-icontext k-primary', handle: () => {\r\n                            this.dlg.content.upload().subscribe(\r\n                                res => {\r\n                                    if (res) {\r\n                                        resolve(res);\r\n                                        flag = 1;\r\n                                        this.dlg.close();\r\n                                    }\r\n                                }\r\n                            );\r\n                        }\r\n                    },\r\n                    {\r\n                        text: this.localpipe.transform('close'), cls: 'k-button k-button-icontext', handle: () => {\r\n                            this.dlg.close();\r\n                        }\r\n                    }\r\n                ],\r\n\r\n                showButtons: true,\r\n                showMaxButton: false,\r\n                beforeClose: (): Observable<boolean> => {\r\n                    if (flag == 0)\r\n                        this.dlg.content.cancel();\r\n                    return of(true);\r\n                }\r\n            });\r\n        })\r\n    }\r\n\r\n    uploadFile(formId: string, rootId: string, oldIdList: string[] = []) {\r\n        return this.uploadFileWithLimit(formId, rootId, null, oldIdList);\r\n    }\r\n\r\n\r\n    uploadFileWithLimit(formId: string, rootId: string, limit: UploadLimit, oldIdList: string[] = []) {\r\n        let flag = 0;\r\n        return new Promise(resolve => {\r\n            var uploadFactory = this.componentFactoryResolver.resolveComponentFactory(FileUploadComponent);\r\n            var uploadRef = uploadFactory.create(this.injector);\r\n            if (limit != null) {\r\n                uploadRef.instance.fileCount = limit.fileCount;\r\n                uploadRef.instance.securityInfo=limit.securityInfo;\r\n                if (limit.fileType != null && limit.fileType != \"\")\r\n                    uploadRef.instance.fileType = limit.fileType\r\n            }\r\n\r\n            uploadRef.instance.rootId = rootId;\r\n            uploadRef.instance.formId = formId;\r\n            uploadRef.instance.oldIdList = oldIdList;\r\n\r\n            this.dlg = this.modalService.show(uploadRef, {\r\n                title: this.localpipe.transform('uploadFile'),\r\n                width: 950, height: 570,\r\n                buttons: [\r\n                    {\r\n\r\n                        text: this.localpipe.transform('save'), cls: 'k-button k-button-icontext k-primary', handle: () => {\r\n                            this.dlg.content.upload().subscribe(\r\n                                res => {\r\n                                    if (res) {\r\n                                        resolve(res);\r\n                                        flag = 1;\r\n                                        this.dlg.close();\r\n                                    }\r\n                                }\r\n                            );\r\n                        }\r\n                    },\r\n                    {\r\n                        text: this.localpipe.transform('close'), cls: 'k-button k-button-icontext', handle: () => {\r\n                            this.dlg.close();\r\n                        }\r\n                    }\r\n                ],\r\n\r\n                showButtons: true,\r\n                showMaxButton: false,\r\n                beforeClose: (): Observable<boolean> => {\r\n                    if (flag == 0)\r\n                        this.dlg.content.cancel();\r\n                    return of(true);\r\n                }\r\n            });\r\n        })\r\n    }\r\n}"]}

package/esm5/public-api.js

@@ -26,4 +26,7 @@ export { GspFormUploadEntity } from './lib/upload/entity/gspformuploadentity';
 export { FileInfo } from './lib/upload/entity/fileinfo';
 export { OperatingModes } from './lib/upload/entity/operatingmodes';
 export { FileState } from './lib/upload/entity/filestate';
-//# sourceMappingURL=data:application/json;base64,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
+export { GspDocSecurityBaseInfo } from './lib/upload/entity/gspdocsecuritynaseinfo';
+export { SecurityEntity } from './lib/upload/entity/securityentity';
+export { ExStorageFileInfo } from './lib/upload/entity/extensionstoragefileinfo';
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/gsp-svc-formdoc-upload.js

@@ -11,7 +11,7 @@ import { ProgressModule } from '@farris/ui-progress';
 import { FormsModule } from '@angular/forms';
 import { ComboListModule } from '@farris/ui-combo-list';
 import { LanguageService, HttpService } from '@ecp-caf/caf-common';
-import { Injectable, Pipe, Inject, LOCALE_ID, Component, NgModule, Injector, ComponentFactoryResolver, Input, ViewChild, defineInjectable } from '@angular/core';
+import { Injectable, Pipe, Inject, LOCALE_ID, Component, NgModule, ViewChild, Input, Injector, ComponentFactoryResolver, defineInjectable } from '@angular/core';
 import { BsModalService } from '@farris/ui-modal';
 import { of as of$1 } from 'rxjs';
 import { HttpClientModule } from '@angular/common/http';
@@ -284,6 +284,26 @@ class UploadService {
             return of(error);
         })));
     }
+    /**
+     * @param {?} baseInfo
+     * @return {?}
+     */
+    getSecurityInfoList(baseInfo) {
+        /** @type {?} */
+        let url = "/api/runtime/dfs/v1.0/storagestrategy/security";
+        url = url + "?id=" + baseInfo.securityId + "&level=" + baseInfo.securityLevel;
+        return this.http.get(url).pipe(tap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => { })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        (error) => {
+            return of(error);
+        })));
+    }
     /**
      * @param {?} storageInfoList
      * @param {?} rootId
@@ -308,6 +328,37 @@ class UploadService {
             return of(error);
         })));
     }
+    /**
+     * @param {?} uploadFileInfoList
+     * @param {?} rootId
+     * @return {?}
+     */
+    saveSecurityInfo(uploadFileInfoList, rootId) {
+        /** @type {?} */
+        let url = "/api/runtime/dfs/v1.0/doc/exproperty";
+        /** @type {?} */
+        let reqList = [];
+        uploadFileInfoList.forEach((/**
+         * @param {?} element
+         * @return {?}
+         */
+        element => {
+            /** @type {?} */
+            let request = { id: element.metadataId, rootId: rootId, exProperty: JSON.stringify(element.securityInfo) };
+            reqList.push(request);
+        }));
+        return this.http.post(url, reqList).pipe(tap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => { })), catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        (error) => {
+            return of(error);
+        })));
+    }
     /**
      * @param {?} formId
      * @param {?} rootId
@@ -535,6 +586,13 @@ LocalLangPipe.ctorParameters = () => [
     { type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] }
 ];
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class GspDocSecurityBaseInfo {
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -575,10 +633,12 @@ class FileUploadComponent {
         this.uploadedProcess = {};
         this.defaultPropertyName = "";
         this.propertiesNames = [];
+        this.securityInfoList = [];
         this.queueListStyle = { width: '480px' };
         this.dropListValue = "";
         this.uploadedFileTotal = 0;
         this.haveExtensionProperty = false;
+        this.haveSecurityInfo = false;
         this.uploadedFileInfoList = [];
         this.oldUploadedFileList = [];
         //uploadedNameList = [];
@@ -587,6 +647,7 @@ class FileUploadComponent {
         this.fileType = "*";
         this.fileCount = 0;
         this.oldIdList = [];
+        this.securityInfo = null;
         this.totalLoad = null;
         this.exStorageFileList = [];
         if (this.injector) {
@@ -601,6 +662,25 @@ class FileUploadComponent {
         if (navigator.userAgent.indexOf('Firefox') >= 0)
             this.checkboxPos.top = '14px';
         //if (this.storageService != null) {
+        if (this.securityInfo != null) {
+            this.uploadService.getSecurityInfoList(this.securityInfo).subscribe((/**
+             * @param {?} res
+             * @return {?}
+             */
+            res => {
+                this.haveSecurityInfo = true;
+                /** @type {?} */
+                let i = 0;
+                res.forEach((/**
+                 * @param {?} element
+                 * @return {?}
+                 */
+                element => {
+                    this.securityInfoList.push({ id: i.toString(), securityId: element.securityId, securityLevel: element.securityLevel, name: element.name });
+                    i++;
+                }));
+            }));
+        }
         this.uploadService.getStorageExtensionInfo().subscribe((/**
          * @param {?} res
          * @return {?}
@@ -653,10 +733,11 @@ class FileUploadComponent {
      * @return {?}
      */
     showLoading() {
-        if (this.totalLoad == null)
-            this.totalLoad = this.loadService.show({
-                message: this.localepipe.transform('uploading')
-            });
+        this.hasSelectedFile = true;
+        // if (this.totalLoad == null)
+        //   this.totalLoad = this.loadService.show({
+        //     message: this.localepipe.transform('uploading')
+        //   });
     }
     /**
      * @param {?} $event
@@ -666,8 +747,8 @@ class FileUploadComponent {
         // const loading = this.loadService.show({
         //   message: this.localepipe.transform('uploading')
         // });
-        this.totalLoad.close();
-        this.totalLoad = null;
+        // this.totalLoad.close();
+        // this.totalLoad = null;
         this.hasSelectedFile = true;
         this.selectedFiles = document.querySelector('#file');
         if (this.fileCount > 0) {
@@ -854,7 +935,9 @@ class FileUploadComponent {
             uploadProcess: 0,
             errorMessage: "",
             extensionDropListId: 0,
-            extensionName: ""
+            extensionName: "",
+            securityDropListId: 0,
+            securityInfo: this.securityInfoList[0]
         };
         if (this.storageExtension != null)
             fileInfo.extensionName = this.defaultPropertyName;
@@ -869,6 +952,7 @@ class FileUploadComponent {
         uploadFileInfo.fileName = fileInfo.name;
         uploadFileInfo.fileSize = fileInfo.size;
         uploadFileInfo.state = state;
+        uploadFileInfo.securityInfo = this.securityInfoList[0];
         while (chunkIndex < chunkTotal) {
             /** @type {?} */
             let uploadInfo = new GspFormUploadEntity;
@@ -1204,6 +1288,21 @@ class FileUploadComponent {
         }
         return name;
     }
+    /**
+     * @param {?} $event
+     * @param {?} file
+     * @return {?}
+     */
+    securityChange($event, file) {
+        file.securityInfo = $event.data;
+        /** @type {?} */
+        let uploadFile = this.uploadFileInfoList.filter((/**
+         * @param {?} x
+         * @return {?}
+         */
+        x => x.metadataId = file.id))[0];
+        uploadFile.securityInfo = $event.data;
+    }
     /**
      * @param {?} $event
      * @param {?} file
@@ -1260,6 +1359,9 @@ class FileUploadComponent {
             this.msgService.warning(this.localepipe.transform('wait'));
             return of$1(false);
         }
+        if (this.haveSecurityInfo) {
+            this.uploadService.saveSecurityInfo(this.uploadFileInfoList, this.rootId).subscribe();
+        }
         if (this.storageExtension == null)
             return of$1(this.uploadFileInfoList);
         else {
@@ -1378,7 +1480,7 @@ class FileUploadComponent {
 FileUploadComponent.decorators = [
     { type: Component, args: [{
                 selector: 'app-file-upload',
-                template: "<div *ngIf=\"hasSelectedFile\">\n\n    <div class=\"farris-header\" style=\"height: 50px; width: 100%\">\n        <div class=\"btn btn-secondary upload_button\">\n            <img [src]=\"uploadLittleIconAddress\">\n            <span>{{'uploadFile' | locale}} </span>\n            <input type=\"file\" (focus)=\"showLoading()\" (change)=\"fileSelected($event)\" id=\"file\" multiple=\"multiple\" title=\"\" [accept]=\"fileType\">\n        </div>\n\n\n        <button *ngIf=\"showType==0 && !fileAllSelected && files.length >0 \" style=\"padding-left: 20px\" class=\"btn-link btn ng-star-inserted\" (click)=\"selectAllFile()\">{{'selectAll' | locale}}</button>\n        <button *ngIf=\"showType==0 && fileAllSelected  && files.length >0 \" style=\"padding-left: 20px\" class=\"btn-link btn ng-star-inserted\" (click)=\"selectAllFile()\">{{'selectNull' | locale}}</button>\n        <button *ngIf=\"showType==0 && selectedFileCount>0\" style=\"padding-left: 20px\" class=\"btn-link btn ng-star-inserted\" (click)=\"listMultipleDeleteFile()\">{{'delete' | locale}}</button>\n\n        <button *ngIf=\"showType==1 && selectedFileCount>0\" style=\"padding-left: 20px\" class=\"btn-link btn ng-star-inserted\" (click)=\"listMultipleDeleteFile()\">{{'delete' | locale}}</button>\n\n        <kendo-buttongroup [selection]=\"'single'\" class=\"button_group_upload \" style=\"background-color: #ffffff; color: #388FFF;border: 1px solid #ddd;\" look=\"flat\">\n            <button kendoButton [selected]=\"true\" [toggleable]=\"true\" [imageUrl]=\"'/platform/runtime/dfs/images/piclist.png'\" (click)=\"showByGroup()\"></button>\n            <button kendoButton [toggleable]=\"true\" [imageUrl]=\"'/platform/runtime/dfs/images/queuelist.png'\" (click)=\"showByList()\"></button>\n        </kendo-buttongroup>\n\n\n    </div>\n\n    <!-- <div class=\"progress\" style=\"height: 12px;\">\n    <div class=\"progress-bar\" role=\"progressbar\" [ngStyle]=\"uploadProcess\"></div>\n  </div> -->\n\n    <div class=\"pic_list\" *ngIf=\"showType==0\">\n        <ul *ngFor=\"let file of files\">\n            <li (mouseenter)=\"mouseOver(file)\" (mouseleave)=\"mouseOut(file)\">\n                <div *ngIf=\"file.isUploading\">\n                    <farris-progress [type]=\"'circle'\" [percent]=\"file.uploadProcess\" [strokeLinecap]=\"'square'\" [status]=\"'active'\"></farris-progress>\n                </div>\n\n                <table *ngIf=\"!file.uploadResult && !file.isUploading\" style=\"margin: 0 auto; border: 1px solid #ddd; width: 135px; height: 160px;\">\n                    <tr style=\"margin: 0 auto ; height: 80px;\">\n                        <td style=\"text-align: center\"><span class=\"f-icon f-icon-error\"></span></td>\n                    </tr>\n                    <tr style=\"margin: 0 auto ; height: 30px;\">\n                        <td style=\"text-align: center\"> {{'uploadFailure' | locale}} </td>\n                    </tr>\n                    <tr>\n                        <td style=\"text-align: center\"><button style=\"margin: 0 auto ; height: 20px; \" class=\"btn-link btn ng-star-inserted\" (click)=\"showErrorMessage(file)\">{{'detail' | locale}}</button></td>\n                    </tr>\n                </table>\n                <div *ngIf=\"!file.isUploading && file.uploadResult\" style=\"border: 1px solid #ddd;\">\n                    <img [src]='file.source'>\n                    <div *ngIf=\"haveExtensionProperty\" style=\"width: 133px; height: 25px; background-color: white; position: absolute;bottom: 0; \">\n\n                        <div style=\"width: 100px;height: 25px;position:absolute;margin: 0 17px;\">\n                            <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"propertiesNames\" [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"typeChange($event,file)\" [enableClear]=\"false\">\n                                <!-- <ng-template #itemTemp let-item>\n                                    <div class=\"combo-list\">\n                                        <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                        <span class=\"combo-list-label\">{{item.label}}</span>\n                                    </div>\n                                </ng-template> -->\n                            </farris-combo-list>\n                        </div>\n                    </div>\n                </div>\n                <table *ngIf=\"!file.isUploading\">\n                    <tr style=\"height: 20px\">\n                        <td style=\"width: 15px; vertical-align: middle; text-align: center\">\n                            <!-- <input type=\"checkbox\" [id]=\"file.name\" (click)=\"checkoutSelectFile(file.name)\">  -->\n                            <div class=\"farris-input-wrap\" style=\"height: 20px\" (click)=\"checkoutSelectFile(file)\">\n                                <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0;height: 20px;\" [ngStyle]=\"checkboxPos\">\n                                    <input class=\"custom-control-input\" type=\"checkbox\" [id]=\"file.name\" [(ngModel)]=\"file.selectd\">\n                                    <label class=\"custom-control-label\" style=\"padding: 0 0 10px 0; position: relative; top: -8px;\"></label>\n                                </div>\n                            </div>\n                        </td>\n                        <td style=\"width: 120px; vertical-align: middle; text-align: center\" [title]=\"file.name\">\n                            {{file.picListDisplayName}}</td>\n                    </tr>\n                </table>\n                <!-- <span>{{file.picListDisplayName}}</span> -->\n                <!-- <p class=\"filename\">{{file.picListDisplayName}}</p> -->\n                <button *ngIf=\"!file.isUploading && file.mouseOn\" style=\"position: absolute; top: 0; right: 0px; width: 24px; height: 24px;\" kendoButton [icon]=\"'delete'\" (click)=\"listDeleteFile(file)\"></button>\n                <!-- <button *ngIf=\"file.hasUploaded\" class=\"k-primary\" kendoButton [icon]=\"'check'\" [disabled]=\"true\"></button> -->\n            </li>\n        </ul>\n        <br>\n    </div>\n\n    <div class=\"queue_list\" *ngIf=\"showType==1\">\n        <table>\n            <tr style=\"height: 50px; table-layout:fixed;\">\n                <th style=\"width: 40px; vertical-align: middle; text-align: center\">\n                    <!-- <input type=\"checkbox\" id=\"allCheckBox\" (click)=\"selectAllFile()\"> -->\n                    <div class=\"farris-input-wrap\" (click)=\"selectAllFile()\">\n                        <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0\">\n                            <input class=\"custom-control-input\" type=\"checkbox\" id=\"allCheckBox\" [(ngModel)]=\"fileAllSelected\">\n                            <label class=\"custom-control-label\" style=\"padding: 0\"></label>\n                        </div>\n                    </div>\n                </th>\n                <th style=\"vertical-align: middle\" [ngStyle]=\"queueListStyle\">{{'fileName' | locale}}</th>\n                <th style=\"width: 100px; vertical-align: middle\">{{'size' | locale}}</th>\n                <th style=\"width: 170px; vertical-align: middle; text-align: center\">{{'state' | locale}}</th>\n                <th *ngIf=\"haveExtensionProperty\" style=\"width: 100px; vertical-align: middle; text-align: center\">\n                    {{storageExtension.extensionName}}\n                </th>\n                <th style=\"width: 140px; vertical-align: middle; text-align: center\">{{'operation' | locale}}</th>\n            </tr>\n        </table>\n        <div style=\"height: 370px; overflow: auto;\">\n            <table>\n                <tr *ngFor=\"let file of files\" style=\"height: 40px\">\n                    <td colspan=\"5\" *ngIf=\"file.isUploading\">\n                        <!-- <div style=\"width:100%; display: table-cell; vertical-align: middle; text-align: center; \"> -->\n                        <div style=\"width: 500px;margin:0 auto\">\n                            <farris-progress [percent]=\"file.uploadProcess\" [status]=\"'active'\">\n                            </farris-progress>\n                        </div>\n\n                    </td>\n                    <td *ngIf=\"!file.isUploading\" style=\" width: 40px; vertical-align: middle; text-align: center\">\n                        <!-- <input type=\"checkbox\" [id]=\"file.name\" (click)=\"checkoutSelectFile(file.name)\"> -->\n                        <div class=\"farris-input-wrap\" (click)=\"checkoutSelectFile(file)\">\n                            <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0\">\n                                <input class=\"custom-control-input\" type=\"checkbox\" [id]=\"file.name\" [(ngModel)]=\"file.selectd\">\n                                <label class=\"custom-control-label\" style=\"padding: 0\"></label>\n                            </div>\n                        </div>\n                    </td>\n                    <td *ngIf=\"!file.isUploading\" style=\"vertical-align: middle\" [ngStyle]=\"queueListStyle\">\n                        {{file.queueListDisplayName}}</td>\n                    <td *ngIf=\"!file.isUploading\" style=\"width: 100px; vertical-align: middle\">{{file.size}}</td>\n                    <td *ngIf=\"!file.isUploading\" style=\"text-align: center; width: 170px; vertical-align: middle;\">\n                        <table *ngIf=\"!file.uploadResult\" style=\"margin: 0 auto\">\n                            <tr style=\"margin: 0 auto\">\n                                <td><span class=\"f-icon f-icon-error\"></span></td>\n                                <td> {{'uploadFailure' | locale}} </td>\n                                <td><button style=\"height: 24px\" class=\"btn-link btn ng-star-inserted\" (click)=\"showErrorMessage(file)\">{{'detail' | locale}}</button></td>\n                            </tr>\n                        </table>\n                        <!-- <span *ngIf=\"!file.uploadResult\"><span class=\"f-icon f-icon-error\"></span> \u4E0A\u4F20\u5931\u8D25 <button\n              class=\"btn-link btn ng-star-inserted\" (click)=\"showErrorMessage(file)\">\u8BE6\u60C5</button></span> -->\n                        <span *ngIf=\"file.uploadResult\"><span class=\"f-icon f-icon-success\"></span> {{'uploadSucceed' | locale}}</span>\n                    </td>\n                    <td *ngIf=\"!file.isUploading&&haveExtensionProperty\" style=\"text-align: center; width: 100px; vertical-align: middle;\">\n                        <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"propertiesNames\" [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"typeChange($event,file)\" [enableClear]=\"false\">\n                            <!-- <ng-template #itemTemp let-item>\n                                    <div class=\"combo-list\">\n                                        <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                        <span class=\"combo-list-label\">{{item.label}}</span>\n                                    </div>\n                                </ng-template> -->\n                        </farris-combo-list>\n                    </td>\n                    <td *ngIf=\"!file.isUploading\" style=\"text-align: center; width: 140px; vertical-align: middle;\">\n                        <!-- <button *ngIf=\"file.uploadResult\" class=\"btn-link btn ng-star-inserted\" (click)=\"retryUploadFile(file.name)\">\u91CD\u8BD5</button> -->\n                        <button class=\"btn-link btn ng-star-inserted\" style=\"margin: 0 auto\" (click)=\"listDeleteFile(file)\">{{'delete' | locale}}</button>\n                    </td>\n\n                </tr>\n            </table>\n        </div>\n    </div>\n</div>\n\n<div *ngIf=\"!hasSelectedFile\" class='home_page'>\n    <img [src]=\"uploadIconAddress\">\n    <div>\n        <span class=\"btn btn-primary btn-lg\">\u4E0A\u4F20\u6587\u4EF6 </span>\n        <input type=\"file\" (focus)=\"showLoading()\" (change)=\"fileSelected($event)\" id=\"file\" multiple=\"multiple\" title=\"\" [accept]=\"fileType\">\n    </div>\n</div>",
+                template: "<div *ngIf=\"hasSelectedFile\">\n\n    <div class=\"farris-header\" style=\"height: 50px; width: 100%\">\n        <div class=\"btn btn-secondary upload_button\">\n            <img [src]=\"uploadLittleIconAddress\">\n            <span>{{'uploadFile' | locale}} </span>\n            <input type=\"file\" (focus)=\"showLoading()\" (change)=\"fileSelected($event)\" id=\"file\" multiple=\"multiple\"\n                title=\"\" [accept]=\"fileType\">\n        </div>\n\n\n        <button *ngIf=\"showType==0 && !fileAllSelected && files.length >0 \" style=\"padding-left: 20px\"\n            class=\"btn-link btn ng-star-inserted\" (click)=\"selectAllFile()\">{{'selectAll' | locale}}</button>\n        <button *ngIf=\"showType==0 && fileAllSelected  && files.length >0 \" style=\"padding-left: 20px\"\n            class=\"btn-link btn ng-star-inserted\" (click)=\"selectAllFile()\">{{'selectNull' | locale}}</button>\n        <button *ngIf=\"showType==0 && selectedFileCount>0\" style=\"padding-left: 20px\"\n            class=\"btn-link btn ng-star-inserted\" (click)=\"listMultipleDeleteFile()\">{{'delete' | locale}}</button>\n\n        <button *ngIf=\"showType==1 && selectedFileCount>0\" style=\"padding-left: 20px\"\n            class=\"btn-link btn ng-star-inserted\" (click)=\"listMultipleDeleteFile()\">{{'delete' | locale}}</button>\n\n        <kendo-buttongroup [selection]=\"'single'\" class=\"button_group_upload \"\n            style=\"background-color: #ffffff; color: #388FFF;border: 1px solid #ddd;\" look=\"flat\">\n            <button kendoButton [selected]=\"true\" [toggleable]=\"true\"\n                [imageUrl]=\"'/platform/runtime/dfs/images/piclist.png'\" (click)=\"showByGroup()\"></button>\n            <button kendoButton [toggleable]=\"true\" [imageUrl]=\"'/platform/runtime/dfs/images/queuelist.png'\"\n                (click)=\"showByList()\"></button>\n        </kendo-buttongroup>\n\n\n    </div>\n\n    <!-- <div class=\"progress\" style=\"height: 12px;\">\n    <div class=\"progress-bar\" role=\"progressbar\" [ngStyle]=\"uploadProcess\"></div>\n  </div> -->\n\n    <div class=\"pic_list\" *ngIf=\"showType==0\">\n        <ul *ngFor=\"let file of files\">\n            <li (mouseenter)=\"mouseOver(file)\" (mouseleave)=\"mouseOut(file)\">\n                <div *ngIf=\"file.isUploading\">\n                    <farris-progress [type]=\"'circle'\" [percent]=\"file.uploadProcess\" [strokeLinecap]=\"'square'\"\n                        [status]=\"'active'\"></farris-progress>\n                </div>\n\n                <table *ngIf=\"!file.uploadResult && !file.isUploading\"\n                    style=\"margin: 0 auto; border: 1px solid #ddd; width: 135px; height: 160px;\">\n                    <tr style=\"margin: 0 auto ; height: 80px;\">\n                        <td style=\"text-align: center\"><span class=\"f-icon f-icon-error\"></span></td>\n                    </tr>\n                    <tr style=\"margin: 0 auto ; height: 30px;\">\n                        <td style=\"text-align: center\"> {{'uploadFailure' | locale}} </td>\n                    </tr>\n                    <tr>\n                        <td style=\"text-align: center\"><button style=\"margin: 0 auto ; height: 20px; \"\n                                class=\"btn-link btn ng-star-inserted\" (click)=\"showErrorMessage(file)\">{{'detail' |\n                                locale}}</button></td>\n                    </tr>\n                </table>\n                <div *ngIf=\"!file.isUploading && file.uploadResult\" style=\"border: 1px solid #ddd;\">\n                    <img [src]='file.source'>\n                    <div *ngIf=\"haveExtensionProperty\"\n                        style=\"width: 133px; height: 25px; background-color: white; position: absolute;bottom: 0; \">\n\n                        <div style=\"width: 100px;height: 25px;position:absolute;margin: 0 17px;\">\n                            <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"propertiesNames\"\n                                [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"typeChange($event,file)\"\n                                [enableClear]=\"false\">\n                                <!-- <ng-template #itemTemp let-item>\n                                    <div class=\"combo-list\">\n                                        <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                        <span class=\"combo-list-label\">{{item.label}}</span>\n                                    </div>\n                                </ng-template> -->\n                            </farris-combo-list>\n                        </div>\n                    </div>\n                    <div *ngIf=\"haveSecurityInfo\"\n                        style=\"width: 133px; height: 25px; background-color: white; position: absolute;bottom: 0; \">\n\n                        <div style=\"width: 100px;height: 25px;position:absolute;margin: 0 17px;\">\n                            <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"securityInfoList\"\n                                [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"securityChange($event,file)\"\n                                [enableClear]=\"false\">\n                                <!-- <ng-template #itemTemp let-item>\n                                    <div class=\"combo-list\">\n                                        <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                        <span class=\"combo-list-label\">{{item.label}}</span>\n                                    </div>\n                                </ng-template> -->\n                            </farris-combo-list>\n                        </div>\n                    </div>\n                </div>\n                <table *ngIf=\"!file.isUploading\">\n                    <tr style=\"height: 20px\">\n                        <td style=\"width: 15px; vertical-align: middle; text-align: center\">\n                            <!-- <input type=\"checkbox\" [id]=\"file.name\" (click)=\"checkoutSelectFile(file.name)\">  -->\n                            <div class=\"farris-input-wrap\" style=\"height: 20px\" (click)=\"checkoutSelectFile(file)\">\n                                <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0;height: 20px;\"\n                                    [ngStyle]=\"checkboxPos\">\n                                    <input class=\"custom-control-input\" type=\"checkbox\" [id]=\"file.name\"\n                                        [(ngModel)]=\"file.selectd\">\n                                    <label class=\"custom-control-label\"\n                                        style=\"padding: 0 0 10px 0; position: relative; top: -8px;\"></label>\n                                </div>\n                            </div>\n                        </td>\n                        <td style=\"width: 120px; vertical-align: middle; text-align: center\" [title]=\"file.name\">\n                            {{file.picListDisplayName}}</td>\n                    </tr>\n                </table>\n                <!-- <span>{{file.picListDisplayName}}</span> -->\n                <!-- <p class=\"filename\">{{file.picListDisplayName}}</p> -->\n                <button *ngIf=\"!file.isUploading && file.mouseOn\"\n                    style=\"position: absolute; top: 0; right: 0px; width: 24px; height: 24px;\" kendoButton\n                    [icon]=\"'delete'\" (click)=\"listDeleteFile(file)\"></button>\n                <!-- <button *ngIf=\"file.hasUploaded\" class=\"k-primary\" kendoButton [icon]=\"'check'\" [disabled]=\"true\"></button> -->\n            </li>\n        </ul>\n        <br>\n    </div>\n\n    <div class=\"queue_list\" *ngIf=\"showType==1\">\n        <table>\n            <tr style=\"height: 50px; table-layout:fixed;\">\n                <th style=\"width: 40px; vertical-align: middle; text-align: center\">\n                    <!-- <input type=\"checkbox\" id=\"allCheckBox\" (click)=\"selectAllFile()\"> -->\n                    <div class=\"farris-input-wrap\" (click)=\"selectAllFile()\">\n                        <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0\">\n                            <input class=\"custom-control-input\" type=\"checkbox\" id=\"allCheckBox\"\n                                [(ngModel)]=\"fileAllSelected\">\n                            <label class=\"custom-control-label\" style=\"padding: 0\"></label>\n                        </div>\n                    </div>\n                </th>\n                <th style=\"vertical-align: middle\" [ngStyle]=\"queueListStyle\">{{'fileName' | locale}}</th>\n                <th style=\"width: 100px; vertical-align: middle\">{{'size' | locale}}</th>\n                <th style=\"width: 170px; vertical-align: middle; text-align: center\">{{'state' | locale}}</th>\n                <th *ngIf=\"haveExtensionProperty\" style=\"width: 100px; vertical-align: middle; text-align: center\">\n                    {{storageExtension.extensionName}}\n                </th>\n                <th style=\"width: 140px; vertical-align: middle; text-align: center\">{{'operation' | locale}}</th>\n            </tr>\n        </table>\n        <div style=\"height: 370px; overflow: auto;\">\n            <table>\n                <tr *ngFor=\"let file of files\" style=\"height: 40px\">\n                    <td colspan=\"5\" *ngIf=\"file.isUploading\">\n                        <!-- <div style=\"width:100%; display: table-cell; vertical-align: middle; text-align: center; \"> -->\n                        <div style=\"width: 500px;margin:0 auto\">\n                            <farris-progress [percent]=\"file.uploadProcess\" [status]=\"'active'\">\n                            </farris-progress>\n                        </div>\n\n                    </td>\n                    <td *ngIf=\"!file.isUploading\" style=\" width: 40px; vertical-align: middle; text-align: center\">\n                        <!-- <input type=\"checkbox\" [id]=\"file.name\" (click)=\"checkoutSelectFile(file.name)\"> -->\n                        <div class=\"farris-input-wrap\" (click)=\"checkoutSelectFile(file)\">\n                            <div class=\"custom-control custom-checkbox\" style=\"margin: 4px 0 0\">\n                                <input class=\"custom-control-input\" type=\"checkbox\" [id]=\"file.name\"\n                                    [(ngModel)]=\"file.selectd\">\n                                <label class=\"custom-control-label\" style=\"padding: 0\"></label>\n                            </div>\n                        </div>\n                    </td>\n                    <td *ngIf=\"!file.isUploading\" style=\"vertical-align: middle\" [ngStyle]=\"queueListStyle\">\n                        {{file.queueListDisplayName}}</td>\n                    <td *ngIf=\"!file.isUploading\" style=\"width: 100px; vertical-align: middle\">{{file.size}}</td>\n                    <td *ngIf=\"!file.isUploading\" style=\"text-align: center; width: 170px; vertical-align: middle;\">\n                        <table *ngIf=\"!file.uploadResult\" style=\"margin: 0 auto\">\n                            <tr style=\"margin: 0 auto\">\n                                <td><span class=\"f-icon f-icon-error\"></span></td>\n                                <td> {{'uploadFailure' | locale}} </td>\n                                <td><button style=\"height: 24px\" class=\"btn-link btn ng-star-inserted\"\n                                        (click)=\"showErrorMessage(file)\">{{'detail' | locale}}</button></td>\n                            </tr>\n                        </table>\n                        <!-- <span *ngIf=\"!file.uploadResult\"><span class=\"f-icon f-icon-error\"></span> \u4E0A\u4F20\u5931\u8D25 <button\n              class=\"btn-link btn ng-star-inserted\" (click)=\"showErrorMessage(file)\">\u8BE6\u60C5</button></span> -->\n                        <span *ngIf=\"file.uploadResult\"><span class=\"f-icon f-icon-success\"></span> {{'uploadSucceed' |\n                            locale}}</span>\n                    </td>\n                    <td *ngIf=\"!file.isUploading&&haveExtensionProperty\"\n                        style=\"text-align: center; width: 100px; vertical-align: middle;\">\n                        <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"propertiesNames\"\n                            [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"typeChange($event,file)\"\n                            [enableClear]=\"false\">\n                            <!-- <ng-template #itemTemp let-item>\n                                    <div class=\"combo-list\">\n                                        <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                        <span class=\"combo-list-label\">{{item.label}}</span>\n                                    </div>\n                                </ng-template> -->\n                        </farris-combo-list>\n                    </td>\n                    <td *ngIf=\"!file.isUploading&&haveSecurityInfo\"\n                        style=\"text-align: center; width: 100px; vertical-align: middle;\">\n                        <farris-combo-list [(ngModel)]=\"file.extensionDropListId\" [data]=\"securityInfoList\"\n                            [idField]=\"'id'\" [textField]=\"'name'\" (selectChange)=\"securityChange($event,file)\"\n                            [enableClear]=\"false\">\n                            <!-- <ng-template #itemTemp let-item>\n                            <div class=\"combo-list\">\n                                <span [class]=\"'combo-list-circle combo-list-'+item.state\"></span>\n                                <span class=\"combo-list-label\">{{item.label}}</span>\n                            </div>\n                        </ng-template> -->\n                        </farris-combo-list>\n                    </td>\n\n                    <td *ngIf=\"!file.isUploading\" style=\"text-align: center; width: 140px; vertical-align: middle;\">\n                        <!-- <button *ngIf=\"file.uploadResult\" class=\"btn-link btn ng-star-inserted\" (click)=\"retryUploadFile(file.name)\">\u91CD\u8BD5</button> -->\n                        <button class=\"btn-link btn ng-star-inserted\" style=\"margin: 0 auto\"\n                            (click)=\"listDeleteFile(file)\">{{'delete' | locale}}</button>\n                    </td>\n\n                </tr>\n            </table>\n        </div>\n    </div>\n</div>\n\n<div *ngIf=\"!hasSelectedFile\" class='home_page'>\n    <img [src]=\"uploadIconAddress\">\n    <div>\n        <span class=\"btn btn-primary btn-lg\">{{'uploadFile' | locale}} </span>\n        <input type=\"file\" (change)=\"fileSelected($event)\" id=\"file\" multiple=\"multiple\" title=\"\" [accept]=\"fileType\">\n        <!-- <input type=\"file\" (focus)=\"showLoading()\" (change)=\"fileSelected($event)\" id=\"file\" multiple=\"multiple\" title=\"\" [accept]=\"fileType\"> -->\n    </div>\n</div>",
                 styles: [".home_page{text-align:center}.home_page img{position:absolute;top:180px;margin-left:-35px;width:70px;height:56px}.home_page div{position:absolute;left:50%;top:255px;margin-left:-75px;width:150px;height:32px;overflow:hidden}.home_page div span{width:150px;height:32px;position:absolute;z-index:10;left:0}.home_page div input{position:absolute;left:0;top:0;opacity:0;filter:'alpha(opacity=0)';z-index:11}.upload_button{width:110px;height:32px;overflow:hidden}.upload_button span{position:relative;right:-4px;top:4px;width:56px;height:22px;font-size:14px}.upload_button input{height:32px;width:110px;position:absolute;left:22px;top:12px;opacity:0;filter:'alpha(opacity=0)';overflow:hidden}.upload_button img{position:relative;left:-6px;top:3px;width:14px;height:14px}.button_group_upload{position:absolute;right:18px;top:12px;height:26px;width:53px}.button_group_upload button{height:26px;width:26px}.fileinput-button{position:absolute;right:60px;bottom:40px;overflow:hidden;width:24px;height:24px;border-radius:12px;transform:scale(2.5);-ms-transform:scale(2.5);-moz-transform:scale(2.5);-webkit-transform:scale(2.5);-o-transform:scale(2.5);color:#0686fd}.fileinput-button input{position:absolute;left:0;top:0;opacity:0;filter:'alpha(opacity=0)'}.pic-droplist{height:24px;color:#e0e1e2;background-color:#e0e1e2}.pic-droplist input-group{display:table-cell;width:100px;text-align:center;border:0}.pic-droplist input-group div{border:0}.pic-droplist input-group div div,.pic-droplist input-group div input{background-color:#e0e1e2}.pic_list{padding:0;height:420px;overflow-y:auto;overflow-x:hidden}.pic_list ul{padding:0;list-style:none;width:100%;margin:20px 0 0 20px}.pic_list ul li{height:180px;width:135px;margin:8px 0 8px 12px;float:left;overflow:hidden;align-items:center;position:relative}.pic_list ul li div{width:135px;height:160px;margin:auto;display:table-cell;vertical-align:middle;text-align:center;position:relative}.pic_list ul li div img{max-width:120px;max-height:118px;align-items:center;margin:auto;vertical-align:middle;text-align:center}.pic_list ul li span.filename{width:100px;text-align:center;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.queue_list{display:block;height:420px;overflow-y:auto}.file_list{list-style:none;margin:0;padding:0;overflow-x:hidden;overflow-y:auto}.file_list li{height:50px;line-height:35px;font-size:16px;position:relative}.file_list li button{float:right;top:6px;right:10px;width:20px}.file_list li p.title{padding:0 0 0 6px;margin:0 210px 0 0}.file_list li p.size{position:absolute;width:100px;top:0;right:100px}"]
             }] }
 ];
@@ -1395,6 +1497,7 @@ FileUploadComponent.propDecorators = {
     fileType: [{ type: Input }],
     fileCount: [{ type: Input }],
     oldIdList: [{ type: Input }],
+    securityInfo: [{ type: Input }],
     opCell: [{ type: ViewChild, args: ['opCell',] }]
 };
 
@@ -1729,6 +1832,7 @@ class UploadDialogService {
             var uploadRef = uploadFactory.create(this.injector);
             if (limit != null) {
                 uploadRef.instance.fileCount = limit.fileCount;
+                uploadRef.instance.securityInfo = limit.securityInfo;
                 if (limit.fileType != null && limit.fileType != "")
                     uploadRef.instance.fileType = limit.fileType;
             }
@@ -1822,6 +1926,7 @@ class UploadLimit {
     constructor() {
         this.fileType = "*";
         this.fileCount = 0;
+        this.securityInfo = null;
     }
 }
 
@@ -1846,6 +1951,13 @@ class GspDocMetaProperty {
 class FileInfo {
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class SecurityEntity {
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1856,6 +1968,6 @@ class FileInfo {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { FormdocUploadService, FormdocUploadComponent, FormdocUploadModule, UploadDialogMoudle, UploadDialogComponent, UploadDialogService, UploadService, DownloadService, FileUploadComponent, UploadFileInfo, UploadModule, ɵa, UploadLimit, GspFormDocOperateEntity, GspFormRemoveListEntity, GspFormUploadListEntity, GspFormDocInfo, GspDocMetaProperty, GspFormUploadEntity, FileInfo, OperatingModes, FileState, LocalLangPipe as ɵb };
+export { FormdocUploadService, FormdocUploadComponent, FormdocUploadModule, UploadDialogMoudle, UploadDialogComponent, UploadDialogService, UploadService, DownloadService, FileUploadComponent, UploadFileInfo, UploadModule, ɵa, UploadLimit, GspFormDocOperateEntity, GspFormRemoveListEntity, GspFormUploadListEntity, GspFormDocInfo, GspDocMetaProperty, GspFormUploadEntity, FileInfo, OperatingModes, FileState, GspDocSecurityBaseInfo, SecurityEntity, ExStorageFileInfo, LocalLangPipe as ɵb };
 
 //# sourceMappingURL=gsp-svc-formdoc-upload.js.map