#1517 - Added new behaviour when user create a new task (#1769)

* #1517 - added search task into filters by id feature

* #1517 - added test for tasklist service

* #1517 - Added test for filter component

demo-shell-ng2/app/components/activiti/activiti-demo.component.ts

@@ -162,8 +162,9 @@ export class ActivitiDemoComponent implements AfterViewInit {
     }
 
     onStartTaskSuccess(event: any) {
-        this.activitifilter.selectFirstFilter();
+        this.activitifilter.selectFilterWithTask(event.id);
         this.taskFilter = this.activitifilter.getCurrentFilter();
+        this.activititasklist.landingTaskId = event.id;
         this.activititasklist.reload();
     }
 

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

@@ -16,6 +16,7 @@
  */
 
 import { SimpleChange } from '@angular/core';
+import { async } from '@angular/core/testing';
 import { Observable } from 'rxjs/Rx';
 import { LogServiceMock } from 'ng2-alfresco-core';
 import { ActivitiFilters } from './activiti-filters.component';
@@ -29,8 +30,18 @@ describe('ActivitiFilters', () => {
     let logService: LogServiceMock;
 
     let fakeGlobalFilter = [];
-    fakeGlobalFilter.push(new FilterRepresentationModel({name: 'FakeInvolvedTasks', filter: { state: 'open', assignment: 'fake-involved'}}));
+    fakeGlobalFilter.push(new FilterRepresentationModel({
-    fakeGlobalFilter.push(new FilterRepresentationModel({name: 'FakeMyTasks', filter: { state: 'open', assignment: 'fake-assignee'}}));
+        name: 'FakeInvolvedTasks',
+        filter: { state: 'open', assignment: 'fake-involved' }
+    }));
+    fakeGlobalFilter.push(new FilterRepresentationModel({
+        name: 'FakeMyTasks',
+        filter: { state: 'open', assignment: 'fake-assignee' }
+    }));
+    let fakeFilter = new FilterRepresentationModel({
+        name: 'FakeMyTasks',
+        filter: { state: 'open', assignment: 'fake-assignee' }
+    });
 
     let fakeGlobalFilterPromise = new Promise(function (resolve, reject) {
         resolve(fakeGlobalFilter);
@@ -164,7 +175,10 @@ describe('ActivitiFilters', () => {
     });
 
     it('should return the current filter after one is selected', () => {
-        let filter = new FilterRepresentationModel({name: 'FakeMyTasks', filter: { state: 'open', assignment: 'fake-assignee'}});
+        let filter = new FilterRepresentationModel({
+            name: 'FakeMyTasks',
+            filter: { state: 'open', assignment: 'fake-assignee' }
+        });
         expect(filterList.currentFilter).toBeUndefined();
         filterList.selectFilter(filter);
         expect(filterList.getCurrentFilter()).toBe(filter);
@@ -178,4 +192,25 @@ describe('ActivitiFilters', () => {
 
         expect(filterList.getFiltersByAppId).toHaveBeenCalled();
     });
+
+    it('should change the current filter if a filter with taskid is found', async(() => {
+        spyOn(activitiService, 'isTaskRelatedToFilter').and.returnValue(Observable.of(fakeFilter));
+        filterList.filters = fakeGlobalFilter;
+        filterList.selectFilterWithTask('111');
+
+        expect(filterList.currentFilter).toBe(fakeFilter);
+    }));
+
+    it('should not change the current filter if no filter with taskid is found', async(() => {
+        let filter = new FilterRepresentationModel({
+            name: 'FakeMyTasks',
+            filter: { state: 'open', assignment: 'fake-assignee' }
+        });
+        filterList.filters = fakeGlobalFilter;
+        filterList.currentFilter = filter;
+        spyOn(activitiService, 'isTaskRelatedToFilter').and.returnValue(Observable.of(null));
+        filterList.selectFilterWithTask('111');
+
+        expect(filterList.currentFilter).toBe(filter);
+    }));
 });

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

@@ -144,6 +144,24 @@ export class ActivitiFilters implements OnInit, OnChanges {
         this.filterClick.emit(filter);
     }
 
+    public selectFilterWithTask(taskId: string) {
+        let filteredFilterList: FilterRepresentationModel[] = [];
+        this.activiti.getFilterForTaskById(taskId, this.filters).subscribe(
+            (filter: FilterRepresentationModel) => {
+                filteredFilterList.push(filter);
+            },
+            (err) => {
+                this.logService.error(err);
+                this.onError.emit(err);
+            },
+            () => {
+                if (filteredFilterList.length > 0) {
+                    let myTaskFilter = filteredFilterList.find(filter => filter.name === 'My Tasks');
+                    this.currentFilter = myTaskFilter ? myTaskFilter : filteredFilterList[0];
+                }
+            });
+    }
+
     /**
      * Select the first filter of a list if present
      */

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

@@ -15,11 +15,15 @@
  * limitations under the License.
  */
 
-import { TestBed } from '@angular/core/testing';
+import { TestBed, async } from '@angular/core/testing';
 import { CoreModule } from 'ng2-alfresco-core';
 import { ActivitiTaskListService } from './activiti-tasklist.service';
 import { TaskDetailsModel } from '../models/task-details.model';
-import { FilterRepresentationModel, AppDefinitionRepresentationModel, TaskQueryRequestRepresentationModel } from '../models/filter.model';
+import {
+    FilterRepresentationModel,
+    AppDefinitionRepresentationModel,
+    TaskQueryRequestRepresentationModel
+} from '../models/filter.model';
 import { Comment } from '../models/comment.model';
 
 declare let AlfrescoApi: any;
@@ -36,12 +40,12 @@ describe('ActivitiTaskListService', () => {
         data: [
             new AppDefinitionRepresentationModel(
                 {
-                    id: 1, name: 'FakeInvolvedTasks', recent: false, icon: 'glyphicon-align-left',
+                    id: '1', name: 'FakeInvolvedTasks', recent: false, icon: 'glyphicon-align-left',
                     filter: { sort: 'created-desc', name: '', state: 'open', assignment: 'fake-involved' }
                 }
             ),
             {
-                id: 2, name: 'FakeMyTasks', recent: false, icon: 'glyphicon-align-left',
+                id: '2', name: 'FakeMyTasks', recent: false, icon: 'glyphicon-align-left',
                 filter: { sort: 'created-desc', name: '', state: 'open', assignment: 'fake-assignee' }
             }
         ]
@@ -81,7 +85,18 @@ describe('ActivitiTaskListService', () => {
         size: 1, total: 1, start: 0,
         data: [
             {
-                id: 1, name: 'FakeNameTask', description: null, category: null,
+                id: '1', name: 'FakeNameTask', description: null, category: null,
+                assignee: fakeUser,
+                created: '2016-07-15T11:19:17.440+0000'
+            }
+        ]
+    };
+
+    let secondFakeTaskList = {
+        size: 1, total: 1, start: 0,
+        data: [
+            {
+                id: '200', name: 'FakeNameTask', description: null, category: null,
                 assignee: fakeUser,
                 created: '2016-07-15T11:19:17.440+0000'
             }
@@ -122,6 +137,40 @@ describe('ActivitiTaskListService', () => {
         ]
     };
 
+    let fakeRepresentationFilter1: FilterRepresentationModel = new FilterRepresentationModel({
+        appId: 1,
+        name: 'CONTAIN FILTER',
+        recent: true,
+        icon: 'glyphicon-align-left',
+        filter: {
+            processDefinitionId: null,
+            processDefinitionKey: null,
+            name: null,
+            state: 'open',
+            sort: 'created-desc',
+            assignment: 'involved',
+            dueAfter: null,
+            dueBefore: null
+        }
+    });
+
+    let fakeRepresentationFilter2: FilterRepresentationModel = new FilterRepresentationModel({
+        appId: 2,
+        name: 'NO TASK FILTER',
+        recent: false,
+        icon: 'glyphicon-inbox',
+        filter: {
+            processDefinitionId: null,
+            processDefinitionKey: null,
+            name: null,
+            state: 'open',
+            sort: 'created-desc',
+            assignment: 'assignee',
+            dueAfter: null,
+            dueBefore: null
+        }
+    });
+
     let fakeAppPromise = new Promise(function (resolve, reject) {
         resolve(fakeAppFilter);
     });
@@ -522,4 +571,63 @@ describe('ActivitiTaskListService', () => {
         });
     });
 
+    it('should return the filter if it contains task id', (done) => {
+        let taskId = '1';
+        let filterFake = new FilterRepresentationModel({
+            name: 'FakeNameFilter',
+            assignment: 'fake-assignement',
+            filter: {
+                processDefinitionKey: '1',
+                assignment: 'fake',
+                state: 'none',
+                sort: 'asc'
+            }
+        });
+
+        service.isTaskRelatedToFilter(taskId, filterFake).subscribe(
+            (res: any) => {
+                expect(res).toBeDefined();
+                expect(res).not.toBeNull();
+                done();
+            }
+        );
+
+        jasmine.Ajax.requests.mostRecent().respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify(fakeTaskList)
+        });
+    });
+
+    it('should return the filters if it contains task id', async(() => {
+        let taskId = '1';
+
+        let fakeFilterList: FilterRepresentationModel[] = [];
+        fakeFilterList.push(fakeRepresentationFilter1, fakeRepresentationFilter2);
+        let resultFilter = null;
+        service.getFilterForTaskById(taskId, fakeFilterList).subscribe(
+            (res: FilterRepresentationModel) => {
+                resultFilter = res;
+            },
+            () => {
+            },
+            () => {
+                expect(resultFilter).toBeDefined();
+                expect(resultFilter).not.toBeNull();
+                expect(resultFilter.name).toBe('CONTAIN FILTER');
+            });
+
+        jasmine.Ajax.requests.at(0).respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify(fakeTaskList)
+        });
+
+        jasmine.Ajax.requests.at(1).respondWith({
+            'status': 200,
+            contentType: 'application/json',
+            responseText: JSON.stringify(secondFakeTaskList)
+        });
+    }));
+
 });

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

@@ -18,7 +18,10 @@
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Rx';
 import { AlfrescoApiService, LogService } from 'ng2-alfresco-core';
-import { FilterRepresentationModel, TaskQueryRequestRepresentationModel } from '../models/filter.model';
+import {
+    FilterRepresentationModel,
+    TaskQueryRequestRepresentationModel
+} from '../models/filter.model';
 import { Comment } from '../models/comment.model';
 import { User } from '../models/user.model';
 import { TaskDetailsModel } from '../models/task-details.model';
@@ -65,6 +68,48 @@ export class ActivitiTaskListService {
             }).catch(err => this.handleError(err));
     }
 
+    /**
+     * Return all the filters in the list where the task id belong
+     * @param taskId - string
+     * @param filter - FilterRepresentationModel []
+     * @returns {FilterRepresentationModel}
+     */
+    getFilterForTaskById(taskId: string, filterList: FilterRepresentationModel[]): Observable<FilterRepresentationModel> {
+        return Observable.from(filterList)
+            .flatMap((filter: FilterRepresentationModel) => this.isTaskRelatedToFilter(taskId, filter))
+            .filter((filter: FilterRepresentationModel) => filter != null);
+    }
+
+    /**
+     * Return the search node for query task based on the given filter
+     * @param filter - FilterRepresentationModel
+     * @returns {TaskQueryRequestRepresentationModel}
+     */
+    private generateTaskRequestNodeFromFilter(filter: FilterRepresentationModel): TaskQueryRequestRepresentationModel {
+        let requestNode = {
+            appDefinitionId: filter.appId,
+            processDefinitionKey: filter.filter.processDefinitionKey,
+            assignment: filter.filter.assignment,
+            state: filter.filter.state,
+            sort: filter.filter.sort
+        };
+        return new TaskQueryRequestRepresentationModel(requestNode);
+    }
+
+    /**
+     * Check if a taskId is filtered with the given filter
+     * @param taskId - string
+     * @param filter - FilterRepresentationModel
+     * @returns {FilterRepresentationModel}
+     */
+    isTaskRelatedToFilter(taskId: string, filter: FilterRepresentationModel): Observable<FilterRepresentationModel> {
+        let requestNodeForFilter = this.generateTaskRequestNodeFromFilter(filter);
+        return Observable.fromPromise(this.callApiTasksFiltered(requestNodeForFilter))
+            .map((res: any) => {
+                return res.data.find(element => element.id === taskId) ? filter : null;
+            }).catch(err => this.handleError(err));
+    }
+
     /**
      * Retrive all the tasks filtered by filterModel
      * @param filter - TaskFilterRepresentationModel