Implémentation SkydiverId API

src/app/core/models/index.ts

@@ -6,7 +6,6 @@ export * from './calculator.model';
 export * from './canopy.model';
 export * from './canopysize.model';
 export * from './chart.model';
-export * from './reducerow.model';
 export * from './dropzone.model';
 export * from './errors.model';
 export * from './jump.model';
@@ -14,4 +13,5 @@ export * from './jump-list.model';
 export * from './jump-list-config.model';
 export * from './profile.model';
 export * from './qcm.model';
+export * from './shared.model';
 export * from './user.model';

src/app/core/models/jump-list-config.model.ts

@@ -33,4 +33,6 @@ export interface JumpListFilters {
     hauteurRangeEnd?: number;
     yearRangeStart?: number;
     yearRangeEnd?: number;
+    dateRangeStart?: string;
+    dateRangeEnd?: string;
 }

src/app/core/models/jump.model.ts

@@ -1,6 +1,7 @@
 import { FormControl } from '@angular/forms';
 
 import { Profile } from './profile.model';
+import { PageLinks, PageMeta } from './shared.model';
 
 export interface Jump {
     slug: string;
@@ -23,12 +24,26 @@ export interface Jump {
     zone?: string;
     dossier?: string;
     video?: string;
+    files: Array<JumpFile>;
+    x2data: X2Data;
     author: Profile;
     createdAt: string;
     updatedAt: string;
     //isEdit?: boolean;
     isSelected?: boolean;
 }
+export enum JumpFileType {
+    CSV = "csv",
+    IMAGE = "image",
+    KML = "kml",
+    VIDEO = "video",
+}
+export interface JumpFile {
+    slug: string;
+    name: string;
+    path: string;
+    type: JumpFileType;
+}
 
 export interface JumpForm {
     date: FormControl<string>;
@@ -69,6 +84,11 @@ export interface JumpByCategorie {
     count: number;
 }
 
+export interface JumpByDay {
+    jumps: Array<Partial<Jump>>;
+    count: number;
+}
+
 export interface JumpByModule {
     categorie: string;
     module: string;
@@ -88,12 +108,89 @@ export interface JumpYears {
     count: number;
 }
 
+export interface SkydiverIdJumps {
+    items: Array<X2Data>;
+    _links: PageLinks;
+    _meta: PageMeta;
+}
+
+export interface X2Data {
+    id: string;
+    name: string;
+    type: string;
+    description: string;
+    landingZone: string;
+    speed: {
+        freeFall: {
+            vertical: {
+                max: number;
+                avg: number;
+            };
+            horizontal: {
+                max: number;
+                avg: number;
+            };
+        };
+        underCanopy: {
+            vertical: {
+                max: number;
+                avg: number;
+            };
+            horizontal: {
+                max: number;
+                avg: number;
+            };
+        };
+    };
+    glideRatio: {
+        freeFall: {
+            max: number;
+            avg: number;
+        };
+        underCanopy: {
+            max: number;
+            avg: number;
+        };
+    };
+    duration: {
+        freeFall: number;
+        underCanopy: number;
+    };
+    distance: {
+        exitFromLandingZone: number;
+        totalFlying: number;
+        totalHorizontal: number;
+    };
+    altitude: {
+        exit: number;
+        deployment: number;
+    };
+    cutaway: string;
+    malfunctions:Array<
+        {
+            name: string;
+            type: string;
+        }
+    >;
+    date: string;
+    createdOn: string;
+}
+
+export interface JumpPageData {
+    jump: Jump;
+    prevJump: Jump;
+    nextJump: Jump;
+    _links: PageLinks;
+    _meta: PageMeta;
+}
+
 export interface JumpsPageData {
     jumpsByCategory: Array<JumpByCategorie>;
     jumpsByDate: Array<JumpByDate>;
     jumpsByDateByModule: Array<JumpByDateByModule>;
     jumpsByModule: Array<JumpByModule>;
     jumpsByYears: Array<JumpYears>;
+    //jumpsFromSkydiverIdApi: SkydiverIdJumps;
     lastjump: Jump;
     /*yearsCount: number;
     jumpsByCategoryCount: number;

src/app/core/models/menu.model.ts

@@ -7,4 +7,5 @@ export interface Menu {
     icon: string;
     desc?: string;
     badge?: Badge[];
+    color?: string;
 }

src/app/core/models/shared.model.ts

@@ -0,0 +1,30 @@
+
+export interface PageLinks {
+    self: {
+        href: string;
+    };
+    first: {
+        href: string;
+    };
+    last: {
+        href: string;
+    };
+    prev: {
+        href: string;
+    };
+    next: {
+        href: string;
+    };
+}
+
+export interface PageMeta {
+    totalCount: number;
+    pageCount: number;
+    currentPage: number;
+    perPage: number;
+}
+
+export interface ReduceRow {
+    key: string[];
+    value: number;
+}

src/app/core/resolvers/jump-resolver.service.ts

@@ -2,10 +2,10 @@ import { inject } from '@angular/core';
 import { ActivatedRouteSnapshot, ResolveFn } from '@angular/router';
 import { take } from 'rxjs/operators';
 
-import { Jump } from 'src/app/core/models';
+import { JumpPageData } from 'src/app/core/models';
 import { JumpsService } from 'src/app/core/services';
 
-export const jumpResolver: ResolveFn<Jump> = (
+export const jumpResolver: ResolveFn<JumpPageData> = (
     route: ActivatedRouteSnapshot
 ) => {
     return inject(JumpsService).get(route.params['slug']).pipe(take(1));

src/app/core/services/applications.service.ts

@@ -23,7 +23,9 @@ export class ApplicationsService {
         return this.apiService
             .get(
                 '/applications' + ((config.type === 'feed') ? '/feed' : ''),
-                new HttpParams({ fromObject: <any>params })
+                new HttpParams({ fromObject: <{
+                    [param: string]: string | number | boolean | readonly (string | number | boolean)[];
+                }>params })
             );
     }
 

src/app/core/services/calculator.service.ts

@@ -27,8 +27,8 @@ export class CalculatorService {
 
     private _getTableLine(weight: number): number {
         let line: number;
-        let min = 60;
-        let max = 110;
+        const min = 60;
+        const max = 110;
         if (weight < min) {
             line = min;
         } else if (weight > max) {
@@ -52,14 +52,14 @@ export class CalculatorService {
         /* const maxRange = 2000; */
         /* DT48 - 08 février 2024 */
         const maxRange = 1600;
-        let result: CalculatorResult = {
+        const result: CalculatorResult = {
             min: 59,
             min11: 34
         };
         if (jumps > maxRange) {
             return result;
         }
-        let index: number = (this._getTableLine(weight) - this._getTableLine(0));
+        const index: number = (this._getTableLine(weight) - this._getTableLine(0));
         result.min = weightSizes[index].ranges[this._getTableColumn(jumps)].value!;
         result.min11 = this._reduceLimit(result.min, 11);
 
@@ -71,27 +71,23 @@ export class CalculatorService {
     }
 
     public getCanopySizes(weight: number, reduce = false): number[] {
-        var data: number[] = [];
         if (weight < 60) {
             weight = 60;
         }
         if (weight > 110) {
             weight = 110;
         }
-        if (weight >= 60 && weight <= 110) {
-            const line = (weight - this._getTableLine(0));
-            let data = weightSizes[line];
-            if (reduce) {
-                return data.ranges.map((range: WeightSizeRange): number => {
-                    return Math.ceil(range.value! * (100 - 11) / 100);
-                });
-            } else {
-                return data.ranges.map((range: WeightSizeRange): number => {
-                    return range.value!;
-                });
-            }
+        const line = (weight - this._getTableLine(0));
+        const data = weightSizes[line];
+        if (reduce) {
+            return data.ranges.map((range: WeightSizeRange): number => {
+                return Math.ceil(range.value! * (100 - 11) / 100);
+            });
+        } else {
+            return data.ranges.map((range: WeightSizeRange): number => {
+                return range.value!;
+            });
         }
-        return data;
     }
 
     public getCharge(canopySize: number, nakedWeight: number, equipementWeight: number): number {
@@ -99,7 +95,7 @@ export class CalculatorService {
     }
 
     public getRangeNum(jumps: number): number {
-        let data: WeightSizeRange[] = weightSizes[0].ranges;
+        const data: WeightSizeRange[] = weightSizes[0].ranges;
         let num: number = 1;
         /* DT48 - 13 mars 2020 */
         /* const maxRange = 2000; */

src/app/core/services/jump-table.service.ts

@@ -11,8 +11,8 @@ export class JumpTableService {
     _jumpRefreshBS = new BehaviorSubject<boolean>(false);
 
     constructor() {
-        this.tableRefresh = false;;
-        this.jumpRefresh = false;;
+        this.tableRefresh = false;
+        this.jumpRefresh = false;
 
         //this._tableRefreshBS.next(this.tableRefresh);
         //this._jumpRefreshBS.next(this.jumpRefresh);

src/app/core/services/jumps.service.ts

@@ -4,7 +4,11 @@ import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 
 import { ApiService } from './api.service';
-import { Jump, JumpByCategorie, JumpByDate, JumpByModule, JumpList, JumpListConfig, JumpListFilters } from 'src/app/core/models';
+import {
+    Jump, JumpByCategorie, JumpByDate, JumpByDay, JumpByModule, JumpFile,
+    JumpList, JumpListConfig, JumpListFilters, JumpPageData,
+    X2Data, SkydiverIdJumps
+} from 'src/app/core/models';
 
 @Injectable({ providedIn: 'root' })
 export class JumpsService {
@@ -44,52 +48,67 @@ export class JumpsService {
         */
         const params: JumpListFilters = {} as JumpListFilters;
         Object.assign(params, config.filters);
-
         return this.apiService
             .get(
                 '/jumps' + ((config.type === 'feed') ? '/feed' : ''),
-                new HttpParams({ fromObject: <any>params })
+                new HttpParams({ fromObject: <{
+                    [param: string]: string | number | boolean | readonly (string | number | boolean)[];
+                }>params })
             );
     }
 
-    get(slug: string): Observable<Jump> {
-        return this.apiService.get(`/jumps/${slug}`)
-            .pipe(map(data => data.jump));
+    get(slug: string): Observable<JumpPageData> {
+        /* return this.apiService.get(`/jumps/${slug}`)
+            .pipe(map(data => {
+                return { jump: data.jump, prevJump: data.prevJump, nextJump: data.nextJump };
+            })); */
+        return this.apiService.get(`/jumps/${slug}`);
     }
 
-    getAll(): Observable<[Jump]> {
-        return this.apiService.get('/jumps')
-            .pipe(map(data => data.jumps));
+    getAll(): Observable<Array<Jump>> {
+        return this.apiService.get('/jumps').pipe(map(data => data.jumps));
     }
 
     getAllByDate(): Observable<Array<JumpByDate>> {
-        return this.apiService.get('/jumps/allByDate')
-            .pipe(map(data => data.jumps));
+        return this.apiService.get('/jumps/allByDate').pipe(map(data => data.jumps));
     }
 
     getAllByCategorie(): Observable<Array<JumpByCategorie>> {
-        return this.apiService.get('/jumps/allByCategorie')
-            .pipe(map(data => data.jumps));
+        return this.apiService.get('/jumps/allByCategorie').pipe(map(data => data.jumps));
+    }
+
+    getAllByDay(config: JumpListConfig): Observable<Array<JumpByDay>> {
+        const params: JumpListFilters = {} as JumpListFilters;
+        Object.assign(params, config.filters);
+        return this.apiService.get('/jumps/allByDay', new HttpParams({ fromObject: <{
+            [param: string]: string | number | boolean | readonly (string | number | boolean)[];
+        }>params }))
+            .pipe(map(data => data.days));
     }
 
     getAllByModule(): Observable<Array<JumpByModule>> {
-        return this.apiService.get('/jumps/allByModule')
+        return this.apiService.get('/jumps/allByModule').pipe(map(data => data.jumps));
+    }
+
+    getAllFromSkydiverIdApi(config: JumpListConfig): Observable<SkydiverIdJumps> {
+        const params: JumpListFilters = {} as JumpListFilters;
+        Object.assign(params, config.filters);
+        return this.apiService.get('/jumps/allFromSkydiverIdApi', new HttpParams({ fromObject: <{
+            [param: string]: string | number | boolean | readonly (string | number | boolean)[];
+        }>params }))
             .pipe(map(data => data.jumps));
     }
 
     getLastJump(): Observable<Jump> {
-        return this.apiService.get('/jumps/last')
-            .pipe(map(data => data.jump));
+        return this.apiService.get('/jumps/last').pipe(map(data => data.jump));
     }
 
     create(jump: Jump): Observable<Jump> {
-        return this.apiService.post('/jumps/', { jump: jump })
-            .pipe(map(data => data.jump));
+        return this.apiService.post('/jumps/', { jump: jump }).pipe(map(data => data.jump));
     }
 
     update(jump: Jump): Observable<Jump> {
-        return this.apiService.put(`/jumps/${jump.slug}`, { jump: jump })
-            .pipe(map(data => data.jump));
+        return this.apiService.put(`/jumps/${jump.slug}`, { jump: jump }).pipe(map(data => data.jump));
     }
 
     destroy(slug: string) {
@@ -99,16 +118,29 @@ export class JumpsService {
     save(jump: Jump): Observable<Jump> {
         // If we're updating an existing jump
         if (jump.slug) {
-            return this.apiService.put('/jumps/' + jump.slug, { jump: jump })
-                .pipe(map(data => data.jump));
+            return this.apiService.put(`/jumps/${jump.slug}`, { jump: jump }).pipe(map(data => data.jump));
 
             // Otherwise, create a new jump
         } else {
-            return this.apiService.post('/jumps/', { jump: jump })
-                .pipe(map(data => data.jump));
+            return this.apiService.post('/jumps/', { jump: jump }).pipe(map(data => data.jump));
         }
     }
 
+    saveX2Data(slug: string, file: JumpFile, data: X2Data): Observable<Jump> {
+        return this.apiService.post(`/jumps/data/${slug}`, { file: file, data: data })
+            .pipe(map(data => data.jump));
+    }
+
+    saveFile(slug: string, file: JumpFile): Observable<JumpFile> {
+        return this.apiService.post(`/jumps/file/${slug}`, { file: file })
+            .pipe(map(data => data.file));
+    }
+
+    saveKml(slug: string, file: JumpFile): Observable<JumpFile> {
+        return this.apiService.post(`/jumps/kml/${slug}`, { file: file })
+            .pipe(map(data => data.file));
+    }
+
     getAeronefs() {
         /*
         [

src/app/core/services/utilities.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import { BubbleDataPoint, Chart, ChartTypeRegistry, Point } from 'chart.js';
+import { Chart } from 'chart.js';
 import { Configuration } from 'ng-chartist';
 
 import { BarConfig, CircleConfig, DoughnutConfig, LineConfig } from 'src/app/core/models';