feat(avrop): Created mock-api and models for avrop. (TV-288)

Squashed commit of the following:

commit 36959e892dea1213659ba26ceba797b81e1c7769
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Fri Aug 6 14:28:04 2021 +0200

    Added relationships to the mock-api data

commit e2b86b43908952cd4c46af7f58885c6e34b7eb2e
Merge: ece070a 229fb83
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Fri Aug 6 10:08:37 2021 +0200

    Merge branch 'develop' into feature/TV-288-avrop-mock-and-models

commit ece070ac9f04a3aa1984611371586b32c9d5a222
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Fri Aug 6 09:25:59 2021 +0200

    Removed duplicates from avrop mock-data

commit 005acd29f452316f1337132cf4721e4b3a409097
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 5 14:53:03 2021 +0200

    Added more mock-data

commit 23ce076912c5b9e7dfa9615d28654d8d09622775
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 5 12:04:37 2021 +0200

    Added example api-call to avrop-api service

commit 01629a1e1089e38914825408991276b5e847a709
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 5 11:43:48 2021 +0200

    Added mappings

commit b489c2edb99e07929b84309f784eb097d43f31cd
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Thu Aug 5 11:22:49 2021 +0200

    Added avrop models and mock-data

commit fe3d61962115e8e5b8bac3bade1609c2ef6a9bac
Author: Erik Tiekstra <erik.tiekstra@arbetsformedlingen.se>
Date:   Wed Aug 4 15:16:33 2021 +0200

    WIP

apps/dafa-web/src/app/shared/models/api/avrop.response.model.ts

@@ -0,0 +1,30 @@
+export interface AvropResponse {
+  id: string;
+  deltagare: string;
+  genomforandeReferens: number;
+  orgId: string;
+  leverantorId: number;
+  organisationsnummer: string;
+  utforandeVerksamhetId: number;
+  utforandeverksamhet: string;
+  kommunKod: string;
+  kommun: string;
+  utforandeAdressId: number;
+  adress: string;
+  ordernummer: string;
+  bokningsId: number;
+  personnummer: string;
+  sokandeId: number;
+  tjanstekod: string;
+  tjansteNamn: string;
+  deltagandeGrad: number;
+  startdatumAvrop: string;
+  slutdatumAvrop: string;
+  aktnummerDiariet: string;
+  tolkbehov: string;
+  sprakstod: string;
+  sparkod: string;
+  sparNamn: string;
+  supervisorId: number;
+  recievedTimestamp: string;
+}

apps/dafa-web/src/app/shared/models/api/kommun.response.model.ts

@@ -0,0 +1,4 @@
+export interface KommunResponse {
+  id: number;
+  name: string;
+}

apps/dafa-web/src/app/shared/models/api/tjanst.response.model.ts

@@ -0,0 +1,4 @@
+export interface TjanstResponse {
+  code: string;
+  name: string;
+}

apps/dafa-web/src/app/shared/models/api/utforande-verksamhet.response.model.ts

@@ -0,0 +1,4 @@
+export interface UtforandeVerksamhetResponse {
+  id: number;
+  name: string;
+}

apps/dafa-web/src/app/shared/models/avrop.model.ts

@@ -0,0 +1,54 @@
+import { AvropResponse } from './api/avrop.response.model';
+
+export interface AvropCompact {
+  id: string; // id
+  sokandeId: number; // sokandeId
+  name: string; // deltagare
+  tjanst: string; // tjansteNamn
+  startDate: Date; // startdatumAvrop
+  endDate: Date; // slutdatumAvrop
+  translator: string; // tolkbehov
+  languageSupport: string; // sprakstod
+  utforandeAdress: string; // adress
+  trackCode: string; // sparkod
+}
+
+export interface Avrop extends AvropCompact {
+  genomforandeReferens: number; // genomforandeReferens
+  participationFrequency: number; // deltagandeGrad
+  utforandeVerksamhet: string; // utforandeverksamhet
+}
+
+export function mapAvropResponseToAvrop(data: AvropResponse): Avrop {
+  const {
+    id,
+    sokandeId,
+    deltagare,
+    tjansteNamn,
+    startdatumAvrop,
+    slutdatumAvrop,
+    tolkbehov,
+    sprakstod,
+    adress,
+    sparkod,
+    genomforandeReferens,
+    deltagandeGrad,
+    utforandeverksamhet,
+  } = data;
+
+  return {
+    id,
+    sokandeId,
+    name: deltagare,
+    tjanst: tjansteNamn,
+    startDate: new Date(startdatumAvrop),
+    endDate: new Date(slutdatumAvrop),
+    translator: tolkbehov,
+    languageSupport: sprakstod,
+    utforandeAdress: adress,
+    trackCode: sparkod,
+    genomforandeReferens,
+    participationFrequency: deltagandeGrad,
+    utforandeVerksamhet: utforandeverksamhet,
+  };
+}

apps/dafa-web/src/app/shared/models/kommun.model.ts

@@ -0,0 +1,15 @@
+import { KommunResponse } from './api/kommun.response.model';
+
+export interface Kommun {
+  id: number;
+  name: string;
+}
+
+export function mapKommunResponseToKommun(data: KommunResponse): Kommun {
+  const { id, name } = data;
+
+  return {
+    id,
+    name,
+  };
+}

apps/dafa-web/src/app/shared/models/tjanst.model.ts

@@ -0,0 +1,15 @@
+import { TjanstResponse } from './api/tjanst.response.model';
+
+export interface Tjanst {
+  code: string;
+  name: string;
+}
+
+export function mapTjanstResponseToTjanst(data: TjanstResponse): Tjanst {
+  const { code, name } = data;
+
+  return {
+    code,
+    name,
+  };
+}

apps/dafa-web/src/app/shared/models/utforande-verksamhet.model.ts

@@ -0,0 +1,17 @@
+import { UtforandeVerksamhetResponse } from './api/utforande-verksamhet.response.model';
+
+export interface UtforandeVerksamhet {
+  id: number;
+  name: string;
+}
+
+export function mapUtforandeVerksamhetResponseToUtforandeVerksamhet(
+  data: UtforandeVerksamhetResponse
+): UtforandeVerksamhet {
+  const { id, name } = data;
+
+  return {
+    id,
+    name,
+  };
+}

apps/dafa-web/src/app/shared/services/api/avrop-api.service.ts

@@ -1,9 +1,13 @@
+import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import { Observable, of } from 'rxjs';
+import { environment } from '@dafa-environment';
-import { delay } from 'rxjs/operators';
+import { AvropResponse } from '@dafa-models/api/avrop.response.model';
+import { Avrop, mapAvropResponseToAvrop } from '@dafa-models/avrop.model';
 import { MultiselectFilterOption } from '@dafa-models/multiselect-filter-option';
-import { HandledareAvrop } from '../../../pages/avrop/models/handledare-avrop';
+import { Observable, of } from 'rxjs';
+import { delay, map } from 'rxjs/operators';
 import { DeltagareAvrop } from '../../../pages/avrop/models/deltagare-avrop';
+import { HandledareAvrop } from '../../../pages/avrop/models/handledare-avrop';
 
 const tempHandledareMock: HandledareAvrop[] = [
   { id: '1', fullName: 'Göran Persson' },
@@ -28,10 +32,24 @@ const tempTjansterMock: MultiselectFilterOption[] = [
 
 const tempMockDelay = 300;
 
+const API_HEADERS = { headers: environment.api.headers };
+
 @Injectable({
   providedIn: 'root',
 })
 export class AvropApiService {
+  private _apiBaseUrl = `${environment.api.url}/avrop`;
+
+  private _fetchAllAvrop$: Observable<AvropResponse[]> = this.httpClient.get<AvropResponse[]>(`${this._apiBaseUrl}`, {
+    ...API_HEADERS,
+  });
+
+  constructor(private httpClient: HttpClient) {}
+
+  public allAvrop$: Observable<Avrop[]> = this._fetchAllAvrop$.pipe(
+    map(response => response.map(data => mapAvropResponseToAvrop(data)))
+  );
+
   getNyaDeltagare$(
     tjanstIds: MultiselectFilterOption[],
     kommunIds: MultiselectFilterOption[],

mock-api/dafa-web/scripts/avrop.js

@@ -1,43 +1,64 @@
 import faker from 'faker';
-import services from './services.js';
+import kommuner from './kommuner.js';
 import languages from './languages.js';
 import organizations from './organizations.js';
-import kommuner from './kommuner.js';
+import tjanster from './tjanster.js';
 
 faker.locale = 'sv';
 
-const SERVICES = services.generate();
+const TJANSTER = tjanster.generate();
 const SUPORTLANGUAGES = languages.generate();
-const TRACK = ['a', 'b', 'c'];
+const TRACK = ['A', 'B', 'C'];
 const ORGANIZATIONS = organizations.generate();
 const KOMMUNER = kommuner.generate();
+const FREKVENSER = ['25%', '50%', '75%', '100%'];
 
-function generateIncomingAvrop(amount = 10) {
+function generateAvrop(amount = 10, deltagare) {
-  const avropList = [];
+  const avrop = [];
-  const language = SUPORTLANGUAGES[Math.floor(Math.random() * SUPORTLANGUAGES.length)];
 
   for (let i = 1; i <= amount; ++i) {
-    const avrop = {
+    const organization = ORGANIZATIONS[Math.floor(Math.random() * ORGANIZATIONS.length)];
+    const kommun = KOMMUNER[Math.floor(Math.random() * KOMMUNER.length)];
+    const tjanst = TJANSTER[Math.floor(Math.random() * TJANSTER.length)];
+    const track = TRACK[Math.floor(Math.random() * TRACK.length)];
+    const currentDeltagare = deltagare[i - 1];
+
+    avrop.push({
       id: faker.datatype.uuid(),
-      firstName: faker.name.firstName(),
+      deltagare: currentDeltagare.fullName,
-      lastName: faker.name.lastName(),
+      genomforandeReferens: faker.datatype.number({ min: 100000000, max: 999999999 }),
-      service: SERVICES[Math.floor(Math.random() * SERVICES.length)].name,
+      orgId: faker.datatype.uuid(),
-      track: TRACK[Math.floor(Math.random() * TRACK.length)],
+      leverantorId: faker.datatype.number({ min: 1000, max: 99999 }),
-      errandNumber: faker.datatype.number({ min: 100000, max: 999999 }),
+      organisationsnummer: organization.organizationNumber,
-      startDate: faker.date.recent(),
+      utforandeVerksamhetId: organization.id,
-      endDate: faker.date.future(),
+      utforandeverksamhet: organization.name,
-      supportLanguage: language.name,
+      kommunKod: kommun.kommunCode,
-      interpreter: language.name,
+      kommun: kommun.kommun,
-      organization: ORGANIZATIONS[Math.floor(Math.random() * ORGANIZATIONS.length)],
+      utforandeAdressId: faker.datatype.number({ min: 10000, max: 99999 }),
-      kommun: KOMMUNER[Math.floor(Math.random() * KOMMUNER.length)].kommun,
+      adress: `${organization.address.street} ${organization.address.houseNumber}`,
-    };
+      ordernummer: `AKTTEST-${faker.datatype.number({ min: 10000, max: 99999 })}`,
-    avropList.push({ ...avrop, fullName: `${avrop.firstName} ${avrop.lastName}` });
+      bokningsId: faker.datatype.number({ min: 100000, max: 999999 }),
+      personnummer: currentDeltagare.personnummer,
+      sokandeId: currentDeltagare.id,
+      tjanstekod: tjanst.code,
+      tjansteNamn: tjanst.name,
+      deltagandeGrad: FREKVENSER[Math.floor(Math.random() * FREKVENSER.length)],
+      startdatumAvrop: faker.date.recent(),
+      slutdatumAvrop: faker.date.future(),
+      aktnummerDiariet: `Af-2021/0000 ${faker.datatype.number({ min: 1000, max: 9999 })}`,
+      tolkbehov: SUPORTLANGUAGES[Math.floor(Math.random() * SUPORTLANGUAGES.length)],
+      sprakstod: SUPORTLANGUAGES[Math.floor(Math.random() * SUPORTLANGUAGES.length)],
+      sparkod: track,
+      sparNamn: `Nivå ${track}: ${tjanst.name}`,
+      supervisorId: Math.random() > 0.3 && faker.datatype.uuid(),
+      recievedTimestamp: faker.date.recent(),
+    });
   }
 
-  console.info('Incoming avrop generated...');
+  console.info('Avrop generated...');
-  return avropList;
+  return avrop;
 }
 
 export default {
-  generate: generateIncomingAvrop,
+  generate: generateAvrop,
 };

mock-api/dafa-web/scripts/employees.js

@@ -1,11 +1,11 @@
 import faker from 'faker';
 import authorizations from './authorizations.js';
 import organizations from './organizations.js';
-import services from './services.js';
+import tjanster from './tjanster.js';
 
 faker.locale = 'sv';
 
-const SERVICES = services.generate();
+const TJANSTER = tjanster.generate();
 const ORGANIZATIONS = organizations.generate();
 
 function generateEmployees(amount = 10) {
@@ -23,7 +23,7 @@ function generateEmployees(amount = 10) {
         }
       )}`,
       organizations: [ORGANIZATIONS[Math.floor(Math.random() * ORGANIZATIONS.length)]],
-      services: [SERVICES[Math.floor(Math.random() * SERVICES.length)]],
+      services: [TJANSTER[Math.floor(Math.random() * TJANSTER.length)]],
       authorizations: authorizations.generate(),
       createdAt: Date.now(),
     };

mock-api/dafa-web/scripts/generate-api.js

@@ -5,22 +5,76 @@ import avrop from './avrop.js';
 import currentUser from './current-user.js';
 import deltagare from './deltagare.js';
 import employees from './employees.js';
-import kommuner from './kommuner.js';
 import languages from './languages.js';
-import organizations from './organizations.js';
 import participants from './participants.js';
-import services from './services.js';
 
 const generatedEmployees = employees.generate(50);
+const generatedDeltagare = deltagare.generate(50);
+const generatedAvrop = avrop.generate(10, generatedDeltagare.slice(0, 10));
+const tjanster = [];
+const organizations = [];
+const kommuner = [];
+
+generatedAvrop.forEach(({ tjanstekod, tjansteNamn, utforandeVerksamhetId, utforandeverksamhet, kommunKod, kommun }) => {
+  const tjanstExists = tjanster.find(tjanst => tjanst.code === tjanstekod);
+  const organizationExists = organizations.find(organization => organization.id === utforandeVerksamhetId);
+  const kommunExists = kommuner.find(kommun => kommun.kommunCode === kommunKod);
+
+  if (tjanstExists) {
+    if (!tjanstExists.related_utforandeverksamhetIds.includes(utforandeVerksamhetId)) {
+      tjanstExists.related_utforandeverksamhetIds.push(utforandeVerksamhetId);
+    }
+    if (!tjanstExists.related_kommunCodes.includes(kommunKod)) {
+      tjanstExists.related_kommunCodes.push(kommunKod);
+    }
+  } else {
+    tjanster.push({
+      code: tjanstekod,
+      name: tjansteNamn,
+      related_utforandeverksamhetIds: [utforandeVerksamhetId],
+      related_kommunCodes: [kommunKod],
+    });
+  }
+  if (organizationExists) {
+    if (!organizationExists.related_tjanstIds.includes(tjanstekod)) {
+      organizationExists.related_tjanstIds.push(tjanstekod);
+    }
+    if (!organizationExists.related_kommunCodes.includes(kommunKod)) {
+      organizationExists.related_kommunCodes.push(kommunKod);
+    }
+  } else {
+    organizations.push({
+      id: utforandeVerksamhetId,
+      name: utforandeverksamhet,
+      related_tjanstIds: [tjanstekod],
+      related_kommunCodes: [kommunKod],
+    });
+  }
+  if (kommunExists) {
+    if (!kommunExists.related_tjanstIds.includes(tjanstekod)) {
+      kommunExists.related_tjanstIds.push(tjanstekod);
+    }
+    if (!kommunExists.related_utforandeverksamhetIds.includes(utforandeVerksamhetId)) {
+      kommunExists.related_utforandeverksamhetIds.push(utforandeVerksamhetId);
+    }
+  } else {
+    kommuner.push({
+      kommunCode: kommunKod,
+      kommun,
+      related_tjanstIds: [tjanstekod],
+      related_utforandeverksamhetIds: [utforandeVerksamhetId],
+    });
+  }
+});
 
 const apiData = {
-  services: services.generate(),
   languages: languages.generate(),
   employees: generatedEmployees,
-  kommuner: kommuner.generate(),
+  avrop: generatedAvrop,
-  organizations: organizations.generate(),
+  tjanster,
-  avrop: avrop.generate(3),
+  organizations,
-  deltagare: deltagare.generate(50),
+  kommuner,
+  deltagare: generatedDeltagare,
   participants: participants.generate(50).map(participant => ({
     ...participant,
     employeeId: generatedEmployees[Math.floor(Math.random() * generatedEmployees.length)].id,

mock-api/dafa-web/scripts/participants.js

@@ -1,9 +1,9 @@
 import faker from 'faker';
-import services from './services.js';
+import tjanster from './tjanster.js';
 
 faker.locale = 'sv';
 
-const SERVICES = services.generate();
+const TJANSTER = tjanster.generate();
 const STATUSES = ['active', 'follow-up'];
 const STEPS = ['Gemensam planering', 'Periodisk rapport', 'Resultatrapport', 'Slutrapport'];
 
@@ -16,7 +16,7 @@ function generateParticipants(amount = 10) {
       firstName: faker.name.firstName(),
       lastName: faker.name.lastName(),
       status: STATUSES[Math.floor(Math.random() * STATUSES.length)],
-      service: SERVICES[Math.floor(Math.random() * SERVICES.length)].name,
+      service: TJANSTER[Math.floor(Math.random() * TJANSTER.length)].name,
       nextStep: STEPS[Math.floor(Math.random() * STEPS.length)],
       errandNumber: faker.datatype.number({ min: 100000, max: 999999 }),
       startDate: faker.date.recent(),

mock-api/dafa-web/scripts/services.js

@@ -1,35 +0,0 @@
-import faker from 'faker';
-
-faker.locale = 'sv';
-
-function generateServices() {
-  const services = [
-    {
-      id: faker.datatype.uuid(),
-      name: 'KROM',
-    },
-    {
-      id: faker.datatype.uuid(),
-      name: 'KVL',
-    },
-    // {
-    //   id: faker.datatype.uuid(),
-    //   name: 'STOM',
-    // },
-    // {
-    //   id: faker.datatype.uuid(),
-    //   name: 'YSM',
-    // },
-    // {
-    //   id: faker.datatype.uuid(),
-    //   name: 'AUB',
-    // },
-  ];
-
-  console.info('Services generated...');
-  return services;
-}
-
-export default {
-  generate: generateServices,
-};

mock-api/dafa-web/scripts/tjanster.js

@@ -0,0 +1,35 @@
+import faker from 'faker';
+
+faker.locale = 'sv';
+
+function generateTjanster() {
+  const tjanster = [
+    {
+      code: faker.datatype.uuid(),
+      name: 'Kundval Rusta och matcha',
+    },
+    {
+      code: faker.datatype.uuid(),
+      name: 'Karriärvägledning',
+    },
+    // {
+    //   code: faker.datatype.uuid(),
+    //   name: 'STOM',
+    // },
+    // {
+    //   code: faker.datatype.uuid(),
+    //   name: 'YSM',
+    // },
+    // {
+    //   code: faker.datatype.uuid(),
+    //   name: 'AUB',
+    // },
+  ];
+
+  console.info('Tjanster generated...');
+  return tjanster;
+}
+
+export default {
+  generate: generateTjanster,
+};

mock-api/dafa-web/server.js

@@ -18,6 +18,9 @@ server.use(
     '/auth': '/currentUser',
     '/customerinfo/*/*': '/deltagare/$2',
     '/customerinfo': '/deltagare',
+    '/avrop/tjanster*': '/tjanster$1',
+    '/avrop/utforandeverksamheter*': '/organizations$1',
+    '/avrop/kommuner*': '/kommuner$1',
     '*page=*': '$1_page=$2',
     '*limit=*': '$1_limit=$2',
     '*sort=*': '$1_sort=$2',
@@ -33,7 +36,11 @@ router.render = (req, res) => {
     return res.status(401).jsonp({ error: 'No valid access-token' });
   }
 
-  const params = new URLSearchParams(req._parsedUrl.query);
+  if (res.statusCode === 404) {
+    return res.status(404).jsonp({ error: `Can't find path: ${pathname}` });
+  }
+
+  const params = req._parsedUrl.query ? new URLSearchParams(req._parsedUrl.query) : null;
 
   // Add createdAt to the body
   if (req.originalMethod === 'POST') {
@@ -46,11 +53,27 @@ router.render = (req, res) => {
     let data = res.locals.data;
     const deltagareRegex = /(?:\/customerinfo\/)(contact|driverlicense|education\/highest|education|translator|work\/disability|work\/languages|work\/experience)/g;
     const isDeltagarePath = deltagareRegex.exec(pathname);
+    const avropRegex = /(?:\/avrop\/)(tjanster|utforandeverksamheter|kommuner)/g;
+    const isAvropPath = avropRegex.exec(pathname);
 
     if (isDeltagarePath) {
       const deltagareSubPath = getDeltagareSubPath(isDeltagarePath[1]);
       data = res.locals.data[deltagareSubPath] || {};
     }
+    if (isAvropPath) {
+      if (params) {
+        const newData = [];
+        params.forEach((value, key) => {
+          if (key === 'kommunCodes') {
+            value = +value;
+          }
+          newData.push(...data.filter(item => item[`related_${key}`].includes(value)));
+        });
+
+        data = newData.filter((value, index, arr) => arr.findIndex(item => item.code === value.code) === index);
+      }
+    }
+
     res.jsonp({
       data,
       ...appendMetaData(params, res),
@@ -64,7 +87,7 @@ server.listen(8000, () => {
 });
 
 function appendMetaData(params, res) {
-  if (params.has('_page')) {
+  if (params && params.has('_page')) {
     const limit = +params.get('_limit');
     const page = +params.get('_page');
     const count = res.get('X-Total-Count');