The process filter should not be created twice (#1789)

ng2-components/ng2-activiti-processlist/src/components/activiti-filters.component.spec.ts

@@ -46,12 +46,15 @@ describe('ActivitiFilters', () => {
 
     beforeEach(() => {
         logService = new LogServiceMock();
-        activitiService = new ActivitiProcessService(null);
+        activitiService = new ActivitiProcessService(null, logService);
         filterList = new ActivitiProcessFilters(null, activitiService, logService);
     });
 
     it('should return the filter task list', (done) => {
         spyOn(activitiService, 'getProcessFilters').and.returnValue(Observable.fromPromise(fakeGlobalFilterPromise));
+        const appId = '1';
+        let change = new SimpleChange(null, appId);
+        filterList.ngOnChanges({ 'appId': change });
 
         filterList.onSuccess.subscribe((res) => {
             expect(res).toBeDefined();
@@ -74,7 +77,8 @@ describe('ActivitiFilters', () => {
         spyOn(activitiService, 'getDeployedApplications').and.returnValue(Observable.fromPromise(fakeDeployedApplicationsPromise));
         spyOn(activitiService, 'getProcessFilters').and.returnValue(Observable.fromPromise(fakeGlobalFilterPromise));
 
-        filterList.appName = 'test';
+        let change = new SimpleChange(null, 'test');
+        filterList.ngOnChanges({ 'appName': change });
 
         filterList.onSuccess.subscribe((res) => {
             let deployApp: any = activitiService.getDeployedApplications;
@@ -87,9 +91,12 @@ describe('ActivitiFilters', () => {
     });
 
     it('should emit an error with a bad response', (done) => {
-        filterList.appId = 1;
         spyOn(activitiService, 'getProcessFilters').and.returnValue(Observable.fromPromise(fakeErrorFilterPromise));
 
+        const appId = '1';
+        let change = new SimpleChange(null, appId);
+        filterList.ngOnChanges({ 'appId': change });
+
         filterList.onError.subscribe((err) => {
             expect(err).toBeDefined();
             done();
@@ -99,9 +106,12 @@ describe('ActivitiFilters', () => {
     });
 
     it('should emit an error with a bad response', (done) => {
-        filterList.appName = 'fake-app';
         spyOn(activitiService, 'getDeployedApplications').and.returnValue(Observable.fromPromise(fakeErrorFilterPromise));
 
+        const appId = 'fake-app';
+        let change = new SimpleChange(null, appId);
+        filterList.ngOnChanges({ 'appName': change });
+
         filterList.onError.subscribe((err) => {
             expect(err).toBeDefined();
             done();

ng2-components/ng2-activiti-processlist/src/components/activiti-filters.component.ts

@@ -67,8 +67,6 @@ export class ActivitiProcessFilters implements OnInit, OnChanges {
         this.filter$.subscribe((filter: FilterProcessRepresentationModel) => {
             this.filters.push(filter);
         });
-
-        this.getFilters(this.appId, this.appName);
     }
 
     ngOnChanges(changes: SimpleChanges) {
@@ -84,19 +82,6 @@ export class ActivitiProcessFilters implements OnInit, OnChanges {
         }
     }
 
-    /**
-     * Return the task list filtered by appId or by appName
-     * @param appId
-     * @param appName
-     */
-    getFilters(appId?: number, appName?: string) {
-        if (appName) {
-            this.getFiltersByAppName(appName);
-        } else {
-            this.getFiltersByAppId(appId);
-        }
-    }
-
     /**
      * Return the filter list filtered by appId
      * @param appId - optional
@@ -104,12 +89,31 @@ export class ActivitiProcessFilters implements OnInit, OnChanges {
     getFiltersByAppId(appId?: number) {
         this.activiti.getProcessFilters(appId).subscribe(
             (res: FilterProcessRepresentationModel[]) => {
-                this.resetFilter();
-                res.forEach((filter) => {
-                    this.filterObserver.next(filter);
-                });
-                this.selectFirstFilter();
-                this.onSuccess.emit(res);
+                if (res.length === 0 && this.isFilterListEmpty()) {
+                    this.activiti.createDefaultFilters(appId).subscribe(
+                        (resDefault: FilterProcessRepresentationModel[]) => {
+                            this.resetFilter();
+                            resDefault.forEach((filter) => {
+                                this.filterObserver.next(filter);
+                            });
+
+                            this.selectFirstFilter();
+                            this.onSuccess.emit(resDefault);
+                        },
+                        (errDefault: any) => {
+                            this.logService.error(errDefault);
+                            this.onError.emit(errDefault);
+                        }
+                    );
+                } else {
+                    this.resetFilter();
+                    res.forEach((filter) => {
+                        this.filterObserver.next(filter);
+                    });
+
+                    this.selectFirstFilter();
+                    this.onSuccess.emit(res);
+                }
             },
             (err: any) => {
                 this.logService.error(err);

ng2-components/ng2-activiti-processlist/src/services/activiti-process.service.spec.ts

@@ -21,7 +21,6 @@ import { CoreModule, AlfrescoApiService } from 'ng2-alfresco-core';
 import { FilterRepresentationModel } from 'ng2-activiti-tasklist';
 import { AlfrescoApi } from 'alfresco-js-api';
 import {
-    fakeEmptyFilters,
     fakeFilters,
     fakeError,
     fakeApp1,
@@ -32,9 +31,11 @@ import {
 } from '../assets/activiti-process.service.mock';
 import { exampleProcess } from '../assets/activiti-process.model.mock';
 import { ProcessFilterRequestRepresentation } from '../models/process-instance-filter.model';
+import { FilterProcessRepresentationModel } from '../models/filter-process.model';
 import { ProcessInstanceVariable } from '../models/process-instance-variable.model';
 import { ActivitiProcessService } from './activiti-process.service';
 
+declare let jasmine: any;
 describe('ActivitiProcessService', () => {
 
     let service: ActivitiProcessService;
@@ -603,26 +604,18 @@ describe('ActivitiProcessService', () => {
                 );
             }));
 
-            it('should return the default filters when none are returned by the API', async(() => {
-                getFilters = getFilters.and.returnValue(Promise.resolve(fakeEmptyFilters));
-
-                service.getProcessFilters(null).subscribe(
-                    (res) => {
-                        expect(res.length).toBe(3);
+            it('should return the default filters', (done) => {
+                service.createDefaultFilters(1234).subscribe(
+                    (res: FilterProcessRepresentationModel []) => {
+                        expect(res).toBeDefined();
+                        expect(res.length).toEqual(3);
+                        expect(res[0].name).toEqual('Running');
+                        expect(res[1].name).toEqual('Completed');
+                        expect(res[2].name).toEqual('All');
+                        done();
                     }
                 );
-            }));
-
-            it('should create the default filters when none are returned by the API', async(() => {
-                getFilters = getFilters.and.returnValue(Promise.resolve(fakeEmptyFilters));
-                createFilter = createFilter.and.returnValue(Promise.resolve({}));
-
-                service.getProcessFilters(null).subscribe(
-                    () => {
-                        expect(createFilter).toHaveBeenCalledTimes(3);
-                    }
-                );
-            }));
+            });
 
             it('should pass on any error that is returned by the API', async(() => {
                 getFilters = getFilters.and.returnValue(Promise.reject(fakeError));

ng2-components/ng2-activiti-processlist/src/services/activiti-process.service.ts

@@ -17,7 +17,7 @@
 
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
-import { AlfrescoApiService } from 'ng2-alfresco-core';
+import { AlfrescoApiService, LogService } from 'ng2-alfresco-core';
 import { ProcessInstance, ProcessDefinitionRepresentation } from '../models/index';
 import { ProcessFilterRequestRepresentation } from '../models/process-instance-filter.model';
 import { ProcessInstanceVariable } from './../models/process-instance-variable.model';
@@ -29,7 +29,8 @@ declare var moment: any;
 @Injectable()
 export class ActivitiProcessService {
 
-    constructor(private apiService: AlfrescoApiService) {
+    constructor(private apiService: AlfrescoApiService,
+                private logService: LogService) {
     }
 
     /**
@@ -64,9 +65,6 @@ export class ActivitiProcessService {
                     let filterModel = new FilterProcessRepresentationModel(filter);
                     filters.push(filterModel);
                 });
-                if (response && response.data && response.data.length === 0) {
-                    return this.createDefaultFilters(appId);
-                }
                 return filters;
             })
             .catch(err => this.handleError(err));
@@ -77,29 +75,42 @@ export class ActivitiProcessService {
      * @param appId
      * @returns {FilterRepresentationModel[]}
      */
-    private createDefaultFilters(appId: number): FilterProcessRepresentationModel[] {
-        let filters: FilterProcessRepresentationModel[] = [];
+    public createDefaultFilters(appId: number): Observable<FilterProcessRepresentationModel[]> {
+        let runnintFilter = this.getRunningFilterInstance(appId);
+        let runnintObservable = this.addFilter(runnintFilter);
 
-        let involvedTasksFilter = this.getRunningFilterInstance(appId);
-        this.addFilter(involvedTasksFilter);
-        filters.push(involvedTasksFilter);
+        let completedFilter = this.getCompletedFilterInstance(appId);
+        let completedObservable = this.addFilter(completedFilter);
 
-        let myTasksFilter = this.getCompletedFilterInstance(appId);
-        this.addFilter(myTasksFilter);
-        filters.push(myTasksFilter);
+        let allFilter = this.getAllFilterInstance(appId);
+        let allObservable = this.addFilter(allFilter);
 
-        let queuedTasksFilter = this.getAllFilterInstance(appId);
-        this.addFilter(queuedTasksFilter);
-        filters.push(queuedTasksFilter);
-
-        return filters;
+        return Observable.create(observer => {
+            Observable.forkJoin(
+                runnintObservable,
+                completedObservable,
+                allObservable
+            ).subscribe(
+                (res) => {
+                    let filters: FilterProcessRepresentationModel[] = [];
+                    res.forEach((filter) => {
+                        if (filter.name === runnintFilter.name) {
+                            filters.push(runnintFilter);
+                        } else if (filter.name === completedFilter.name) {
+                            filters.push(completedFilter);
+                        } else if (filter.name === allFilter.name) {
+                            filters.push(allFilter);
+                        }
+                    });
+                    observer.next(filters);
+                    observer.complete();
+                },
+                (err: any) => {
+                    this.logService.error(err);
+                });
+        });
     }
 
-    /**
-     * Return a static Running filter instance
-     * @param appId
-     * @returns {FilterProcessRepresentationModel}
-     */
     private getRunningFilterInstance(appId: number): FilterProcessRepresentationModel {
         return new FilterProcessRepresentationModel({
             'name': 'Running',
@@ -147,7 +158,10 @@ export class ActivitiProcessService {
      */
     addFilter(filter: FilterProcessRepresentationModel): Observable<FilterProcessRepresentationModel> {
         return Observable.fromPromise(this.callApiAddFilter(filter))
-            .catch(err => this.handleError(err));
+            .map(res => res)
+            .map((response: FilterProcessRepresentationModel) => {
+                return response;
+            }).catch(err => this.handleError(err));
     }
 
     getProcess(id: string): Observable<ProcessInstance> {

ng2-components/ng2-activiti-tasklist/src/components/activiti-filters.component.ts

@@ -105,14 +105,33 @@ export class ActivitiFilters implements OnInit, OnChanges {
     getFiltersByAppId(appId?: string) {
         this.activiti.getTaskListFilters(appId).subscribe(
             (res: FilterRepresentationModel[]) => {
-                this.resetFilter();
-                res.forEach((filter) => {
-                    this.filterObserver.next(filter);
-                });
-                this.selectFirstFilter();
-                this.onSuccess.emit(res);
+                if (res.length === 0 && this.isFilterListEmpty()) {
+                    this.activiti.createDefaultFilters(appId).subscribe(
+                        (resDefault: FilterRepresentationModel[]) => {
+                            this.resetFilter();
+                            resDefault.forEach((filter) => {
+                                this.filterObserver.next(filter);
+                            });
+
+                            this.selectFirstFilter();
+                            this.onSuccess.emit(resDefault);
+                        },
+                        (errDefault: any) => {
+                            this.logService.error(errDefault);
+                            this.onError.emit(errDefault);
+                        }
+                    );
+                } else {
+                    this.resetFilter();
+                    res.forEach((filter) => {
+                        this.filterObserver.next(filter);
+                    });
+
+                    this.selectFirstFilter();
+                    this.onSuccess.emit(res);
+                }
             },
-            (err) => {
+            (err: any) => {
                 this.logService.error(err);
                 this.onError.emit(err);
             }

ng2-components/ng2-activiti-tasklist/src/services/activiti-tasklist.service.spec.ts

@@ -26,14 +26,9 @@ import {
 } from '../models/filter.model';
 import { Comment } from '../models/comment.model';
 
-declare let AlfrescoApi: any;
 declare let jasmine: any;
 
 describe('ActivitiTaskListService', () => {
-    let fakeEmptyFilters = {
-        size: 0, total: 0, start: 0,
-        data: []
-    };
 
     let fakeFilters = {
         size: 2, total: 2, start: 0,
@@ -431,29 +426,50 @@ describe('ActivitiTaskListService', () => {
         });
     });
 
-    it('should call the createDefaultFilter when the list is empty', (done) => {
-        spyOn(service, 'createDefaultFilter');
-
-        service.getTaskListFilters().subscribe(
-            (res) => {
-                expect(service.createDefaultFilter).toHaveBeenCalled();
+    it('should return the default filters', (done) => {
+        service.createDefaultFilters('1234').subscribe(
+            (res: FilterRepresentationModel []) => {
+                expect(res).toBeDefined();
+                expect(res.length).toEqual(4);
+                expect(res[0].name).toEqual('Involved Tasks');
+                expect(res[1].name).toEqual('My Tasks');
+                expect(res[2].name).toEqual('Queued Tasks');
+                expect(res[3].name).toEqual('Completed Tasks');
                 done();
             }
         );
 
-        jasmine.Ajax.requests.mostRecent().respondWith({
+        jasmine.Ajax.requests.at(0).respondWith({
             'status': 200,
             contentType: 'application/json',
-            responseText: JSON.stringify(fakeEmptyFilters)
+            responseText: JSON.stringify({
+                id: '111', name: 'Involved Tasks', filter: { assignment: 'fake-involved' }
+            })
         });
-    });
 
-    it('should return the default filters', () => {
-        spyOn(service, 'addFilter');
-        let filters = service.createDefaultFilter(null);
-        expect(service.addFilter).toHaveBeenCalledTimes(4);
-        expect(filters).toBeDefined();
-        expect(filters.length).toEqual(4);
+        jasmine.Ajax.requests.at(1).respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify({
+                id: '222', name: 'My Tasks', filter: { assignment: 'fake-assignee' }
+            })
+        });
+
+        jasmine.Ajax.requests.at(2).respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify({
+                id: '333', name: 'Queued Tasks', filter: { assignment: 'fake-candidate' }
+            })
+        });
+
+        jasmine.Ajax.requests.at(3).respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify({
+                id: '444', name: 'Completed Tasks', filter: { assignment: 'fake-involved' }
+            })
+        });
     });
 
     it('should add a filter ', (done) => {

ng2-components/ng2-activiti-tasklist/src/services/activiti-tasklist.service.ts

@@ -61,9 +61,6 @@ export class ActivitiTaskListService {
                     let filterModel = new FilterRepresentationModel(filter);
                     filters.push(filterModel);
                 });
-                if (response && response.data && response.data.length === 0) {
-                    return this.createDefaultFilter(appId);
-                }
                 return filters;
             }).catch(err => this.handleError(err));
     }
@@ -204,26 +201,46 @@ export class ActivitiTaskListService {
      * @param appId
      * @returns {FilterRepresentationModel[]}
      */
-    createDefaultFilter(appId: string): FilterRepresentationModel[] {
-        let filters: FilterRepresentationModel[] = [];
-
+    public createDefaultFilters(appId: string): Observable<FilterRepresentationModel[]> {
         let involvedTasksFilter = this.getInvolvedTasksFilterInstance(appId);
-        this.addFilter(involvedTasksFilter);
-        filters.push(involvedTasksFilter);
+        let involvedObservable = this.addFilter(involvedTasksFilter);
 
         let myTasksFilter = this.getMyTasksFilterInstance(appId);
-        this.addFilter(myTasksFilter);
-        filters.push(myTasksFilter);
+        let myTaskObservable = this.addFilter(myTasksFilter);
 
         let queuedTasksFilter = this.getQueuedTasksFilterInstance(appId);
-        this.addFilter(queuedTasksFilter);
-        filters.push(queuedTasksFilter);
+        let queuedObservable = this.addFilter(queuedTasksFilter);
 
         let completedTasksFilter = this.getCompletedTasksFilterInstance(appId);
-        this.addFilter(completedTasksFilter);
-        filters.push(completedTasksFilter);
+        let completeObservable = this.addFilter(completedTasksFilter);
 
-        return filters;
+        return Observable.create(observer => {
+            Observable.forkJoin(
+                involvedObservable,
+                myTaskObservable,
+                queuedObservable,
+                completeObservable
+            ).subscribe(
+                (res) => {
+                    let filters: FilterRepresentationModel[] = [];
+                    res.forEach((filter) => {
+                        if (filter.name === involvedTasksFilter.name) {
+                            filters.push(involvedTasksFilter);
+                        } else if (filter.name === myTasksFilter.name) {
+                            filters.push(myTasksFilter);
+                        } else if (filter.name === queuedTasksFilter.name) {
+                            filters.push(queuedTasksFilter);
+                        } else if (filter.name === completedTasksFilter.name) {
+                            filters.push(completedTasksFilter);
+                        }
+                    });
+                    observer.next(filters);
+                    observer.complete();
+                },
+                (err: any) => {
+                    this.logService.error(err);
+                });
+        });
     }
 
     /**