More services

src/Squidex/app/app.module.ts

@@ -26,7 +26,9 @@ import {
     LanguageService,
     SqxFrameworkModule,
     TitlesConfig,
-    TitleService
+    TitleService,
+    UsersProviderService,
+    UsersService
 } from './shared';
 
 import {
@@ -63,6 +65,8 @@ const baseUrl = window.location.protocol + '//' + window.location.host + '/';
         MustBeAuthenticatedGuard,
         MustBeNotAuthenticatedGuard,
         TitleService,
+        UsersProviderService,
+        UsersService,
         { provide: ApiUrlConfig, useValue: new ApiUrlConfig(baseUrl) },
         { provide: CurrencyConfig, useValue: new CurrencyConfig('EUR', '€', true) },
         { provide: DecimalSeparatorConfig, useValue: new DecimalSeparatorConfig('.') },

src/Squidex/app/shared/index.ts

@@ -13,5 +13,7 @@ export * from './services/apps-store.service';
 export * from './services/apps.service';
 export * from './services/auth.service';
 export * from './services/languages.service';
+export * from './services/users-provider.service';
+export * from './services/users.service';
 
 export * from 'framework';

src/Squidex/app/shared/services/app-contributors.service.spec.ts

@@ -26,7 +26,7 @@ describe('AppContributorsService', () => {
         appContributorsService = new AppContributorsService(authService.object, new ApiUrlConfig('http://service/p/'));
     });
 
-    it('should make get request with auth service', () => {
+    it('should make get request with auth service to get app contributors', () => {
         authService.setup(x => x.authGet('http://service/p/api/apps/my-app/contributors'))
             .returns(() => Observable.of(
                 new Ng2Http.Response(
@@ -58,7 +58,7 @@ describe('AppContributorsService', () => {
         authService.verifyAll();
     });
 
-    it('should make post assign contributor', () => {
+    it('should make post request to assign contributor', () => {
         const contributor = new AppContributor('123', 'Owner');
 
         authService.setup(x => x.authPost('http://service/p/api/apps/my-app/contributors', TypeMoq.It.is(c => c === contributor)))

src/Squidex/app/shared/services/app-contributors.service.ts

@@ -1,4 +1,3 @@
-
 /*
  * Squidex Headless CMS
  * 

src/Squidex/app/shared/services/auth.service.ts

@@ -20,11 +20,15 @@ import { Observable, Subject } from 'rxjs';
 import { ApiUrlConfig } from 'framework';
 
 export class Profile {
-    public get displayName() {
+    public get id(): string {
+        return this.user.profile['sub'];
+    }
+
+    public get displayName(): string {
         return this.user.profile['urn:squidex:name'];
     }
 
-    public get pictureUrl() {
+    public get pictureUrl(): string {
         return this.user.profile['urn:squidex:picture'];
     }
 
@@ -136,7 +140,6 @@ export class AuthService {
         this.currentUser = new Profile(user);
 
         this.isAuthenticatedChanged$.next(true);
-
     }
 
     private onDeauthenticated() {

src/Squidex/app/shared/services/users-provider.service.spec.ts

@@ -0,0 +1,89 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as TypeMoq from 'typemoq';
+
+import { Observable } from 'rxjs';
+
+import {
+    AuthService,
+    Profile,
+    User,
+    UsersProviderService,
+    UsersService,
+} from './../';
+
+describe('UsersProviderService', () => {
+    let authService: TypeMoq.Mock<AuthService>;
+    let usersService: TypeMoq.Mock<UsersService>;
+    let usersProviderService: UsersProviderService;
+
+    beforeEach(() => {
+        authService = TypeMoq.Mock.ofType(AuthService);
+        usersService = TypeMoq.Mock.ofType(UsersService);
+        usersProviderService = new UsersProviderService(usersService.object, authService.object);
+    });
+
+    it('Should return users service when user not cached', () => {
+        const user = new User('123', 'path/to/image', 'mail@domain.com');
+
+        usersService.setup(x => x.getUser('123'))
+            .returns(() => Observable.of(user))
+            .verifiable(TypeMoq.Times.once());
+            
+        let resultingUser: User = null;
+
+        usersProviderService.getUser('123').subscribe(result => {
+            resultingUser = result;
+        }).unsubscribe();
+
+        expect(resultingUser).toBe(user);
+
+        usersService.verifyAll();
+    });
+
+    it('Should return provide user from cache', () => {
+        const user = new User('123', 'path/to/image', 'mail@domain.com');
+
+        usersService.setup(x => x.getUser('123'))
+            .returns(() => Observable.of(user))
+            .verifiable(TypeMoq.Times.once());
+            
+        usersProviderService.getUser('123');
+        
+        let resultingUser: User = null;
+
+        usersProviderService.getUser('123').subscribe(result => {
+            resultingUser = result;
+        }).unsubscribe();
+
+        expect(resultingUser).toBe(user);
+
+        usersService.verifyAll();
+    });
+
+    it('Should return Me when user is current user', () => {
+        const user = new User('123', 'path/to/image', 'mail@domain.com');
+
+        authService.setup(x => x.user)
+            .returns(() => new Profile(<any>{ profile: { sub: '123'}}));
+
+        usersService.setup(x => x.getUser('123'))
+            .returns(() => Observable.of(user))
+            .verifiable(TypeMoq.Times.once());
+            
+        let resultingUser: User = null;
+
+        usersProviderService.getUser('123').subscribe(result => {
+            resultingUser = result;
+        }).unsubscribe();
+
+        expect(resultingUser).toEqual(new User('123', 'path/to/image', 'Me'));
+
+        usersService.verifyAll();
+    });
+});

src/Squidex/app/shared/services/users-provider.service.ts

@@ -0,0 +1,44 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as Ng2 from '@angular/core';
+
+import { Observable,  } from 'rxjs';
+
+import { User, UsersService } from './users.service';
+
+import { AuthService } from './auth.service';
+
+@Ng2.Injectable()
+export class UsersProviderService {
+    private readonly caches: { [id: string]: Observable<User> } = {};
+
+    constructor(
+        private readonly usersService: UsersService,
+        private readonly authService: AuthService,
+    ) {
+    }
+
+    public getUser(id: string): Observable<User> {
+        let result = this.caches[id];
+
+        if (!result) {
+            result = this.caches[id] = 
+                this.usersService.getUser(id)
+                    .map(u => {
+                        if (this.authService.user && u.id === this.authService.user.id) {
+                            return new User(u.id, u.profileUrl, 'Me');
+                        } else {
+                            return u;
+                        }
+                    })
+                    .publishLast().refCount();
+        }
+
+        return result;
+    }
+}

src/Squidex/app/shared/services/users.service.spec.ts

@@ -0,0 +1,122 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as TypeMoq from 'typemoq';
+import * as Ng2Http from '@angular/http';
+
+import { Observable } from 'rxjs';
+
+import {
+    ApiUrlConfig,
+    AuthService,
+    User,
+    UsersService,
+} from './../';
+
+describe('UsersService', () => {
+    let authService: TypeMoq.Mock<AuthService>;
+    let usersService: UsersService;
+
+    beforeEach(() => {
+        authService = TypeMoq.Mock.ofType(AuthService);
+        usersService = new UsersService(authService.object, new ApiUrlConfig('http://service/p/'));
+    });
+
+    it('should make get request with auth service to get many users', () => {
+        authService.setup(x => x.authGet('http://service/p/api/users/?query='))
+            .returns(() => Observable.of(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        body: [{
+                            id: '123',
+                            profileUrl: 'path/to/image1',
+                            displayName: 'mail1@domain.com'
+                        }, {
+                            id: '456',
+                            profileUrl: 'path/to/image2',
+                            displayName: 'mail2@domain.com'
+                        }]
+                    })
+                )
+            ))
+            .verifiable(TypeMoq.Times.once());
+
+        let user: User[] = null;
+        
+        usersService.getUsers().subscribe(result => {
+            user = result;
+        }).unsubscribe();
+
+        expect(user).toEqual(
+            [
+                new User('123', 'path/to/image1', 'mail1@domain.com'),
+                new User('456', 'path/to/image2', 'mail2@domain.com')
+            ]);
+
+        authService.verifyAll();
+    });
+
+    it('should make get request with auth service and query to get many users', () => {
+        authService.setup(x => x.authGet('http://service/p/api/users/?query=my-query'))
+            .returns(() => Observable.of(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        body: [{
+                            id: '123',
+                            profileUrl: 'path/to/image1',
+                            displayName: 'mail1@domain.com'
+                        }, {
+                            id: '456',
+                            profileUrl: 'path/to/image2',
+                            displayName: 'mail2@domain.com'
+                        }]
+                    })
+                )
+            ))
+            .verifiable(TypeMoq.Times.once());
+
+        let user: User[] = null;
+        
+        usersService.getUsers('my-query').subscribe(result => {
+            user = result;
+        }).unsubscribe();
+
+        expect(user).toEqual(
+            [
+                new User('123', 'path/to/image1', 'mail1@domain.com'),
+                new User('456', 'path/to/image2', 'mail2@domain.com')
+            ]);
+
+        authService.verifyAll();
+    });
+
+    it('should make get request with auth service to get single user', () => {
+        authService.setup(x => x.authGet('http://service/p/api/users/123'))
+            .returns(() => Observable.of(
+                new Ng2Http.Response(
+                    new Ng2Http.ResponseOptions({
+                        body: {
+                            id: '123',
+                            profileUrl: 'path/to/image',
+                            displayName: 'mail@domain.com'
+                        }
+                    })
+                )
+            ))
+            .verifiable(TypeMoq.Times.once());
+
+        let user: User = null;
+        
+        usersService.getUser('123').subscribe(result => {
+            user = result;
+        }).unsubscribe();
+
+        expect(user).toEqual(new User('123', 'path/to/image', 'mail@domain.com'));
+
+        authService.verifyAll();
+    });
+});

src/Squidex/app/shared/services/users.service.ts

@@ -0,0 +1,58 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as Ng2 from '@angular/core';
+
+import { Observable } from 'rxjs';
+
+import { ApiUrlConfig } from 'framework';
+
+import { AuthService } from './auth.service';
+
+export class User {
+    constructor(
+        public readonly id: string,
+        public readonly profileUrl: string,
+        public readonly displayName: string
+    ) {
+    }
+}
+
+@Ng2.Injectable()
+export class UsersService {
+    constructor(
+        private readonly authService: AuthService,
+        private readonly apiUrl: ApiUrlConfig
+    ) {
+    }
+
+    public getUsers(query?: string): Observable<User[]> {
+        return this.authService.authGet(this.apiUrl.buildUrl(`api/users/?query=${query || ''}`))
+                .map(response => {                    
+                    const body: any[] = response.json() || [];
+
+                    return body.map(item => {
+                        return new User(
+                            item.id,
+                            item.profileUrl,
+                            item.displayName);
+                    });
+                });
+    }
+
+    public getUser(id: string): Observable<User> {
+        return this.authService.authGet(this.apiUrl.buildUrl(`api/users/${id}`))
+                .map(response => {                    
+                    const body: any = response.json();
+
+                    return new User(
+                        body.id,
+                        body.profileUrl,
+                        body.displayName);
+                });
+    }
+}

src/Squidex/runtimeconfig.template.json

@@ -0,0 +1,5 @@
+{
+  "configProperties": {
+    "System.GC.Server": true
+  }
+}