arbetsformedlingen/mina-sidor-fa-web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(avrop): Added additional functionality to avrop-flow. (TV-411)

Browse Source 
Squashed commit of the following:

commit b174dd7480baa5e5e4b7f4bea4c9fc674d344c0c
Merge: e1f9d2d 0661d22
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 26 11:50:11 2021 +0200

    Merged develop and resolved conflicts

commit e1f9d2d49e279e704b760a3cbe45941cdcfb81d9
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 26 11:41:45 2021 +0200

    Now fetching handledare and patching through API

commit cc017fdc6eb5d9620399eee011341a0307fe5658
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 25 16:02:20 2021 +0200

    Updated some functionality

commit 345712842c12af08dd4a956d0d2fdfd2592ab3de
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 25 15:32:22 2021 +0200

    Implmented pagination and select all

commit 95f9be3fae6d3f3b258897be9b78f49442ee0747
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 25 13:03:41 2021 +0200

    Renamed avrop-table instances to avrop-list and avrop-table-row to avrop-row

commit 5f1e11bff74c942e2c8b9e62892f043dc299f612
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 25 12:54:56 2021 +0200

    Added some changes to mock-api related to parameter changes inside avrop

commit 71b199744a31b2a4b8bcaa6870094fd900851030
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 25 12:23:57 2021 +0200

    added qp to avrop requests

commit dc0e34b4971ddfd3d683d482502439b961df8852
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 16:02:31 2021 +0200

    Renamed multiple variablenames inside avrop-api

commit 8a4d5471cf637db7d90c6659c893f6841ec9c961
Merge: be9e9b3 50a83f7
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 13:57:50 2021 +0200

    Merged develop and fixed conflicts

commit be9e9b323aee76493b5035cd79f6058781ae4c1a
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 13:27:16 2021 +0200

    Moved around elements inside avrop component

commit 7ede2d00cd7ed105ef12be88e2ab788841329f00
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 09:34:57 2021 +0200

    Moved around some components and other files to match project-structure

commit 7d1396216de643388a5690f2fa2733f127623b6c
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 09:04:28 2021 +0200

    Fixed issues with utforande verksamheter model and mock-data

commit 22baca18c25bd4ce8dcc713e91126214882cf017
Merge: 4ba3c1c 59ce393
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 08:56:02 2021 +0200

    Merged develop and fixed conflicts

commit 4ba3c1ce9dac206602de9651a98aecfd5857a0e5
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 08:48:21 2021 +0200

    Fixed issues with tjanst model and mock-data

commit 50d8c698778fa64cedd4249f6852715d038b450c
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Tue Aug 24 08:40:25 2021 +0200

    Fixed issues with kommun-model and mock-data
This commit is contained in:
Erik Tiekstra
2021-08-26 13:46:17 +02:00
parent 0661d2209b
commit 1f26e80cb3
68 changed files with 2331 additions and 1992 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
apps/mina-sidor-fa/src/app/shared/services/api/avrop-api.service.ts
View File

@@ -2,92 +2,98 @@ import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { environment } from '@msfa-environment';
import { AvropTjanstResponse } from '@msfa-models/api/avrop-tjanst.response.model';
import { AvropResponse } from '@msfa-models/api/avrop.response.model';
import { AvropApiResponse } from '@msfa-models/api/avrop.response.model';
import { HandledareResponse } from '@msfa-models/api/handledare.response.model';
import { KommunResponse } from '@msfa-models/api/kommun.response.model';
import { Params } from '@msfa-models/api/params.model';
import { UtforandeVerksamhetResponse } from '@msfa-models/api/utforande-verksamhet.response.model';
import { mapResponseToAvropTjanst } from '@msfa-models/avrop-tjanst.model';
import { Avrop, mapAvropResponseToAvrop } from '@msfa-models/avrop.model';
import { mapKommunResponseToKommun } from '@msfa-models/kommun.model';
import { MultiselectFilterOption } from '@msfa-models/multiselect-filter-option';
import { mapUtforandeVerksamhetResponseToUtforandeVerksamhet } from '@msfa-models/utforande-verksamhet.model';
import { Observable, of } from 'rxjs';
import { delay, filter, map } from 'rxjs/operators';
import { HandledareAvrop } from '../../../pages/avrop/models/handledare-avrop';
const tempHandledareMock: HandledareAvrop[] = [
{ id: '1', fullName: 'Göran Persson' },
{ id: '2', fullName: 'Stefan Löfven' },
];
const tempMockDelay = 300;
import { AvropTjanst, mapResponseToAvropTjanst } from '@msfa-models/avrop-tjanst.model';
import { AvropCompact, AvropCompactData, mapAvropResponseToAvrop } from '@msfa-models/avrop.model';
import { Handledare, mapHandledareResponseToHandledare } from '@msfa-models/handledare.model';
import { Kommun, mapKommunResponseToKommun } from '@msfa-models/kommun.model';
import {
mapUtforandeVerksamhetResponseToUtforandeVerksamhet,
UtforandeVerksamhet,
} from '@msfa-models/utforande-verksamhet.model';
import { BehaviorSubject, Observable, of } from 'rxjs';
import { filter, map, tap } from 'rxjs/operators';
@Injectable({
providedIn: 'root',
})
export class AvropApiService {
private _apiBaseUrl = `${environment.api.url}/avrop`;
private _lockedAvropSnapshot$ = new BehaviorSubject<AvropCompact[]>(null);
private _availableHandledareSnapshot$ = new BehaviorSubject<Handledare[]>(null);
constructor(private httpClient: HttpClient) {}
getNyaAvrop$(
tjanstIds: MultiselectFilterOption[],
kommunIds: MultiselectFilterOption[],
utforandeVerksamhetIds: MultiselectFilterOption[],
offset = 0,
limit = 20
): Observable<Avrop[]> {
return this.httpClient.get<{ data: AvropResponse[] }>(`${this._apiBaseUrl}`).pipe(
filter(response => !!response?.data),
map(({ data }) => data.map(avrop => mapAvropResponseToAvrop(avrop)))
);
get lockedAvropValue(): AvropCompact[] {
return this._lockedAvropSnapshot$.getValue();
}
getSelectableHandledare$(deltagare: Avrop[]): Observable<HandledareAvrop[]> {
// TODO replace with API-call
console.log('[API call] getSelectableHandledare$. Inputs: deltagare', deltagare);
return of(tempHandledareMock).pipe(delay(tempMockDelay));
}
getSelectableTjanster$(
selectedKommuner: MultiselectFilterOption[],
selectedUtforandeVerksamheter: MultiselectFilterOption[]
): Observable<MultiselectFilterOption[]> {
return this.httpClient.get<{ data: AvropTjanstResponse[] }>(`${this._apiBaseUrl}/tjanster`).pipe(
filter(response => !!response?.data),
map(({ data }) => data.map(tjanster => ({ label: mapResponseToAvropTjanst(tjanster).name })))
);
}
getSelectableUtforandeVerksamheter$(
selectedTjanster: MultiselectFilterOption[],
selectedKommuner: MultiselectFilterOption[]
): Observable<MultiselectFilterOption[]> {
fetchAvrop$(params: Params): Observable<AvropCompactData> {
return this.httpClient
.get<{ data: UtforandeVerksamhetResponse[] }>(`${this._apiBaseUrl}/utforandeverksamheter`)
.get<AvropApiResponse>(`${this._apiBaseUrl}`, { params })
.pipe(map(({ data, meta }) => ({ data: data.map(avrop => mapAvropResponseToAvrop(avrop)), meta })));
}
fetchAvailableHandledare$(avrop: AvropCompact[]): Observable<Handledare[]> {
const lockedAvropIsEqual = this.lockedAvropValue?.every(
(lockedAvrop, index) => lockedAvrop.id === avrop[index]?.id
);
// Checking to see if we really need to make a new api-request
if (lockedAvropIsEqual) {
return of(this._availableHandledareSnapshot$.getValue());
}
this._lockedAvropSnapshot$.next(avrop);
return this.httpClient.get<{ data: HandledareResponse[] }>(`${this._apiBaseUrl}/handledare`).pipe(
map(({ data }) => data.map(handledare => mapHandledareResponseToHandledare(handledare))),
tap(handledare => {
this._availableHandledareSnapshot$.next(handledare);
})
);
}
fetchAvailableTjanster$(params: Params): Observable<AvropTjanst[]> {
return this.httpClient
.get<{ data: AvropTjanstResponse[] }>(`${this._apiBaseUrl}/tjanster`, { params })
.pipe(
filter(response => !!response?.data),
map(({ data }) => data.map(tjanster => mapResponseToAvropTjanst(tjanster)))
);
}
fetchAvailableUtforandeVerksamheter$(params: Params): Observable<UtforandeVerksamhet[]> {
return this.httpClient
.get<{ data: UtforandeVerksamhetResponse[] }>(`${this._apiBaseUrl}/utforandeverksamheter`, { params })
.pipe(
filter(response => !!response?.data),
map(({ data }) =>
data.map(utforandeverksamheter => ({
label: mapUtforandeVerksamhetResponseToUtforandeVerksamhet(utforandeverksamheter).name,
}))
data.map(utforandeverksamheter => mapUtforandeVerksamhetResponseToUtforandeVerksamhet(utforandeverksamheter))
)
);
}
getSelectableKommuner$(
selectedTjanster: MultiselectFilterOption[],
selectedUtforandeVerksamheter: MultiselectFilterOption[]
): Observable<MultiselectFilterOption[]> {
return this.httpClient.get<{ data: KommunResponse[] }>(`${this._apiBaseUrl}/kommuner`).pipe(
filter(response => !!response?.data),
map(({ data }) => data.map(kommun => ({ label: mapKommunResponseToKommun(kommun).name })))
);
fetchAvailableKommuner$(params: Params): Observable<Kommun[]> {
return this.httpClient
.get<{ data: KommunResponse[] }>(`${this._apiBaseUrl}/kommuner`, { params })
.pipe(
filter(response => !!response?.data),
map(({ data }) => data.map(kommun => mapKommunResponseToKommun(kommun)))
);
}
async tilldelaHandledare(deltagare: Avrop[], handledare: HandledareAvrop): Promise<void> {
console.log('[API call] SAVE avrop. Inputs: deltagare, handledare', deltagare, handledare);
await of(null).pipe(delay(200)).toPromise();
// TODO anropa API
return;
async assignHandledare(avrop: AvropCompact[], handledareId: string): Promise<void> {
const params: Params = {
avropIds: avrop.map(deltagare => deltagare.id),
ciamUserId: handledareId,
};
return this.httpClient
.patch<void>(`${this._apiBaseUrl}/handledare/assign`, null, { params })
.toPromise();
}
}

4
apps/mina-sidor-fa/src/app/shared/services/api/deltagare.service.ts
View File

@@ -10,6 +10,7 @@ import { DisabilityResponse } from '@msfa-models/api/disability.response.model';
import { DriversLicenseResponse } from '@msfa-models/api/drivers-license.response.model';
import { EducationsResponse } from '@msfa-models/api/educations.response.model';
import { HighestEducationResponse } from '@msfa-models/api/highest-education.response.model';
import { Params } from '@msfa-models/api/params.model';
import { TranslatorResponse } from '@msfa-models/api/translator.response.model';
import { WorkExperiencesResponse } from '@msfa-models/api/work-experiences.response.model';
import { WorkLanguagesResponse } from '@msfa-models/api/work-languages.response.model';
@@ -84,14 +85,13 @@ export class DeltagareService extends UnsubscribeDirective {
page: number,
sort: Sort<keyof DeltagareCompact>
): Observable<DeltagareCompactData> {
const params: { [param: string]: string | string[] } = {
const params: Params = {
sort: sort.key as string,
order: sort.order as string,
limit: limit.toString(),
page: page.toString(),
};
console.log(params);
return this.httpClient
.get<DeltagareCompactApiResponse>(this._apiBaseUrl, {
params,

14
apps/mina-sidor-fa/src/app/shared/services/api/employee.service.ts
View File

@@ -8,12 +8,16 @@ import { DeleteEmployeeMockApiResponse } from '@msfa-models/api/delete-employee.
import {
EmployeeCompactResponse,
EmployeeResponse,
EmployeesApiResponse
EmployeesApiResponse,
} from '@msfa-models/api/employee.response.model';
import { Params } from '@msfa-models/api/params.model';
import {
Employee, EmployeeInviteRequestData, EmployeesData, mapEmployeeToRequestData,
Employee,
EmployeeInviteRequestData,
EmployeesData,
mapEmployeeToRequestData,
mapResponseToEmployee,
mapResponseToEmployeeCompact
mapResponseToEmployeeCompact,
} from '@msfa-models/employee.model';
import { errorToCustomError } from '@msfa-models/error/custom-error';
import { Sort } from '@msfa-models/sort.model';
@@ -97,7 +101,7 @@ export class EmployeeService extends UnsubscribeDirective {
searchFilter: string,
onlyEmployeesWithoutAuthorization?: boolean
): Observable<EmployeesData> {
const params: { [param: string]: string | string[] } = {
const params: Params = {
sort: sort.key as string,
order: sort.order as string,
limit: limit.toString(),
@@ -175,7 +179,7 @@ export class EmployeeService extends UnsubscribeDirective {
public postEmployeeInvitation(email: string): Observable<string[]> {
return this.httpClient
.post<{ data: EmployeeInviteRequestData }>(`${this._apiBaseUrl}/invite`, {
emails: Object.values(email)
emails: Object.values(email),
})
.pipe(
take(1),

245
apps/mina-sidor-fa/src/app/shared/services/avrop.service.ts Normal file
View File

@@ -0,0 +1,245 @@
import { Injectable } from '@angular/core';
import { Params } from '@msfa-models/api/params.model';
import { Avrop, AvropCompactData } from '@msfa-models/avrop.model';
import { Handledare } from '@msfa-models/handledare.model';
import { MultiselectFilterOption } from '@msfa-models/multiselect-filter-option';
import { AvropApiService } from '@msfa-services/api/avrop-api.service';
import { BehaviorSubject, combineLatest, Observable } from 'rxjs';
import { filter, map, switchMap } from 'rxjs/operators';
type Step = 1 | 2 | 3 | 4;
@Injectable({
providedIn: 'root',
})
export class AvropService {
private _limit$ = new BehaviorSubject<number>(5);
private _page$ = new BehaviorSubject<number>(1);
private _filteredTjanster$ = new BehaviorSubject<MultiselectFilterOption[]>(null);
private _filteredUtforandeVerksamheter$ = new BehaviorSubject<MultiselectFilterOption[]>(null);
private _filteredKommuner$ = new BehaviorSubject<MultiselectFilterOption[]>(null);
private _selectedAvrop$ = new BehaviorSubject<Avrop[]>([]);
private _avropIsLocked$ = new BehaviorSubject<boolean>(null);
private _selectedHandledareId$ = new BehaviorSubject<string>(null);
private _handledareIsConfirmed$ = new BehaviorSubject<boolean>(false);
private _avropIsSubmitted$ = new BehaviorSubject<boolean>(false);
private _error$ = new BehaviorSubject<string>(null);
public filteredTjanster$: Observable<MultiselectFilterOption[]> = this._filteredTjanster$.asObservable();
public filteredUtforandeVerksamheter$: Observable<
MultiselectFilterOption[]
> = this._filteredUtforandeVerksamheter$.asObservable();
public filteredKommuner$: Observable<MultiselectFilterOption[]> = this._filteredKommuner$.asObservable();
public selectedAvrop$: Observable<Avrop[]> = this._selectedAvrop$.asObservable();
public avropIsLocked$: Observable<boolean> = this._avropIsLocked$.asObservable();
public selectedHandledare$: Observable<Handledare> = this._selectedHandledareId$.pipe(
filter(selectedHandledare => !!selectedHandledare),
switchMap(handledareId =>
this.availableHandledare$.pipe(
map(availableHandledare => availableHandledare.find(handledare => handledare.ciamUserId === handledareId))
)
)
);
public handledareIsConfirmed$: Observable<boolean> = this._handledareIsConfirmed$.asObservable();
public avropIsSubmitted$: Observable<boolean> = this._avropIsSubmitted$.asObservable();
public error$: Observable<string> = this._error$.asObservable();
public avropData$: Observable<AvropCompactData> = combineLatest([
this._filteredTjanster$,
this._filteredUtforandeVerksamheter$,
this._filteredKommuner$,
this._page$,
this._limit$,
]).pipe(switchMap(() => this.avropApiService.fetchAvrop$(this._getParams('avrop'))));
public availableTjanster$: Observable<MultiselectFilterOption[]> = combineLatest([
this._filteredUtforandeVerksamheter$,
this._filteredKommuner$,
]).pipe(switchMap(() => this.avropApiService.fetchAvailableTjanster$(this._getParams('tjanster'))));
public availableUtforandeVerksamheter$: Observable<MultiselectFilterOption[]> = combineLatest([
this._filteredTjanster$,
this._filteredKommuner$,
]).pipe(
switchMap(() => this.avropApiService.fetchAvailableUtforandeVerksamheter$(this._getParams('utforandeVerksamheter')))
);
public availableKommuner$: Observable<MultiselectFilterOption[]> = combineLatest([
this._filteredTjanster$,
this._filteredUtforandeVerksamheter$,
]).pipe(switchMap(() => this.avropApiService.fetchAvailableKommuner$(this._getParams('kommuner'))));
private _lockedAvrop$: Observable<Avrop[]> = combineLatest([this.selectedAvrop$, this.avropIsLocked$]).pipe(
map(([selectedAvrop, isLocked]) => (isLocked ? selectedAvrop : null))
);
public availableHandledare$: Observable<Handledare[]> = this._lockedAvrop$.pipe(
filter(lockedAvrop => !!lockedAvrop),
switchMap(lockedAvrop => this.avropApiService.fetchAvailableHandledare$(lockedAvrop))
);
public currentStep$: Observable<Step> = combineLatest([
this._handledareIsConfirmed$,
this._avropIsLocked$,
this._avropIsSubmitted$,
]).pipe(
map(([confirmedHandledare, avropIsLocked, avropIsSubmitted]) => {
return AvropService.calculateStep(confirmedHandledare, avropIsLocked, avropIsSubmitted);
})
);
private static calculateStep(confirmedHandledare: boolean, avropIsLocked: boolean, avropIsSubmitted: boolean): Step {
if (avropIsLocked) {
if (confirmedHandledare) {
if (avropIsSubmitted) {
return 4;
}
return 3;
}
return 2;
}
return 1;
}
private _getParams(type: 'avrop' | 'kommuner' | 'tjanster' | 'utforandeVerksamheter'): Params {
const tjanstKod = this._filteredTjanster$.getValue()?.length
? { tjanstKod: this._filteredTjanster$.getValue().map(tjanst => tjanst.id) }
: null;
const kommunKod = this._filteredKommuner$.getValue()?.length
? { kommunKod: this._filteredKommuner$.getValue().map(kommun => kommun.id) }
: null;
const utforandeverksamhetId = this._filteredUtforandeVerksamheter$.getValue()?.length
? {
utforandeverksamhetId: this._filteredUtforandeVerksamheter$
.getValue()
.map(utforandeVerksamhet => utforandeVerksamhet.id),
}
: null;
switch (type) {
case 'avrop':
return {
...tjanstKod,
...kommunKod,
...utforandeverksamhetId,
page: this._page$.getValue().toString(),
limit: this._limit$.getValue().toString(),
};
case 'kommuner':
return {
...tjanstKod,
...utforandeverksamhetId,
};
case 'tjanster':
return {
...kommunKod,
...utforandeverksamhetId,
};
case 'utforandeVerksamheter':
return {
...tjanstKod,
...kommunKod,
};
default:
return {};
}
}
public setSelectedAvrop(deltagare: Avrop[]): void {
this._selectedAvrop$.next(deltagare);
}
constructor(private avropApiService: AvropApiService) {}
public resetError(): void {
this._error$.next(null);
}
public lockSelectedAvrop(): void {
this.resetError();
if ((this._selectedAvrop$?.value?.length ?? -1) <= 0) {
this._error$.next('För att låsa deltagare behöver några ha markerats först.');
return;
}
this._avropIsLocked$.next(true);
}
public unlockSelectedAvrop(): void {
this.resetError();
this._avropIsLocked$.next(false);
}
public confirmHandledare(): void {
this.resetError();
if (!this._selectedHandledareId$?.value) {
this._error$.next('För att kunna tilldela behövs en handledare väljas först.');
return;
}
this._handledareIsConfirmed$.next(true);
}
public unconfirmHandledare(): void {
this.resetError();
this._handledareIsConfirmed$.next(false);
}
public async save(): Promise<void> {
this.resetError();
if (!this._handledareIsConfirmed$) {
this._error$.next('Handledaren måste bekräftas innan avropet kan sparas');
return;
}
if (!this._avropIsLocked$) {
this._error$.next('Deltagarlistan måste låsas innan avropet kan sparas');
return;
}
await this.avropApiService.assignHandledare(this._selectedAvrop$.value, this._selectedHandledareId$.value);
this._avropIsSubmitted$.next(true);
}
public assignHandledare(handledareId: string): void {
this._selectedHandledareId$.next(handledareId);
}
public setSelectedTjanster(selectedFilterOptions: MultiselectFilterOption[]): void {
this._filteredTjanster$.next(selectedFilterOptions);
}
public setSelectedUtforandeVerksamheter(selectedFilterOptions: MultiselectFilterOption[]): void {
this._filteredUtforandeVerksamheter$.next(selectedFilterOptions);
}
public setSelectedKommuner(selectedFilterOptions: MultiselectFilterOption[]): void {
this._filteredKommuner$.next(selectedFilterOptions);
}
public goToStep1(): void {
this._selectedHandledareId$.next(null);
this._selectedAvrop$.next([]);
this._avropIsLocked$.next(false);
this._handledareIsConfirmed$.next(false);
}
public removeKommun(kommunToRemove: MultiselectFilterOption): void {
this.setSelectedKommuner(this._filteredKommuner$.value.filter(selectedKommun => selectedKommun !== kommunToRemove));
}
public removeUtforandeVerksamhet(utforandeVerksamhetToRemove: MultiselectFilterOption): void {
this.setSelectedUtforandeVerksamheter(
this._filteredUtforandeVerksamheter$.value.filter(
selectedUtforandeVerksamhet => selectedUtforandeVerksamhet !== utforandeVerksamhetToRemove
)
);
}
public removeTjanst(tjanstToRemove: MultiselectFilterOption): void {
this.setSelectedTjanster(this._filteredTjanster$.value.filter(selectedTjanst => selectedTjanst !== tjanstToRemove));
}
public setPage(page: number): void {
this._page$.next(page);
}
}