From 0bd05a2d4caf83c5e5a15901ee5065a7bc4154cd Mon Sep 17 00:00:00 2001 From: Vito Albano Date: Mon, 31 Oct 2016 14:09:43 +0000 Subject: [PATCH] Added remove involved user to people service --- .../services/activiti-people.service.spec.ts | 169 ++++++++++++++++++ .../src/services/activiti-people.service.ts | 73 ++++++++ 2 files changed, 242 insertions(+) create mode 100644 ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.spec.ts create mode 100644 ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.ts diff --git a/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.spec.ts b/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.spec.ts new file mode 100644 index 0000000000..85fbcf4619 --- /dev/null +++ b/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.spec.ts @@ -0,0 +1,169 @@ +/*! + * @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 { ReflectiveInjector } from '@angular/core'; +import { + AlfrescoAuthenticationService, + AlfrescoSettingsService, + AlfrescoApiService +} from 'ng2-alfresco-core'; +import { User } from '../models/user.model'; +import { ActivitiPeopleService } from './activiti-people.service'; + +declare let jasmine: any; + +const firstInvolvedUser: User = new User({ + id: '1', + email: 'fake-user1@fake.com', + firstName: 'fakeName1', + lastName: 'fakeLast1' +}); + +const secondInvolvedUser: User = new User({ + id: '2', + email: 'fake-user2@fake.com', + firstName: 'fakeName2', + lastName: 'fakeLast2' +}); + +const fakeInvolveUserList: User[] = [firstInvolvedUser, secondInvolvedUser]; + +describe('Activiti People Search Service', () => { + + let service, injector, apiService; + + beforeEach(() => { + injector = ReflectiveInjector.resolveAndCreate([ + AlfrescoSettingsService, + AlfrescoApiService, + AlfrescoAuthenticationService, + ActivitiPeopleService + ]); + }); + + beforeEach(() => { + service = injector.get(ActivitiPeopleService); + apiService = injector.get(AlfrescoApiService); + }); + + it('can instantiate service with authorization', () => { + expect(apiService).not.toBeNull('authorization should be provided'); + let serviceApi = new ActivitiPeopleService(null, apiService); + + expect(serviceApi instanceof ActivitiPeopleService).toBe(true, 'new service should be ok'); + }); + + describe('when user is logged in', () => { + + beforeEach(() => { + jasmine.Ajax.install(); + }); + + afterEach(() => { + jasmine.Ajax.uninstall(); + }); + + it('should be able to retrieve people to involve in the task', (done) => { + service.getWorkflowUsers('fake-task-id', 'fake-filter').subscribe( + (users: User[]) => { + expect(users).toBeDefined(); + expect(users.length).toBe(2); + expect(users[0].id).toEqual('1'); + expect(users[0].email).toEqual('fake-user1@fake.com'); + expect(users[0].firstName).toEqual('fakeName1'); + expect(users[0].lastName).toEqual('fakeLast1'); + done(); + }); + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 200, + contentType: 'json', + responseText: {data: fakeInvolveUserList} + }); + }); + + it('should return empty list when there are no users to involve', (done) => { + service.getWorkflowUsers('fake-task-id', 'fake-filter').subscribe( + (users: User[]) => { + expect(users).toBeDefined(); + expect(users.length).toBe(0); + done(); + }); + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 200, + contentType: 'json', + responseText: {} + }); + }); + + it('getWorkflowUsers catch errors call', (done) => { + service.getWorkflowUsers('fake-task-id', 'fake-filter').subscribe(() => { + }, () => { + done(); + }); + + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 403 + }); + }); + + it('should be able to involve people in the task', (done) => { + service.involveUserWithTask('fake-task-id', 'fake-user-id').subscribe( + () => { + expect(jasmine.Ajax.requests.mostRecent().method).toBe('PUT'); + expect(jasmine.Ajax.requests.mostRecent().url).toContain('tasks/fake-task-id/action/involve'); + done(); + }); + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 200 + }); + }); + + it('involveUserWithTask catch errors call', (done) => { + service.involveUserWithTask('fake-task-id', 'fake-user-id').subscribe(() => { + }, () => { + done(); + }); + + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 403 + }); + }); + + it('should be able to remove involved people from task', (done) => { + service.removeInvolvedUser('fake-task-id', 'fake-user-id').subscribe( + () => { + expect(jasmine.Ajax.requests.mostRecent().method).toBe('PUT'); + expect(jasmine.Ajax.requests.mostRecent().url).toContain('tasks/fake-task-id/action/remove-involved'); + done(); + }); + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 200 + }); + }); + + it('removeInvolvedUser catch errors call', (done) => { + service.removeInvolvedUser('fake-task-id', 'fake-user-id').subscribe(() => { + }, () => { + done(); + }); + + jasmine.Ajax.requests.mostRecent().respondWith({ + status: 403 + }); + }); + }); +}); diff --git a/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.ts b/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.ts new file mode 100644 index 0000000000..1e5e99433d --- /dev/null +++ b/ng2-components/ng2-activiti-tasklist/src/services/activiti-people.service.ts @@ -0,0 +1,73 @@ +/*! + * @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 { Injectable } from '@angular/core'; +import { AlfrescoApiService, AlfrescoAuthenticationService } from 'ng2-alfresco-core'; +import { Observable } from 'rxjs/Rx'; +import { Response } from '@angular/http'; +import { User } from '../models/user.model'; + +@Injectable() +export class ActivitiPeopleService { + + constructor(private authService: AlfrescoAuthenticationService, + private alfrescoJsApi: AlfrescoApiService) { + } + + getWorkflowUsers(taskId: string, searchWord: string): Observable { + let option = {excludeTaskId: taskId, filter: searchWord}; + return Observable.fromPromise(this.getWorkflowUserApi(option)) + .map((response: any) => response.data || []) + .catch(this.handleError); + } + + involveUserWithTask(taskId: string, idToInvolve: string): Observable { + let node = {userId: idToInvolve}; + return Observable.fromPromise(this.involveUserToTaskApi(taskId, node)) + .catch(this.handleError); + } + + removeInvolvedUser(taskId: string, idToRemove: string): Observable { + let node = {userId: idToRemove}; + return Observable.fromPromise(this.removeInvolvedUserFromTaskApi(taskId, node)) + .catch(this.handleError); + } + + private getWorkflowUserApi(options: any) { + return this.alfrescoJsApi.getInstance().activiti.usersWorkflowApi.getUsers(options); + } + + private involveUserToTaskApi(taskId: string, node: any) { + return this.alfrescoJsApi.getInstance().activiti.taskActionsApi.involveUser(taskId, node); + } + + private removeInvolvedUserFromTaskApi(taskId: string, node: any) { + return this.alfrescoJsApi.getInstance().activiti.taskActionsApi.removeInvolvedUser(taskId, node); + } + + /** + * Throw the error + * @param error + * @returns {ErrorObservable} + */ + private handleError(error: Response) { + // in a real world app, we may send the error to some remote logging infrastructure + // instead of just logging it to the console + console.error(error); + return Observable.throw(error || 'Server error'); + } +}