1) Apps services

2) Coverage fixed

.gitignore

@@ -246,3 +246,5 @@ ModelManifest.xml
 
 # OpenCover
 GeneratedReports/
+
+_test-output

src/Squidex/app-config/karma.coverage.conf.js

@@ -17,7 +17,7 @@ module.exports = function (config) {
         ],
 
         preprocessors: {
-            './config/karma-test-shim.js': ['webpack', 'sourcemap'],
+            './app-config/karma-test-shim.js': ['webpack', 'sourcemap'],
         },
 
         /**

src/Squidex/app/app.component.spec.ts

@@ -1,10 +1,24 @@
 import { TestBed } from '@angular/core/testing';
 
+import { RouterModule, provideRoutes } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+
 import { AppComponent } from './app.component';
 
 describe('App', () => {
     beforeEach(() => {
-        TestBed.configureTestingModule({ declarations: [AppComponent] });
+        TestBed.configureTestingModule({ 
+            declarations: [
+                AppComponent
+            ],
+            imports: [
+                RouterModule,
+                RouterTestingModule
+            ],
+            providers: [
+                provideRoutes([])
+            ]
+        });
     });
     
     it('should work', () => {

src/Squidex/app/framework/utils/date-time.spec.ts

@@ -13,7 +13,7 @@ describe('DateTime', () => {
     const now = DateTime.now();
 
     it('should parse from iso string', () => {
-        const value = DateTime.parse('2013-10-16T12:13:14.125', DateTime.iso8601());
+        const value = DateTime.parseISO('2013-10-16T12:13:14.125');
 
         expect(value.year).toBe(2013);
         expect(value.month).toBe(10);
@@ -28,7 +28,7 @@ describe('DateTime', () => {
     });
 
     it('should throw when date string to parse is null', () => {
-        expect(() => DateTime.parseUTC('#', DateTime.iso8601())).toThrow();
+        expect(() => DateTime.parseISO('#')).toThrow();
     });
 
     it('should throw when date string to parse is invalid', () => {
@@ -37,21 +37,21 @@ describe('DateTime', () => {
 
     it('should parse Microsoft date format', () => {
         const actual = DateTime.parseMSDate('/Date(1224043200000)/');
-        const expected = DateTime.parse('2008-10-15T04:00:00', DateTime.iso8601());
+        const expected = DateTime.parseISO('2008-10-15T04:00:00');
 
         expect(actual).toEqual(expected);
     });
 
     it('should parse Microsoft date format with positive offset', () => {
         const actual = DateTime.parseMSDate('/Date(1224043200000+2)/');
-        const expected = DateTime.parse('2008-10-15T06:00:00', DateTime.iso8601());
+        const expected = DateTime.parseISO('2008-10-15T06:00:00');
 
         expect(actual).toEqual(expected);
     });
 
     it('should parse Microsoft date format with negative offset', () => {
         const actual = DateTime.parseMSDate('/Date(1224043200000-2)/');
-        const expected = DateTime.parse('2008-10-15T02:00:00', DateTime.iso8601());
+        const expected = DateTime.parseISO('2008-10-15T02:00:00');
 
         expect(actual).toEqual(expected);
     });
@@ -78,7 +78,7 @@ describe('DateTime', () => {
     });
 
     it('should print to formatted string', () => {
-        const value = DateTime.parseUTC('2013-10-16T12:13:14T', DateTime.iso8601());
+        const value = DateTime.parseISO_UTC('2013-10-16T12:13:14T');
         const actual = value.toStringFormat('hh:mm');
         const expected = '12:13';
         
@@ -86,7 +86,7 @@ describe('DateTime', () => {
     });
 
     it('should print to iso string', () => {
-        const value = DateTime.parseUTC('2013-10-16T12:13:14', DateTime.iso8601());
+        const value = DateTime.parseISO_UTC('2013-10-16T12:13:14');
         const actual = value.toString().substr(0, 19);
         const expected = '2013-10-16T12:13:14';
         
@@ -94,35 +94,35 @@ describe('DateTime', () => {
     });
 
     it('should print to valid utc string', () => {
-        const value = DateTime.parseUTC('2013-10-16T12:13:14', DateTime.iso8601());
+        const value = DateTime.parseISO_UTC('2013-10-16T12:13:14');
 
         expect(value.toUTCString()).toBeDefined();
     });
 
     it('should print from format with underscore', () => {
-        const actual = DateTime.parse('2013-10-16T00:00:00', DateTime.iso8601());
+        const actual = DateTime.parseISO('2013-10-16T00:00:00');
         const expected = DateTime.parse('10_2013_16', 'MM_YYYY_DD');
 
         expect(actual).toEqual(expected);
     });
 
     it('should calculate valid first of week', () => {
-        const actual = DateTime.parseUTC('2013-10-16T12:13:14.125', DateTime.iso8601()).date.firstOfWeek();
-        const expected = DateTime.parseUTC('2013-10-14T00:00:00', DateTime.iso8601());
+        const actual = DateTime.parseISO_UTC('2013-10-16T12:13:14.125').date.firstOfWeek();
+        const expected = DateTime.parseISO_UTC('2013-10-14T00:00:00');
 
         expect(actual).toEqual(expected);
     });
 
     it('should calculate valid first of month', () => {
-        const actual = DateTime.parseUTC('2013-10-16T12:13:14.125', DateTime.iso8601()).date.firstOfMonth();
-        const expected = DateTime.parseUTC('2013-10-01', DateTime.iso8601());
+        const actual = DateTime.parseISO_UTC('2013-10-16T12:13:14.125').date.firstOfMonth();
+        const expected = DateTime.parseISO_UTC('2013-10-01');
 
         expect(actual).toEqual(expected);
     });
 
     it('should add various offsets to date time', () => {
         const actual =
-            DateTime.parseUTC('2013-05-01T12:12:12.100', DateTime.iso8601())
+            DateTime.parseISO_UTC('2013-05-01T12:12:12.100')
                 .addYears(1)
                 .addMonths(2)
                 .addDays(13)
@@ -130,7 +130,7 @@ describe('DateTime', () => {
                 .addMinutes(10)
                 .addSeconds(15)
                 .addMilliseconds(125);
-        const expected = DateTime.parseUTC('2014-07-16T15:22:27.225', DateTime.iso8601());
+        const expected = DateTime.parseISO_UTC('2014-07-16T15:22:27.225');
 
         expect(actual).toEqual(expected);
     });

src/Squidex/app/framework/utils/date-time.ts

@@ -96,6 +96,14 @@ export class DateTime {
         return new DateTime(date);
     }
 
+    public static parseISO(value: string): DateTime {
+        return DateTime.parse(value, DateTime.iso8601());
+    }
+
+    public static parseISO_UTC(value: string): DateTime {
+        return DateTime.parseUTC(value, DateTime.iso8601());
+    }
+
     public static parse(value: string, format: string): DateTime {
         const parsedMoment = moment(value, format);
 

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

@@ -0,0 +1,59 @@
+/*
+ * Squidex Headless CMS
+ * 
+ * @license
+ * Copyright (c) Sebastian Stehle. All rights reserved
+ */
+
+import * as Ng2 from '@angular/core';
+
+import { Observable } from 'rxjs';
+
+import { ApiUrlConfig, DateTime } from './../../framework';
+import { AuthService } from './auth.service';
+
+export class AppDto {
+    constructor(
+        private readonly id: string,
+        private readonly name: string,
+        private readonly created: DateTime,
+        private readonly lastModified: DateTime
+    ) {
+    }
+}
+
+export class AppCreateDto {
+    constructor(
+        private readonly name: string
+    ) {
+    }
+}
+
+@Ng2.Injectable()
+export class AppsService {
+    constructor(
+        private readonly authService: AuthService, 
+        private readonly apiUrl: ApiUrlConfig
+    ) {
+    }
+
+    public getApps(): Observable<AppDto[]> {
+        return this.authService.authGet(this.apiUrl.buildUrl('/api/apps'))
+                .map(response => {
+                    let body: any[] = response.json() || [];
+
+                    return body.map(item => {
+                        return new AppDto(
+                            item.id,
+                            item.name,
+                            DateTime.parseISO(item.created),
+                            DateTime.parseISO(item.lastModified)
+                        );
+                    });
+                });
+    }
+
+    public postApp(app: AppCreateDto): Observable<any> {
+        return this.authService.authPost(this.apiUrl.buildUrl('api/apps'), app);
+    }
+}

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

@@ -6,6 +6,7 @@
  */
 
 import * as Ng2 from '@angular/core';
+import * as Ng2Http from '@angular/http';
 
 import {
     Log,
@@ -30,16 +31,18 @@ export class AuthService {
         return this.currentUser;
     }
 
-    constructor(apiUrl: ApiUrlConfig) {
+    constructor(apiUrl: ApiUrlConfig,
+        private readonly http: Ng2Http.Http, 
+    ) {
         Log.logger = console;
 
         this.userManager = new UserManager({
                       client_id: 'squidex-frontend',
+                          scope: 'squidex-api openid profile ',
+                  response_type: 'id_token token',
             silent_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-silent/'),
              popup_redirect_uri: apiUrl.buildUrl('identity-server/client-callback-popup/'),
                       authority: apiUrl.buildUrl('identity-server/'),
-                  response_type: 'id_token token',
-                          scope: 'openid profile squidex-api'
         });
 
         this.userManager.getUser()
@@ -51,10 +54,14 @@ export class AuthService {
             });
 
         this.userManager.events.addUserUnloaded(() => {
-                this.currentUser = null;
+            this.currentUser = null;
         });
     }
 
+    public logout(): Observable<any> {
+        return Observable.fromPromise(this.userManager.signoutRedirectCallback());
+    }
+
     public login(): Observable<User> {
         let userPromise =
             this.userManager.signinSilent()
@@ -70,7 +77,38 @@ export class AuthService {
         return Observable.fromPromise(userPromise);
     }
 
-    public logout(): Observable<any> {
-        return Observable.fromPromise(this.userManager.signoutRedirectCallback());
+    public authGet(url: string, options?: Ng2Http.RequestOptions): Observable<Ng2Http.Response> {
+        options = this.setRequestOptions(options);
+
+        return this.http.get(url, options);
+    }
+
+    public authPut(url: string, data: any, options?: Ng2Http.RequestOptions): Observable<Ng2Http.Response> {
+        options = this.setRequestOptions(options);
+
+        return this.http.put(url, data, options);
+    }
+
+    public authDelete(url: string, options?: Ng2Http.RequestOptions): Observable<Ng2Http.Response> {
+        options = this.setRequestOptions(options);
+        return this.http.delete(url, options);
+    }
+
+    public authPost(url: string, data: any, options?: Ng2Http.RequestOptions): Observable<Ng2Http.Response> {
+        options = this.setRequestOptions(options);
+
+        return this.http.post(url, data, options);
+    }
+
+    private setRequestOptions(options?: Ng2Http.RequestOptions) {
+        if (!options) {
+            options = new Ng2Http.RequestOptions();
+
+            options.headers.append('Content-Type', 'application/json');
+        }
+
+        options.headers.append('Authorization', '${this.user.token_type} {this.user.access_token}');
+
+        return options;
     }
 }

src/Squidex/karma.conf.js

@@ -0,0 +1 @@
+module.exports = require('./app-config/karma.conf.js');

src/Squidex/package.json

@@ -46,7 +46,7 @@
     "font-awesome-sass-loader": "^1.0.1",
     "html-loader": "^0.4.3",
     "html-webpack-plugin": "^2.22.0",
-    "istanbul-instrumenter-loader": "^1.0.0",
+    "istanbul-instrumenter-loader": "^0.2.0",
     "jasmine-core": "^2.4.1",
     "karma": "^1.1.1",
     "karma-chrome-launcher": "^2.0.0",