inteligr8/alfresco-ng2-components
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-ng2-components.git synced 2025-05-19 17:14:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix unit test upload

Browse Source
This commit is contained in:
mauriziovitale84 2016-07-14 15:31:24 +01:00
parent 7d57073dac
commit 7f3a450e6d
11 changed files with 214 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
ng2-components/ng2-alfresco-upload/src/assets/AlfrescoApi.mock.ts
View File

@ -1,60 +0,0 @@
/*!
* @license
* Copyright 2016 Alfresco Software, Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export class AlfrescoApiMock {
static getClientWithTicket(basePath: string, ticket: string) {
return {authentications: {basicAuth: {password: 'fake-password', type: 'fake-basic', username: 'fake-user'}}};
}
static get NodesApi() {
return NodesApiMock;
}
}
export class NodesApiMock {
constructor(alfrescoClient: any) {
}
addNode(nodeId, nodeBody, opts) {
if (nodeId && nodeBody.name !== 'folder-duplicate-fake') {
return new Promise(function (resolve, reject) {
resolve({
entry: {
isFile: false,
isFolder: true
}
});
});
} else {
return new Promise(function (resolve, reject) {
reject({
response: {
body: {
error: {
statusCode: 409
}
}
}
});
});
}
}
}

8
ng2-components/ng2-alfresco-upload/src/assets/AlfrescoSettingsService.service.mock.ts
View File

@ -21,23 +21,15 @@ import { Injectable } from '@angular/core';
export class AlfrescoSettingsServiceMock {
static DEFAULT_HOST_ADDRESS: string = 'fakehost';
static DEFAULT_CONTEXT_PATH: string = '/fake-path-alfresco';
static DEFAULT_BASE_API_PATH: string = '/fake-api/fake-public/fake-alfresco/fake-versions/1';
private providers: string[] = ['ECM', 'BPM'];
private _host: string = AlfrescoSettingsServiceMock.DEFAULT_HOST_ADDRESS;
private _contextPath = AlfrescoSettingsServiceMock.DEFAULT_CONTEXT_PATH;
private _apiBasePath: string = AlfrescoSettingsServiceMock.DEFAULT_BASE_API_PATH;
public get host(): string {
return this._host;
}
getApiBaseUrl(): string {
return this._host + this._contextPath + this._apiBasePath;
}
getProviders(): string [] {
return this.providers;
}

82
ng2-components/ng2-alfresco-upload/src/assets/upload.service.mock.ts
View File

@ -1,82 +0,0 @@
/*!
* @license
* Copyright 2016 Alfresco Software, Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Observable } from 'rxjs/Observable';
import { FileModel } from '../models/file.model';
import { UploadService } from '../services/upload.service';
import { AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
export class UploadServiceMock extends UploadService {
filesUpload$: Observable<any>;
totalCompleted$: Observable<number>;
constructor(settings: AlfrescoSettingsService, authService: AlfrescoAuthenticationService) {
super(settings, authService);
}
public setOptions(options: any): void {
super.setOptions(options);
}
addToQueue(files: any[]): FileModel[] {
let result = super.addToQueue(files);
this.filesUpload$ = new Observable(observer => {
observer.next(files);
});
return result;
}
createFolder(relativePath: string, name: string) {
let promise: Promise<any>;
if (name !== 'folder-duplicate-fake') {
promise = new Promise(function (resolve, reject) {
resolve({
entry: {
isFile: false,
isFolder: true,
name: name,
nodeType: 'cm:folder'
}
});
});
} else {
promise = new Promise(function (resolve, reject) {
reject({
response: {
body: {
error: {
statusCode: 409
}
}
}
});
});
}
return Observable.fromPromise(promise)
.map(res => {
return res;
})
.do(data => console.log('Node data', data))
.catch((error => {
return Observable.throw(error);
}));
}
public uploadFilesInTheQueue(directory: string, elementEmit: any): void {
};
}

11
ng2-components/ng2-alfresco-upload/src/components/file-uploading-dialog.component.spec.ts
View File

@ -21,7 +21,6 @@ import { FileUploadingDialogComponent } from './file-uploading-dialog.component'
import { FileModel } from '../models/file.model';
import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
import { TranslationMock } from '../assets/translation.service.mock';
import { UploadServiceMock } from '../assets/upload.service.mock';
import { UploadService } from '../services/upload.service';
import { Observable } from 'rxjs/Observable';
import { HTTP_PROVIDERS } from '@angular/http';
@ -34,10 +33,10 @@ describe('FileUploadDialog', () => {
beforeEachProviders(() => {
return [
HTTP_PROVIDERS,
{ provide: AlfrescoSettingsService, useClass: AlfrescoSettingsService },
{ provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
AlfrescoSettingsService,
AlfrescoAuthenticationService,
{ provide: AlfrescoTranslationService, useClass: TranslationMock },
{ provide: UploadService, useClass: UploadServiceMock }
UploadService
];
});
@ -86,11 +85,9 @@ describe('FileUploadDialog', () => {
let file = new FileModel(fileFake);
file.progress = {'percent': 50};
uploadService.addToQueue([file]);
let component = componentFixture.componentInstance;
componentFixture.detectChanges();
uploadService.addToQueue([file]);
component.filesUploadingList = [file];
let compiled = componentFixture.debugElement.nativeElement;

4
ng2-components/ng2-alfresco-upload/src/components/file-uploading-list.component.ts
View File

@ -57,7 +57,7 @@ export class FileUploadingListComponent {
let file = this.filesUploadingList.filter((uploadingFileModel) => {
return uploadingFileModel.id === id;
});
file[0].setAbort();
file[0].emitAbort();
}
/**
@ -68,7 +68,7 @@ export class FileUploadingListComponent {
$event.preventDefault();
}
this.filesUploadingList.forEach((uploadingFileModel: FileModel) => {
uploadingFileModel.setAbort();
uploadingFileModel.emitAbort();
});
}

94
ng2-components/ng2-alfresco-upload/src/components/upload-button.component.spec.ts
View File

@ -20,20 +20,49 @@ import { TestComponentBuilder } from '@angular/compiler/testing';
import { UploadButtonComponent } from './upload-button.component';
import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
import { TranslationMock } from '../assets/translation.service.mock';
import { UploadServiceMock } from '../assets/upload.service.mock';
import { UploadService } from '../services/upload.service';
import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
import { HTTP_PROVIDERS } from '@angular/http';
declare var AlfrescoApi: any;
describe('AlfrescoUploadButton', () => {
let uploadButtonFixture;
let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
let fakeEvent = {
currentTarget: {
files: [file]
},
target: {value: 'fake-name-1'}
};
let fakeResolveRest = {
entry: {
isFile: false,
isFolder: true,
name: 'fake-folder1'
}
};
let fakeResolvePromise = new Promise(function (resolve, reject) {
resolve(fakeResolveRest);
});
let fakeRejectRest = {
response: {
body: {
error: {
statusCode: 409
}
}
}
};
let fakeRejectPromise = new Promise(function (resolve, reject) {
reject(fakeRejectRest);
});
beforeEach( () => {
window['AlfrescoApi'] = AlfrescoApiMock;
window['componentHandler'] = null;
});
@ -41,9 +70,9 @@ describe('AlfrescoUploadButton', () => {
return [
HTTP_PROVIDERS,
{ provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
{ provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
AlfrescoAuthenticationService,
{ provide: AlfrescoTranslationService, useClass: TranslationMock },
{ provide: UploadService, useClass: UploadServiceMock }
UploadService
];
});
@ -84,55 +113,42 @@ describe('AlfrescoUploadButton', () => {
component._uploaderService.uploadFilesInTheQueue = jasmine.createSpy('uploadFilesInTheQueue');
uploadButtonFixture.detectChanges();
let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
let fakeEvent = {
currentTarget: {
files: [file]
},
target: {value: 'fake-value'}
};
component.onFilesAdded(fakeEvent);
expect(component._uploaderService.uploadFilesInTheQueue).toHaveBeenCalledWith('/root-fake-/sites-fake/folder-fake', null);
});
it('should create a folder and call upload file', () => {
it('should create a folder and emit an File uploaded event', (done) => {
let component = uploadButtonFixture.componentInstance;
component.uploadFiles = jasmine.createSpy('uploadFiles');
let doneFn = jasmine.createSpy('success');
component.currentFolderPath = '/fake-root-path';
uploadButtonFixture.detectChanges();
let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'fake-folder1/fake-name-1.json'};
spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeResolvePromise);
let fakeEvent = {
currentTarget: {
files: [file]
},
target: {value: 'fake-value'}
};
component.onSuccess.subscribe(e => {
expect(e.value).toEqual('File uploaded');
done();
});
spyOn(component, 'uploadFiles').and.callFake(() => {
component.onSuccess.emit({
value: 'File uploaded'
}
);
});
component.onDirectoryAdded(fakeEvent);
expect(doneFn).not.toHaveBeenCalledWith(fakeEvent);
});
it('should throws an exception when the folder already exist', () => {
it('should emit an onError event when the folder already exist', (done) => {
let component = uploadButtonFixture.componentInstance;
component.uploadFiles = jasmine.createSpy('uploadFiles');
uploadButtonFixture.detectChanges();
let file = {name: 'fake-name-1', size: 10, webkitRelativePath: 'folder-duplicate-fake/fake-name-1.json'};
spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakeRejectPromise);
component.onError.subscribe(e => {
expect(e.value).toEqual('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
done();
});
let fakeEvent = {
currentTarget: {
files: [file]
},
target: {value: 'fake-value'}
};
component.onDirectoryAdded(fakeEvent);
expect(component.uploadFiles).not.toHaveBeenCalledWith(fakeEvent);
});
});

7
ng2-components/ng2-alfresco-upload/src/components/upload-button.component.ts
View File

@ -76,6 +76,12 @@ export class UploadButtonComponent {
@Output()
onSuccess = new EventEmitter();
@Output()
onError = new EventEmitter();
@Output()
createFolder = new EventEmitter();
translate: AlfrescoTranslationService;
@ -125,6 +131,7 @@ export class UploadButtonComponent {
error => {
let errorMessagePlaceholder = this.getErrorMessage(error.response);
if (errorMessagePlaceholder) {
this.onError.emit({value: errorMessagePlaceholder});
let errorMessage = this.formatString(errorMessagePlaceholder, [directoryName]);
if (errorMessage) {
this._showErrorNotificationBar(errorMessage);

32
ng2-components/ng2-alfresco-upload/src/components/upload-drag-area.component.spec.ts
View File

@ -21,9 +21,7 @@ import { UploadDragAreaComponent } from './upload-drag-area.component';
import { AlfrescoTranslationService, AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
import { TranslationMock } from '../assets/translation.service.mock';
import { UploadServiceMock } from '../assets/upload.service.mock';
import { UploadService } from '../services/upload.service';
import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
import { HTTP_PROVIDERS } from '@angular/http';
declare var AlfrescoApi: any;
@ -33,16 +31,16 @@ describe('AlfrescoUploadDragArea', () => {
let componentFixture;
beforeEach( () => {
window['AlfrescoApi'] = AlfrescoApiMock;
});
beforeEachProviders(() => {
return [
HTTP_PROVIDERS,
{ provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
{ provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
AlfrescoAuthenticationService,
{ provide: AlfrescoTranslationService, useClass: TranslationMock },
{ provide: UploadService, useClass: UploadServiceMock }
UploadService
];
});
@ -142,6 +140,19 @@ describe('AlfrescoUploadDragArea', () => {
component.showUdoNotificationBar = true;
componentFixture.detectChanges();
let fakeRest = {
response: {
body: {
error: {
statusCode: 409
}
}
}
};
let fakePromise = new Promise(function (resolve, reject) {
reject(fakeRest);
});
spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakePromise);
spyOn(component, '_showErrorNotificationBar').and.callFake( () => {
expect(component._showErrorNotificationBar).toHaveBeenCalledWith('FILE_UPLOAD.MESSAGES.FOLDER_ALREADY_EXIST');
done();
@ -175,6 +186,17 @@ describe('AlfrescoUploadDragArea', () => {
}
};
let fakeRest = {
entry: {
isFile: false,
isFolder: true,
name: 'folder-fake'
}
};
let fakePromise = new Promise(function (resolve, reject) {
resolve(fakeRest);
});
spyOn(component._uploaderService, 'callApiCreateFolder').and.returnValue(fakePromise);
spyOn(component, 'onFilesEntityDropped').and.callFake( () => {
expect(component.onFilesEntityDropped).toHaveBeenCalledWith(itemEntity);
done();

31
ng2-components/ng2-alfresco-upload/src/models/file.model.ts
View File

@ -35,7 +35,7 @@ export class FileModel {
abort: boolean = false;
uploading: boolean = false;
file: any;
_xmlHttpRequest: XMLHttpRequest;
promiseUpload: any;
constructor(file: any) {
this.file = file;
@ -53,16 +53,32 @@ export class FileModel {
this.progress = progress;
}
/**
* Emit an event progress on the promise
*/
emitProgres(progress: any): void {
this.setProgres(progress);
this.promiseUpload.emit('progress', progress);
}
setError(): void {
this.error = true;
}
/**
* Emit an event progress on the promise
*/
emitError(): void {
this.setError();
this.promiseUpload.emit('error');
}
setUploading() {
this.uploading = true;
}
setXMLHttpRequest(xmlHttpRequest: XMLHttpRequest) {
this._xmlHttpRequest = xmlHttpRequest;
setPromiseUpload(promiseUpload: any) {
this.promiseUpload = promiseUpload;
}
/**
@ -72,10 +88,17 @@ export class FileModel {
if (!this.done && !this.error) {
this.abort = true;
this.uploading = false;
this._xmlHttpRequest.abort();
}
}
/**
* Emit an event abort on the promise
*/
emitAbort(): void {
this.setAbort();
this.promiseUpload.abort();
}
/**
* Update status of the file when upload finish or is ended.
*/

149
ng2-components/ng2-alfresco-upload/src/services/upload.service.spec.ts
View File

@ -17,38 +17,14 @@
import { it, describe, inject, beforeEach, beforeEachProviders } from '@angular/core/testing';
import { UploadService } from './upload.service';
import { FileModel } from './../models/file.model';
import { AlfrescoSettingsService, AlfrescoAuthenticationService } from 'ng2-alfresco-core';
import { AlfrescoSettingsServiceMock } from '../assets/AlfrescoSettingsService.service.mock';
import { AlfrescoApiMock } from '../assets/AlfrescoApi.mock';
import { HTTP_PROVIDERS } from '@angular/http';
import { EventEmitter } from '@angular/core';
declare var AlfrescoApi: any;
declare let AlfrescoApi: any;
declare let jasmine: any;
let doneFn = jasmine.createSpy('success');
let errorFn = jasmine.createSpy('error');
class MockUploadService extends UploadService {
constructor(settings: AlfrescoSettingsService, authService: AlfrescoAuthenticationService) {
super(settings, authService);
}
createXMLHttpRequestInstance() {
let xhr = new XMLHttpRequest();
xhr.onreadystatechange = function () {
if (this.readyState === this.DONE && this.status === 200) {
doneFn(this.responseText);
} else if (this.readyState === this.DONE && this.status === 404) {
errorFn(this.responseText);
}
};
xhr.abort = jasmine.createSpy('abort');
return xhr;
}
}
describe('AlfrescoUploadService', () => {
let service, options: any;
@ -62,14 +38,12 @@ describe('AlfrescoUploadService', () => {
}
};
window['AlfrescoApi'] = AlfrescoApiMock;
beforeEachProviders(() => {
return [
HTTP_PROVIDERS,
{ provide: AlfrescoSettingsService, useClass: AlfrescoSettingsServiceMock },
{ provide: AlfrescoAuthenticationService, useClass: AlfrescoAuthenticationService },
{ provide: UploadService, useClass: MockUploadService }
UploadService
];
});
@ -82,23 +56,6 @@ describe('AlfrescoUploadService', () => {
jasmine.Ajax.uninstall();
});
it('should show the default option if no method setOption is called', () => {
let empty = {};
service.setOptions(empty);
expect(service.getUrl()).toEqual('/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
let formFields: Object = {};
expect(service.getFormFields()).toEqual(formFields);
});
it('should show the option passed as input', () => {
service.setOptions(options);
expect(service.getUrl()).toEqual('/some/cool/url');
expect(service.getFormFields()).toEqual({
siteid: 'fakeSite',
containerid: 'fakeFolder'
});
});
it('should return an empty queue if no elements are added', () => {
service.setOptions(options);
expect(service.getQueue().length).toEqual(0);
@ -118,73 +75,115 @@ describe('AlfrescoUploadService', () => {
expect(service.getQueue().length).toEqual(2);
});
it('should make XHR done request after the file is added in the queue', () => {
it('should make XHR done request after the file is added in the queue', (done) => {
let emitter = new EventEmitter();
emitter.subscribe(e => {
expect(e.value).toBe('File uploaded');
done();
});
service.setOptions(options);
let filesFake = [{name: 'fake-name', size: 10}];
service.addToQueue(filesFake);
service.uploadFilesInTheQueue('', null);
service.uploadFilesInTheQueue('fake-dir', emitter);
let request = jasmine.Ajax.requests.mostRecent();
expect(request.url).toBe('fakehost/some/cool/url');
expect(request.url).toBe('fakehost/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
expect(request.method).toBe('POST');
// expect(request.data()).toEqual({fileName: 'fake-name.png'});
expect(doneFn).not.toHaveBeenCalled();
jasmine.Ajax.requests.mostRecent().respondWith({
'status': 200,
contentType: 'text/plain',
responseText: 'File uploaded'
});
expect(doneFn).toHaveBeenCalledWith('File uploaded');
});
it('should make XHR error request after an error occur', () => {
it('should make XHR error request after an error occur', (done) => {
let emitter = new EventEmitter();
emitter.subscribe(e => {
expect(e.value).toBe('Error file uploaded');
done();
});
service.setOptions(options);
let filesFake = [{name: 'fake-name', size: 10}];
service.addToQueue(filesFake);
service.uploadFilesInTheQueue('', null);
expect(jasmine.Ajax.requests.mostRecent().url).toBe('fakehost/some/cool/url');
service.uploadFilesInTheQueue('', emitter);
expect(jasmine.Ajax.requests.mostRecent().url)
.toBe('fakehost/alfresco/api/-default-/public/alfresco/versions/1/nodes/-root-/children');
jasmine.Ajax.requests.mostRecent().respondWith({
'status': 404,
contentType: 'text/plain',
responseText: 'Error file uploaded'
});
expect(errorFn).toHaveBeenCalledWith('Error file uploaded');
});
it('should make XHR abort request after the xhr abort is called', () => {
it('should make XHR abort request after the xhr abort is called', (done) => {
let emitter = new EventEmitter();
emitter.subscribe(e => {
expect(e.value).toEqual('File aborted');
done();
});
service.setOptions(options);
let filesFake = [{name: 'fake-name', size: 10}];
service.addToQueue(filesFake);
service.uploadFilesInTheQueue('', null);
service.uploadFilesInTheQueue('', emitter);
let file = service.getQueue();
file[0].setAbort();
expect(file[0]._xmlHttpRequest.abort).toHaveBeenCalled();
file[0].emitAbort();
});
it('should make XHR done request after the file is upload', () => {
service.setOptions(options);
let filesFake = {name: 'fake-name', size: 10};
it('should make XHR error request after the xhr error is called', (done) => {
let emitter = new EventEmitter();
let uploadingFileModel = new FileModel(filesFake);
service.uploadFile(uploadingFileModel, '', null);
expect(jasmine.Ajax.requests.mostRecent().url).toBe('fakehost/some/cool/url');
jasmine.Ajax.requests.mostRecent().respondWith({
'status': 200,
contentType: 'text/plain',
responseText: 'Single File uploaded'
emitter.subscribe(e => {
expect(e.value).toBe('Error file uploaded');
done();
});
expect(doneFn).toHaveBeenCalledWith('Single File uploaded');
service.setOptions(options);
let filesFake = [{name: 'fake-name', size: 10}];
service.addToQueue(filesFake);
service.uploadFilesInTheQueue('', emitter);
let file = service.getQueue();
file[0].emitError();
});
it('should make XHR progress request after the onprogress is called', (done) => {
service.setOptions(options);
let fakeProgress = {
loaded: 500,
total: 1234,
percent: 44
};
let filesFake = [{name: 'fake-name', size: 10}];
service.addToQueue(filesFake);
service.filesUpload$.subscribe( (file) => {
expect(file).toBeDefined();
expect(file[0]).toBeDefined();
expect(file[0].progress).toEqual(fakeProgress);
done();
});
service.uploadFilesInTheQueue('', null);
let file = service.getQueue();
file[0].emitProgres(fakeProgress);
});
it('should make XHR done request after the folder is created', (done) => {
let fakeRest = {
entry: {
isFile: false,
isFolder: true
isFolder: true,
name: 'fake-folder'
}
};
let fakePromise = new Promise(function (resolve, reject) {
resolve(fakeRest);
});
spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
service.setOptions(options);
let defaultPath = '';
let folderName = 'fake-folder';
@ -204,6 +203,10 @@ describe('AlfrescoUploadService', () => {
}
}
};
let fakePromise = new Promise(function (resolve, reject) {
reject(fakeRest);
});
spyOn(service, 'callApiCreateFolder').and.returnValue(fakePromise);
service.setOptions(options);
let defaultPath = '';
let folderName = 'folder-duplicate-fake';

29
ng2-components/ng2-alfresco-upload/src/services/upload.service.ts
View File

@ -56,15 +56,6 @@ export class UploadService {
this.formFields = options.formFields != null ? options.formFields : this.formFields;
}
/**
* Get the form fields
* @returns {Object}
*/
public getFormFields(): Object {
return this.formFields;
}
/**
* Add files to the uploading queue to be uploaded.
*
@ -96,14 +87,14 @@ export class UploadService {
return !uploadingFileModel.uploading && !uploadingFileModel.done && !uploadingFileModel.abort && !uploadingFileModel.error;
});
filesToUpload.forEach((uploadingFileModel) => {
filesToUpload.forEach((uploadingFileModel: FileModel) => {
uploadingFileModel.setUploading();
let _filesUploadObserverProgressBar = this.filesUploadObserverProgressBar;
let _queue = this.queue;
this.authService.getAlfrescoApi().
upload.uploadFile(uploadingFileModel.file, directory)
let promiseUpload = this.authService.getAlfrescoApi().
upload.uploadFile(uploadingFileModel.file, directory)
.on('progress', (progress: any) => {
uploadingFileModel.setProgres(progress);
if (_filesUploadObserverProgressBar) {
@ -112,9 +103,15 @@ export class UploadService {
})
.on('abort', () => {
uploadingFileModel.setAbort();
elementEmit.emit({
value: 'File aborted'
});
})
.on('error', () => {
uploadingFileModel.setError();
elementEmit.emit({
value: 'Error file uploaded'
});
})
.on('success', (data: any) => {
elementEmit.emit({
@ -133,6 +130,8 @@ export class UploadService {
}
}
});
uploadingFileModel.setPromiseUpload(promiseUpload);
});
}
@ -159,7 +158,7 @@ export class UploadService {
* @param name - the folder name
*/
createFolder(relativePath: string, name: string) {
return Observable.fromPromise(this.authService.getAlfrescoApi().node.createFolder(name, relativePath))
return Observable.fromPromise(this.callApiCreateFolder(relativePath, name))
.map(res => {
return res;
})
@ -167,6 +166,10 @@ export class UploadService {
.catch(this.handleError);
}
private callApiCreateFolder(relativePath: string, name: string) {
return this.authService.getAlfrescoApi().node.createFolder(name, relativePath);
}
/**
* Throw the error
* @param error