Auto-create default process-instance filters

Refs #850

ng2-components/ng2-activiti-processlist/karma.conf.js

@@ -34,7 +34,6 @@ module.exports = function (config) {
 
       'node_modules/alfresco-js-api/dist/alfresco-js-api.js',
       {pattern: 'node_modules/ng2-translate/**/*.js', included: false, watched: false},
-      {pattern: 'node_modules/ng2-translate/**/*.js.map', included: false, watched: false},
 
       'karma-test-shim.js',
 
@@ -47,6 +46,7 @@ module.exports = function (config) {
       { pattern: 'node_modules/ng2-alfresco-core/dist/**/*.*', included: false, served: true, watched: false },
       { pattern: 'node_modules/ng2-alfresco-datatable/dist/**/*.*', included: false, served: true, watched: false },
       { pattern: 'node_modules/ng2-activiti-tasklist/dist/**/*.js', included: false, served: true, watched: false },
+      { pattern: 'node_modules/ng2-activiti-form/dist/**/*.js', included: false, served: true, watched: false },
 
       // paths to support debugging with source maps in dev tools
       {pattern: 'src/**/*.ts', included: false, watched: false},

ng2-components/ng2-activiti-processlist/package.json

@@ -57,13 +57,13 @@
     "alfresco-js-api": "^0.3.0",
     "core-js": "^2.4.1",
     "ng2-activiti-tasklist": "0.3.3",
+    "ng2-activiti-form": "0.3.2",
     "ng2-alfresco-core": "0.3.2",
     "ng2-alfresco-datatable": "0.3.2",
     "ng2-translate": "2.5.0",
     "reflect-metadata": "^0.1.3",
     "rxjs": "5.0.0-beta.12",
-    "systemjs": "0.19.27",
+    "systemjs": "0.19.27"
-    "zone.js": "^0.6.23"
   },
   "devDependencies": {
     "@types/core-js": "^0.9.32",

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

@@ -25,18 +25,21 @@ import { ActivitiProcessService } from './activiti-process.service';
 
 describe('ActivitiProcessService', () => {
 
-    let service, injector;
+    let service: ActivitiProcessService;
+    let injector: ReflectiveInjector;
+
+    let fakeEmptyFilters = {
+        size: 0, total: 0, start: 0,
+        data: [ ]
+    };
 
     beforeEach(() => {
         injector = ReflectiveInjector.resolveAndCreate([
             ActivitiProcessService,
-            AlfrescoSettingsService,
             AlfrescoApiService,
-            AlfrescoAuthenticationService
+            AlfrescoAuthenticationService,
+            AlfrescoSettingsService
         ]);
-    });
-
-    beforeEach(() => {
         service = injector.get(ActivitiProcessService);
     });
 
@@ -45,4 +48,25 @@ describe('ActivitiProcessService', () => {
         expect(true).toBe(true);
         done();
     });
+
+    it('should call createDefaultFilters() when the returned filter list is empty', (done) => {
+        spyOn(service, 'createDefaultFilters');
+        spyOn(service, 'callApiGetUserProcessInstanceFilters').and.returnValue(Promise.resolve(fakeEmptyFilters));
+        spyOn(service, 'callApiAddFilter').and.returnValue(Promise.resolve({}));
+
+        service.getProcessFilters(null).subscribe(
+            (res) => {
+                expect(service.createDefaultFilters).toHaveBeenCalled();
+                done();
+            }
+        );
+    });
+
+    it('should return the default filters', () => {
+        spyOn(service, 'addFilter').and.returnValue(Promise.resolve({}));
+        let filters = service.createDefaultFilters(null);
+        expect(service.addFilter).toHaveBeenCalledTimes(3);
+        expect(filters).toBeDefined();
+        expect(filters.length).toEqual(3);
+    });
 });

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

@@ -17,7 +17,7 @@
 
 import {AlfrescoAuthenticationService} from 'ng2-alfresco-core';
 import {ProcessInstance} from '../models/process-instance';
-import {TaskQueryRequestRepresentationModel} from '../models/filter.model';
+import {TaskQueryRequestRepresentationModel, UserProcessInstanceFilterRepresentationModel} from '../models/filter.model';
 import {User} from '../models/user.model';
 import {Comment} from '../models/comment.model';
 import {Injectable}     from '@angular/core';
@@ -59,11 +59,102 @@ export class ActivitiProcessService {
         let filterOpts = appId ? {
             appId: appId
         } : {};
-        return Observable.fromPromise(this.authService.getAlfrescoApi().activiti.userFiltersApi.getUserProcessInstanceFilters(filterOpts))
+        return Observable.fromPromise(this.callApiGetUserProcessInstanceFilters(filterOpts))
-            .map(this.extractData)
+            .map((response: any) => {
+                let filters: UserProcessInstanceFilterRepresentationModel[] = [];
+                response.data.forEach((filter: UserProcessInstanceFilterRepresentationModel) => {
+                    let filterModel = new UserProcessInstanceFilterRepresentationModel(filter);
+                    filters.push(filterModel);
+                });
+                if (response && response.data && response.data.length === 0) {
+                    return this.createDefaultFilters(appId);
+                }
+                return filters;
+            })
             .catch(this.handleError);
     }
 
+    /**
+     * Create and return the default filters
+     * @param appId
+     * @returns {UserProcessInstanceFilterRepresentationModel[]}
+     */
+    createDefaultFilters(appId: string): UserProcessInstanceFilterRepresentationModel[] {
+        let filters: UserProcessInstanceFilterRepresentationModel[] = [];
+
+        let involvedTasksFilter = this.getRunningFilterInstance(appId);
+        this.addFilter(involvedTasksFilter);
+        filters.push(involvedTasksFilter);
+
+        let myTasksFilter = this.getCompletedFilterInstance(appId);
+        this.addFilter(myTasksFilter);
+        filters.push(myTasksFilter);
+
+        let queuedTasksFilter = this.getAllFilterInstance(appId);
+        this.addFilter(queuedTasksFilter);
+        filters.push(queuedTasksFilter);
+
+        return filters;
+    }
+
+    /**
+     * Return a static Running filter instance
+     * @param appId
+     * @returns {UserProcessInstanceFilterRepresentationModel}
+     */
+    getRunningFilterInstance(appId: string): UserProcessInstanceFilterRepresentationModel {
+        return new UserProcessInstanceFilterRepresentationModel({
+            'name': 'Running',
+            'appId': appId,
+            'recent': true,
+            'icon': 'glyphicon-random',
+            'filter': {'sort': 'created-desc', 'name': '', 'state': 'running'}
+        });
+    }
+
+    /**
+     * Return a static Completed filter instance
+     * @param appId
+     * @returns {UserProcessInstanceFilterRepresentationModel}
+     */
+    getCompletedFilterInstance(appId: string): UserProcessInstanceFilterRepresentationModel {
+        return new UserProcessInstanceFilterRepresentationModel({
+            'name': 'Completed',
+            'appId': appId,
+            'recent': false,
+            'icon': 'glyphicon-ok-sign',
+            'filter': {'sort': 'created-desc', 'name': '', 'state': 'completed'}
+        });
+    }
+
+    /**
+     * Return a static All filter instance
+     * @param appId
+     * @returns {UserProcessInstanceFilterRepresentationModel}
+     */
+    getAllFilterInstance(appId: string): UserProcessInstanceFilterRepresentationModel {
+        return new UserProcessInstanceFilterRepresentationModel({
+            'name': 'All',
+            'appId': appId,
+            'recent': true,
+            'icon': 'glyphicon-th',
+            'filter': {'sort': 'created-desc', 'name': '', 'state': 'all'}
+        });
+    }
+
+    /**
+     * Add a filter
+     * @param filter - UserProcessInstanceFilterRepresentationModel
+     * @returns {UserProcessInstanceFilterRepresentationModel}
+     */
+    addFilter(filter: UserProcessInstanceFilterRepresentationModel): Observable<UserProcessInstanceFilterRepresentationModel> {
+        return Observable.fromPromise(this.callApiAddFilter(filter))
+            .map(res => res)
+            .map((response: UserProcessInstanceFilterRepresentationModel) => {
+                return response;
+            }).catch(this.handleError);
+    }
+
     getProcess(id: string): Observable<ProcessInstance> {
         return Observable.fromPromise(this.authService.getAlfrescoApi().activiti.processApi.getProcessInstance(id))
             .catch(this.handleError);
@@ -152,6 +243,14 @@ export class ActivitiProcessService {
             .catch(this.handleError);
     }
 
+    private callApiGetUserProcessInstanceFilters(filterOpts) {
+        return this.authService.getAlfrescoApi().activiti.userFiltersApi.getUserProcessInstanceFilters(filterOpts);
+    }
+
+    private callApiAddFilter(filter: UserProcessInstanceFilterRepresentationModel) {
+        return this.authService.getAlfrescoApi().activiti.userFiltersApi.createUserProcessInstanceFilter(filter);
+    }
+
     private extractData(res: any) {
         return res.data || {};
     }