[ADF-2553] added select box and updating role (#3148)

* [ADF-2553] start adding dropdown

* [ADF-2553] added select box and updating role

* [ADF-2553] added some fixes

* [ADF-2554] added test for component phase 1

* [ADF-2553] fixed error and added tests

* [ADF-2553] added documentation and improved api call

lib/content-services/permission-manager/services/node-permission.service.spec.ts

@@ -0,0 +1,98 @@
+/*!
+ * @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 { async, TestBed } from '@angular/core/testing';
+import { NodePermissionService } from './node-permission.service';
+import { AlfrescoApiService, SearchService, NodesApiService } from '@alfresco/adf-core';
+import { MinimalNodeEntryEntity, PermissionElement } from 'alfresco-js-api';
+import { Observable } from 'rxjs/Observable';
+import { fakeEmptyResponse, fakeNodeWithOnlyLocally, fakeSiteRoles, fakeSiteNodeResponse } from '../../mock/permission-list.component.mock';
+
+describe('NodePermissionService', () => {
+
+    let service: NodePermissionService,
+        nodeService: NodesApiService,
+        searchApiService: SearchService;
+
+    beforeEach(async(() => {
+        TestBed.configureTestingModule({
+            providers: [
+                AlfrescoApiService,
+                NodePermissionService, SearchService, NodesApiService
+            ]
+        }).compileComponents();
+    }));
+
+    beforeEach(() => {
+        service = TestBed.get(NodePermissionService);
+        searchApiService = TestBed.get(SearchService);
+        nodeService = TestBed.get(NodesApiService);
+    });
+
+    afterEach(() => {
+        TestBed.resetTestingModule();
+    });
+
+    function returnUpdatedNode(nodeId, nodeBody) {
+        let fakeNode: MinimalNodeEntryEntity = {};
+        fakeNode.id = 'fake-updated-node';
+        fakeNode.permissions = nodeBody.permissions;
+        return Observable.of(fakeNode);
+    }
+
+    it('should return a list of roles taken from the site groups', async(() => {
+        spyOn(searchApiService, 'searchByQueryBody').and.returnValue(Promise.resolve(fakeSiteNodeResponse));
+        spyOn(service, 'getGroupMemeberByGroupName').and.returnValue(Observable.of(fakeSiteRoles));
+
+        service.getNodeRoles(fakeNodeWithOnlyLocally).subscribe((roleArray: string[]) => {
+            expect(roleArray).not.toBeNull();
+            expect(roleArray.length).toBe(4);
+            expect(roleArray[0]).toBe('SiteCollaborator');
+        });
+    }));
+
+    it('should return a list of settable if node has no site', async(() => {
+        spyOn(searchApiService, 'searchByQueryBody').and.returnValue(Promise.resolve(fakeEmptyResponse));
+
+        service.getNodeRoles(fakeNodeWithOnlyLocally).subscribe((roleArray: string[]) => {
+            expect(roleArray).not.toBeNull();
+            expect(roleArray.length).toBe(5);
+            expect(roleArray[0]).toBe('Contributor');
+        });
+    }));
+
+    it('should be able to update a locally set permission role', async(() => {
+        const fakeAccessStatus: any = 'DENIED';
+        const fakePermission: PermissionElement = {
+            'authorityId': 'GROUP_EVERYONE',
+            'name': 'Contributor',
+            'accessStatus' : fakeAccessStatus
+        };
+
+        spyOn(nodeService, 'updateNode').and.callFake((nodeId, permissionBody) => returnUpdatedNode(nodeId, permissionBody));
+
+        service.updatePermissionRoles(fakeNodeWithOnlyLocally, fakePermission).subscribe((node: MinimalNodeEntryEntity) => {
+            expect(node).not.toBeNull();
+            expect(node.id).toBe('fake-updated-node');
+            expect(node.permissions.locallySet.length).toBe(1);
+            expect(node.permissions.locallySet[0].authorityId).toBe(fakePermission.authorityId);
+            expect(node.permissions.locallySet[0].name).toBe(fakePermission.name);
+            expect(node.permissions.locallySet[0].accessStatus).toBe(fakePermission.accessStatus);
+        });
+    }));
+
+});

lib/content-services/permission-manager/services/node-permission.service.ts

@@ -0,0 +1,97 @@
+/*!
+ * @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 { Observable } from 'rxjs/Observable';
+import { AlfrescoApiService, SearchService, NodesApiService } from '@alfresco/adf-core';
+import { QueryBody, MinimalNodeEntryEntity, PathElement, GroupMemberEntry, GroupsPaging, GroupMemberPaging, PermissionElement } from 'alfresco-js-api';
+
+@Injectable()
+export class NodePermissionService {
+
+    constructor(private apiService: AlfrescoApiService,
+                private searchApiService: SearchService,
+                private nodeService: NodesApiService) {
+    }
+
+    getNodeRoles(node: MinimalNodeEntryEntity): Observable<string[]> {
+        const retrieveSiteQueryBody: QueryBody = this.buildRetrieveSiteQueryBody(node.path.elements);
+        return Observable.fromPromise(this.searchApiService.searchByQueryBody(retrieveSiteQueryBody))
+            .switchMap((siteNodeList: any) => {
+                if ( siteNodeList.list.entries.length > 0 ) {
+                    let siteName = siteNodeList.list.entries[0].entry.name;
+                    return this.getGroupMembersBySiteName(siteName);
+                } else {
+                    return Observable.of(node.permissions.settable);
+                }
+            });
+    }
+
+    updatePermissionRoles(node: MinimalNodeEntryEntity, updatedPermissionRole: PermissionElement): Observable<MinimalNodeEntryEntity> {
+        let permissionBody = { permissions: { locallySet: []} };
+        const index = node.permissions.locallySet.map((permission) => permission.authorityId).indexOf(updatedPermissionRole.authorityId);
+        permissionBody.permissions.locallySet = permissionBody.permissions.locallySet.concat(node.permissions.locallySet);
+        if (index !== -1) {
+            permissionBody.permissions.locallySet[index] = updatedPermissionRole;
+        } else {
+            permissionBody.permissions.locallySet.push(updatedPermissionRole);
+        }
+        return this.nodeService.updateNode(node.id, permissionBody);
+    }
+
+    private getGroupMembersBySiteName(siteName: string): Observable<string[]> {
+        const groupName = 'GROUP_site_' + siteName;
+        return this.getGroupMemeberByGroupName(groupName)
+            .map((res: GroupsPaging) => {
+                let displayResult: string[] = [];
+                res.list.entries.forEach((member: GroupMemberEntry) => {
+                    displayResult.push(this.formattedRoleName(member.entry.displayName, 'site_' + siteName));
+                });
+                return displayResult;
+            });
+    }
+
+    getGroupMemeberByGroupName(groupName: string, opts?: any): Observable<GroupMemberPaging> {
+        return Observable.fromPromise(this.apiService.groupsApi.getGroupMembers(groupName, opts));
+    }
+
+    private formattedRoleName(displayName, siteName): string {
+        return displayName.replace(siteName + '_', '');
+    }
+
+    private buildRetrieveSiteQueryBody(nodePath: PathElement[]): QueryBody {
+        const pathNames = nodePath.map((node: PathElement) => 'name: "' + node.name + '"');
+        const buildedPathNames = pathNames.join(' OR ');
+        return {
+            'query': {
+                'query': buildedPathNames
+            },
+            'paging': {
+                'maxItems': 100,
+                'skipCount': 0
+            },
+            'include': ['aspectNames', 'properties'],
+            'filterQueries': [
+                {
+                    'query':
+                        "TYPE:'st:site'"
+                }
+            ]
+        };
+    }
+
+}