Admin basket: fix upload, cleanups

src/app/admin/admin-basket/admin-basket-resolver.service.ts

@@ -3,18 +3,17 @@ import { Router, RouterStateSnapshot, ActivatedRouteSnapshot } from '@angular/ro
 import { Observable, forkJoin } from 'rxjs'
 import { map } from 'rxjs/operators'
 
-import { AdminBasketDataService } from './data.service'
-import { AdminBasket } from '../../openapi'
+import { AdminBasket, AdminService } from '../../openapi'
 
 @Injectable()
 export class BasketResolver  {
     constructor(
         private router: Router,
-        private basketDataService: AdminBasketDataService,
+        private adminService: AdminService,
     ) {}
 
     resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<AdminBasket> {
         var name = route.paramMap.get('name')
-        return this.basketDataService.getBasket(name)
+        return this.adminService.getBasketApiAdminBasketNameGet({name: name})
     }
 }

src/app/admin/admin-basket/admin-basket-upload/basket-upload.component.html

@@ -5,7 +5,7 @@
             <mat-select formControlName="project">
                 <mat-option
                     *ngFor="let item of basket.projects.length == 0 ? adminDataService.surveyMeta.projects : basket.projects"
-                    [value]="item.name">
+                    [value]="item.id">
                     {{ item.name }}
                 </mat-option>
             </mat-select>
@@ -15,7 +15,7 @@
             <mat-select formControlName="surveyor">
                 <mat-option
                     *ngFor="let item of adminDataService.surveyMeta.surveyors"
-                    [value]="item.name">
+                    [value]="item.id">
                     {{ item.name }}
                 </mat-option>
             </mat-select>
@@ -25,7 +25,7 @@
             <mat-select formControlName="equipment">
                 <mat-option
                     *ngFor="let item of adminDataService.surveyMeta.equipments"
-                    [value]="item.name">
+                    [value]="item.id">
                     {{ item.name }}
                 </mat-option>
             </mat-select>

src/app/admin/admin-basket/admin-basket-upload/basket-upload.component.ts

@@ -1,13 +1,13 @@
 import { Component, OnInit, Input, ViewChild, ElementRef,
     ChangeDetectorRef, ChangeDetectionStrategy, SimpleChanges, OnChanges } from '@angular/core'
 import { HttpClient } from '@angular/common/http'
-import { UntypedFormGroup, UntypedFormControl, Validators } from '@angular/forms'
+import { FormGroup, Validators, FormControl } from '@angular/forms'
 
 import { MatTableDataSource } from '@angular/material/table'
 
 import { AdminDataService } from '../../admin-data.service'
 import { AdminBasketFile } from '../data.service'
-import { AdminBasket } from '../../../openapi'
+import { AdminBasket, AdminService } from '../../../openapi'
 import { MatSnackBar } from '@angular/material/snack-bar'
 import { HtmlSnackbarComponent } from '../../../custom-snackbar/custom-snackbar.component'
 
@@ -23,6 +23,7 @@ export class AdminBasketUploadComponent implements OnInit, OnChanges {
         private cdr: ChangeDetectorRef,
         private http: HttpClient,
         private snackBar: MatSnackBar,
+        public adminService: AdminService,
     ) {}
 
     @ViewChild('fileInput') fileInput: ElementRef
@@ -31,18 +32,22 @@ export class AdminBasketUploadComponent implements OnInit, OnChanges {
 
     //upload_fields = ['store', 'status', 'project', 'surveyor', 'equipment']
 
-    formGroup: UntypedFormGroup = new UntypedFormGroup({})
+    formGroup: FormGroup = new FormGroup({})
 
     ngOnInit() {
-        let dflt = this.adminDataService.surveyMeta.default
-        this.formGroup = new UntypedFormGroup({
-            'store_misc': new UntypedFormControl(dflt['store_misc'], [Validators.required]),
-            'store_line_work': new UntypedFormControl(dflt['store_line_work'], [Validators.required]),
-            'status': new UntypedFormControl(dflt.status, [Validators.required]),
-            'project': new UntypedFormControl(dflt.project, [Validators.required]),
-            'surveyor': new UntypedFormControl(dflt.surveyor, [Validators.required]),
-            'equipment': new UntypedFormControl(dflt.equipment, [Validators.required]),
-            'autoImport': new UntypedFormControl(true),
+        const sm = this.adminDataService.surveyMeta
+        const dflt = sm.default
+        const dfltProject: number = sm.projects.find(e => e['name'] == dflt.project)?.id
+        const dfltSurveyor: number = sm.surveyors.find(e => e['name'] == dflt.surveyor)?.id
+        const dfltEquipment: number = sm.equipments.find(e => e['name'] == dflt.equipment)?.id
+        this.formGroup = new FormGroup({
+            'store_misc': new FormControl(dflt['store_misc'], [Validators.required]),
+            'store_line_work': new FormControl(dflt['store_line_work'], [Validators.required]),
+            'status': new FormControl(dflt.status, [Validators.required]),
+            'project': new FormControl(dfltProject, [Validators.required]),
+            'surveyor': new FormControl(dfltSurveyor, [Validators.required]),
+            'equipment': new FormControl(dfltEquipment, [Validators.required]),
+            'autoImport': new FormControl(true),
         })
         this.setupRequired()
     }
@@ -65,16 +70,16 @@ export class AdminBasketUploadComponent implements OnInit, OnChanges {
     }
 
     onFileUpload() {
-        const formData = new FormData()
-        formData.append('file', <File>this.fileInput.nativeElement.files[0])
-        let fg = this.formGroup.getRawValue()
-        for (let field in fg) {
-            if (this.basket.uploadFields.indexOf(field) != -1) {
-                formData.append(field, fg[field])
+        this.adminService.uploadBasketFileApiAdminBasketUploadNamePost({
+            name: this.basket.name,
+            equipmentId: this.formGroup.get('equipment').value,
+            projectId: this.formGroup.get('project').value,
+            surveyorId: this.formGroup.get('surveyor').value,
+            autoImport: this.formGroup.get('autoImport').value,
+            formData: {
+                file: <File>this.fileInput.nativeElement.files[0]
             }
-        }
-        formData.append('autoImport', this.formGroup.get('autoImport').value)
-        this.http.post('upload/basket/' + this.basket.name, formData).subscribe(
+        }).subscribe(
             resp => {
                 let importResult = resp['import_result']
                 const importTime = resp['time'] || (importResult && importResult['time'])

src/app/admin/admin-basket/basket.component.ts

@@ -10,8 +10,8 @@ import { MatSort } from '@angular/material/sort'
 import { MatTableDataSource } from '@angular/material/table'
 
 import { AdminDataService } from '../admin-data.service'
-import { AdminBasketDataService, AdminBasketFile } from './data.service'
-import { AdminBasket } from '../../openapi'
+import { AdminBasketFile } from './data.service'
+import { AdminBasket, AdminService } from '../../openapi'
 import { HtmlSnackbarComponent } from '../../custom-snackbar/custom-snackbar.component'
 
 @Component({
@@ -23,10 +23,10 @@ import { HtmlSnackbarComponent } from '../../custom-snackbar/custom-snackbar.com
 export class AdminBasketComponent implements OnInit {
     constructor(
         public adminDataService: AdminDataService,
-        public adminBasketDataService: AdminBasketDataService,
         private route: ActivatedRoute,
         private snackBar: MatSnackBar,
         private cdr: ChangeDetectorRef,
+        public adminService: AdminService,
     ) {}
 
     basket: AdminBasket
@@ -78,7 +78,11 @@ export class AdminBasketComponent implements OnInit {
     }
 
     importItem(item: AdminBasketFile, dryRun: boolean) {
-        this.adminBasketDataService.importItem(this.basket.name, item.id, dryRun).subscribe(
+        return this.adminService.importBasketFileApiAdminBasketImportBasketFileIdGet({
+            basket: this.basket.name,
+            fileId: item.id,
+            dryRun: dryRun
+        }).subscribe(
             resp => {
                 this.basket.files.find(row => row.id == item.id).time = new Date(resp.time).toLocaleString()
                 this.snackBar.openFromComponent(HtmlSnackbarComponent, {
@@ -91,7 +95,10 @@ export class AdminBasketComponent implements OnInit {
     }
 
     deleteItem(item: AdminBasketFile) {
-        this.adminBasketDataService.deleteItem(this.basket.name, item.id).subscribe(
+        return this.adminService.deleteBasketFileApiAdminBasketDeleteBasketFileIdGet({
+            basket: this.basket.name,
+            fileId: item.id
+        }).subscribe(
             id => {
                 let dsi = this.dataSource.data.findIndex(fi => fi['id'] == id)
                 this.dataSource.data.splice(dsi, 1)

src/app/admin/admin-basket/data.service.ts

@@ -36,78 +36,3 @@ export class AdminBasketUploadFieldData {
         public equipments: string[],
     ) {}
 }
-
-@Injectable()
-export class AdminBasketDataService {
-    constructor(
-        // private apollo: Apollo,
-        public adminService: AdminService,
-    ) {}
-
-    getBaskets(): Observable<BasketNameOnly[]> {
-        // Get the list a basket names
-        return this.adminService.getBasketsApiAdminBasketGet()
-    }
-
-    getBasketUploadFieldData(): Observable<AdminBasketUploadFieldData> {
-        // Get the list a basket names
-        console.warn('Migrate Graphql')
-        return observableOf()
-        // return this.apollo.query({
-        //     query: getAdminBasketUploadFieldDataQuery,
-        // }).pipe(map(
-        //     res => res['data']['admin_basket_upload_field_data'].map(
-        //         (data: object) => new AdminBasketUploadFieldData(
-        //             data['store'],
-        //             data['status'],
-        //             data['project'],
-        //             data['surveyor'],
-        //             data['equipment'],
-        //         )
-        //     )
-        // ))
-    }
-
-    getBasket(name: string): Observable<AdminBasket> {
-        // Get all info and content of a basket
-        return this.adminService.getBasketApiAdminBasketNameGet({name: name})
-    }
-
-    importItem(basket: string, fileId: number, dryRun: boolean=false): Observable<BasketImportResult> {
-        return this.adminService.importBasketFileApiAdminBasketImportBasketFileIdGet({
-            basket: basket,
-            fileId: fileId,
-            dryRun: dryRun
-        })
-        console.warn('Migrate Graphql')
-        return observableOf()
-        // return this.apollo.mutate({
-        //     mutation: importAdminBasketItemMutation,
-        //     variables: {
-        //         basket: basket,
-        //         id: id,
-        //         dryRun: dryRun
-        //     }
-        // }).pipe(map(
-        //     resp => new BasketImportResult(
-        //         resp['data']['importBasketItem']['result']['time'],
-        //         resp['data']['importBasketItem']['result']['message'],
-        //         JSON.parse(resp['data']['importBasketItem']['result']['details']),
-        //     )
-        // ))
-    }
-
-    deleteItem(basket: string, id: number) {
-        console.warn('Migrate Graphql')
-        return observableOf()
-        // return this.apollo.mutate({
-        //     mutation: deleteAdminBasketItemMutation,
-        //     variables: {
-        //         basket: basket,
-        //         id: id,
-        //     }
-        // }).pipe(map(
-        //     resp => resp['data']['deleteBasketItem']['result']
-        // ))
-    }
-}

src/app/admin/admin-resolver.service.ts

@@ -3,8 +3,7 @@ import { Router, RouterStateSnapshot, ActivatedRouteSnapshot } from '@angular/ro
 import { Observable, forkJoin } from 'rxjs'
 
 import { AdminDataService } from './admin-data.service'
-import { AdminBasketDataService } from './admin-basket/data.service'
-import { BasketNameOnly, SurveyMeta } from '../openapi'
+import { BasketNameOnly, SurveyMeta, AdminService } from '../openapi'
 
 
 @Injectable()
@@ -12,7 +11,7 @@ export class AdminResolver  {
     constructor(
         private router: Router,
         private dataService: AdminDataService,
-        private basketDataService: AdminBasketDataService,
+        private adminService: AdminService,
     ) {}
 
     resolve(
@@ -20,7 +19,7 @@ export class AdminResolver  {
         state: RouterStateSnapshot,
         ): Observable<[BasketNameOnly[], SurveyMeta]> {
         return forkJoin([
-            this.basketDataService.getBaskets(),
+            this.adminService.getBasketsApiAdminBasketGet(),
             this.dataService.getSurveyMeta(),
         ])
     }

src/app/admin/admin.module.ts

@@ -50,7 +50,6 @@ import { GisafAdminCategoryDialogComponent } from './admin-manage/category/dialo
 import { AdminDetailModule } from './admin-detail/admin-detail.module'
 import { AdminManageDataService } from './admin-manage/data.service'
 import { AdminManageAccessDataService } from './admin-manage/access/access-data.service'
-import { AdminBasketDataService } from './admin-basket/data.service';
 import { ProjectComponent } from './admin-manage/project/project.component'
 import { GisafAdminProjectDialogComponent } from './admin-manage/project/dialog.component';
 import { AdminIntegrityComponent } from './admin-manage/integrity/integrity.component'
@@ -130,7 +129,6 @@ import { PipesModule } from '../pipes.module'
         AdminDataService,
         AdminManageDataService,
         AdminManageAccessDataService,
-        AdminBasketDataService,
         WebsocketService,
     ]
 })

src/app/openapi/core/OpenAPI.ts

@@ -1,5 +1,4 @@
 import type { HttpResponse } from '@angular/common/http';import type { ApiRequestOptions } from './ApiRequestOptions';
-import type { TResult } from './types';
 
 type Headers = Record<string, string>;
 type Middleware<T> = (value: T) => T | Promise<T>;
@@ -33,7 +32,6 @@ export type OpenAPIConfig = {
 	ENCODE_PATH?: ((path: string) => string) | undefined;
 	HEADERS?: Headers | Resolver<Headers> | undefined;
 	PASSWORD?: string | Resolver<string> | undefined;
-	RESULT?: TResult;
 	TOKEN?: string | Resolver<string> | undefined;
 	USERNAME?: string | Resolver<string> | undefined;
 	VERSION: string;
@@ -47,7 +45,6 @@ export const OpenAPI: OpenAPIConfig = {
 	ENCODE_PATH: undefined,
 	HEADERS: undefined,
 	PASSWORD: undefined,
-	RESULT: 'body',
 	TOKEN: undefined,
 	USERNAME: undefined,
 	VERSION: '2023.4.dev63+g52e1d21.d20240408',

src/app/openapi/core/request.ts

@@ -160,7 +160,7 @@ export const getHeaders = (config: OpenAPIConfig, options: ApiRequestOptions): O
 export const getRequestBody = (options: ApiRequestOptions): unknown => {
 	if (options.body) {
 		if (options.mediaType?.includes('application/json') || options.mediaType?.includes('+json')) {
-			return JSON.stringify(options.body)
+			return JSON.stringify(options.body);
 		} else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
 			return options.body;
 		} else {
@@ -290,7 +290,7 @@ export const request = <T>(config: OpenAPIConfig, http: HttpClient, options: Api
 		}),
 		switchMap(async response => {
 			for (const fn of config.interceptors.response._fns) {
-				response = await fn(response)
+				response = await fn(response);
 			}
 			const responseBody = getResponseBody(response);
 			const responseHeader = getResponseHeader(response, options.responseHeader);

src/app/openapi/core/types.ts

@@ -1,12 +0,0 @@
-import type { ApiResult } from './ApiResult';
-
-export type TResult = 'body' | 'raw';
-
-export type TApiResponse<T extends TResult, TData> =
-  Exclude<T, 'raw'> extends never
-    ? ApiResult<TData>
-    : ApiResult<TData>['body'];
-
-export type TConfig<T extends TResult> = {
-  _result?: T;
-};

src/app/openapi/index.ts

@@ -1,8 +1,7 @@
+// This file is auto-generated by @hey-api/openapi-ts
 
 export { ApiError } from './core/ApiError';
-export { OpenAPI } from './core/OpenAPI';
-export type { OpenAPIConfig } from './core/OpenAPI';
-
-export * from './models'
-export * from './schemas'
-export * from './services'
+export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';

src/app/openapi/services.gen.ts

@@ -0,0 +1,703 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import type { Observable } from 'rxjs';
+import { OpenAPI } from './core/OpenAPI';
+import { request as __request } from './core/request';
+import type { $OpenApiTs } from './types.gen';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ApiService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Bootstrap
+ * @returns BootstrapData Successful Response
+ * @throws ApiError
+ */
+    public bootstrapApiBootstrapGet(): Observable<$OpenApiTs['/api/bootstrap']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/bootstrap',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Login For Access Token
+ * @returns Token Successful Response
+ * @throws ApiError
+ */
+    public loginForAccessTokenApiTokenPost(data: $OpenApiTs['/api/token']['post']['req']): Observable<$OpenApiTs['/api/token']['post']['res'][200]> {
+        const { formData } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'POST',
+    url: '/api/token',
+    formData,
+    mediaType: 'application/x-www-form-urlencoded',
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Logout
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public logoutApiLogoutGet(): Observable<$OpenApiTs['/api/logout']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/logout',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Users
+ * @returns UserRead Successful Response
+ * @throws ApiError
+ */
+    public getUsersApiUsersGet(): Observable<$OpenApiTs['/api/users']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/users',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Roles
+ * @returns RoleRead Successful Response
+ * @throws ApiError
+ */
+    public getRolesApiRolesGet(): Observable<$OpenApiTs['/api/roles']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/roles',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Acls
+ * New: ACLs returned as UserRoleLink
+ * @returns UserRoleLink Successful Response
+ * @throws ApiError
+ */
+    public getAclsApiAclsGet(): Observable<$OpenApiTs['/api/acls']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/acls',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Categories
+ * @returns CategoryRead Successful Response
+ * @throws ApiError
+ */
+    public getCategoriesApiCategoriesGet(): Observable<$OpenApiTs['/api/categories']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/categories',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Categories P
+ * @returns CategoryRead Successful Response
+ * @throws ApiError
+ */
+    public getCategoriesPApiCategoriesPandasGet(): Observable<$OpenApiTs['/api/categories_pandas']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/categories_pandas',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * List Data Providers
+ * Return a list of data providers, for use with the api (graphs, etc)
+ * :return:
+ * @returns DataProvider Successful Response
+ * @throws ApiError
+ */
+    public listDataProvidersApiDataProvidersGet(): Observable<$OpenApiTs['/api/data-providers']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/data-providers',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Model List
+ * Json REST store API compatible with Flask Potion and Angular
+ * Get the list of items (used for making the list of items in measures)
+ * Filter only items with at least one measure
+ * @returns MeasuresItem Successful Response
+ * @throws ApiError
+ */
+    public getModelListApiDataProviderStoreGet(data: $OpenApiTs['/api/data-provider/{store}']['get']['req']): Observable<$OpenApiTs['/api/data-provider/{store}']['get']['res'][200]> {
+        const { store } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/data-provider/{store}',
+    path: {
+        store
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Model Values
+ * Get values
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public getModelValuesApiStoreNameValuesValueGet(data: $OpenApiTs['/api/{store_name}/values/{value}']['get']['req']): Observable<$OpenApiTs['/api/{store_name}/values/{value}']['get']['res'][200]> {
+        const { storeName, value, where, resample } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/{store_name}/values/{value}',
+    path: {
+        store_name: storeName,
+        value
+    },
+    query: {
+        where,
+        resample
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Stores
+ * @returns Store Successful Response
+ * @throws ApiError
+ */
+    public getStoresApiStoresGet(): Observable<$OpenApiTs['/api/stores']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/stores',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Projects
+ * @returns Project Successful Response
+ * @throws ApiError
+ */
+    public getProjectsApiProjectsGet(): Observable<$OpenApiTs['/api/projects']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/projects',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Survey Meta
+ * @returns SurveyMeta Successful Response
+ * @throws ApiError
+ */
+    public getSurveyMetaApiSurveyMetaGet(): Observable<$OpenApiTs['/api/survey_meta']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/survey_meta',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Feature Info
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public getFeatureInfoApiFeatureInfoStoreIdGet(data: $OpenApiTs['/api/feature-info/{store}/{id}']['get']['req']): Observable<$OpenApiTs['/api/feature-info/{store}/{id}']['get']['res'][200]> {
+        const { store, id } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/feature-info/{store}/{id}',
+    path: {
+        store,
+        id
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Model Info
+ * @returns ModelInfo Successful Response
+ * @throws ApiError
+ */
+    public getModelInfoApiModelInfoStoreGet(data: $OpenApiTs['/api/model-info/{store}']['get']['req']): Observable<$OpenApiTs['/api/model-info/{store}']['get']['res'][200]> {
+        const { store } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/model-info/{store}',
+    path: {
+        store
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Plot Params
+ * @returns PlotParams Successful Response
+ * @throws ApiError
+ */
+    public getPlotParamsApiPlotParamsStoreGet(data: $OpenApiTs['/api/plot-params/{store}']['get']['req']): Observable<$OpenApiTs['/api/plot-params/{store}']['get']['res'][200]> {
+        const { store, id, value } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/plot-params/{store}',
+    path: {
+        store
+    },
+    query: {
+        id,
+        value
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Actions
+ * @returns ActionsStore Successful Response
+ * @throws ApiError
+ */
+    public getActionsApiActionsGet(): Observable<$OpenApiTs['/api/actions']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/actions',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Execute Tag Action
+ * @returns ActionsResults Successful Response
+ * @throws ApiError
+ */
+    public executeTagActionApiExecTagActionsPost(data: $OpenApiTs['/api/execTagActions']['post']['req']): Observable<$OpenApiTs['/api/execTagActions']['post']['res'][200]> {
+        const { requestBody } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'POST',
+    url: '/api/execTagActions',
+    body: requestBody,
+    mediaType: 'application/json',
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class GeoapiService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Get Geojson
+ * Some REST stores coded manually (route prefixed with "gj": geojson).
+ * :param store_name: name of the model
+ * :return: json
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public getGeojsonApiGjStoreNameGet(data: $OpenApiTs['/api/gj/{store_name}']['get']['req']): Observable<$OpenApiTs['/api/gj/{store_name}']['get']['res'][200]> {
+        const { storeName, ifNoneMatch, simplify, preserveTopology } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/gj/{store_name}',
+    path: {
+        store_name: storeName
+    },
+    headers: {
+        'If-None-Match': ifNoneMatch,
+        simplify,
+        preserveTopology
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class AdminService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Get Baskets
+ * @returns BasketNameOnly Successful Response
+ * @throws ApiError
+ */
+    public getBasketsApiAdminBasketGet(): Observable<$OpenApiTs['/api/admin/basket']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/admin/basket',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Basket
+ * @returns AdminBasket Successful Response
+ * @throws ApiError
+ */
+    public getBasketApiAdminBasketNameGet(data: $OpenApiTs['/api/admin/basket/{name}']['get']['req']): Observable<$OpenApiTs['/api/admin/basket/{name}']['get']['res'][200]> {
+        const { name } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/admin/basket/{name}',
+    path: {
+        name
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Upload Basket File
+ * @returns AdminBasketFile Successful Response
+ * @throws ApiError
+ */
+    public uploadBasketFileApiAdminBasketUploadNamePost(data: $OpenApiTs['/api/admin/basket/upload/{name}']['post']['req']): Observable<$OpenApiTs['/api/admin/basket/upload/{name}']['post']['res'][200]> {
+        const { name, formData, projectId, surveyorId, equipmentId, autoImport } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'POST',
+    url: '/api/admin/basket/upload/{name}',
+    path: {
+        name
+    },
+    query: {
+        project_id: projectId,
+        surveyor_id: surveyorId,
+        equipment_id: equipmentId,
+        auto_import: autoImport
+    },
+    formData,
+    mediaType: 'multipart/form-data',
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Download Basket File
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public downloadBasketFileApiAdminBasketDownloadNameFileIdFileNameGet(data: $OpenApiTs['/api/admin/basket/download/{name}/{file_id}/{file_name}']['get']['req']): Observable<$OpenApiTs['/api/admin/basket/download/{name}/{file_id}/{file_name}']['get']['res'][200]> {
+        const { name, fileId, fileName } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/admin/basket/download/{name}/{file_id}/{file_name}',
+    path: {
+        name,
+        file_id: fileId,
+        file_name: fileName
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Import Basket File
+ * @returns BasketImportResult Successful Response
+ * @throws ApiError
+ */
+    public importBasketFileApiAdminBasketImportBasketFileIdGet(data: $OpenApiTs['/api/admin/basket/import/{basket}/{file_id}']['get']['req']): Observable<$OpenApiTs['/api/admin/basket/import/{basket}/{file_id}']['get']['res'][200]> {
+        const { basket, fileId, dryRun } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/admin/basket/import/{basket}/{file_id}',
+    path: {
+        basket,
+        file_id: fileId
+    },
+    query: {
+        dryRun
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Delete Basket File
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public deleteBasketFileApiAdminBasketDeleteBasketFileIdGet(data: $OpenApiTs['/api/admin/basket/delete/{basket}/{file_id}']['get']['req']): Observable<$OpenApiTs['/api/admin/basket/delete/{basket}/{file_id}']['get']['res'][200]> {
+        const { basket, fileId } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/admin/basket/delete/{basket}/{file_id}',
+    path: {
+        basket,
+        file_id: fileId
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DashboardService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Get Groups
+ * @returns DashboardGroup Successful Response
+ * @throws ApiError
+ */
+    public getGroupsApiDashboardGroupsGet(): Observable<$OpenApiTs['/api/dashboard/groups']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/dashboard/groups',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Home
+ * @returns DashboardHome Successful Response
+ * @throws ApiError
+ */
+    public getHomeApiDashboardHomeGet(): Observable<$OpenApiTs['/api/dashboard/home']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/dashboard/home',
+    errors: {
+        404: 'Not found'
+    }
+});
+    }
+    
+    /**
+ * Get Dashboard Page
+ * @returns Dashboard Successful Response
+ * @throws ApiError
+ */
+    public getDashboardPageApiDashboardPageGroupNameGet(data: $OpenApiTs['/api/dashboard/page/{group}/{name}']['get']['req']): Observable<$OpenApiTs['/api/dashboard/page/{group}/{name}']['get']['res'][200]> {
+        const { group, name } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/dashboard/page/{group}/{name}',
+    path: {
+        group,
+        name
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class MapService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Get Init Data
+ * @returns MapInitData Successful Response
+ * @throws ApiError
+ */
+    public getInitDataApiMapInitDataGet(): Observable<$OpenApiTs['/api/map/init-data']['get']['res'][200]> {
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/map/init-data'
+});
+    }
+    
+    /**
+ * Get Base Style
+ * @returns BaseStyle Successful Response
+ * @throws ApiError
+ */
+    public getBaseStyleApiMapBaseStyleNameGet(data: $OpenApiTs['/api/map/base_style/{name}']['get']['req']): Observable<$OpenApiTs['/api/map/base_style/{name}']['get']['res'][200]> {
+        const { name } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/map/base_style/{name}',
+    path: {
+        name
+    },
+    errors: {
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Get Layer Style
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public getLayerStyleApiMapLayerStyleStoreGet(data: $OpenApiTs['/api/map/layer_style/{store}']['get']['req']): Observable<$OpenApiTs['/api/map/layer_style/{store}']['get']['res'][200]> {
+        const { store } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/map/layer_style/{store}',
+    path: {
+        store
+    },
+    errors: {
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DownloadService {
+    constructor(public readonly http: HttpClient) {
+    }
+    
+    /**
+ * Download Csv
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public downloadCsvApiDownloadCsvStoreModelIdValueResampleGet(data: $OpenApiTs['/api/download/csv/{store}/{model_id}/{value}/{resample}']['get']['req']): Observable<$OpenApiTs['/api/download/csv/{store}/{model_id}/{value}/{resample}']['get']['res'][200]> {
+        const { store, modelId, value, resample } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/download/csv/{store}/{model_id}/{value}/{resample}',
+    path: {
+        store,
+        model_id: modelId,
+        value,
+        resample
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+    /**
+ * Execute Action
+ * Download the result of an action
+ * @returns unknown Successful Response
+ * @throws ApiError
+ */
+    public executeActionApiDownloadPluginNameStoreIdGet(data: $OpenApiTs['/api/download/plugin/{name}/{store}/{id}']['get']['req']): Observable<$OpenApiTs['/api/download/plugin/{name}/{store}/{id}']['get']['res'][200]> {
+        const { name, store, id } = data;
+        return __request(OpenAPI, this.http, {
+    method: 'GET',
+    url: '/api/download/plugin/{name}/{store}/{id}',
+    path: {
+        name,
+        store,
+        id
+    },
+    errors: {
+        404: 'Not found',
+        422: 'Validation Error'
+    }
+});
+    }
+    
+}