@cleavelandprice/ngx-lib 3.7.2 → 3.8.0

package/esm2022/sharepoint/services/sharepoint.service.mjs

@@ -0,0 +1,149 @@
+import { Injectable, Optional } from '@angular/core';
+import { of } from 'rxjs';
+import moment from 'moment';
+import { ServiceConfig } from '../model/service-config';
+import * as i0 from "@angular/core";
+import * as i1 from "../model/service-config";
+import * as i2 from "@angular/common/http";
+class SharePointService {
+    //#region Utilities
+    cacheExpired(cache) {
+        if (!cache) {
+            return true;
+        }
+        const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;
+        const expiration = moment(cache.lastUpdate)
+            .add(lifeMinutes, 'minutes');
+        return moment().isAfter(expiration);
+    }
+    //#endregion
+    //#region Initialization
+    constructor(config, http) {
+        this.config = config;
+        this.http = http;
+        this.defaultCacheLifeMinutes = 720;
+        this.config = this.config ?? new ServiceConfig();
+        this.configureCaching();
+        this.configureLogging();
+    }
+    configureCaching() {
+        // If caching config is missing entirely, give it a default
+        this.config.caching = this.config.caching ?? {
+            enabled: false,
+            lifeMinutes: this.defaultCacheLifeMinutes
+        };
+        this.cache = {
+            photos: undefined,
+            users: undefined
+        };
+    }
+    configureLogging() {
+        // If logging config is missing entirely, give it a default
+        this.config.logging = this.config.logging ?? {
+            dataCached: false,
+            cachedDataReturned: false,
+            freshDataReturned: false,
+            cacheCleared: false
+        };
+    }
+    //#endregion
+    getListItems(request) {
+        const apiUrl = this.config.apiUrl;
+        const endpoint = this.config.listItemsEndpoint;
+        return this.http.post(`${apiUrl}${endpoint}`, request);
+    }
+    getPhotos() {
+        const request = {
+            username: this.config.username,
+            password: this.config.password,
+            site: this.config.photos.site,
+            list: this.config.photos.list,
+            additionalPropertiesToRetrieve: this.config.photos.additionalPropertiesToRetrieve
+        };
+        const observable$ = this.getListItems(request);
+        if (this.config.caching?.enabled) {
+            if (this.cacheExpired(this.cache?.photos)) {
+                // Get the data and cache it
+                observable$.subscribe(data => {
+                    this.cache.photos = {
+                        data,
+                        lastUpdate: moment()
+                    };
+                    if (this.config.logging?.dataCached) {
+                        const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;
+                        console.log(`Photos cached for ${lifeMinutes} minutes`);
+                    }
+                });
+            }
+            else {
+                // Cache exists and hasn't expired yet
+                if (this.config.logging?.cachedDataReturned) {
+                    console.log('Returning cached photos');
+                }
+                return of(this.cache.photos.data);
+            }
+        }
+        // Cache is either disabled or expired, return data from API
+        if (this.config.logging?.freshDataReturned) {
+            console.log('Returning fresh photos');
+        }
+        return observable$;
+    }
+    getUsers(request, id) {
+        const apiUrl = this.config.apiUrl;
+        const endpoint = this.config.usersEndpoint;
+        const observable$ = this.http.post(`${apiUrl}${endpoint}/${id ?? ''}`, request);
+        //#region Single user
+        if (id) {
+            return observable$;
+        }
+        //#endregion
+        //#region Multiple users
+        if (this.config.caching?.enabled) {
+            if (this.cacheExpired(this.cache.users)) {
+                // Get the data and cache it
+                observable$.subscribe(data => {
+                    this.cache.users = {
+                        data: data,
+                        lastUpdate: moment()
+                    };
+                    if (this.config.logging?.dataCached) {
+                        const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;
+                        console.log(`Users cached for ${lifeMinutes} minutes`);
+                    }
+                });
+            }
+            else {
+                // Cache exists and hasn't expired yet
+                if (this.config.logging?.cachedDataReturned) {
+                    console.log('Returning cached users');
+                }
+                return of(this.cache.users.data);
+            }
+        }
+        // Cache is either disabled or expired, return data from API
+        if (this.config.logging?.freshDataReturned) {
+            console.log('Returning fresh users');
+        }
+        return observable$;
+        //#endregion
+    }
+    clearCache() {
+        this.cache = undefined;
+        if (this.config.logging?.cacheCleared) {
+            console.log('Cache cleared');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointService, deps: [{ token: i1.ServiceConfig, optional: true }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointService, providedIn: 'root' }); }
+}
+export { SharePointService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ServiceConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sharepoint.service.js","sourceRoot":"","sources":["../../../../../../projects/cleavelandprice/ngx-lib/sharepoint/src/services/sharepoint.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Observable, of } from 'rxjs';\r\nimport moment from 'moment';\r\n\r\nimport { CacheObject } from '../model/cache-object';\r\nimport { ListItem } from '../model/list-item';\r\nimport { ListItemsRequest } from '../model/list-items-request';\r\nimport { PhotoItem } from '../model/photo-item';\r\nimport { ServiceConfig } from '../model/service-config';\r\nimport { UserRequest } from '../model/user-request';\r\nimport { User } from '../model/user';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SharePointService {\r\n  private cache: {\r\n    users: CacheObject<User> | undefined,\r\n    photos: CacheObject<PhotoItem> | undefined\r\n  } | undefined;\r\n\r\n  private defaultCacheLifeMinutes = 720;\r\n\r\n  //#region Utilities\r\n  private cacheExpired<T>(cache: CacheObject<T>): boolean {\r\n    if (!cache) {\r\n      return true;\r\n    }\r\n\r\n    const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;\r\n    const expiration = moment(cache.lastUpdate)\r\n      .add(lifeMinutes, 'minutes');\r\n\r\n    return moment().isAfter(expiration);\r\n  }\r\n  //#endregion\r\n\r\n  //#region Initialization\r\n    constructor(@Optional() private config: ServiceConfig,\r\n              private http: HttpClient) {\r\n\r\n                this.config = this.config ?? new ServiceConfig();\r\n                \r\n                this.configureCaching();\r\n                this.configureLogging();\r\n  }\r\n\r\n  private configureCaching(): void {\r\n    // If caching config is missing entirely, give it a default\r\n    this.config.caching = this.config.caching ?? {\r\n      enabled: false,\r\n      lifeMinutes: this.defaultCacheLifeMinutes\r\n    };\r\n\r\n    this.cache = {\r\n      photos: undefined,\r\n      users: undefined\r\n    };\r\n  }\r\n\r\n  private configureLogging(): void {\r\n    // If logging config is missing entirely, give it a default\r\n    this.config.logging = this.config.logging ?? {\r\n      dataCached: false,\r\n      cachedDataReturned: false,\r\n      freshDataReturned: false,\r\n      cacheCleared: false\r\n    }\r\n  }\r\n  //#endregion\r\n\r\n  getListItems(request: ListItemsRequest): Observable<ListItem[]> {\r\n    const apiUrl = this.config.apiUrl;\r\n    const endpoint = this.config.listItemsEndpoint;\r\n\r\n    return this.http.post<ListItem[]>(`${apiUrl}${endpoint}`, request);\r\n  }\r\n\r\n  getPhotos(): Observable<PhotoItem[]> {\r\n    const request: ListItemsRequest = {\r\n      username: this.config.username,\r\n      password: this.config.password,\r\n      site: this.config.photos.site,\r\n      list: this.config.photos.list,\r\n      additionalPropertiesToRetrieve: this.config.photos.additionalPropertiesToRetrieve\r\n    };\r\n\r\n    const observable$ = this.getListItems(request) as Observable<PhotoItem[]>;\r\n\r\n    if (this.config.caching?.enabled) {\r\n      if (this.cacheExpired<PhotoItem>(this.cache?.photos!)) {\r\n        // Get the data and cache it\r\n        observable$.subscribe(data => {\r\n          this.cache!.photos = {\r\n            data,\r\n            lastUpdate: moment()\r\n          };\r\n\r\n          if (this.config.logging?.dataCached) {\r\n            const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;\r\n            console.log(`Photos cached for ${lifeMinutes} minutes`);\r\n          }\r\n        });\r\n      } else {\r\n        // Cache exists and hasn't expired yet\r\n        if (this.config.logging?.cachedDataReturned) {\r\n          console.log('Returning cached photos');\r\n        }\r\n\r\n        return of(this.cache!.photos!.data);\r\n      }\r\n    }\r\n\r\n    // Cache is either disabled or expired, return data from API\r\n    if (this.config.logging?.freshDataReturned) {\r\n      console.log('Returning fresh photos');\r\n    }\r\n\r\n    return observable$;\r\n  }\r\n\r\n  getUsers(request: UserRequest, id?: number): Observable<User | User[]> {\r\n    const apiUrl = this.config.apiUrl;\r\n    const endpoint = this.config.usersEndpoint;\r\n    \r\n    const observable$ = this.http.post<User | User[]>(`${apiUrl}${endpoint}/${id ?? ''}`, request);\r\n\r\n    //#region Single user\r\n    if (id) {\r\n      return observable$;\r\n    }\r\n    //#endregion\r\n\r\n    //#region Multiple users\r\n    if (this.config.caching?.enabled) {\r\n      if (this.cacheExpired<User>(this.cache!.users!)) {\r\n        // Get the data and cache it\r\n        observable$.subscribe(data => {\r\n          this.cache!.users = {\r\n            data: data as User[],\r\n            lastUpdate: moment()\r\n          };\r\n\r\n          if (this.config.logging?.dataCached) {\r\n            const lifeMinutes = this.config.caching?.lifeMinutes ?? this.defaultCacheLifeMinutes;\r\n            console.log(`Users cached for ${lifeMinutes} minutes`);\r\n          }\r\n        });\r\n      } else {\r\n        // Cache exists and hasn't expired yet\r\n        if (this.config.logging?.cachedDataReturned) {\r\n          console.log('Returning cached users');\r\n        }\r\n\r\n        return of(this.cache!.users!.data);\r\n      }\r\n    }\r\n\r\n    // Cache is either disabled or expired, return data from API\r\n    if (this.config.logging?.freshDataReturned) {\r\n      console.log('Returning fresh users');\r\n    }\r\n\r\n    return observable$;\r\n    //#endregion\r\n  }\r\n\r\n  clearCache(): void {\r\n    this.cache = undefined;\r\n\r\n    if (this.config.logging?.cacheCleared) {\r\n      console.log('Cache cleared');\r\n    }\r\n  }\r\n}"]}

package/esm2022/sharepoint/sharepoint.module.mjs

@@ -0,0 +1,50 @@
+import { NgModule, Optional, SkipSelf } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ServiceConfig } from './model/service-config';
+import { SharePointService } from './services/sharepoint.service';
+import { EmployeePhotoUrlPipe } from './pipes/employee-photo-url.pipe';
+import { EmployeePhotoComponent } from './components/employee-photo/employee-photo.component';
+import * as i0 from "@angular/core";
+class SharePointModule {
+    static forRoot(config) {
+        return {
+            ngModule: SharePointModule,
+            providers: [
+                SharePointService,
+                { provide: ServiceConfig, useValue: config }
+            ]
+        };
+    }
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error('SharePointModule is already loaded. Import it in the AppModule only');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointModule, deps: [{ token: SharePointModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: SharePointModule, declarations: [EmployeePhotoUrlPipe,
+            EmployeePhotoComponent], imports: [CommonModule], exports: [EmployeePhotoUrlPipe,
+            EmployeePhotoComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointModule, imports: [CommonModule] }); }
+}
+export { SharePointModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: SharePointModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        EmployeePhotoUrlPipe,
+                        EmployeePhotoComponent
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [
+                        EmployeePhotoUrlPipe,
+                        EmployeePhotoComponent
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: SharePointModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/upload/cleavelandprice-ngx-lib-upload.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public_api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYXZlbGFuZHByaWNlLW5neC1saWItdXBsb2FkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xlYXZlbGFuZHByaWNlL25neC1saWIvdXBsb2FkL3NyYy9jbGVhdmVsYW5kcHJpY2Utbmd4LWxpYi11cGxvYWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2022/upload/components/upload/upload.component.mjs

@@ -0,0 +1,35 @@
+import { Component, Output, EventEmitter } from '@angular/core';
+import { UploadDialogComponent } from './../upload-dialog/upload-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "./../../services/upload.service";
+import * as i3 from "@angular/material/button";
+class UploadComponent {
+    constructor(dialog, uploadService) {
+        this.dialog = dialog;
+        this.uploadService = uploadService;
+        this.dialogClosed = new EventEmitter();
+    }
+    ngOnInit() {
+        this.uploadButtonText = this.uploadService.config.uploadButtonText ?
+            this.uploadService.config.uploadButtonText :
+            'Upload';
+    }
+    openUploadDialog() {
+        this.dialog.open(UploadDialogComponent, { width: '50%' })
+            .afterClosed().subscribe(() => this.dialogClosed.emit());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadComponent, deps: [{ token: i1.MatDialog }, { token: i2.UploadService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: UploadComponent, selector: "cp-upload", outputs: { dialogClosed: "dialogClosed" }, ngImport: i0, template: '<button mat-raised-button (click)="openUploadDialog()">{{ uploadButtonText }}</button>', isInline: true, dependencies: [{ kind: "component", type: i3.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }] }); }
+}
+export { UploadComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cp-upload',
+                    template: '<button mat-raised-button (click)="openUploadDialog()">{{ uploadButtonText }}</button>'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.UploadService }]; }, propDecorators: { dialogClosed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/upload/components/upload-dialog/upload-dialog.component.mjs

@@ -0,0 +1,87 @@
+import { Component, ViewChild } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "./../../services/upload.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/list";
+import * as i6 from "@angular/material/progress-bar";
+class UploadDialogComponent {
+    constructor(dialogRef, uploadService) {
+        this.dialogRef = dialogRef;
+        this.uploadService = uploadService;
+        this.files = new Set();
+        this.canBeClosed = true;
+        this.showCancelButton = true;
+        this.uploading = false;
+        this.uploadSuccessful = false;
+    }
+    ngOnInit() {
+        this.primaryButtonText = this.uploadService.config.uploadDialogUploadButtonText;
+    }
+    addFiles() {
+        this.file.nativeElement.click();
+    }
+    onFilesAdded() {
+        const files = this.file.nativeElement.files;
+        for (const key in files) {
+            if (!isNaN(parseInt(key))) {
+                // See if the file already exists
+                this.uploadService.exists(files[key].name)
+                    .subscribe(exists => {
+                    if (exists) {
+                        this.existingFileConflict = files[key].name;
+                    }
+                    if (!exists) {
+                        this.files.add(files[key]);
+                    }
+                });
+            }
+        }
+    }
+    closeDialog() {
+        // if everything was uploaded already, just close the dialog
+        if (this.uploadSuccessful) {
+            return this.dialogRef.close();
+        }
+        // set the component state to "uploading"
+        this.uploading = true;
+        // start the upload and save the progress map
+        this.progress = this.uploadService.upload(this.files);
+        // convert the progress map into an array
+        const allProgressObservables = [];
+        for (let key in this.progress) {
+            allProgressObservables.push(this.progress[key].progress);
+        }
+        // Adjust the state variables
+        // The OK-button should have the text "Finish" now
+        this.primaryButtonText = this.uploadService.config.uploadDialogFinishButtonText;
+        // The dialog should not be closed while uploading
+        this.canBeClosed = false;
+        this.dialogRef.disableClose = true;
+        // Hide the cancel-button
+        this.showCancelButton = false;
+        // When all progress-observables are completed...
+        forkJoin(allProgressObservables).subscribe(end => {
+            // ... the dialog can be closed again...
+            this.canBeClosed = true;
+            this.dialogRef.disableClose = false;
+            // ... the upload was successful...
+            this.uploadSuccessful = true;
+            // ... and the component is no longer uploading
+            this.uploading = false;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadDialogComponent, deps: [{ token: i1.MatDialogRef }, { token: i2.UploadService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: UploadDialogComponent, selector: "ng-component", viewQueries: [{ propertyName: "file", first: true, predicate: ["file"], descendants: true, static: true }], ngImport: i0, template: "<input type=\"file\" #file style=\"display: none\" (change)=\"onFilesAdded()\" multiple />\n\n<div mat-dialog-title id=\"title\">\n  <div>{{ uploadService.config.uploadDialogTitle }}</div>\n  <button [disabled]=\"uploading || uploadSuccessful\" mat-raised-button color=\"primary\" class=\"add-files-btn\" (click)=\"addFiles()\">\n    {{ uploadService.config.uploadDialogAddFilesButtonText }}\n  </button>\n</div>\n\n<div id=\"conflict\" *ngIf=\"existingFileConflict\">\n  {{ existingFileConflict }} already exists on the server and cannot be overwritten\n</div>\n\n<mat-dialog-content>\n  <mat-list>\n    <mat-list-item *ngFor=\"let file of files\">\n      <h4 mat-line>{{file.name}}</h4>\n      <mat-progress-bar *ngIf=\"progress\" mode=\"determinate\" [value]=\"progress[file.name].progress | async\"></mat-progress-bar>\n    </mat-list-item>\n  </mat-list>\n</mat-dialog-content>\n\n<mat-dialog-actions id=\"actions\">\n  <button *ngIf=\"showCancelButton\" mat-button mat-dialog-close>{{ uploadService.config.uploadDialogCancelButtonText }}</button>\n  <button *ngIf=\"files.size > 0\" mat-raised-button color=\"primary\" [disabled]=\"!canBeClosed\" (click)=\"closeDialog()\">{{ primaryButtonText }}</button>\n</mat-dialog-actions>\n", styles: ["#title{display:flex;justify-content:space-between}#actions{display:flex;justify-content:flex-end}#conflict{font-size:.8em;color:red;margin-top:.5em}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i1.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "component", type: i5.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i5.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "component", type: i6.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] }); }
+}
+export { UploadDialogComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadDialogComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<input type=\"file\" #file style=\"display: none\" (change)=\"onFilesAdded()\" multiple />\n\n<div mat-dialog-title id=\"title\">\n  <div>{{ uploadService.config.uploadDialogTitle }}</div>\n  <button [disabled]=\"uploading || uploadSuccessful\" mat-raised-button color=\"primary\" class=\"add-files-btn\" (click)=\"addFiles()\">\n    {{ uploadService.config.uploadDialogAddFilesButtonText }}\n  </button>\n</div>\n\n<div id=\"conflict\" *ngIf=\"existingFileConflict\">\n  {{ existingFileConflict }} already exists on the server and cannot be overwritten\n</div>\n\n<mat-dialog-content>\n  <mat-list>\n    <mat-list-item *ngFor=\"let file of files\">\n      <h4 mat-line>{{file.name}}</h4>\n      <mat-progress-bar *ngIf=\"progress\" mode=\"determinate\" [value]=\"progress[file.name].progress | async\"></mat-progress-bar>\n    </mat-list-item>\n  </mat-list>\n</mat-dialog-content>\n\n<mat-dialog-actions id=\"actions\">\n  <button *ngIf=\"showCancelButton\" mat-button mat-dialog-close>{{ uploadService.config.uploadDialogCancelButtonText }}</button>\n  <button *ngIf=\"files.size > 0\" mat-raised-button color=\"primary\" [disabled]=\"!canBeClosed\" (click)=\"closeDialog()\">{{ primaryButtonText }}</button>\n</mat-dialog-actions>\n", styles: ["#title{display:flex;justify-content:space-between}#actions{display:flex;justify-content:flex-end}#conflict{font-size:.8em;color:red;margin-top:.5em}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: i2.UploadService }]; }, propDecorators: { file: [{
+                type: ViewChild,
+                args: ['file', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-dialog.component.js","sourceRoot":"","sources":["../../../../../../../projects/cleavelandprice/ngx-lib/upload/src/components/upload-dialog/upload-dialog.component.ts","../../../../../../../projects/cleavelandprice/ngx-lib/upload/src/components/upload-dialog/upload-dialog.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, OnInit, ViewChild } from '@angular/core';\r\nimport { MatDialogRef } from '@angular/material/dialog';\r\nimport { forkJoin } from 'rxjs';\r\n\r\nimport { UploadService } from './../../services/upload.service';\r\n\r\n@Component({\r\n  templateUrl: './upload-dialog.component.html',\r\n  styleUrls: ['./upload-dialog.component.css']\r\n})\r\nexport class UploadDialogComponent implements OnInit {\r\n  @ViewChild('file', { static: true }) file!: ElementRef;\r\n  public files: Set<File> = new Set();\r\n  existingFileConflict: string | undefined;\r\n\r\n  // State\r\n  progress: any;\r\n  canBeClosed = true;\r\n  primaryButtonText: string | undefined;\r\n  showCancelButton = true;\r\n  uploading = false;\r\n  uploadSuccessful = false;\r\n  \r\n  constructor(public dialogRef: MatDialogRef<UploadDialogComponent>, public uploadService: UploadService) { }\r\n\r\n  ngOnInit() {\r\n    this.primaryButtonText = this.uploadService.config.uploadDialogUploadButtonText;\r\n  }\r\n\r\n  addFiles() {\r\n    this.file.nativeElement.click();\r\n  }\r\n\r\n  onFilesAdded() {\r\n    const files: { [key: string]: File } = this.file.nativeElement.files;\r\n    for (const key in files) {\r\n      if (!isNaN(parseInt(key))) {\r\n        // See if the file already exists\r\n        this.uploadService.exists(files[key].name)\r\n          .subscribe(exists => {\r\n            if (exists) {\r\n              this.existingFileConflict = files[key].name;\r\n            }\r\n\r\n            if (!exists) {\r\n              this.files.add(files[key]);\r\n            }\r\n          });\r\n      }\r\n    }\r\n  }\r\n\r\n  closeDialog() {\r\n    // if everything was uploaded already, just close the dialog\r\n    if (this.uploadSuccessful) {\r\n      return this.dialogRef.close();\r\n    }\r\n\r\n    // set the component state to \"uploading\"\r\n    this.uploading = true;\r\n\r\n    // start the upload and save the progress map\r\n    this.progress = this.uploadService.upload(this.files);\r\n\r\n    // convert the progress map into an array\r\n    const allProgressObservables: any[] = [];\r\n\r\n    for (let key in this.progress) {\r\n      allProgressObservables.push(this.progress[key].progress);\r\n    }\r\n\r\n    // Adjust the state variables\r\n\r\n    // The OK-button should have the text \"Finish\" now\r\n    this.primaryButtonText = this.uploadService.config.uploadDialogFinishButtonText;\r\n\r\n    // The dialog should not be closed while uploading\r\n    this.canBeClosed = false;\r\n    this.dialogRef.disableClose = true;\r\n\r\n    // Hide the cancel-button\r\n    this.showCancelButton = false;\r\n\r\n    // When all progress-observables are completed...\r\n    forkJoin(allProgressObservables).subscribe(end => {\r\n      // ... the dialog can be closed again...\r\n      this.canBeClosed = true;\r\n      this.dialogRef.disableClose = false;\r\n\r\n      // ... the upload was successful...\r\n      this.uploadSuccessful = true;\r\n\r\n      // ... and the component is no longer uploading\r\n      this.uploading = false;\r\n    });\r\n  }\r\n}\r\n","<input type=\"file\" #file style=\"display: none\" (change)=\"onFilesAdded()\" multiple />\n\n<div mat-dialog-title id=\"title\">\n  <div>{{ uploadService.config.uploadDialogTitle }}</div>\n  <button [disabled]=\"uploading || uploadSuccessful\" mat-raised-button color=\"primary\" class=\"add-files-btn\" (click)=\"addFiles()\">\n    {{ uploadService.config.uploadDialogAddFilesButtonText }}\n  </button>\n</div>\n\n<div id=\"conflict\" *ngIf=\"existingFileConflict\">\n  {{ existingFileConflict }} already exists on the server and cannot be overwritten\n</div>\n\n<mat-dialog-content>\n  <mat-list>\n    <mat-list-item *ngFor=\"let file of files\">\n      <h4 mat-line>{{file.name}}</h4>\n      <mat-progress-bar *ngIf=\"progress\" mode=\"determinate\" [value]=\"progress[file.name].progress | async\"></mat-progress-bar>\n    </mat-list-item>\n  </mat-list>\n</mat-dialog-content>\n\n<mat-dialog-actions id=\"actions\">\n  <button *ngIf=\"showCancelButton\" mat-button mat-dialog-close>{{ uploadService.config.uploadDialogCancelButtonText }}</button>\n  <button *ngIf=\"files.size > 0\" mat-raised-button color=\"primary\" [disabled]=\"!canBeClosed\" (click)=\"closeDialog()\">{{ primaryButtonText }}</button>\n</mat-dialog-actions>\n"]}

package/{esm2020 → esm2022}/upload/model/database-file-info.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2UtZmlsZS1pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2xlYXZlbGFuZHByaWNlL25neC1saWIvdXBsb2FkL3NyYy9tb2RlbC9kYXRhYmFzZS1maWxlLWluZm8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRGF0YWJhc2VGaWxlSW5mbyB7XHJcbiAgICBuYW1lOiBzdHJpbmc7XHJcbiAgICB0aW1lc3RhbXA6IERhdGU7XHJcbiAgICBkYkFwcElkOiBzdHJpbmc7XHJcbiAgICBleHRlcm5hbFJlZmVyZW5jZUlkPzogbnVtYmVyO1xyXG4gICAgY29tbWVudD86IHN0cmluZztcclxufVxyXG4iXX0=

package/{esm2020 → esm2022}/upload/model/file-upload-request.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQtcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL3VwbG9hZC9zcmMvbW9kZWwvZmlsZS11cGxvYWQtcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBGaWxlVXBsb2FkUmVxdWVzdCB7XHJcbiAgICBhcHBJZD86IHN0cmluZztcclxuICAgIG5hbWU/OiBzdHJpbmc7XHJcbiAgICBleHRlcm5hbFJlZmVyZW5jZUlkPzogbnVtYmVyO1xyXG4gICAgZm9sZGVyPzogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/{esm2020 → esm2022}/upload/model/filesystem-file-info.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZXN5c3RlbS1maWxlLWluZm8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi91cGxvYWQvc3JjL21vZGVsL2ZpbGVzeXN0ZW0tZmlsZS1pbmZvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEZpbGVzeXN0ZW1GaWxlSW5mbyB7XHJcbiAgICBuYW1lOiBzdHJpbmc7XHJcbiAgICBhdHRyaWJ1dGVzPzogbnVtYmVyO1xyXG4gICAgY3JlYXRpb25UaW1lOiBEYXRlO1xyXG4gICAgZGlyZWN0b3J5OiBzdHJpbmc7XHJcbiAgICBleHRlbnNpb246IHN0cmluZztcclxuICAgIGZ1bGxuYW1lOiBzdHJpbmc7XHJcbiAgICBsYXN0QWNjZXNzVGltZTogRGF0ZTtcclxuICAgIGxhc3RXcml0ZVRpbWU6IERhdGU7XHJcbiAgICByZWFkT25seTogYm9vbGVhbjtcclxuICAgIHNpemU6IG51bWJlcjtcclxufVxyXG4iXX0=

package/{esm2020 → esm2022}/upload/model/service-config.mjs

@@ -1,16 +1,16 @@
-import { ServiceConfig as NgxLibServiceConfig } from '@cleavelandprice/ngx-lib';
-export class ServiceConfig extends NgxLibServiceConfig {
-    // See the comment in the library's main service-config.ts file for an explanation
-    constructor(useSsl_or_customApiUrl = false) {
-        super(useSsl_or_customApiUrl);
-        this.databaseEndpoint = '/upload/database';
-        this.uploadDialogTitle = 'Upload Files';
-        // UI configuration
-        this.uploadButtonText = 'Upload';
-        this.uploadDialogCancelButtonText = 'Cancel';
-        this.uploadDialogFinishButtonText = 'Finish';
-        this.uploadDialogUploadButtonText = 'Upload';
-        this.uploadDialogAddFilesButtonText = 'Add Files';
-    }
-}
+import { ServiceConfig as NgxLibServiceConfig } from '@cleavelandprice/ngx-lib';
+export class ServiceConfig extends NgxLibServiceConfig {
+    // See the comment in the library's main service-config.ts file for an explanation
+    constructor(useSsl_or_customApiUrl = false) {
+        super(useSsl_or_customApiUrl);
+        this.databaseEndpoint = '/upload/database';
+        this.uploadDialogTitle = 'Upload Files';
+        // UI configuration
+        this.uploadButtonText = 'Upload';
+        this.uploadDialogCancelButtonText = 'Cancel';
+        this.uploadDialogFinishButtonText = 'Finish';
+        this.uploadDialogUploadButtonText = 'Upload';
+        this.uploadDialogAddFilesButtonText = 'Add Files';
+    }
+}
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYi91cGxvYWQvc3JjL21vZGVsL3NlcnZpY2UtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLElBQUksbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUVoRixNQUFNLE9BQU8sYUFBYyxTQUFRLG1CQUFtQjtJQWVsRCxrRkFBa0Y7SUFDbEYsWUFBWSx5QkFBMkMsS0FBSztRQUN4RCxLQUFLLENBQUMsc0JBQXNCLENBQUMsQ0FBQztRQWhCbEMscUJBQWdCLEdBQUcsa0JBQWtCLENBQUM7UUFDdEMsc0JBQWlCLEdBQUcsY0FBYyxDQUFDO1FBTW5DLG1CQUFtQjtRQUNuQixxQkFBZ0IsR0FBRyxRQUFRLENBQUM7UUFDNUIsaUNBQTRCLEdBQUcsUUFBUSxDQUFDO1FBQ3hDLGlDQUE0QixHQUFHLFFBQVEsQ0FBQztRQUN4QyxpQ0FBNEIsR0FBRyxRQUFRLENBQUM7UUFDeEMsbUNBQThCLEdBQUcsV0FBVyxDQUFDO0lBSzdDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlcnZpY2VDb25maWcgYXMgTmd4TGliU2VydmljZUNvbmZpZyB9IGZyb20gJ0BjbGVhdmVsYW5kcHJpY2Uvbmd4LWxpYic7XHJcblxyXG5leHBvcnQgY2xhc3MgU2VydmljZUNvbmZpZyBleHRlbmRzIE5neExpYlNlcnZpY2VDb25maWcge1xyXG4gICAgZGF0YWJhc2VFbmRwb2ludCA9ICcvdXBsb2FkL2RhdGFiYXNlJztcclxuICAgIHVwbG9hZERpYWxvZ1RpdGxlID0gJ1VwbG9hZCBGaWxlcyc7XHJcbiAgICB1cGxvYWRQYXRoOiBzdHJpbmcgfCB1bmRlZmluZWQ7XHJcbiAgICBjb21tZW50OiBzdHJpbmcgfCB1bmRlZmluZWQ7XHJcbiAgICBkYkFwcElkOiBzdHJpbmcgfCB1bmRlZmluZWQ7XHJcbiAgICBleHRlcm5hbFJlZmVyZW5jZUlkOiBzdHJpbmcgfCB1bmRlZmluZWQ7XHJcbiAgICBcclxuICAgIC8vIFVJIGNvbmZpZ3VyYXRpb25cclxuICAgIHVwbG9hZEJ1dHRvblRleHQgPSAnVXBsb2FkJztcclxuICAgIHVwbG9hZERpYWxvZ0NhbmNlbEJ1dHRvblRleHQgPSAnQ2FuY2VsJztcclxuICAgIHVwbG9hZERpYWxvZ0ZpbmlzaEJ1dHRvblRleHQgPSAnRmluaXNoJztcclxuICAgIHVwbG9hZERpYWxvZ1VwbG9hZEJ1dHRvblRleHQgPSAnVXBsb2FkJztcclxuICAgIHVwbG9hZERpYWxvZ0FkZEZpbGVzQnV0dG9uVGV4dCA9ICdBZGQgRmlsZXMnO1xyXG5cclxuICAgIC8vIFNlZSB0aGUgY29tbWVudCBpbiB0aGUgbGlicmFyeSdzIG1haW4gc2VydmljZS1jb25maWcudHMgZmlsZSBmb3IgYW4gZXhwbGFuYXRpb25cclxuICAgIGNvbnN0cnVjdG9yKHVzZVNzbF9vcl9jdXN0b21BcGlVcmw6IGJvb2xlYW4gfCBzdHJpbmcgPSBmYWxzZSkge1xyXG4gICAgICAgIHN1cGVyKHVzZVNzbF9vcl9jdXN0b21BcGlVcmwpO1xyXG4gICAgfVxyXG59Il19

package/{esm2020 → esm2022}/upload/public_api.mjs

@@ -1,9 +1,9 @@
-export * from './model/database-file-info';
-export * from './model/file-upload-request';
-export * from './model/filesystem-file-info';
-export * from './model/service-config';
-export * from './components/upload/upload.component';
-export * from './components/upload-dialog/upload-dialog.component';
-export * from './services/upload.service';
-export * from './upload.module';
+export * from './model/database-file-info';
+export * from './model/file-upload-request';
+export * from './model/filesystem-file-info';
+export * from './model/service-config';
+export * from './components/upload/upload.component';
+export * from './components/upload-dialog/upload-dialog.component';
+export * from './services/upload.service';
+export * from './upload.module';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NsZWF2ZWxhbmRwcmljZS9uZ3gtbGliL3VwbG9hZC9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxvREFBb0QsQ0FBQztBQUVuRSxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vZGVsL2RhdGFiYXNlLWZpbGUtaW5mbyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwvZmlsZS11cGxvYWQtcmVxdWVzdCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwvZmlsZXN5c3RlbS1maWxlLWluZm8nO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGVsL3NlcnZpY2UtY29uZmlnJztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy91cGxvYWQvdXBsb2FkLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy91cGxvYWQtZGlhbG9nL3VwbG9hZC1kaWFsb2cuY29tcG9uZW50JztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvdXBsb2FkLnNlcnZpY2UnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi91cGxvYWQubW9kdWxlJzsiXX0=

package/esm2022/upload/services/upload.service.mjs

@@ -0,0 +1,92 @@
+import { Injectable, Optional } from '@angular/core';
+import { HttpRequest, HttpEventType, HttpResponse, HttpHeaders } from '@angular/common/http';
+import { Subject } from 'rxjs';
+import { ServiceConfig } from '../model/service-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../model/service-config";
+// https://malcoded.com/posts/angular-file-upload-component-with-express
+class UploadService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this.config = this.config ?? new ServiceConfig();
+    }
+    upload(files) {
+        // this will be the our resulting map
+        const status = {};
+        files.forEach(file => {
+            // create a new multipart-form for every file
+            const formData = new FormData();
+            formData.append('file', file, file.name);
+            // create a http-post request and pass the form
+            // tell it to report the upload progress
+            // A 'Destination' header is used to optionally configure the file upload destination (filesystem)
+            // A 'DbAppId' header is used to configure the unique identifier of database uploads
+            let headers = new HttpHeaders();
+            if (this.config.uploadPath) {
+                headers = headers.set('Destination', this.config.uploadPath);
+            }
+            if (this.config.dbAppId) {
+                headers = headers.set('DbAppId', this.config.dbAppId);
+            }
+            if (this.config.externalReferenceId) {
+                headers = headers.set('ExternalReferenceId', this.config.externalReferenceId);
+            }
+            if (this.config.comment) {
+                headers = headers.set('Comment', this.config.comment);
+            }
+            const req = new HttpRequest('POST', `${this.config.apiUrl}${this.config.databaseEndpoint}`, formData, {
+                reportProgress: true,
+                responseType: 'blob',
+                headers
+            });
+            // create a new progress-subject for every file
+            const progress = new Subject();
+            // send the http-request and subscribe for progress-updates
+            this.http.request(req).subscribe(event => {
+                if (event.type === HttpEventType.UploadProgress) {
+                    // calculate the progress percentage
+                    const percentDone = Math.round(100 * event.loaded / (event.total ?? 1));
+                    // pass the percentage into the progress-stream
+                    progress.next(percentDone);
+                }
+                else if (event instanceof HttpResponse) {
+                    // Close the progress-stream if we get an answer form the API
+                    // The upload is complete
+                    progress.complete();
+                }
+            });
+            // Save every progress-observable in a map of all observables
+            status[file.name] = {
+                progress: progress.asObservable()
+            };
+        });
+        // return the map of progress.observables
+        return status;
+    }
+    exists(fileName) {
+        const query = `${this.config.apiUrl}${this.config.databaseEndpoint}`.toLowerCase().indexOf('filesystem') === -1 ?
+            { name: fileName, dbAppId: this.config.dbAppId } :
+            { name: fileName, destination: this.config.uploadPath };
+        return this.http.post(`${this.config.apiUrl}${this.config.databaseEndpoint}/exists`, query);
+    }
+    download(request) {
+        return this.http.post(`${this.config.apiUrl}${this.config.databaseEndpoint}/stream`, request, { responseType: 'blob' });
+    }
+    getUploadInfo(request) {
+        return this.http.post(`${this.config.apiUrl}${this.config.databaseEndpoint}/info`, request);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadService, deps: [{ token: i1.HttpClient }, { token: i2.ServiceConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadService, providedIn: 'root' }); }
+}
+export { UploadService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ServiceConfig, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.service.js","sourceRoot":"","sources":["../../../../../../projects/cleavelandprice/ngx-lib/upload/src/services/upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\r\nimport { HttpClient, HttpRequest, HttpEventType, HttpResponse, HttpHeaders } from '@angular/common/http';\r\nimport { Subject ,  Observable } from 'rxjs';\r\n\r\nimport { DatabaseFileInfo } from '../model/database-file-info';\r\nimport { FilesystemFileInfo } from '../model/filesystem-file-info';\r\nimport { FileUploadRequest } from '../model/file-upload-request';\r\nimport { ServiceConfig } from '../model/service-config';\r\n\r\n// https://malcoded.com/posts/angular-file-upload-component-with-express\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UploadService {\r\n  constructor(private http: HttpClient,\r\n    @Optional() public config: ServiceConfig) {\r\n\r\n      this.config = this.config ?? new ServiceConfig();\r\n    }\r\n\r\n  public upload(files: Set<File>): any { // {[key: string]: Observable<number>} {\r\n    // this will be the our resulting map\r\n    const status: {[key: string]: {progress: Observable<number>}} = {};\r\n\r\n    files.forEach(file => {\r\n      // create a new multipart-form for every file\r\n      const formData: FormData = new FormData();\r\n      formData.append('file', file, file.name);\r\n\r\n      // create a http-post request and pass the form\r\n      // tell it to report the upload progress\r\n\r\n      // A 'Destination' header is used to optionally configure the file upload destination (filesystem)\r\n      // A 'DbAppId' header is used to configure the unique identifier of database uploads\r\n      \r\n      let headers = new HttpHeaders();\r\n      if (this.config.uploadPath) {\r\n        headers = headers.set('Destination', this.config.uploadPath);\r\n      }\r\n      if (this.config.dbAppId) {\r\n        headers = headers.set('DbAppId', this.config.dbAppId);\r\n      }\r\n      if (this.config.externalReferenceId) {\r\n        headers = headers.set('ExternalReferenceId', this.config.externalReferenceId);\r\n      }\r\n      if (this.config.comment) {\r\n        headers = headers.set('Comment', this.config.comment);\r\n      }\r\n\r\n      const req = new HttpRequest('POST', `${this.config.apiUrl}${this.config.databaseEndpoint}`, formData, {\r\n        reportProgress: true,\r\n        responseType: 'blob',\r\n        headers\r\n      });\r\n\r\n      // create a new progress-subject for every file\r\n      const progress = new Subject<number>();\r\n\r\n      // send the http-request and subscribe for progress-updates\r\n      this.http.request(req).subscribe(event => {\r\n        if (event.type === HttpEventType.UploadProgress) {\r\n\r\n          // calculate the progress percentage\r\n          const percentDone = Math.round(100 * event.loaded / (event.total ?? 1));\r\n\r\n          // pass the percentage into the progress-stream\r\n          progress.next(percentDone);\r\n        } else if (event instanceof HttpResponse) {\r\n\r\n          // Close the progress-stream if we get an answer form the API\r\n          // The upload is complete\r\n          progress.complete();\r\n        }\r\n      });\r\n\r\n      // Save every progress-observable in a map of all observables\r\n      status[file.name] = {\r\n        progress: progress.asObservable()\r\n      };\r\n    });\r\n\r\n    // return the map of progress.observables\r\n    return status;\r\n  }\r\n\r\n  public exists(fileName: string): Observable<boolean> {\r\n    const query = `${this.config.apiUrl}${this.config.databaseEndpoint}`.toLowerCase().indexOf('filesystem') === -1 ?\r\n      { name: fileName, dbAppId: this.config.dbAppId } :\r\n      { name: fileName, destination: this.config.uploadPath };\r\n\r\n    return this.http.post<boolean>(`${this.config.apiUrl}${this.config.databaseEndpoint}/exists`, query);\r\n  }\r\n\r\n  public download(request: FileUploadRequest): Observable<Blob> {\r\n    return this.http.post(`${this.config.apiUrl}${this.config.databaseEndpoint}/stream`, request, { responseType: 'blob' });\r\n  }\r\n\r\n  public getUploadInfo(request: FileUploadRequest):\r\n    Observable<DatabaseFileInfo | DatabaseFileInfo[] | FilesystemFileInfo | FilesystemFileInfo[]> {\r\n    return this.http.post<DatabaseFileInfo | DatabaseFileInfo[] | FilesystemFileInfo | FilesystemFileInfo[]>\r\n      (`${this.config.apiUrl}${this.config.databaseEndpoint}/info`, request);\r\n  }\r\n}\r\n"]}