OZG-7473 implement aggregation mapping patching

Sub task: OZG-7887

alfa-client/apps/admin/src/app/app.component.spec.ts

@@ -297,7 +297,7 @@ describe('AppComponent', () => {
       it('should navigate to statistik if aggregation mapping link exists', () => {
         component._navigateByConfiguration(createConfigurationResource([ConfigurationLinkRel.AGGREGATION_MAPPINGS]));
 
-        expect(router.navigate).toHaveBeenCalledWith(['/statistik']);
+        expect(router.navigate).toHaveBeenCalledWith(['/aggregation-mapping']);
       });
 
       it('should navigate to unavailable page if no link exists', () => {

alfa-client/apps/admin/src/app/app.component.ts

@@ -123,7 +123,7 @@ export class AppComponent implements OnInit {
     if (hasLink(configurationResource, ConfigurationLinkRel.SETTING)) {
       this.navigate(ROUTES.POSTFACH);
     } else if (hasLink(configurationResource, ConfigurationLinkRel.AGGREGATION_MAPPINGS)) {
-      this.navigate(ROUTES.STATISTIK);
+      this.navigate(ROUTES.AGGREGATION_MAPPING);
     } else {
       this.navigate(ROUTES.UNAVAILABLE);
     }

alfa-client/apps/admin/src/app/app.routes.ts

@@ -83,7 +83,7 @@ export const appRoutes: Route[] = [
     title: 'Unavailable',
   },
   {
-    path: ROUTES.STATISTIK,
+    path: ROUTES.AGGREGATION_MAPPING,
     component: StatistikPageComponent,
     title: 'Admin | Statistik',
     runGuardsAndResolvers: 'always',
@@ -91,7 +91,15 @@ export const appRoutes: Route[] = [
     data: <GuardData>{ linkRelName: ConfigurationLinkRel.AGGREGATION_MAPPINGS },
   },
   {
-    path: ROUTES.STATISTIK_NEU,
+    path: ROUTES.AGGREGATION_MAPPING_NEU,
+    component: StatistikFieldsFormPageComponent,
+    title: 'Admin | Statistik weitere Felder auswerten',
+    runGuardsAndResolvers: 'always',
+    canActivate: [configurationGuard],
+    data: <GuardData>{ linkRelName: ConfigurationLinkRel.AGGREGATION_MAPPINGS },
+  },
+  {
+    path: ROUTES.AGGREGATION_MAPPING_ID,
     component: StatistikFieldsFormPageComponent,
     title: 'Admin | Statistik weitere Felder auswerten',
     runGuardsAndResolvers: 'always',

alfa-client/libs/admin/configuration/src/lib/menu-container/menu/menu.component.html

@@ -4,7 +4,7 @@
   </ods-nav-item>
 }
 @if (configurationStateResource.resource | hasLink: configurationLinkRel.AGGREGATION_MAPPINGS) {
-  <ods-nav-item data-test-id="statistik-navigation" caption="Statistik" path="/statistik">
+  <ods-nav-item data-test-id="statistik-navigation" caption="Statistik" [path]="'/' + ROUTES.AGGREGATION_MAPPING">
     <ods-statistic-icon icon />
   </ods-nav-item>
 }

alfa-client/libs/admin/configuration/src/lib/menu-container/menu/menu.component.ts

 import { ConfigurationLinkRel, ConfigurationResource } from '@admin-client/configuration-shared';
+import { ROUTES } from '@admin-client/shared';
 import { HasLinkPipe, StateResource } from '@alfa-client/tech-shared';
 import { CommonModule } from '@angular/common';
 import { Component, Input } from '@angular/core';
@@ -14,4 +15,5 @@ export class MenuComponent {
   @Input() configurationStateResource: StateResource<ConfigurationResource>;
 
   public readonly configurationLinkRel = ConfigurationLinkRel;
+  public readonly ROUTES = ROUTES;
 }

alfa-client/libs/admin/reporting-shared/src/index.ts

+export * from './lib/aggregation-mapping-list-resource.service';
 export * from './lib/aggregation-mapping-resource.service';
 export * from './lib/aggregation-mapping.model';
 export * from './lib/aggregation-mapping.provider';

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping-list-resource.service.ts

+import { ConfigurationLinkRel, ConfigurationResource, ConfigurationService } from '@admin-client/configuration-shared';
+import { ListResourceServiceConfig, ResourceListService, ResourceRepository } from '@alfa-client/tech-shared';
+import { AggregationMappingListLinkRel } from './aggregation-mapping.linkrel';
+import { AggregationMappingListResource, AggregationMappingResource } from './aggregation-mapping.model';
+
+export class AggregationMappingListResourceService extends ResourceListService<
+  ConfigurationResource,
+  AggregationMappingListResource,
+  AggregationMappingResource
+> {}
+
+export function createAggregationMappingListResourceService(
+  repository: ResourceRepository,
+  configurationService: ConfigurationService,
+) {
+  return new ResourceListService(buildConfig(configurationService), repository);
+}
+
+function buildConfig(configurationService: ConfigurationService): ListResourceServiceConfig<ConfigurationResource> {
+  return {
+    baseResource: configurationService.get(),
+    listLinkRel: ConfigurationLinkRel.AGGREGATION_MAPPINGS,
+    listResourceListLinkRel: AggregationMappingListLinkRel.LIST,
+    createLinkRel: AggregationMappingListLinkRel.SELF,
+  };
+}

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping-resource.service.spec.ts

+import { AggregationMappingResource } from '@admin-client/reporting-shared';
+import { ROUTES } from '@admin-client/shared';
+import { NavigationService, RouteData } from '@alfa-client/navigation-shared';
+import {
+  createEmptyStateResource,
+  createStateResource,
+  decodeUrlFromEmbedding,
+  ResourceRepository,
+  ResourceServiceConfig,
+  StateResource,
+} from '@alfa-client/tech-shared';
+import { Mock, mock, useFromMock } from '@alfa-client/test-utils';
+import { UrlSegment } from '@angular/router';
+import { faker } from '@faker-js/faker';
+import { afterAll, expect } from '@jest/globals';
+import { ResourceUri } from '@ngxp/rest';
+import { Observable, of } from 'rxjs';
+import { createRouteData, createUrlSegment } from '../../../../navigation-shared/test/navigation-test-factory';
+import { singleColdCompleted } from '../../../../tech-shared/test/marbles';
+import { createAggregationMappingResource } from '../../test/aggregation-mapping';
+import * as module from './aggregation-mapping-resource.service';
+
+jest.mock('@alfa-client/tech-shared', () => ({
+  ...jest.requireActual('@alfa-client/tech-shared'),
+  decodeUrlFromEmbedding: jest.fn(),
+}));
+
+const decodeUrlFromEmbeddingMock: jest.Mock = decodeUrlFromEmbedding as jest.Mock;
+
+describe('AggregationMappingResourceService', () => {
+  let repository: Mock<ResourceRepository>;
+  let navigationService: Mock<NavigationService>;
+
+  beforeEach(() => {
+    repository = mock(ResourceRepository);
+    navigationService = mock(NavigationService);
+  });
+
+  describe('build config', () => {
+    const _getResourceByNavigationRoute: jest.SpyInstance = jest
+      .spyOn(module, '_getResourceByNavigationRoute')
+      .mockImplementation();
+
+    afterAll(() => {
+      _getResourceByNavigationRoute.mockRestore();
+    });
+
+    it('should get resource by navigation route', () => {
+      module._buildResourceServiceConfig(useFromMock(repository), useFromMock(navigationService));
+
+      expect(_getResourceByNavigationRoute).toHaveBeenCalled();
+    });
+
+    it('should have aggregation mapping static resource', () => {
+      const staticResource: StateResource<AggregationMappingResource> = createStateResource(createAggregationMappingResource());
+      _getResourceByNavigationRoute.mockReturnValue(of(staticResource));
+
+      const config: ResourceServiceConfig<AggregationMappingResource> = module._buildResourceServiceConfig(
+        useFromMock(repository),
+        useFromMock(navigationService),
+      );
+
+      expect(config.resource).toBeObservable(singleColdCompleted(staticResource));
+    });
+  });
+
+  describe('get resource by navigation route', () => {
+    const routeData: RouteData = createRouteData();
+    const _isAggregationMappingEditUrl: jest.SpyInstance = jest
+      .spyOn(module, '_isAggregationMappingEditUrl')
+      .mockImplementation();
+    const _getAggregationMappingResourceByRoute: jest.SpyInstance = jest
+      .spyOn(module, '_getAggregationMappingResourceByRoute')
+      .mockImplementation();
+
+    beforeEach(() => {
+      navigationService.getCurrentRouteData.mockReturnValue(of(routeData));
+    });
+
+    afterAll(() => {
+      _isAggregationMappingEditUrl.mockRestore();
+      _getAggregationMappingResourceByRoute.mockRestore();
+    });
+
+    it('should get current route data', () => {
+      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();
+
+      expect(navigationService.getCurrentRouteData).toHaveBeenCalled();
+    });
+
+    it('should check if url contains resource uri', () => {
+      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();
+
+      expect(_isAggregationMappingEditUrl).toHaveBeenCalled();
+    });
+
+    it('should get aggregation mapping resource by route', () => {
+      module._getResourceByNavigationRoute(useFromMock(repository), useFromMock(navigationService)).subscribe();
+
+      expect(_getAggregationMappingResourceByRoute).toHaveBeenCalled();
+    });
+
+    it('should return aggregation mapping by route', () => {
+      const stateResource: StateResource<AggregationMappingResource> = createStateResource(createAggregationMappingResource());
+      _getAggregationMappingResourceByRoute.mockReturnValue(of(stateResource));
+      _isAggregationMappingEditUrl.mockReturnValue(true);
+
+      const resourceByRoute$: Observable<StateResource<AggregationMappingResource>> = module._getResourceByNavigationRoute(
+        useFromMock(repository),
+        useFromMock(navigationService),
+      );
+
+      expect(resourceByRoute$).toBeObservable(singleColdCompleted(stateResource));
+    });
+
+    it('should return empty state resource', () => {
+      const stateResource: StateResource<AggregationMappingResource> = createEmptyStateResource();
+      _isAggregationMappingEditUrl.mockReturnValue(false);
+
+      const resourceByRoute$: Observable<StateResource<AggregationMappingResource>> = module._getResourceByNavigationRoute(
+        useFromMock(repository),
+        useFromMock(navigationService),
+      );
+
+      expect(resourceByRoute$).toBeObservable(singleColdCompleted(stateResource));
+    });
+  });
+
+  describe('is aggregation mapping edit url', () => {
+    it.each([0, 1, 3])('should return false of wrong number of segments = %d', (numberOfSegments: number) => {
+      const routeData: RouteData = {
+        ...createRouteData(),
+        urlSegments: Array(numberOfSegments).fill(createUrlSegment()),
+      };
+
+      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
+    });
+
+    it('should return false if first path is wrong', () => {
+      const routeData: RouteData = {
+        ...createRouteData(),
+        urlSegments: Array(2).fill(createUrlSegment()),
+      };
+
+      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
+    });
+
+    it('should return false if second path is wrong', () => {
+      const firstUrlSegment: UrlSegment = createUrlSegment();
+      firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
+      const secondUrlSegment: UrlSegment = createUrlSegment();
+      secondUrlSegment.path = 'neu';
+      const routeData: RouteData = {
+        ...createRouteData(),
+        urlSegments: [firstUrlSegment, secondUrlSegment],
+      };
+
+      expect(module._isAggregationMappingEditUrl(routeData)).toBe(false);
+    });
+
+    it('should return true', () => {
+      const firstUrlSegment: UrlSegment = createUrlSegment();
+      firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
+      const secondUrlSegment: UrlSegment = createUrlSegment();
+      secondUrlSegment.path = faker.internet.url();
+      const routeData: RouteData = {
+        ...createRouteData(),
+        urlSegments: [firstUrlSegment, secondUrlSegment],
+      };
+
+      expect(module._isAggregationMappingEditUrl(routeData)).toBe(true);
+    });
+  });
+
+  describe('get aggregation mapping resource by route', () => {
+    const firstUrlSegment: UrlSegment = createUrlSegment();
+    firstUrlSegment.path = ROUTES.AGGREGATION_MAPPING;
+    const secondUrlSegment: UrlSegment = createUrlSegment();
+    secondUrlSegment.path = faker.internet.url();
+    const routeData: RouteData = {
+      ...createRouteData(),
+      urlSegments: [firstUrlSegment, secondUrlSegment],
+    };
+    const uri: ResourceUri = faker.internet.url();
+    const resource: AggregationMappingResource = createAggregationMappingResource();
+
+    beforeEach(() => {
+      decodeUrlFromEmbeddingMock.mockReturnValue(uri);
+      repository.getResource.mockReturnValue(of(resource));
+    });
+
+    it('should decode url', () => {
+      module._getAggregationMappingResourceByRoute(useFromMock(repository), routeData);
+
+      expect(decodeUrlFromEmbeddingMock).toHaveBeenCalledWith(secondUrlSegment.path);
+    });
+
+    it('should get resource', () => {
+      module._getAggregationMappingResourceByRoute(useFromMock(repository), routeData);
+
+      expect(repository.getResource).toHaveBeenCalledWith(uri);
+    });
+
+    it('should return state resource', () => {
+      const stateResource$: Observable<StateResource<AggregationMappingResource>> = module._getAggregationMappingResourceByRoute(
+        useFromMock(repository),
+        routeData,
+      );
+
+      expect(stateResource$).toBeObservable(singleColdCompleted(createStateResource(resource)));
+    });
+  });
+});

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping-resource.service.ts

-import { ConfigurationLinkRel, ConfigurationResource, ConfigurationService } from '@admin-client/configuration-shared';
-import { ListResourceServiceConfig, ResourceListService, ResourceRepository } from '@alfa-client/tech-shared';
-import { AggregationMappingListLinkRel } from './aggregation-mapping.linkrel';
-import { AggregationMappingListResource, AggregationMappingResource } from './aggregation-mapping.model';
+import { ROUTES } from '@admin-client/shared';
+import { NavigationService, RouteData } from '@alfa-client/navigation-shared';
+import {
+  ApiResourceService,
+  createEmptyStateResource,
+  createStateResource,
+  decodeUrlFromEmbedding,
+  ResourceRepository,
+  ResourceServiceConfig,
+  StateResource,
+} from '@alfa-client/tech-shared';
+import { UrlSegment } from '@angular/router';
+import { iif, map, Observable, of, switchMap } from 'rxjs';
+import * as module from './aggregation-mapping-resource.service';
+import { AggregationMappingLinkRel } from './aggregation-mapping.linkrel';
+import { AggregationMappingResource } from './aggregation-mapping.model';
 
-export class AggregationMappingListResourceService extends ResourceListService<
-  ConfigurationResource,
-  AggregationMappingListResource,
+export class AggregationMappingResourceService extends ApiResourceService<
+  AggregationMappingResource,
   AggregationMappingResource
 > {}
 
 export function createAggregationMappingResourceService(
   repository: ResourceRepository,
-  configurationService: ConfigurationService,
-) {
-  return new ResourceListService(buildConfig(configurationService), repository);
+  navigationService: NavigationService,
+): AggregationMappingResourceService {
+  return new AggregationMappingResourceService(_buildResourceServiceConfig(repository, navigationService), repository);
 }
 
-function buildConfig(configurationService: ConfigurationService): ListResourceServiceConfig<ConfigurationResource> {
+export function _buildResourceServiceConfig(
+  repository: ResourceRepository,
+  navigationService: NavigationService,
+): ResourceServiceConfig<AggregationMappingResource> {
+  module._getResourceByNavigationRoute(repository, navigationService);
   return {
-    baseResource: configurationService.get(),
-    listLinkRel: ConfigurationLinkRel.AGGREGATION_MAPPINGS,
-    listResourceListLinkRel: AggregationMappingListLinkRel.LIST,
-    createLinkRel: AggregationMappingListLinkRel.SELF,
+    resource: module._getResourceByNavigationRoute(repository, navigationService),
+    getLinkRel: AggregationMappingLinkRel.SELF,
+    edit: { linkRel: AggregationMappingLinkRel.SELF },
+    delete: { linkRel: AggregationMappingLinkRel.SELF },
   };
 }
+
+export function _getResourceByNavigationRoute(
+  repository: ResourceRepository,
+  navigationService: NavigationService,
+): Observable<StateResource<AggregationMappingResource>> {
+  return navigationService
+    .getCurrentRouteData()
+    .pipe(
+      switchMap((route: RouteData) =>
+        iif(
+          () => module._isAggregationMappingEditUrl(route),
+          module._getAggregationMappingResourceByRoute(repository, route),
+          of(createEmptyStateResource<AggregationMappingResource>()),
+        ),
+      ),
+    );
+}
+
+export function _isAggregationMappingEditUrl(route: RouteData): boolean {
+  const urlSegments: UrlSegment[] = route.urlSegments;
+  return urlSegments.length === 2 && urlSegments[0].path === ROUTES.AGGREGATION_MAPPING && urlSegments[1].path !== 'neu';
+}
+
+export function _getAggregationMappingResourceByRoute(
+  repository: ResourceRepository,
+  route: RouteData,
+): Observable<StateResource<AggregationMappingResource>> {
+  const uri: string = decodeUrlFromEmbedding(route.urlSegments[1].path);
+  return repository.getResource(uri).pipe(map((resource: AggregationMappingResource) => createStateResource(resource)));
+}

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping.linkrel.ts

@@ -2,3 +2,7 @@ export enum AggregationMappingListLinkRel {
   LIST = 'aggregationMappings',
   SELF = 'self',
 }
+
+export enum AggregationMappingLinkRel {
+  SELF = 'self',
+}

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping.provider.ts

+import { NavigationService } from '@alfa-client/navigation-shared';
 import { ResourceRepository } from '@alfa-client/tech-shared';
 import { Provider } from '@angular/core';
 import { ConfigurationService } from 'libs/admin/configuration-shared/src/lib/configuration.service';
 import {
   AggregationMappingListResourceService,
+  createAggregationMappingListResourceService,
+} from './aggregation-mapping-list-resource.service';
+import {
+  AggregationMappingResourceService,
   createAggregationMappingResourceService,
 } from './aggregation-mapping-resource.service';
 import { AggregationMappingService } from './aggregation-mapping.service';
@@ -10,8 +15,13 @@ import { AggregationMappingService } from './aggregation-mapping.service';
 export const AggregationMappingProvider: Provider[] = [
   {
     provide: AggregationMappingListResourceService,
-    useFactory: createAggregationMappingResourceService,
+    useFactory: createAggregationMappingListResourceService,
     deps: [ResourceRepository, ConfigurationService],
   },
+  {
+    provide: AggregationMappingResourceService,
+    useFactory: createAggregationMappingResourceService,
+    deps: [ResourceRepository, NavigationService],
+  },
   AggregationMappingService,
 ];

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping.service.spec.ts

@@ -2,26 +2,33 @@ import { createStateResource, StateResource } from '@alfa-client/tech-shared';
 import { Mock, mock } from '@alfa-client/test-utils';
 import { TestBed } from '@angular/core/testing';
 import { expect } from '@jest/globals';
-import { singleCold } from 'libs/tech-shared/test/marbles';
-import { Observable } from 'rxjs';
+import { singleCold, singleColdCompleted } from 'libs/tech-shared/test/marbles';
+import { Observable, of } from 'rxjs';
 import {
   createAggregationMapping,
   createAggregationMappingListResource,
   createAggregationMappingResource,
 } from '../../test/aggregation-mapping';
-import { AggregationMappingListResourceService } from './aggregation-mapping-resource.service';
+import { AggregationMappingListResourceService } from './aggregation-mapping-list-resource.service';
+import { AggregationMappingResourceService } from './aggregation-mapping-resource.service';
 import { AggregationMapping, AggregationMappingListResource, AggregationMappingResource } from './aggregation-mapping.model';
 import { AggregationMappingService } from './aggregation-mapping.service';
 
 describe('AggregationMappingService', () => {
   let service: AggregationMappingService;
   let listResourceService: Mock<AggregationMappingListResourceService>;
+  let resourceService: Mock<AggregationMappingResourceService>;
 
   beforeEach(() => {
     listResourceService = mock(AggregationMappingListResourceService);
+    resourceService = mock(AggregationMappingResourceService);
 
     TestBed.configureTestingModule({
-      providers: [AggregationMappingService, { provide: AggregationMappingListResourceService, useValue: listResourceService }],
+      providers: [
+        AggregationMappingService,
+        { provide: AggregationMappingListResourceService, useValue: listResourceService },
+        { provide: AggregationMappingResourceService, useValue: resourceService },
+      ],
     });
 
     service = TestBed.inject(AggregationMappingService);
@@ -87,4 +94,39 @@ describe('AggregationMappingService', () => {
       expect(listResourceService.refresh).toHaveBeenCalled();
     });
   });
+
+  describe('get by current url', () => {
+    const stateResource = createStateResource(createAggregationMappingResource());
+    beforeEach(() => {
+      resourceService.get = jest.fn().mockReturnValue(of(stateResource));
+    });
+
+    it('should call resource service', () => {
+      service.getByCurrentUrl();
+
+      expect(resourceService.get).toHaveBeenCalled();
+    });
+
+    it('should emit resource', () => {
+      expect(service.getByCurrentUrl()).toBeObservable(singleColdCompleted(stateResource));
+    });
+  });
+
+  describe('save', () => {
+    const aggregationMapping: AggregationMapping = createAggregationMapping();
+    const stateResource = createStateResource(createAggregationMappingResource());
+    beforeEach(() => {
+      resourceService.save = jest.fn().mockReturnValue(of(stateResource));
+    });
+
+    it('should call resource service', () => {
+      service.save(aggregationMapping);
+
+      expect(resourceService.save).toHaveBeenCalledWith(aggregationMapping);
+    });
+
+    it('should emit saved state resource', () => {
+      expect(service.save(aggregationMapping)).toBeObservable(singleColdCompleted(stateResource));
+    });
+  });
 });

alfa-client/libs/admin/reporting-shared/src/lib/aggregation-mapping.service.ts

 import { StateResource } from '@alfa-client/tech-shared';
 import { inject, Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
-import { AggregationMappingListResourceService } from './aggregation-mapping-resource.service';
+import { AggregationMappingListResourceService } from './aggregation-mapping-list-resource.service';
+import { AggregationMappingResourceService } from './aggregation-mapping-resource.service';
 import { AggregationMapping, AggregationMappingListResource, AggregationMappingResource } from './aggregation-mapping.model';
 
 @Injectable()
 export class AggregationMappingService {
-  readonly listService = inject(AggregationMappingListResourceService);
+  private readonly listService = inject(AggregationMappingListResourceService);
+  private readonly resourceService = inject(AggregationMappingResourceService);
 
   public getList(): Observable<StateResource<AggregationMappingListResource>> {
     return this.listService.getList();
@@ -19,4 +21,12 @@ export class AggregationMappingService {
   public refreshList(): void {
     this.listService.refresh();
   }
+
+  public getByCurrentUrl(): Observable<StateResource<AggregationMappingResource>> {
+    return this.resourceService.get();
+  }
+
+  public save(aggregationMapping: AggregationMapping): Observable<StateResource<AggregationMappingResource>> {
+    return this.resourceService.save(aggregationMapping);
+  }
 }

alfa-client/libs/admin/shared/src/lib/routes.ts

@@ -28,6 +28,7 @@ export enum ROUTES {
   BENUTZER_ID = 'benutzer/:userid',
   ORGANISATIONSEINHEITEN = 'organisationseinheiten',
   UNAVAILABLE = 'unavailable',
-  STATISTIK = 'statistik',
-  STATISTIK_NEU = 'statistik/neu',
+  AGGREGATION_MAPPING = 'aggregation-mapping',
+  AGGREGATION_MAPPING_NEU = 'aggregation-mapping/neu',
+  AGGREGATION_MAPPING_ID = 'aggregation-mapping/:aggregationMappingId',
 }

alfa-client/libs/admin/statistik/src/lib/aggregation-mapping-list/aggregation-mapping-list-item/aggregation-mapping-list-item.component.html

-<ods-list-item [path]="" [attr.data-test-id]="aggregationMapping.name | convertForDataTest">
+<ods-list-item [path]="aggregationMapping | toResourceUri" [attr.data-test-id]="aggregationMapping.name | convertForDataTest">
   <dl class="flex-1 font-semibold">
     <dt class="sr-only">Name</dt>
     <dd data-test-class="fullname">{{ aggregationMapping.name }}</dd>

alfa-client/libs/admin/statistik/src/lib/aggregation-mapping-list/aggregation-mapping-list-item/aggregation-mapping-list-item.component.spec.ts

+import { AggregationMappingResource } from '@admin-client/reporting-shared';
+import { ToResourceUriPipe } from '@alfa-client/tech-shared';
+import { getElementFromFixtureByType } from '@alfa-client/test-utils';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { expect } from '@jest/globals';
+import { ListItemComponent } from '@ods/system';
+import { MockComponent } from 'ng-mocks';
+import { createAggregationMappingResource } from '../../../../../reporting-shared/test/aggregation-mapping';
 import { AggregationMappingListItemComponent } from './aggregation-mapping-list-item.component';
 
 describe('AggregationMappingListItemComponent', () => {
   let component: AggregationMappingListItemComponent;
   let fixture: ComponentFixture<AggregationMappingListItemComponent>;
 
+  const toResourceUriPipe: ToResourceUriPipe = new ToResourceUriPipe();
+  const aggregationMappingResource: AggregationMappingResource = createAggregationMappingResource();
+
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      imports: [AggregationMappingListItemComponent],
+      imports: [AggregationMappingListItemComponent, ToResourceUriPipe, MockComponent(ListItemComponent)],
     }).compileComponents();
 
     fixture = TestBed.createComponent(AggregationMappingListItemComponent);
     component = fixture.componentInstance;
+    component.aggregationMapping = aggregationMappingResource;
     fixture.detectChanges();
   });
 
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  describe('template', () => {
+    describe('list item', () => {
+      it('should have inputs', () => {
+        const comp: ListItemComponent = getElementFromFixtureByType(fixture, ListItemComponent);
+
+        expect(comp.path).toEqual(toResourceUriPipe.transform(aggregationMappingResource));
+      });
+    });
+  });
 });

alfa-client/libs/admin/statistik/src/lib/aggregation-mapping-list/aggregation-mapping-list-item/aggregation-mapping-list-item.component.ts

 import { AggregationMappingResource } from '@admin-client/reporting-shared';
-import { ConvertForDataTestPipe } from '@alfa-client/tech-shared';
+import { ConvertForDataTestPipe, ToResourceUriPipe } from '@alfa-client/tech-shared';
 import { Component, Input } from '@angular/core';
 import { ListItemComponent } from '@ods/system';
 
@@ -7,7 +7,7 @@ import { ListItemComponent } from '@ods/system';
   selector: 'admin-aggregation-mapping-list-item',
   standalone: true,
   templateUrl: './aggregation-mapping-list-item.component.html',
-  imports: [ConvertForDataTestPipe, ListItemComponent],
+  imports: [ConvertForDataTestPipe, ListItemComponent, ToResourceUriPipe],
   styles: [':host {@apply block}'],
 })
 export class AggregationMappingListItemComponent {

alfa-client/libs/admin/statistik/src/lib/statistik-container/statistik-container.component.html

@@ -26,7 +26,7 @@
 <h1 class="heading-1" data-test-id="statistik-header-text">Statistik</h1>
 <ods-routing-button
   class="my-4 w-fit"
-  [linkPath]="ROUTES.STATISTIK_NEU"
+  [linkPath]="ROUTES.AGGREGATION_MAPPING_NEU"
   text="Weitere Felder auswerten"
   dataTestId="weitere-felder-auswerten-button"
 />

alfa-client/libs/admin/statistik/src/lib/statistik-fields-form/statistik-fields-form.component.html

 <h2 class="heading-2" data-test-id="statistik-fields-form-header-text">Felder zur Auswertung hinzufügen</h2>
 
+<ods-spinner [stateResource]="aggregationMappingStateResource$ | async">
   <div class="flex max-w-4xl flex-col gap-4">
     <form class="form flex-col" [formGroup]="formService.form" class="flex flex-col gap-2">
       <ods-text-editor
@@ -37,7 +38,8 @@
     </ods-button>
 
     <div class="mt-4 flex gap-4">
-    <admin-save-button [successLinkPath]="Routes.STATISTIK" />
-    <admin-cancel-button [linkPath]="Routes.STATISTIK" />
+      <admin-save-button [successLinkPath]="Routes.AGGREGATION_MAPPING" />
+      <admin-cancel-button [linkPath]="Routes.AGGREGATION_MAPPING" />
     </div>
   </div>
+</ods-spinner>

alfa-client/libs/admin/statistik/src/lib/statistik-fields-form/statistik-fields-form.component.spec.ts

-import { ADMIN_FORMSERVICE } from '@admin-client/shared';
-import { EMPTY_STRING } from '@alfa-client/tech-shared';
-import { dispatchEventFromFixture, existsAsHtmlElement, mock, Mock, MockEvent } from '@alfa-client/test-utils';
+import { AggregationMappingResource } from '@admin-client/reporting-shared';
+import { ADMIN_FORMSERVICE, ROUTES } from '@admin-client/shared';
+import { createStateResource, EMPTY_STRING, StateResource } from '@alfa-client/tech-shared';
+import {
+  dispatchEventFromFixture,
+  existsAsHtmlElement,
+  getElementFromFixtureByType,
+  mock,
+  Mock,
+  MockEvent,
+} from '@alfa-client/test-utils';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { FormBuilder, FormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';
+import { expect } from '@jest/globals';
 import { TextEditorComponent } from '@ods/component';
 import { ButtonComponent, PlusIconComponent } from '@ods/system';
 import { MockComponent } from 'ng-mocks';
+import { of } from 'rxjs';
 import { getDataTestIdOf } from '../../../../../tech-shared/test/data-test';
+import { singleColdCompleted } from '../../../../../tech-shared/test/marbles';
+import { createAggregationMappingResource } from '../../../../reporting-shared/test/aggregation-mapping';
 import { AdminCancelButtonComponent } from '../../../../shared/src/lib/admin-cancel-button/admin-cancel-button.component';
 import { AdminSaveButtonComponent } from '../../../../shared/src/lib/admin-save-button/admin-save-button.component';
 import { StatistikFieldsFormComponent } from './statistik-fields-form.component';
@@ -21,6 +33,10 @@ describe('AdminStatistikFieldsFormComponent', () => {
   const formIdInputTestId: string = getDataTestIdOf('form-id');
   const addMappingButton: string = getDataTestIdOf('add-mapping');
 
+  const aggregationMappingStateResource: StateResource<AggregationMappingResource> = createStateResource(
+    createAggregationMappingResource(),
+  );
+
   const formBuilder: FormBuilder = new FormBuilder();
 
   let formService: Mock<StatistikFieldsFormService>;
@@ -35,6 +51,7 @@ describe('AdminStatistikFieldsFormComponent', () => {
     });
 
     formService = <any>{ ...mock(StatistikFieldsFormService), form };
+    formService.get = jest.fn().mockReturnValue(of(aggregationMappingStateResource));
 
     await TestBed.configureTestingModule({
       imports: [
@@ -73,6 +90,16 @@ describe('AdminStatistikFieldsFormComponent', () => {
     expect(component).toBeTruthy();
   });
 
+  describe('component', () => {
+    it('should get aggregation mapping from form service', () => {
+      expect(formService.get).toHaveBeenCalled();
+    });
+
+    it('should initial values', () => {
+      expect(component.aggregationMappingStateResource$).toBeObservable(singleColdCompleted(aggregationMappingStateResource));
+    });
+  });
+
   describe('template', () => {
     describe('form engine input', () => {
       it('should exists', () => {
@@ -109,5 +136,21 @@ describe('AdminStatistikFieldsFormComponent', () => {
         });
       });
     });
+
+    describe('save button', () => {
+      it('should have link path', () => {
+        const comp: AdminSaveButtonComponent = getElementFromFixtureByType(fixture, AdminSaveButtonComponent);
+
+        expect(comp.successLinkPath).toEqual(ROUTES.AGGREGATION_MAPPING);
+      });
+    });
+
+    describe('cancel button', () => {
+      it('should have link path', () => {
+        const comp: AdminCancelButtonComponent = getElementFromFixtureByType(fixture, AdminCancelButtonComponent);
+
+        expect(comp.linkPath).toEqual(ROUTES.AGGREGATION_MAPPING);
+      });
+    });
   });
 });