[AAE-4995] Expand ADF PeopleContentService to create new person (#6931)

* [AAE-4995] Expose create/list content users API in ADF PeopleContentService

* * Updated documentation

* * Removed listPeople api

* * Added unit tests and improved old tests

* * Updated doc with js-api doc link

* *Fixed lint errors

* * Fixed failing unit tests

docs/core/services/people-content.service.md

@@ -20,6 +20,10 @@ Gets information about a Content Services user.
     Gets information about a user identified by their username.
     -   _personId:_ `string`  - ID of the target user
     -   **Returns** [`Observable`](http://reactivex.io/documentation/observable.html)`<any>` - User information
+-   **createPerson**(newPerson: [PersonBodyCreate](https://github.com/Alfresco/alfresco-js-api/blob/develop/src/api/content-rest-api/docs/PersonBodyCreate.md)): [`Observable`](http://reactivex.io/documentation/observable.html)`<`[`EcmUserModel`](../../core/models/ecm-user.model.md)`>`<br/>
+    Creates new person.
+    -   _newPerson:_ `<`[PersonBodyCreate](https://github.com/Alfresco/alfresco-js-api/blob/develop/src/api/content-rest-api/docs/PersonBodyCreate.md)`>`  - Object containing the new person details
+    -   **Returns** [`Observable`](http://reactivex.io/documentation/observable.html) `<`[`EcmUserModel`](../../core/models/ecm-user.model.md)`[]>` - Created new person.
 
 ## Details
 
@@ -32,6 +36,10 @@ See the
 [getPerson](https://github.com/Alfresco/alfresco-js-api/blob/master/src/alfresco-core-rest-api/docs/PeopleApi.md#getPerson)
 method in the Alfresco JS API for more information about the REST calls used by this service.
 
+See the
+[createPerson](https://github.com/Alfresco/alfresco-js-api/blob/master/src/api/content-rest-api/docs/PeopleApi.md#createPerson)
+method in the Alfresco JS API for more information about the REST calls used by this service.
+
 ## See also
 
 -   [People process service](people-process.service.md)

lib/core/mock/ecm-user.service.mock.ts

@@ -90,3 +90,12 @@ export let fakeEcmEditedUser = {
     enabled: true,
     emailNotificationsEnabled: true
 };
+
+export const createNewPersonMock = {
+    id: 'fake-id',
+    firstName: 'fake-ecm-first-name',
+    lastName: 'fake-ecm-last-name',
+    description: 'i am a fake user for test',
+    password: 'fake-avatar-id',
+    email: 'fakeEcm@ecmUser.com'
+};

lib/core/services/people-content.service.spec.ts

@@ -15,87 +15,90 @@
  * limitations under the License.
  */
 
-import { async, inject, TestBed } from '@angular/core/testing';
-import { AlfrescoApiService } from './alfresco-api.service';
+import { fakeEcmUser, createNewPersonMock } from '../mock/ecm-user.service.mock';
+import { AlfrescoApiServiceMock } from '../mock/alfresco-api.service.mock';
+import { CoreTestingModule } from '../testing/core.testing.module';
 import { PeopleContentService } from './people-content.service';
+import { AlfrescoApiService } from './alfresco-api.service';
+import { setupTestBed } from '../testing/setup-test-bed';
+import { TranslateModule } from '@ngx-translate/core';
+import { TestBed } from '@angular/core/testing';
+import { LogService } from './log.service';
 
-class PeopleContentServiceTest {
-    service: any = null;
-    setup: any = {
-        rejectGetPerson: false
-    };
+describe('PeopleContentService', () => {
 
-    constructor(setup: any = {}) {
-        Object.assign(this.setup, setup);
+    let service: PeopleContentService;
+    let logService: LogService;
 
-        const { alfrescoApiServiceMock } = this;
+    setupTestBed({
+        imports: [
+            TranslateModule.forRoot(),
+            CoreTestingModule
+        ],
+        providers: [
+            { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock }
+        ]
+    });
 
-        const alfrescoApiServiceProvider = {
-            provide: AlfrescoApiService,
-            useValue: alfrescoApiServiceMock
-        };
+    beforeEach(() => {
+        service = TestBed.inject(PeopleContentService);
+        logService = TestBed.inject(LogService);
+    });
 
-        TestBed.configureTestingModule({
-            providers: [
-                alfrescoApiServiceProvider,
-                PeopleContentService
-            ]
+    it('should be able to fetch person details based on id', (done) => {
+        spyOn(service.peopleApi, 'getPerson').and.returnValue(Promise.resolve({ entry: fakeEcmUser }));
+        service.getPerson('fake-id').subscribe((person) => {
+            expect(person.entry.id).toEqual('fake-id');
+            expect(person.entry.email).toEqual('fakeEcm@ecmUser.com');
+            done();
         });
+    });
 
-        inject([ PeopleContentService ], (service) => {
-            this.service = service;
-        })();
-    }
+    it('calls getPerson api method by an id', (done) => {
+        const getPersonSpy = spyOn(service.peopleApi, 'getPerson').and.returnValue(Promise.resolve({}));
+        service.getPerson('fake-id').subscribe(() => {
+            expect(getPersonSpy).toHaveBeenCalledWith('fake-id');
+            done();
+        });
+    });
 
-    private get alfrescoApiServiceMock(): any {
-        const { setup } = this;
+    it('calls getPerson api method with "-me-"', (done) => {
+        const getPersonSpy = spyOn(service.peopleApi, 'getPerson').and.returnValue(Promise.resolve({}));
+        service.getPerson('-me-').subscribe(() => {
+            expect(getPersonSpy).toHaveBeenCalledWith('-me-');
+            done();
+        });
+    });
 
-        const peopleApiMock = {
-            getPerson: jasmine.createSpy('getPersonSpy').and.callFake((personId) => {
-                return new Promise((resolve, reject) => {
-                    setup.rejectGetPerson
-                        ? reject()
-                        : resolve({ id: personId });
-                });
-            })
-        };
+    it('should be able to create new person', (done) => {
+        spyOn(service.peopleApi, 'createPerson').and.returnValue(Promise.resolve({ entry: fakeEcmUser }));
+        service.createPerson(createNewPersonMock).subscribe((person) => {
+            expect(person.id).toEqual('fake-id');
+            expect(person.email).toEqual('fakeEcm@ecmUser.com');
+            done();
+        });
+    });
 
-        return {
-            getInstance: () => {
-                return {
-                    core: { peopleApi: peopleApiMock }
-                };
-            }
-        };
-    }
+    it('should be able to call createPerson api with new person details', (done) => {
+        const createPersonSpy = spyOn(service.peopleApi, 'createPerson').and.returnValue(Promise.resolve({ entry: fakeEcmUser }));
+        service.createPerson(createNewPersonMock).subscribe((person) => {
+            expect(person.id).toEqual('fake-id');
+            expect(person.email).toEqual('fakeEcm@ecmUser.com');
+            expect(createPersonSpy).toHaveBeenCalledWith(createNewPersonMock, undefined);
+            done();
+        });
+    });
 
-    get peopleApiGetPersonSpy() {
-        return this.service.peopleApi.getPerson;
-    }
-
-    get peopleApiGetPersonArguments() {
-        return this.peopleApiGetPersonSpy.calls.mostRecent().args;
-    }
-}
-
-describe('PeopleAPI', () => {
-    describe('Get persons', () => {
-        it('calls method by an id', async(() => {
-            const test = new PeopleContentServiceTest();
-
-            test.service.getPerson('person-1').subscribe(() => {
-                expect(test.peopleApiGetPersonArguments[0])
-                    .toBe('person-1');
-            });
-        }));
-
-        it('calls method with "-me-"', async(() => {
-            const test = new PeopleContentServiceTest();
-
-            test.service.getCurrentPerson().subscribe(() => {
-                expect(test.peopleApiGetPersonArguments[0])
-                    .toBe('-me-');
-            });
-        }));
+    it('should be able to throw an error if createPerson api failed', (done) => {
+        const createPersonSpy = spyOn(service.peopleApi, 'createPerson').and.returnValue(Promise.reject({ message: 'failed to create new person' }));
+        const logErrorSpy = spyOn(logService, 'error');
+        service.createPerson(createNewPersonMock).subscribe(
+        () => {},
+        (error) => {
+            expect(error).toEqual({ message: 'failed to create new person' });
+            expect(createPersonSpy).toHaveBeenCalled();
+            expect(logErrorSpy).toHaveBeenCalledWith({ message: 'failed to create new person' });
+            done();
+        });
     });
 });

lib/core/services/people-content.service.ts

@@ -16,19 +16,24 @@
  */
 
 import { Injectable } from '@angular/core';
-import { Observable, from, of } from 'rxjs';
+import { Observable, from, throwError } from 'rxjs';
 import { AlfrescoApiService } from './alfresco-api.service';
-import { catchError } from 'rxjs/operators';
+import { catchError, map } from 'rxjs/operators';
+import { PersonEntry, PeopleApi, PersonBodyCreate } from '@alfresco/js-api';
+import { EcmUserModel } from '../models/ecm-user.model';
+import { LogService } from './log.service';
 
 @Injectable({
     providedIn: 'root'
 })
 export class PeopleContentService {
 
-    constructor(private apiService: AlfrescoApiService) {}
+    private _peopleApi: PeopleApi;
 
-    private get peopleApi() {
-       return this.apiService.getInstance().core.peopleApi;
+    constructor(private apiService: AlfrescoApiService, private logService: LogService) {}
+
+    get peopleApi() {
+        return this._peopleApi || (this._peopleApi = new PeopleApi(this.apiService.getInstance()));
     }
 
     /**
@@ -40,7 +45,7 @@ export class PeopleContentService {
         const promise = this.peopleApi.getPerson(personId);
 
         return from(promise).pipe(
-            catchError((err) => of(err))
+            catchError((error) => this.handleError(error))
         );
     }
 
@@ -51,4 +56,21 @@ export class PeopleContentService {
     getCurrentPerson(): Observable<any> {
         return this.getPerson('-me-');
     }
+
+    /**
+     * Creates new person.
+     * @param newPerson Object containing the new person details.
+     * @returns Created new person
+     */
+    createPerson(newPerson: PersonBodyCreate, opts?: any): Observable<EcmUserModel> {
+        return from(this.peopleApi.createPerson(newPerson, opts)).pipe(
+            map((res: PersonEntry) => <EcmUserModel> res?.entry),
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    private handleError(error: any) {
+        this.logService.error(error);
+        return throwError(error || 'Server error');
+    }
 }