myrtex-mf-competition 1.0.71 → 1.0.73

package/src/lib/modules/competition-header/services/competition-header.service.ts

@@ -0,0 +1,47 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { CompetitionHeaderVersionModel } from '../models/competition-header-version.model';
+import { CompetitionVersionStatusEnum, EndpointBaseService } from 'myrtex-mf-ui-composite';
+
+@Injectable()
+export class CompetitionHeaderService extends EndpointBaseService {
+
+  private url = '/application' + this.restPath + '/competition';
+
+  constructor(http: HttpClient, injector: Injector) {
+    super(http, injector);
+  }
+
+  public getHeader(competitionId?: string): Observable<CompetitionHeaderVersionModel> {
+    return this.http.get<CompetitionHeaderVersionModel>(`${this.url}/${competitionId}/header`);
+  }
+
+  public createVersion(competitionId?: string): Observable<string> {
+    return this.http.post<string>(`${this.url}/${competitionId}/version`, {});
+  }
+
+  public deleteVersion(competitionId?: string, versionId?: string): Observable<boolean> {
+    return this.http.delete<boolean>(`${this.url}/${competitionId}/version/${versionId}`);
+  }
+
+  public versionChangeStatus(competitionId?: string, versionId?: string, status?: CompetitionVersionStatusEnum): Observable<boolean> {
+    return this.http.post<boolean>(`${this.url}/${competitionId}/version/${versionId}/to-status/${status}`, {});
+  }
+
+  public activate(competitionId?: string): Observable<any> {
+    return this.http.post<any>(`${this.url}/${competitionId}/activate`, {});
+  }
+
+  public pause(competitionId?: string): Observable<any> {
+    return this.http.post<any>(`${this.url}/${competitionId}/pause`, {});
+  }
+
+  public complete(competitionId?: string): Observable<any> {
+    return this.http.post<any>(`${this.url}/${competitionId}/complete`, {});
+  }
+
+  public cancel(competitionId?: string): Observable<any> {
+    return this.http.post<any>(`${this.url}/${competitionId}/cancel`, {});
+  }
+}

package/src/lib/modules/competition-header/services/settings.service.ts

@@ -0,0 +1,17 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable, Injector} from '@angular/core';
+import {EndpointBaseService} from 'myrtex-mf-ui-composite';
+import {Observable} from 'rxjs';
+import { EBLinksModel } from '../models/eb-links.model';
+
+@Injectable()
+export class SettingsService extends EndpointBaseService {
+
+  constructor(protected http: HttpClient, protected injector: Injector) {
+    super(http, injector);
+  }
+
+  public getSelelectionEditEbLinks(): Observable<EBLinksModel> {
+    return this.http.get<EBLinksModel>('/m-data/minfin/selection/edit/eb-links');
+  }
+}

package/src/lib/modules/competition-header/store/competition-header.actions.ts

@@ -0,0 +1,102 @@
+import { createAction, props } from '@ngrx/store';
+import {CompetitionHeaderVersionModel} from '../models/competition-header-version.model';
+import { CompetitionVersionStatusEnum } from 'myrtex-mf-ui-composite';
+
+export enum ECompetitionHeaderActions {
+
+  LoadCompetitionHeader = '[Competition] Load Header',
+  LoadCompetitionHeaderSuccess = '[Competition] Load Header Success',
+
+  DeleteCompetitionVersion = '[Competition] Delete Version',
+  DeleteCompetitionVersionSuccess = '[Competition] Delete Version Success',
+
+  CreateCompetitionVersion = '[Competition] Create Version',
+  CreateCompetitionVersionSuccess = '[Competition] Create Version Success',
+
+  CompetitionVersionChangeStatus = '[Competition] Version Change Status',
+  CompetitionVersionChangeStatusSuccess = '[Competition] Version Change Status Success',
+  CompetitionVersionChangeStatusManual = '[Competition] Version Change Status Manual',
+
+  SelectCompetitionVersion = '[Competition] Select Version',
+
+  ActivateCompetition = '[Competition] Activate',
+  PauseCompetition = '[Competition] Pause',
+  CancelCompetition = '[Competition] Cancel',
+  CancelCompetitionWithValidation = '[Competition] Cancel With Validation',
+  CompleteCompetition = '[Competition] Complete',
+
+  CompetitionChangeStatusSuccess = '[Competition] ChangeStatus Success',
+}
+
+export const loadCompetitionHeader = createAction(
+  ECompetitionHeaderActions.LoadCompetitionHeader
+);
+
+export const loadCompetitionHeaderSuccess = createAction(
+  ECompetitionHeaderActions.LoadCompetitionHeaderSuccess,
+  props<{ competitionHeader: CompetitionHeaderVersionModel }>()
+);
+
+export const deleteCompetitionVersion = createAction(
+  ECompetitionHeaderActions.DeleteCompetitionVersion,
+  props<{ versionId: string }>()
+);
+
+export const deleteCompetitionVersionSuccess = createAction(
+  ECompetitionHeaderActions.DeleteCompetitionVersionSuccess,
+  props<{ versionId: string }>()
+);
+
+export const createCompetitionVersion = createAction(
+  ECompetitionHeaderActions.CreateCompetitionVersion
+);
+
+export const competitionVersionChangeStatus = createAction(
+  ECompetitionHeaderActions.CompetitionVersionChangeStatus,
+  props<{ versionId: string, status: CompetitionVersionStatusEnum }>()
+);
+
+export const competitionVersionChangeStatusSuccess = createAction(
+  ECompetitionHeaderActions.CompetitionVersionChangeStatusSuccess,
+  props<{ versionId: string, status: CompetitionVersionStatusEnum }>()
+);
+
+export const competitionVersionChangeStatusManual = createAction(
+  ECompetitionHeaderActions.CompetitionVersionChangeStatusManual,
+  props<{ versionId: string, status: CompetitionVersionStatusEnum }>()
+);
+
+export const createCompetitionVersionSuccess = createAction(
+  ECompetitionHeaderActions.CreateCompetitionVersionSuccess,
+  props<{ versionId: string }>()
+);
+
+export const selectCompetitionVersion = createAction(
+  ECompetitionHeaderActions.SelectCompetitionVersion,
+  props<{ versionId: string }>()
+);
+
+export const activateCompetition = createAction(
+  ECompetitionHeaderActions.ActivateCompetition
+);
+
+export const pauseCompetition = createAction(
+  ECompetitionHeaderActions.PauseCompetition
+);
+
+export const cancelCompetition = createAction(
+  ECompetitionHeaderActions.CancelCompetition
+);
+
+export const cancelCompetitionWithValidation = createAction(
+  ECompetitionHeaderActions.CancelCompetitionWithValidation,
+  props<{ versionId: string }>()
+);
+
+export const completeCompetition = createAction(
+  ECompetitionHeaderActions.CompleteCompetition
+);
+
+export const competitionChangeStatusSuccess = createAction(
+  ECompetitionHeaderActions.CompetitionChangeStatusSuccess
+);

package/src/lib/modules/competition-header/store/competition-header.effects.ts

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { select, Store } from '@ngrx/store';
+import { EMPTY } from 'rxjs';
+import { catchError, map, switchMap, tap, withLatestFrom } from 'rxjs/operators';
+import * as CompetitionHeaderActions from './competition-header.actions';
+import { cancelCompetitionWithValidation, ECompetitionHeaderActions } from './competition-header.actions';
+import { CompetitionHeaderVersionModel } from '../models/competition-header-version.model';
+import { CompetitionHeaderService } from '../services/competition-header.service';
+import {
+  AlertService,
+  CompetitionVersionStatusEnum,
+  MessageSeverity,
+  selectCompetitionId,
+  Utilities
+} from 'myrtex-mf-ui-composite';
+
+
+@Injectable()
+export class CompetitionHeaderEffects {
+
+  loadCompetitionHeader$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.LoadCompetitionHeader),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.getHeader(competitionId).pipe(
+        map((result: CompetitionHeaderVersionModel) => CompetitionHeaderActions.loadCompetitionHeaderSuccess({competitionHeader: result})),
+        catchError((err) => {
+          this.alertService.showMessage(err, null, MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })));
+
+  deleteCompetitionVersion$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.DeleteCompetitionVersion),
+    map((action: { versionId: string }) => action.versionId),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([versionId, competitionId]) => {
+      return this.competitionHeaderService.deleteVersion(competitionId, versionId).pipe(
+        map((result: boolean) => CompetitionHeaderActions.deleteCompetitionVersionSuccess({versionId})),
+        catchError((err) => {
+          this.alertService.showMessage(err, null, MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })));
+
+  deleteCompetitionVersionSuccess$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.DeleteCompetitionVersionSuccess),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    tap(([, competitionId]) => window.location.href = `/application/competitions/item?competitionId=${competitionId}`)
+  ), {dispatch: false});
+
+  createCompetitionVersion$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CreateCompetitionVersion),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.createVersion(competitionId).pipe(
+        map((result: string) => CompetitionHeaderActions.createCompetitionVersionSuccess({versionId: result})),
+        catchError((err) => {
+          this.alertService.showMessage(err, null, MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })));
+
+  createCompetitionVersionSuccess$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CreateCompetitionVersionSuccess),
+    map((action: { versionId: string }) => action.versionId),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    tap(([versionId, competitionId]) =>
+      window.location.href = `/application/competitions/item?competitionId=${competitionId}&versionId=${versionId}`)
+  ), {dispatch: false});
+
+  competitionVersionChangeStatus$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CompetitionVersionChangeStatus),
+    map((action: { versionId: string, status: CompetitionVersionStatusEnum }) => action),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([action, competitionId]) => {
+      return this.competitionHeaderService.versionChangeStatus(competitionId, action.versionId, action.status).pipe(
+        map((result: boolean) => {
+          return CompetitionHeaderActions.competitionVersionChangeStatusSuccess({
+            versionId: action.versionId,
+            status: action.status
+          });
+        }),
+        catchError((err) => {
+          this.alertService.showMessage(err, null, MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })));
+
+  competitionVersionChangeStatusSuccess$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CompetitionVersionChangeStatusSuccess),
+    map((action: { versionId: string, status: CompetitionVersionStatusEnum }) => action),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    tap(([action, competitionId]) => {
+      if (action.status === CompetitionVersionStatusEnum.Validation) {
+        window.location.href = `/m-data/minfin/selection/edit?competitionId=${competitionId}&versionId=${action.versionId}`;
+      } else {
+        window.location.reload();
+      }
+    })
+  ), {dispatch: false});
+
+  selectCompetitionVersion$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.SelectCompetitionVersion),
+    map((action: { versionId: string }) => action.versionId),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    tap(([versionId, competitionId]) => {
+      const newUri = Utilities.updateQueryStringParameter(window.location.href, 'versionId', versionId);
+      window.location.href = newUri;
+    })
+  ), {dispatch: false});
+
+  activateCompetition$ = createEffect(() => (this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.ActivateCompetition),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.activate(competitionId).pipe(
+        map((result: any) => CompetitionHeaderActions.competitionChangeStatusSuccess()),
+        catchError((err, caught) => {
+          this.alertService.showStickyMessage(err, 'Ошибка активации', MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })
+  )));
+
+  pauseCompetition$ = createEffect(() => (this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.PauseCompetition),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.pause(competitionId).pipe(
+        map((result: any) => CompetitionHeaderActions.competitionChangeStatusSuccess()),
+        catchError((err, caught) => {
+          this.alertService.showStickyMessage(err, 'Ошибка приостановки', MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })
+  )));
+
+  completeCompetition$ = createEffect(() => (this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CompleteCompetition),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.complete(competitionId).pipe(
+        map((result: any) => CompetitionHeaderActions.competitionChangeStatusSuccess()),
+        catchError((err, caught) => {
+          this.alertService.showStickyMessage(err, 'Ошибка при завершении', MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })
+  )));
+
+  cancelCompetition$ = createEffect(() => (this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CancelCompetition),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    switchMap(([, competitionId]) => {
+      return this.competitionHeaderService.cancel(competitionId).pipe(
+        map((result: any) => CompetitionHeaderActions.competitionChangeStatusSuccess()),
+        catchError((err, caught) => {
+          this.alertService.showStickyMessage(err, 'Ошибка при отмене', MessageSeverity.error);
+          return EMPTY;
+        })
+      );
+    })
+  )));
+
+  cancelCompetitionWithValidation$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CancelCompetitionWithValidation),
+    map((action: { versionId: string }) => action.versionId),
+    withLatestFrom(this.store.pipe(select(selectCompetitionId))),
+    tap(([versionId, competitionId]) =>
+      window.location.href = `/m-data/minfin/selection/edit/cancel?competitionId=${competitionId}&versionId=${versionId}`)
+  ), {dispatch: false});
+
+  competitionChangeStatusSuccess$ = createEffect(() => this.actions$.pipe(
+    ofType(ECompetitionHeaderActions.CompetitionChangeStatusSuccess),
+    tap(() => window.location.reload())
+  ), {dispatch: false});
+
+  constructor(private competitionHeaderService: CompetitionHeaderService,
+              private actions$: Actions,
+              private store: Store,
+              private alertService: AlertService
+  ) {
+  }
+}

package/src/lib/modules/competition-header/store/competition-header.reducers.ts

@@ -0,0 +1,39 @@
+import {Action, createReducer, on} from '@ngrx/store';
+import * as CompetitionActions from './competition-header.actions';
+import {CompetitionHeaderState, initialCompetitionHeaderState} from './competition-header.state';
+import {CompetitionStatusModel} from '../models/competition-status.model';
+
+const competitionHeaderReducerCreator = createReducer(
+  initialCompetitionHeaderState,
+
+  on(CompetitionActions.loadCompetitionHeaderSuccess, (state, {competitionHeader}) => {
+    const versions = competitionHeader.versions;
+    const competition = {
+      id: competitionHeader.id,
+      status: competitionHeader.status,
+      mode: competitionHeader.mode
+    } as CompetitionStatusModel;
+    return {
+      ...state,
+      competitionVersions: versions,
+      defaultVersionVersionId: competitionHeader.selectedCompetitionVersionId,
+      competition, activityId: competitionHeader.activityId,
+      type: competitionHeader.type
+    };
+  }),
+
+  on(CompetitionActions.competitionVersionChangeStatusManual, (state, {versionId, status}) => {
+    const versions = [...state.competitionVersions];
+    const version = versions.find(s => s.id === versionId);
+    if (version) {
+      const newVersion = {...version};
+      newVersion.status = status;
+      versions.splice(versions.indexOf(version), 1, newVersion);
+    }
+    return {...state, competitionVersions: versions, manualVersionStatusChanged: true};
+  })
+);
+
+export function competitionHeaderReducer(state: CompetitionHeaderState | undefined, action: Action) {
+  return competitionHeaderReducerCreator(state, action);
+}

package/src/lib/modules/competition-header/store/competition-header.selector.ts

@@ -0,0 +1,45 @@
+import {createFeatureSelector, createSelector} from '@ngrx/store';
+import {CompetitionHeaderState} from './competition-header.state';
+import {COMPETITION_HEADER_FEATURE_NAME} from '../constants';
+import { selectCompetitionIdAndVersionId } from 'myrtex-mf-ui-composite';
+
+const competitionVersionsFeature =
+  createFeatureSelector<CompetitionHeaderState>(COMPETITION_HEADER_FEATURE_NAME);
+
+export const selectCompetitionVersions = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.competitionVersions
+);
+
+export const selectCompetitionDefaultVersionId = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.defaultVersionVersionId
+);
+
+export const selectCompetitionSelectedVersionId = createSelector(
+  selectCompetitionIdAndVersionId,
+  selectCompetitionDefaultVersionId,
+  (cv: {competitionId: string | undefined, versionId: string | undefined}, dv: string) => {
+    return cv.versionId ? cv.versionId : dv;
+  }
+);
+
+export const selectCompetitionStatus = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.competition
+);
+
+export const selectManualVersionStatusChanged = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.manualVersionStatusChanged
+);
+
+export const selectActivityId = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.activityId
+);
+
+export const selectCompetitionType = createSelector(
+  competitionVersionsFeature,
+  (state: CompetitionHeaderState) => state.type
+);

package/src/lib/modules/competition-header/store/competition-header.state.ts

@@ -0,0 +1,21 @@
+import { CompetitionTypeEnum } from 'myrtex-mf-ui-composite';
+import {CompetitionStatusModel} from '../models/competition-status.model';
+import {CompetitionVersionModel} from '../models/competition-version.model';
+
+export interface CompetitionHeaderState {
+  competition: CompetitionStatusModel | null;
+  competitionVersions: CompetitionVersionModel[];
+  defaultVersionVersionId: string;
+  manualVersionStatusChanged: boolean;
+  activityId: string | undefined;
+  type: CompetitionTypeEnum | undefined;
+}
+
+export const initialCompetitionHeaderState: CompetitionHeaderState = {
+  competition: null,
+  competitionVersions: [],
+  defaultVersionVersionId: '',
+  manualVersionStatusChanged: false,
+  activityId: undefined,
+  type: undefined
+};

package/{public-api.d.ts → src/public-api.ts}

@@ -1,2 +1,6 @@
+/*
+ * Public API Surface of myrtex-mf-competition
+ */
+
 export * from './lib/modules/competition-header/competition-header.module';
 export * from './lib/modules/competition-header/index';

package/src/test.ts

@@ -0,0 +1,27 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    <T>(id: string): T;
+    keys(): string[];
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting(),
+);
+
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/esm2020/lib/modules/competition-header/competition-header.module.mjs

@@ -1,76 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { EffectsModule } from '@ngrx/effects';
-import { StoreModule } from '@ngrx/store';
-import { CompetitionHeaderComponent } from './components/competition-header.component';
-import { FormsModule } from '@angular/forms';
-import { COMPETITION_HEADER_FEATURE_NAME } from './constants';
-import { competitionHeaderReducer } from './store/competition-header.reducers';
-import { CompetitionHeaderService } from './services/competition-header.service';
-import { CompetitionHeaderCustomButtonsDirective } from './directives/competition-header-custom-buttons.directive';
-import { NgSelectModule } from '@ng-select/ng-select';
-import { MyrtexMfUiCompositeModule, MyrtexUiComponentsModule, TenantSettingsModule } from 'myrtex-mf-ui-composite';
-import { MyrtexSignerModule } from 'myrtex-mf-signer';
-import { CompetitionHeaderEffects } from './store/competition-header.effects';
-import { SettingsService } from './services/settings.service';
-import { DropdownModule } from 'myrta-ui';
-import * as i0 from "@angular/core";
-import * as i1 from "@ngrx/effects";
-import * as i2 from "@ngrx/store";
-export class CompetitionHeaderModule {
-}
-CompetitionHeaderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CompetitionHeaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-CompetitionHeaderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CompetitionHeaderModule, declarations: [CompetitionHeaderComponent,
-        CompetitionHeaderCustomButtonsDirective], imports: [CommonModule, i1.EffectsFeatureModule, i2.StoreFeatureModule, TenantSettingsModule,
-        FormsModule,
-        MyrtexUiComponentsModule,
-        MyrtexMfUiCompositeModule,
-        MyrtexSignerModule,
-        NgSelectModule,
-        DropdownModule], exports: [CompetitionHeaderComponent,
-        CompetitionHeaderCustomButtonsDirective] });
-CompetitionHeaderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CompetitionHeaderModule, providers: [
-        CompetitionHeaderService,
-        SettingsService
-    ], imports: [[
-            CommonModule,
-            EffectsModule.forFeature([CompetitionHeaderEffects]),
-            StoreModule.forFeature(COMPETITION_HEADER_FEATURE_NAME, competitionHeaderReducer),
-            TenantSettingsModule,
-            FormsModule,
-            MyrtexUiComponentsModule,
-            MyrtexMfUiCompositeModule,
-            MyrtexSignerModule,
-            NgSelectModule,
-            DropdownModule
-        ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CompetitionHeaderModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [
-                        CompetitionHeaderComponent,
-                        CompetitionHeaderCustomButtonsDirective,
-                    ],
-                    imports: [
-                        CommonModule,
-                        EffectsModule.forFeature([CompetitionHeaderEffects]),
-                        StoreModule.forFeature(COMPETITION_HEADER_FEATURE_NAME, competitionHeaderReducer),
-                        TenantSettingsModule,
-                        FormsModule,
-                        MyrtexUiComponentsModule,
-                        MyrtexMfUiCompositeModule,
-                        MyrtexSignerModule,
-                        NgSelectModule,
-                        DropdownModule
-                    ],
-                    providers: [
-                        CompetitionHeaderService,
-                        SettingsService
-                    ],
-                    exports: [
-                        CompetitionHeaderComponent,
-                        CompetitionHeaderCustomButtonsDirective,
-                    ]
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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