9367144083

Committed 04 Jun 2024 12:33PM UTC coverage: 88.838% (+0.02%) from 88.822%

Build # 9367144083

Build Type

Pull #3811

github

Committed by

web-flow

Commit Message

Merge 5d0757369 into 1a21a7c1a

Pull Request Pull Request #3811: fix(stark-core): fix support for URL query parameters

Run Details

1263 of 1531 branches covered (82.5%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

5 existing lines in 1 file now uncovered.

3775 of 4140 relevant lines covered (91.18%)

192.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.9

/packages/stark-core/src/modules/routing/services/routing.service.ts

import { Store } from "@ngrx/store";
import { EMPTY, from, Observable } from "rxjs";
import { ErrorHandler, Inject, Injectable } from "@angular/core";
import {
        HookMatchCriteria,
        HookRegOptions,
        HookResult,
        Param,
        PathNode,
        RawParams,
        Rejection,
        RejectType,
        Resolvable,
        StateDeclaration,
        StateObject,
        StateParams,
        StateService,
        TargetState,
        Transition,
        TransitionHookFn,
        TransitionOptions,
        TransitionService,
        TransitionStateHookFn,
        UIRouterGlobals
} from "@uirouter/core";

import { STARK_LOGGING_SERVICE, StarkLoggingService } from "../../logging/services";
import { StarkRoutingService, starkRoutingServiceName } from "./routing.service.intf";
import { StarkRoutingActions } from "../actions";
import { STARK_APP_CONFIG, StarkApplicationConfig } from "../../../configuration/entities/application";
import { StarkRoutingTransitionHook } from "./routing-transition-hook.constants";
import { StarkStateConfigWithParams } from "./state-config-with-params.intf";
import { StarkCoreApplicationState } from "../../../common/store";
import { StarkConfigurationUtil } from "../../../util/configuration.util";
import { starkAppExitStateName, starkAppInitStateName } from "../../session/constants";
import isEmpty from "lodash-es/isEmpty";

/**
 * @ignore
 */
interface StarkState {
        name: string;
        params?: RawParams;
}

/**
 * @ignore
 */
@Injectable()
export class StarkRoutingServiceImpl implements StarkRoutingService {
        public lastTransition?: Transition;
        public knownRejectionCausesRegex: RegExp;
        public knownRejectionCauses: string[];
        public errorLastTransition = "lastTransition needs to be defined";

        // To store the state history
        /** @internal */
        private _starkStateHistory: StarkState[];

        public constructor(
                @Inject(STARK_LOGGING_SERVICE) private logger: StarkLoggingService,
                @Inject(STARK_APP_CONFIG) private appConfig: StarkApplicationConfig,
                private defaultErrorHandler: ErrorHandler,
                private store: Store<StarkCoreApplicationState>,
                private $state: StateService,
                private $transitions: TransitionService,
                private $globals: UIRouterGlobals
        ) {
                // ensuring that the app config is valid before doing anything
                StarkConfigurationUtil.validateConfig(this.appConfig, ["routing"], starkRoutingServiceName);

                this.knownRejectionCauses = [];
                this.knownRejectionCausesRegex = new RegExp(starkRoutingServiceName + ": initial value");
                this._starkStateHistory = [];

                this.addNavigationSuccessHandlers();
                this.addNavigationErrorHandlers();

                this.logger.debug(starkRoutingServiceName + " loaded");
        }

        public navigateTo(newState: string, params?: RawParams, options?: TransitionOptions): Observable<any> {
                this.store.dispatch(
                        StarkRoutingActions.navigate({
                                currentState: this.getCurrentStateName(),
                                newState,
                                options,
                                params
                        })
                );
                return from(this.$state.go(newState, params, options));
        }

        public navigateToHome(params?: RawParams): Observable<any> {
                return this.navigateTo(this.appConfig.homeStateName, params);
        }

        public navigateToPrevious(): Observable<any> {
                const reason = "There is no previous state to navigate to.";

                if (this._starkStateHistory.length > 1) {
                        const previousState: StarkState = this._starkStateHistory[this._starkStateHistory.length - 2];
                        this._starkStateHistory = this._starkStateHistory.slice(0, this._starkStateHistory.length - 2);

                        const regexInitExitStateName = new RegExp("(" + starkAppInitStateName + "|" + starkAppExitStateName + ")");

                        if (
                                (this._starkStateHistory.length === 1 && this._starkStateHistory[0].name.match(regexInitExitStateName)) ||
                                this._starkStateHistory.length === 0
                        ) {
                                this.store.dispatch(StarkRoutingActions.navigationHistoryLimitReached());
                        }

                        if (previousState && !previousState.name.match(regexInitExitStateName) && previousState.name !== "") {
                                return this.navigateTo(previousState.name, previousState.params);
                        }
                }

                this.store.dispatch(StarkRoutingActions.navigationHistoryLimitReached());
                this.logger.warn(starkRoutingServiceName + ": navigateToPrevious - " + reason);
                return EMPTY;
        }

        public reload(): Observable<any> {
                this.store.dispatch(StarkRoutingActions.reload({ state: this.getCurrentStateName() }));
                const reload$: Observable<any> = from(this.$state.reload());
                // dispatch corresponding success action when transition is completed
                reload$.subscribe(
                        () =>
                                this.store.dispatch(
                                        StarkRoutingActions.reloadSuccess({ state: this.getCurrentStateName(), params: this.getCurrentStateParams(true) })
                                ),
                        () =>
                                this.store.dispatch(
                                        StarkRoutingActions.reloadFailure({ state: this.getCurrentStateName(), params: this.getCurrentStateParams(true) })
                                )
                );
                return reload$;
        }

        public getCurrentStateName(): string {
                return <string>this.$globals.current.name;
        }

        public getCurrentState(): StateObject {
                return this.$globals.$current;
        }

        public getCurrentStateConfig(): StateDeclaration {
                return this.$globals.current;
        }

        public getStatesConfig(): StateDeclaration[] {
                return this.$state.get();
        }

        public getStateConfigByUrlPath(urlPath: string): StarkStateConfigWithParams | undefined {
                let targetRoute: StarkStateConfigWithParams | undefined;

                let path!: string;
                let params: string | undefined;
                let hash: string | undefined;
                const paramValues: RawParams = {};

                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                [, path, params, hash, path = path, params = params, path = path, hash = hash, path = path] = urlPath.match(
                        /(.*)\?(.*)#(.*)|(.*)\?(.*)|(.*)#(.*)|(.*)/
                )!;

                if (typeof params === "string") {
                        params.split("&").forEach((param: string) => {
                                const keyValue = param.split("=");
                                paramValues[keyValue[0]] = keyValue[1];
                        });
                }

                const matchedState: StateDeclaration[] = this.getStatesConfig().filter(
                        (state: StateDeclaration) => (<Function>state.$$state)().url && (<Function>state.$$state)().url.exec(path, undefined, hash)
                );

                if (matchedState.length) {
                        targetRoute = {
                                state: matchedState[0],
                                paramValues: {
                                        ...(<Function>matchedState[0].$$state)().url.exec(path, undefined, hash),
                                        ...paramValues
                                }
                        };
                }

                return targetRoute;
        }

        public getStateDeclarationByStateName(stateName: string): StateDeclaration | undefined {
                const stateDeclaration: StateDeclaration = this.$state.get(stateName);

                if (stateDeclaration) {
                        return stateDeclaration;
                }

                return undefined;
        }

        public getCurrentStateParams(includeInherited: boolean = false): RawParams {
                // TODO: This function has unexpected behaviour in some cases
                // for instance:
                //   navigateTo: homepage with params { RequestID: "Request01" }
                //   navigateTo: page-01 with params { RequestID: "Request02" }
                //   navigateTo: page-01-01 with params { RequestID: "Request03" }
                //   navigateTo: homepage with params undefined
                //
                //   getCurrentStateParams returns homepage with params { RequestID: "Request03" }

                const currentParams: StateParams = this.$globals.params;
                const currentStateParams: RawParams = {};
                const stateParams: Param[] = this.$globals.$current.parameters({ inherit: includeInherited });

                // extract the values from the stateOwnParams (no other way to do this :S)
                for (const param of stateParams) {
                        // filter out root state default param "#"
                        if (param.id !== "#") {
                                currentStateParams[param.id] = currentParams[param.id];
                        }
                }

                return currentStateParams;
        }

        public isCurrentUiState(stateName: string, stateParams?: RawParams): boolean {
                if (stateName === this.getCurrentStateName() && stateParams) {
                        const currentStateParams: RawParams = this.getCurrentStateParams(true);
                        let stateParamsMatchCurrent = true;

                        // If there is a value in the stateParams that is different from the currentStateParams, then it is not the current state
                        for (const key in stateParams) {
                                if (
                                        // eslint-disable-next-line no-prototype-builtins
                                        stateParams.hasOwnProperty(key) &&
                                        // eslint-disable-next-line no-prototype-builtins
                                        currentStateParams.hasOwnProperty(key) &&
                                        stateParams[key] !== currentStateParams[key]
                                ) {
                                        stateParamsMatchCurrent = false;
                                        break;
                                }
                        }

                        return stateParamsMatchCurrent;
                }

                return stateName === this.getCurrentStateName();
        }

        public isCurrentUiStateIncludedIn(stateName: string, stateParams?: RawParams): boolean {
                // === true is necessary here because includes method returns TRUE, FALSE or undefined
                // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
                return this.$state.includes(stateName, stateParams) === true;
        }

        public addKnownNavigationRejectionCause(rejectionCause: string): void {
                this.knownRejectionCauses.push(rejectionCause);
                this.knownRejectionCausesRegex = new RegExp(this.knownRejectionCauses.join("|"));
        }

        public addTransitionHook(
                lifecycleHook: string,
                matchCriteria: HookMatchCriteria,
                callback: TransitionHookFn | TransitionStateHookFn,
                options?: HookRegOptions
        ): () => void {
                switch (lifecycleHook) {
                        case StarkRoutingTransitionHook.ON_BEFORE:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onbefore
                                return <() => void>this.$transitions.onBefore(matchCriteria, <TransitionHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_START:
                                // see https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onstart
                                return <() => void>this.$transitions.onStart(matchCriteria, <TransitionHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_EXIT:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onexit
                                return <() => void>this.$transitions.onExit(matchCriteria, <TransitionStateHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_RETAIN:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onretain
                                return <() => void>this.$transitions.onRetain(matchCriteria, <TransitionStateHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_ENTER:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onenter
                                return <() => void>this.$transitions.onEnter(matchCriteria, <TransitionStateHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_FINISH:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onfinish
                                return <() => void>this.$transitions.onFinish(matchCriteria, <TransitionHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_SUCCESS:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onsuccess
                                return <() => void>this.$transitions.onSuccess(matchCriteria, <TransitionHookFn>callback, options);
                        case StarkRoutingTransitionHook.ON_ERROR:
                                // see: https://ui-router.github.io/ng2/docs/latest/classes/transition.transitionservice.html#onerror
                                return <() => void>this.$transitions.onError(matchCriteria, <TransitionHookFn>callback, options);
                        default:
                                throw new Error(starkRoutingServiceName + ": lifecycle hook unknown => " + lifecycleHook);
                }
        }

        /**
         * Adds Angular UI-Router specific handlers for errors..
         * It logs an error and dispatches a NAVIGATE_FAILURE action to the NGRX Store
         */
        private addNavigationErrorHandlers(): void {
                this.logger.debug(starkRoutingServiceName + ": adding navigation error handlers");

                const hookMatchCriteria: HookMatchCriteria = {
                        /* empty criteria */
                };

                // Whenever an error occurs during a router transition
                this.addTransitionHook(
                        StarkRoutingTransitionHook.ON_ERROR,
                        hookMatchCriteria,
                        (transition: Transition): HookResult => {
                                const fromState: StateDeclaration = transition.from();
                                const targetState: TargetState = transition.targetState();
                                const rejection: Rejection = transition.error();
                                const rejectionString: string = rejection.toString();
                                let message: string = starkRoutingServiceName + ": ";
                                const complementaryInfo = `"${targetState.name()}" navigated from "${
                                        fromState.name
                                }". Parameters that were passed: ${JSON.stringify(targetState.params())}`;

                                if (this.knownRejectionCausesRegex.test(rejectionString)) {
                                        const rejectionAction = StarkRoutingActions.navigateRejection({
                                                currentState: <string>fromState.name,
                                                newState: targetState.name().toString(),
                                                params: targetState.params(),
                                                reason: rejectionString
                                        });
                                        message += 'Route transition rejected: "' + complementaryInfo + " Known rejection: " + rejectionString;

                                        // dispatch corresponding action to allow the user to trigger his own effects if needed
                                        this.store.dispatch(rejectionAction);
                                        this.logger.warn(message);
                                } else {
                                        switch (rejection.type) {
                                                case RejectType.IGNORED:
                                                        message += 'Route transition ignored: "' + complementaryInfo + " Rejection: " + rejectionString;

                                                        this.logger.warn(message);
                                                        break;
                                                case RejectType.SUPERSEDED:
                                                        message += 'Route transition superseded: "' + complementaryInfo + " Rejection: " + rejectionString;

                                                        this.logger.warn(message);
                                                        break;
                                                default:
                                                        // dispatch corresponding action to allow the user to trigger his own effects if needed
                                                        this.store.dispatch(
                                                                StarkRoutingActions.navigateFailure({
                                                                        currentState: <string>fromState.name,
                                                                        newState: targetState.name().toString(),
                                                                        params: targetState.params(),
                                                                        error: rejectionString
                                                                })
                                                        );

                                                        // reference: https://ui-router.github.io/ng2/docs/latest/classes/state.stateservice.html#go
                                                        if (rejectionString.match(/transition superseded|transition prevented|transition aborted|transition failed/)) {
                                                                this.logger.warn(starkRoutingServiceName + ": " + rejectionString);
                                                        } else if (rejectionString.match(/resolve error/)) {
                                                                this.logger.error(
                                                                        starkRoutingServiceName + ": An error occurred with a resolve in the new state. " + rejectionString
                                                                );
                                                        } else {
                                                                message += 'Error during route transition: "' + complementaryInfo;
                                                                this.logger.error(message, transition.error());
                                                        }

                                                        break;
                                        }
                                }

                                // HookResult: https://ui-router.github.io/ng2/docs/latest/modules/transition.html#hookresult
                                // boolean | TargetState | void | Promise<boolean | TargetState | void>
                                return false;
                        },
                        { priority: 1000 } // very high priority (this hook should be the first one to be called to dispatch actions immediately)
                );

                // declare the onInvalid handler
                // https://ui-router.github.io/ng2/docs/latest/classes/state.stateservice.html#oninvalid
                this.$state.onInvalid((toState?: TargetState, fromState?: TargetState): HookResult => {
                        const errorType = "Invalid state change";
                        const failureAction = StarkRoutingActions.navigateFailure({
                                currentState: (<TargetState>fromState).name(),
                                newState: (<TargetState>toState).name(),
                                params: (<TargetState>toState).params(),
                                error: errorType
                        });
                        let message: string =
                                starkRoutingServiceName + ': Error while trying to navigate from "' + (<TargetState>fromState).name() + '"';
                        message += ' to "' + (<TargetState>toState).name() + '"';

                        if (toState && !toState.exists()) {
                                message = message + ". The target state does NOT exist";
                        }

                        // dispatch corresponding action to allow the user to trigger his own effects if needed
                        this.store.dispatch(failureAction);
                        this.logger.error(message, new Error("Parameters that were passed: " + JSON.stringify((<TargetState>toState).params())));

                        // TODO redirect to the generic error page once implemented: https://jira.prd.nbb/browse/NG-847
                        // should probably be done via an effect reacting to the StarkRoutingActions.navigateFailure action

                        // HookResult: https://ui-router.github.io/ng2/docs/latest/modules/transition.html#hookresult
                        // boolean | TargetState | void | Promise<boolean | TargetState | void>
                        return false;
                });

                // provide custom default error handler
                // https://ui-router.github.io/ng2/docs/latest/classes/state.stateservice.html#defaulterrorhandler
                this.$state.defaultErrorHandler((error: any): void => {
                        let stringError: string;
                        if (error instanceof Rejection) {
                                stringError = error.toString();
                        } else {
                                stringError = String(error);
                        }

                        if (!this.knownRejectionCausesRegex.test(stringError)) {
                                this.defaultErrorHandler.handleError(Error(stringError));
                        }
                });
        }

        /**
         * Adds Angular UI-Router specific handlers for success..
         * It stores the last transition
         */
        private addNavigationSuccessHandlers(): void {
                this.logger.debug(starkRoutingServiceName + ": adding navigation success handlers");

                const hookMatchCriteria: HookMatchCriteria = {
                        /* empty criteria */
                };

                // Whenever a router transition successfully completes
                this.addTransitionHook(
                        StarkRoutingTransitionHook.ON_SUCCESS,
                        hookMatchCriteria,
                        (transition: Transition): HookResult => {
                                this.lastTransition = transition;
                                // HookResult: https://ui-router.github.io/ng2/docs/latest/modules/transition.html#hookresult
                                // boolean | TargetState | void | Promise<boolean | TargetState | void>

                                const previousStateName: string = <string>transition.from().name;
                                const currentState: TargetState = transition.targetState();
                                const currentStateParams: RawParams = this.getCurrentStateParams(true);

                                this.store.dispatch(
                                        StarkRoutingActions.navigateSuccess({
                                                previousState: previousStateName,
                                                currentState: currentState.name(),
                                                params: currentStateParams
                                        })
                                );

                                if (transition.dynamic()) {
                                        // for a dynamic transition, the last entry in the stateHistory should be re-created rather than being added again!
                                        // so it should be removed first ;)
                                        this._starkStateHistory.pop();
                                }
                                // Add the params of the current state to the _stateTreeParams array
                                this._starkStateHistory.push({ name: currentState.name(), params: currentStateParams });

                                return true; // the transition will resume
                        },
                        { priority: 1000 } // very high priority (this hook should be the first one to be called to keep the lastTransition up to date)
                );
        }

        // FIXME: re-enable this ESLint rule and refactor this function to reduce its cognitive complexity
        // eslint-disable-next-line sonarjs/cognitive-complexity
        public getStateTreeParams(): Map<string, any> {
                const stateTreeParams: Map<string, any> = new Map<string, unknown>();

                if (typeof this.lastTransition !== "undefined") {
                        // we use the TO pathNodes because the resolved values can only be found in those and not in the FROM pathNodes
                        const pathNodes: PathNode[] = this.lastTransition.treeChanges().to;

                        // the array is processed in reverse to start with the child state first (the pathNodesArray is [rootState, ..., childState])
                        let index: number = pathNodes.length - 1;

                        for (index; index >= 0; index--) {
                                const pathNode: PathNode = pathNodes[index];

                                // skipping abstract states and the root state
                                if (!pathNode.state.abstract && pathNode.state !== pathNode.state.root()) {
                                        let stateParams: RawParams | undefined;

                                        for (let i: number = this._starkStateHistory.length - 1; i >= 0; i--) {
                                                if (this._starkStateHistory[i].name === pathNode.state.name) {
                                                        stateParams = this._starkStateHistory[i].params;
                                                        break;
                                                }
                                        }

                                        stateTreeParams.set(pathNode.state.name, stateParams);
                                }
                        }
                } else {
                        this.logger.debug(this.errorLastTransition);
                }

                return stateTreeParams;
        }

        public getStateTreeResolves(): Map<string, any> {
                const stateTreeResolves: Map<string, any> = new Map<string, unknown>();

                if (typeof this.lastTransition !== "undefined") {
                        // we use the TO pathNodes because the resolved values can only be found in those and not in the FROM pathNodes
                        const pathNodes: PathNode[] = this.lastTransition.treeChanges().to;

                        // the array is processed in reverse to start with the child state first (the pathNodesArray is [rootState, ..., childState])
                        let index: number = pathNodes.length - 1;

                        for (index; index >= 0; index--) {
                                const pathNode: PathNode = pathNodes[index];

                                // skipping abstract states and the root state
                                // and taking only the current state and parent/ancestor states
                                if (
                                        !pathNode.state.abstract &&
                                        pathNode.state !== pathNode.state.root() &&
                                        (pathNode.state === this.getCurrentState() || this.isParentState(pathNode.state))
                                ) {
                                        const resolvablesData: { [key: string]: any } = this.extractResolvablesData(pathNode.resolvables);
                                        const stateResolves: any = isEmpty(resolvablesData) ? undefined : resolvablesData;
                                        stateTreeResolves.set(pathNode.state.name, stateResolves);
                                }
                        }
                } else {
                        this.logger.debug(this.errorLastTransition);
                }

                return stateTreeResolves;
        }

        public getStateTreeData(): Map<string, any> {
                const stateTreeData: Map<string, any> = new Map<string, unknown>();

                if (typeof this.lastTransition !== "undefined") {
                        // we use the TO pathNodes to get also the current state (the FROM pathNodes include only the previous/parent states)
                        const pathNodes: PathNode[] = this.lastTransition.treeChanges().to;

                        // the array is processed in reverse to start with the child state first (the pathNodesArray is [rootState, ..., childState])
                        let index: number = pathNodes.length - 1;

                        for (index; index >= 0; index--) {
                                const pathNode: PathNode = pathNodes[index];

                                // skipping abstract states and the root state
                                // and taking only the current state and parent/ancestor states
                                if (
                                        !pathNode.state.abstract &&
                                        pathNode.state !== pathNode.state.root() &&
                                        (pathNode.state === this.getCurrentState() || this.isParentState(pathNode.state))
                                ) {
                                        const stateData: any = isEmpty(pathNode.state.data) ? undefined : pathNode.state.data;
                                        stateTreeData.set(pathNode.state.name, stateData);
                                }
                        }
                } else {
                        this.logger.debug(this.errorLastTransition);
                }

                return stateTreeData;
        }

        /**
         * Check whether the given state is a parent/ancestor of the given currentState
         * @param state - The state that will be checked whether is a parent of the currentState
         * @param currentState - (Optional) If not provided, it is set to the current router state
         */
        private isParentState(state: StateObject, currentState: StateObject = this.getCurrentState()): boolean {
                if (currentState.parent) {
                        if (currentState.parent === state) {
                                return true;
                        }

                        return this.isParentState(state, currentState.parent);
                }

                return false;
        }

        private extractResolvablesData(resolvables: Resolvable[]): { [key: string]: any } {
                const resolvablesData: { [key: string]: any } = {};

                for (const resolvable of resolvables) {
                        // exclude the 'Core Resolvables' added by angular-ui-router
                        // see: https://github.com/ui-router/core/commit/a06948b
                        if (resolvable.token !== "$state$" && resolvable.token !== "$transition$" && resolvable.token !== "$stateParams") {
                                resolvablesData[resolvable.token] = resolvable.data;
                        }
                }

                return resolvablesData;
        }

        // TODO How to fetch translationKey from the State resolves without navigating to that state?
        public getTranslationKeyFromState(stateName: string): string {
                const stateTreeResolves: Map<string, any> = this.getStateTreeResolves();
                const stateData: object = this.$state.get(stateName).data;

                let stateTranslationKey: string | undefined;
                // get the translationKey in case it is defined as a resolve in the state definition
                if (stateTreeResolves.get(stateName)) {
                        stateTranslationKey = stateTreeResolves.get(stateName)["translationKey"];
                }
                // if not found in the resolves then check the state's data object
                // eslint-disable-next-line no-prototype-builtins
                if (stateData && !stateTranslationKey && stateData.hasOwnProperty("translationKey")) {
                        stateTranslationKey = stateData["translationKey"];
                }
                // if no translationKey so far, then the state name is used
                if (!stateTranslationKey) {
                        this.logger.warn(starkRoutingServiceName + ": translation key not found for state " + stateName);
                        stateTranslationKey = stateName;
                }

                return stateTranslationKey;
        }
}

NationalBankBelgium / stark / 9367144083

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous