Revize b887ecc3

Re #8792 - Sensor page - tweak

+ adding error catchup on requests
+ toast message upon request

src/app/app.component.ts

@@ -3 +3 @@
 
 @Component({
   selector: 'app-root',
-  template: '<router-outlet></router-outlet>'
+  template: `<router-outlet></router-outlet><p-toast position="bottom-center" key="mainToast"></p-toast>`
 })
 export class AppComponent {
   title = 'SensLog';

src/app/app.module.ts

@@ -14 +14 @@
 import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
 import {UnitModule} from './unit/unit.module';
 import {ConfirmationService, MessageService} from 'primeng/api';
+import {ToastModule} from 'primeng/toast';
 
 @NgModule({
   declarations: [
@@ -32 +33 @@
     SensorModule,
     FontAwesomeModule,
     UnitModule,
+    ToastModule
   ],
   providers: [
     ConfirmationService,

src/app/auth/interceptors/auth.interceptor.ts

@@ -11 +11 @@
 import {AuthService} from '../services/auth.service';
 import {CookieService} from 'ngx-cookie-service';
 import {GlobalVariable} from '../../globals';
+import {ToastService} from '../../shared/services/toast.service';
 
 @Injectable()
 export class AuthInterceptor implements HttpInterceptor {
 
   constructor(
     private authService: AuthService,
-    private cookieService: CookieService
+    private cookieService: CookieService,
+    private toastService: ToastService
   ) {
   }
 
@@ -36 +38 @@
       });
     }
 
-    console.log('Sending request!');
+    console.log('Sending request!', request);
     return next.handle(request)
       .pipe(
         catchError(err => {
           if ((err instanceof HttpErrorResponse && err.status === 504 || err.status === 502 || err.status === 401 ||
             err.status === 0 || err.status === 500)) {
+            console.log(err);
+            this.toastService.showError(err.error);
             return this.handleError(request, next);
           } else {
             return throwError(err);

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

@@ -76 +76 @@
     this.cookieService.deleteAll();
     localStorage.clear();
     this.router.navigate(['/login']);
+    this.cookieService.deleteAll();
   }
 
   setSessionStorage(userCookie: UserCookie, username) {

src/app/sensor/components/sensor.component.ts

@@ -1 +1 @@
 import {Component, OnInit} from '@angular/core';
 import {ActivatedRoute} from '@angular/router';
-import {Observation} from '../../shared/api/endpoints/models/observation';
 import * as moment from 'moment-timezone';
 import {AnalyticsService} from '../../shared/api/endpoints/services/analytics.service';
 import {AggreationModel} from '../../shared/models/aggreation.model';
 import {GraphLoader} from '../../shared/graph-loading/graphloader';
 import {ObservationService} from '../../shared/api/endpoints/services/observation.service';
-
-declare var require: any;
+import {HttpResponse} from '@angular/common/http';
+import {map} from 'rxjs/operators';
+import {ToastService} from '../../shared/services/toast.service';
 
 @Component({
   selector: 'app-sensor',
@@ -18 +18 @@
 
   sensorId: number;
   unitId: number;
-  observations: Observation[];
   data = [];
   time = [];
   from: Date;
@@ -31 +30 @@
   constructor(
     private activatedRoute: ActivatedRoute,
     private analyticsService: AnalyticsService,
-    private observationService: ObservationService
+    private observationService: ObservationService,
+    private toastService: ToastService
   ) {
     this.sensorId = parseInt(this.activatedRoute.snapshot.paramMap.get('sensorId'), 10);
     this.unitId = parseInt(this.activatedRoute.snapshot.paramMap.get('unitId'), 10);
@@ -52 +52 @@
     let agg = 'HOUR';
     const range: Date[] = [moment().subtract(7, 'days').toDate(), moment().toDate()];
 
+    if (this.from && !this.to || !this.from && this.to) {
+      return;
+    }
+
     if (this.from && this.to) {
       range[0] = this.from;
       range[1] = this.to;
-
-      if (moment(this.to).diff(moment(this.from), 'days') > 7) {
-        this.showAggregation = true;
-      }
     }
 
-  /* this.observationService.getObservation({
-      unit_id: this.unitId,
-      sensor_id: this.sensorId,
-      from: moment(range[0]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3),
-      to: moment(range[1]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3)
-    }).subscribe(
-      observations => {
-        if (observations) {
-          GraphLoader.getObservationGraph(this.sensorId, observations, "#view");
-        }
-      });*/
-
-
+    if (moment(range[1]).diff(moment(range[0]), 'days') > 7) {
+      this.showAggregation = true;
+    }
 
     if (this.selectedAggregationFunction) {
       agg = this.selectedAggregationFunction;
     }
 
-    this.analyticsService.getAnalytics({
+    if (moment(this.to).diff(moment(this.from), 'days') > 7) {
+      this.getAnalytics(range, agg);
+    } else {
+      this.getObservations(range, agg);
+    }
+  }
+
+  getAnalytics(range: Date[], agg: string) {
+    this.analyticsService.getAnalytics$Response({
       unit_id: this.unitId, sensor_id: this.sensorId,
       from: moment(range[0]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3),
       to: moment(range[1]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3), interval: agg
-    }).subscribe(
+    }).pipe(
+      map((response: HttpResponse<any>) => {
+        if (response.status === 200) {
+          return response.body;
+        } else if (response.status === 204) {
+          this.toastService.showWarningNoData();
+          return response.body;
+        } else {
+          return false;
+        }
+      })
+    ).subscribe(
       observations => {
         if (observations) {
           GraphLoader.getGraph(this.sensorId, observations[this.sensorId].data, observations[this.sensorId].interval, '#view');
         } else {
           GraphLoader.getGraph(null, null, null, null);
         }
-      }
-    );
+      }, err => this.toastService.showError(err.error.message));
+  }
 
+  getObservations(range: Date[], agg: string) {
+    this.observationService.getObservation$Response({
+      unit_id: this.unitId,
+      sensor_id: this.sensorId,
+      from: moment(range[0]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3),
+      to: moment(range[1]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3)
+    }).pipe(
+      map((response: HttpResponse<any>) => {
+        if (response.status === 200) {
+          return response.body;
+        } else if (response.status === 204) {
+          this.toastService.showWarningNoData();
+          return response.body;
+        } else {
+          return false;
+        }
+      })
+    ).subscribe(
+      observations => {
+        if (observations) {
+          GraphLoader.getObservationGraph(this.sensorId, observations, '#view');
+        } else {
+          GraphLoader.getObservationGraph(null, null, null);
+        }
+      }, err => this.toastService.showError(err.error.message));
   }
 }

src/app/shared/api/endpoints/services/management.service.ts

@@ -44 +44 @@
    */
   insertUnit$Response(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<StrictHttpResponse<void>> {
+  }): Observable<StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>> {
 
     const rb = new RequestBuilder(this.rootUrl, ManagementService.InsertUnitPath, 'post');
     if (params) {
@@ -52 +52 @@
     }
 
     return this.http.request(rb.build({
-      responseType: 'text',
-      accept: '*/*'
+      responseType: 'json',
+      accept: 'application/json'
     })).pipe(
       filter((r: any) => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return (r as HttpResponse<any>).clone({ body: undefined }) as StrictHttpResponse<void>;
+        return r as StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>;
       })
     );
   }
@@ -74 +74 @@
    */
   insertUnit(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<void> {
+  }): Observable<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }> {
 
     return this.insertUnit$Response(params).pipe(
-      map((r: StrictHttpResponse<void>) => r.body as void)
+      map((r: StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>) => r.body as { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> })
+    );
+  }
+
+  /**
+   * Path part for operation insertSensor
+   */
+  static readonly InsertSensorPath = '/senslog15/ManagementService?Operation=InsertSensor';
+
+  /**
+   * Insert Sensor.
+   *
+   *
+   *
+   * This method provides access to the full `HttpResponse`, allowing access to response headers.
+   * To access only the response body, use `insertSensor()` instead.
+   *
+   * This method sends `application/json` and handles request body of type `application/json`.
+   */
+  insertSensor$Response(params: {
+    body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
+  }): Observable<StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>> {
+
+    const rb = new RequestBuilder(this.rootUrl, ManagementService.InsertSensorPath, 'post');
+    if (params) {
+      rb.body(params.body, 'application/json');
+    }
+
+    return this.http.request(rb.build({
+      responseType: 'json',
+      accept: 'application/json'
+    })).pipe(
+      filter((r: any) => r instanceof HttpResponse),
+      map((r: HttpResponse<any>) => {
+        return r as StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>;
+      })
+    );
+  }
+
+  /**
+   * Insert Sensor.
+   *
+   *
+   *
+   * This method provides access to only to the response body.
+   * To access the full response (for headers, for example), `insertSensor$Response()` instead.
+   *
+   * This method sends `application/json` and handles request body of type `application/json`.
+   */
+  insertSensor(params: {
+    body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
+  }): Observable<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }> {
+
+    return this.insertSensor$Response(params).pipe(
+      map((r: StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>) => r.body as { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> })
     );
   }
 
@@ -206 +260 @@
    */
   deleteSensor$Response(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<StrictHttpResponse<{ 'message'?: string }>> {
+  }): Observable<StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>> {
 
     const rb = new RequestBuilder(this.rootUrl, ManagementService.DeleteSensorPath, 'delete');
     if (params) {
@@ -219 +273 @@
     })).pipe(
       filter((r: any) => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<{ 'message'?: string }>;
+        return r as StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>;
       })
     );
   }
@@ -236 +290 @@
    */
   deleteSensor(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<{ 'message'?: string }> {
+  }): Observable<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }> {
 
     return this.deleteSensor$Response(params).pipe(
-      map((r: StrictHttpResponse<{ 'message'?: string }>) => r.body as { 'message'?: string })
+      map((r: StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>) => r.body as { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> })
     );
   }
 
@@ -260 +314 @@
    */
   updateSensor$Response(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<StrictHttpResponse<void>> {
+  }): Observable<StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>> {
 
     const rb = new RequestBuilder(this.rootUrl, ManagementService.UpdateSensorPath, 'put');
     if (params) {
@@ -268 +322 @@
     }
 
     return this.http.request(rb.build({
-      responseType: 'text',
-      accept: '*/*'
+      responseType: 'json',
+      accept: 'application/json'
     })).pipe(
       filter((r: any) => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return (r as HttpResponse<any>).clone({ body: undefined }) as StrictHttpResponse<void>;
+        return r as StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>;
       })
     );
   }
@@ -290 +344 @@
    */
   updateSensor(params: {
     body: { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }
-  }): Observable<void> {
+  }): Observable<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }> {
 
     return this.updateSensor$Response(params).pipe(
-      map((r: StrictHttpResponse<void>) => r.body as void)
+      map((r: StrictHttpResponse<{ 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> }>) => r.body as { 'unit'?: InsertUnit, 'sensors'?: Array<InsertSensor> })
     );
   }
 

src/app/shared/api/endpoints/services/sensors.service.ts

@@ -9 +9 @@
 import { Observable } from 'rxjs';
 import { map, filter } from 'rxjs/operators';
 
+import { Phenomenon } from '../models/phenomenon';
 
 
 /**
@@ -41 +42 @@
    * This method doesn't expect any request body.
    */
   getPhenomenons$Response(params?: {
-  }): Observable<StrictHttpResponse<Array<any>>> {
+  }): Observable<StrictHttpResponse<Array<Phenomenon>>> {
 
     const rb = new RequestBuilder(this.rootUrl, SensorsService.GetPhenomenonsPath, 'get');
     if (params) {
@@ -53 +54 @@
     })).pipe(
       filter((r: any) => r instanceof HttpResponse),
       map((r: HttpResponse<any>) => {
-        return r as StrictHttpResponse<Array<any>>;
+        return r as StrictHttpResponse<Array<Phenomenon>>;
       })
     );
   }
@@ -69 +70 @@
    * This method doesn't expect any request body.
    */
   getPhenomenons(params?: {
-  }): Observable<Array<any>> {
+  }): Observable<Array<Phenomenon>> {
 
     return this.getPhenomenons$Response(params).pipe(
-      map((r: StrictHttpResponse<Array<any>>) => r.body as Array<any>)
+      map((r: StrictHttpResponse<Array<Phenomenon>>) => r.body as Array<Phenomenon>)
     );
   }
 

src/app/shared/api/openapi.yaml

@@ -53 +53 @@
             application/json:
               schema:
                 $ref: '#/components/schemas/UserCookie'
+        401:
+          description: Wrong username or password
+          content:
+            text/plain:
+              schema:
+                type: string
 
   /senslog15/rest/user:
     get:
@@ -116 +122 @@
                 type: array
                 items:
                   $ref: '#/components/schemas/OldObservation'
+        500:
+          description: Internal server error
 
   /senslog1/GroupService:
     get:
@@ -220 +228 @@
                 properties:
                   sensor:
                     $ref: '#/components/schemas/Sensors'
+        400:
+          description: wrong request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+                  path:
+                    type: string
+                  timestamp:
+                    type: number
 
   /senslog15/ManagementService?Operation=InsertUnit:
     post:
@@ -230 +251 @@
       responses:
         200:
           description: inserted
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  unit:
+                    $ref: '#/components/schemas/InsertUnit'
+                  sensors:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/InsertSensor'
+        400:
+          description: wrong request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                unit:
+                  $ref: '#/components/schemas/InsertUnit'
+                sensors:
+                  type: array
+                  items:
+                    $ref: '#/components/schemas/InsertSensor'
+
+  /senslog15/ManagementService?Operation=InsertSensor:
+    post:
+      tags:
+        - management
+      summary: Insert Sensor
+      operationId: insertSensor
+      responses:
+        200:
+          description: inserted
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  unit:
+                    $ref: '#/components/schemas/InsertUnit'
+                  sensors:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/InsertSensor'
+        400:
+          description: wrong request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
       requestBody:
         required: true
         content:
@@ -258 +342 @@
               schema:
                 type: array
                 items:
-                  $ref: ''#/components/schemas/Phenomenon''
+                  $ref: '#/components/schemas/Phenomenon'
 
   /senslog15/ManagementService?Operation=UpdateUnit:
     put:
@@ -295 +379 @@
                 properties:
                   message:
                     type: string
+        400:
+          description: wrong request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
       requestBody:
         required: true
         content:
@@ -314 +407 @@
       responses:
         200:
           description: deleted
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  unit:
+                    $ref: '#/components/schemas/InsertUnit'
+                  sensors:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/InsertSensor'
+        400:
+          description: wrong request
           content:
             application/json:
               schema:
@@ -344 +450 @@
       responses:
         200:
           description: updated
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  unit:
+                    $ref: '#/components/schemas/InsertUnit'
+                  sensors:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/InsertSensor'
+        400:
+          description: wrong request
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  message:
+                    type: string
       requestBody:
         required: true
         content:

src/app/shared/nav-bar/components/user-insert-popup/user-insert-popup.component.ts

@@ -6 +6 @@
 import {Right} from '../../../api/endpoints/models/right';
 import {FormBuilder, FormGroup, Validators} from '@angular/forms';
 import {HttpResponse} from '@angular/common/http';
+import {ToastService} from '../../../services/toast.service';
 
 @Component({
   selector: 'app-user-insert-popup',
@@ -23 +24 @@
   constructor(
     private formBuilder: FormBuilder,
     private groupService: GroupService,
-    private administrationService: AdministrationService
+    private administrationService: AdministrationService,
+    private toastService: ToastService
   ) {
     this.initForm();
     // TODO this.getGroups();
@@ -56 +58 @@
         userName: this.insertForm.controls.userName.value,
         rightsId: this.insertForm.controls.rights.value,
         userRealName: this.insertForm.controls.userRealName.value,
-          // TODO
-        groupId: 2
+        groupId: 2 // TODO
         }
       }).pipe(
         map((response: HttpResponse<any>) => {
-          if (response.status === 200) { // Accepts only 200 status response, due to API Definition
+          if (response.status === 200) {
             this.close();
           } else {
-            console.log('ERROR');
+            this.toastService.showError(null);
           }
         })
-      ).toPromise();
+      ).toPromise().then().catch(err => this.toastService.showError(err.error));
     }
   }
 

src/app/shared/services/toast.service.ts

@@ +1 @@
+import {Injectable} from '@angular/core';
+import {MessageService} from 'primeng/api';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ToastService {
+
+  constructor(
+    private messageService: MessageService
+  ) {
+  }
+
+  showError(err: any) {
+    this.messageService.add({key: 'mainToast', severity:'error', summary: 'Unsuccessful!', detail: err});
+  }
+
+  showWarningNoData() {
+    this.messageService.add({key: 'mainToast', severity:'warn', summary: 'No data!', detail: 'Can not display any data for given interval and aggregation!'});
+  }
+
+  showSuccess() {
+    this.messageService.add({key: 'mainToast', severity:'success', summary: 'No data!', detail: 'Successful request!'});
+  }
+}