@linid-dm/directory-manager-client-core
Version:
Core package by providing a set of angular components for the Directory Manager app.
172 lines • 22.4 kB
JavaScript
import { __decorate } from "tslib";
/**
* Copyright (C) 2020-2024 Linagora
*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU Affero General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version, provided you comply with the Additional Terms applicable for
* LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU
* Affero General Public License, subsections (b), (c), and (e), pursuant to
* which these Appropriate Legal Notices must notably (i) retain the display of
* the "LinID™" trademark/logo at the top of the interface window, the display
* of the “You are using the Open Source and free version of LinID™, powered by
* Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise
* offer!” infobox and in the e-mails sent with the Program, notice appended to
* any type of outbound messages (e.g. e-mail and meeting requests) as well as
* in the LinID Directory Manager user interface, (ii) retain all hypertext
* links between LinID Directory Manager and https://linid.org/, as well as
* between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA
* intellectual property rights over its trademarks and commercial brands. Other
* Additional Terms apply, see <http://www.linagora.com/licenses/> for more
* details.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
* details.
*
* You should have received a copy of the GNU Affero General Public License and
* its applicable Additional Terms for LinID Directory Manager along with this
* program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero
* General Public License version 3 and <http://www.linagora.com/licenses/> for
* the Additional Terms applicable to the LinID Directory Manager software.
*/
import { Injectable } from '@angular/core';
import { Action, Selector, State } from '@ngxs/store';
import { tap } from 'rxjs';
import { emptyJsTable, mergeInto, toJsTable, } from '../../helpers/jstable.helper';
import * as Error from '../error/error.actions';
import * as ExternalLinks from '../external-links/external-links.actions';
import * as Header from '../header/header.actions';
import * as Home from '../home/home.actions';
import * as LogoutDialog from '../logout-dialog/logout-dialog.actions';
import * as Ui from '../ui/ui.actions';
import * as User from '../user/user.actions';
import * as Configs from './configs.actions';
import * as i0 from "@angular/core";
import * as i1 from "../../services/configs.service";
import * as i2 from "@ngxs/store";
export function initConfigStateDefaultValues() {
return {
...emptyJsTable(),
isFetchingConfigs: false,
isFetchingConfigsError: false,
isFetchingConfigsSuccess: false,
};
}
let ConfigsState = class ConfigsState {
constructor(_configService, _store$) {
this._configService = _configService;
this._store$ = _store$;
}
static isFetchingConfigs(state) {
return state.isFetchingConfigs;
}
static isFetchingConfigsSuccess(state) {
return state.isFetchingConfigsSuccess;
}
static isFetchingConfigsError(state) {
return state.isFetchingConfigsError;
}
static getConfigsById(state) {
return state.byId;
}
static getConfigsAllIds(state) {
return state.allIds;
}
static getConfigsJsTable(state) {
return {
byId: state.byId,
allIds: state.allIds,
};
}
fetchConfigs(ctx) {
ctx.setState({
...ctx.getState(),
isFetchingConfigs: true,
isFetchingConfigsSuccess: false,
isFetchingConfigsError: false,
});
return this._configService.getConfigs().pipe(tap((config) => {
let actions = [];
if (!!config.externalLinks) {
const externalLinksConfig = config.externalLinks;
delete config.externalLinks;
actions.push(new ExternalLinks.SetExternalLinksConfig(externalLinksConfig));
}
const currentUserConfig = config.currentUser;
delete config.currentUser;
const homepageConfig = config.home;
delete config.home;
const headerConfig = config.header;
delete config.header;
const logoutDialogConfig = config.logoutDialog;
delete config.logoutDialog;
const genericErrorMessages = config.genericErrorMessages;
delete config.genericErrorMessages;
const genericAccessibility = config.genericAccessibility;
delete config.genericAccessibility;
actions.push(new User.SetCurrentUserConfig(currentUserConfig), new Home.SetHomepageConfig(homepageConfig), new Header.SetHeaderConfig(headerConfig), new LogoutDialog.SetLogoutDialogConfig(logoutDialogConfig), new Error.SetGenericErrorMessages(genericErrorMessages), new Ui.SetGenericAccessibility(genericAccessibility), new Configs.FetchConfigsSuccess({
configs: toJsTable(config),
}));
this._store$.dispatch(actions);
}));
}
fetchConfigsSuccess(ctx, action) {
ctx.setState({
...ctx.getState(),
...mergeInto({ ...ctx.getState() }, action.payload.configs),
isFetchingConfigs: false,
isFetchingConfigsSuccess: true,
});
}
fetchConfigsError(ctx) {
ctx.setState({
...ctx.getState(),
...emptyJsTable(),
isFetchingConfigs: false,
isFetchingConfigsError: true,
});
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ConfigsState, deps: [{ token: i1.ConfigsService }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ConfigsState }); }
};
__decorate([
Action(Configs.FetchConfigs)
], ConfigsState.prototype, "fetchConfigs", null);
__decorate([
Action(Configs.FetchConfigsSuccess)
], ConfigsState.prototype, "fetchConfigsSuccess", null);
__decorate([
Action(Configs.FetchConfigsError)
], ConfigsState.prototype, "fetchConfigsError", null);
__decorate([
Selector()
], ConfigsState, "isFetchingConfigs", null);
__decorate([
Selector()
], ConfigsState, "isFetchingConfigsSuccess", null);
__decorate([
Selector()
], ConfigsState, "isFetchingConfigsError", null);
__decorate([
Selector()
], ConfigsState, "getConfigsById", null);
__decorate([
Selector()
], ConfigsState, "getConfigsAllIds", null);
__decorate([
Selector()
], ConfigsState, "getConfigsJsTable", null);
ConfigsState = __decorate([
State({
name: 'configs',
defaults: initConfigStateDefaultValues(),
})
], ConfigsState);
export { ConfigsState };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ConfigsState, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i1.ConfigsService }, { type: i2.Store }], propDecorators: { fetchConfigs: [], fetchConfigsSuccess: [], fetchConfigsError: [] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configs.state.js","sourceRoot":"","sources":["../../../../../../../../../packages/libs/client-core/src/lib/shared/states/configs/configs.state.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (C) 2020-2024 Linagora\n *\n * This program is free software: you can redistribute it and/or modify it under\n * the terms of the GNU Affero General Public License as published by the Free\n * Software Foundation, either version 3 of the License, or (at your option) any\n * later version, provided you comply with the Additional Terms applicable for\n * LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU\n * Affero General Public License, subsections (b), (c), and (e), pursuant to\n * which these Appropriate Legal Notices must notably (i) retain the display of\n * the \"LinID™\" trademark/logo at the top of the interface window, the display\n * of the “You are using the Open Source and free version of LinID™, powered by\n * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise\n * offer!” infobox and in the e-mails sent with the Program, notice appended to\n * any type of outbound messages (e.g. e-mail and meeting requests) as well as\n * in the LinID Directory Manager user interface, (ii) retain all hypertext\n * links between LinID Directory Manager and https://linid.org/, as well as\n * between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA\n * intellectual property rights over its trademarks and commercial brands. Other\n * Additional Terms apply, see <http://www.linagora.com/licenses/> for more\n * details.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more\n * details.\n *\n * You should have received a copy of the GNU Affero General Public License and\n * its applicable Additional Terms for LinID Directory Manager along with this\n * program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero\n * General Public License version 3 and <http://www.linagora.com/licenses/> for\n * the Additional Terms applicable to the LinID Directory Manager software.\n */\n\nimport { Injectable } from '@angular/core';\nimport { Action, Selector, State, StateContext, Store } from '@ngxs/store';\nimport { tap } from 'rxjs';\nimport {\n  JsTable,\n  emptyJsTable,\n  mergeInto,\n  toJsTable,\n} from '../../helpers/jstable.helper';\nimport {\n  IConfig,\n  IConfigs,\n  ICurrentUserConfig,\n  IExternalLinksConfig,\n  IGenericAccessibilityConfig,\n  IGenericErrorMessagesConfig,\n  IHeaderConfig,\n  IHomepageConfig,\n  ILogoutDialogConfig,\n} from '../../interfaces/configs.interface';\nimport { ConfigsService } from '../../services/configs.service';\nimport * as Error from '../error/error.actions';\nimport * as ExternalLinks from '../external-links/external-links.actions';\nimport * as Header from '../header/header.actions';\nimport * as Home from '../home/home.actions';\nimport * as LogoutDialog from '../logout-dialog/logout-dialog.actions';\nimport * as Ui from '../ui/ui.actions';\nimport * as User from '../user/user.actions';\nimport * as Configs from './configs.actions';\n\nexport interface ConfigsStateModel extends JsTable<IConfig> {\n  isFetchingConfigs: boolean;\n  isFetchingConfigsError: boolean;\n  isFetchingConfigsSuccess: boolean;\n}\n\nexport function initConfigStateDefaultValues(): ConfigsStateModel {\n  return {\n    ...emptyJsTable<IConfig>(),\n    isFetchingConfigs: false,\n    isFetchingConfigsError: false,\n    isFetchingConfigsSuccess: false,\n  };\n}\n\n@State<ConfigsStateModel>({\n  name: 'configs',\n  defaults: initConfigStateDefaultValues(),\n})\n@Injectable()\nexport class ConfigsState {\n  constructor(\n    private _configService: ConfigsService,\n    private _store$: Store\n  ) {}\n  @Selector()\n  static isFetchingConfigs(state: ConfigsStateModel): boolean {\n    return state.isFetchingConfigs;\n  }\n\n  @Selector()\n  static isFetchingConfigsSuccess(state: ConfigsStateModel): boolean {\n    return state.isFetchingConfigsSuccess;\n  }\n\n  @Selector()\n  static isFetchingConfigsError(state: ConfigsStateModel): boolean {\n    return state.isFetchingConfigsError;\n  }\n\n  @Selector()\n  static getConfigsById(state: ConfigsStateModel): {\n    readonly [id: string]: IConfig;\n  } {\n    return state.byId;\n  }\n\n  @Selector()\n  static getConfigsAllIds(state: ConfigsStateModel): string[] {\n    return state.allIds;\n  }\n\n  @Selector()\n  static getConfigsJsTable(state: ConfigsStateModel): JsTable<IConfig> {\n    return {\n      byId: state.byId,\n      allIds: state.allIds,\n    };\n  }\n\n  @Action(Configs.FetchConfigs)\n  fetchConfigs(ctx: StateContext<ConfigsStateModel>): any {\n    ctx.setState({\n      ...ctx.getState(),\n      isFetchingConfigs: true,\n      isFetchingConfigsSuccess: false,\n      isFetchingConfigsError: false,\n    });\n    return this._configService.getConfigs().pipe(\n      tap((config: IConfigs) => {\n        let actions: any[] = [];\n        if (!!config.externalLinks) {\n          const externalLinksConfig: IExternalLinksConfig =\n            config.externalLinks;\n          delete config.externalLinks;\n          actions.push(\n            new ExternalLinks.SetExternalLinksConfig(externalLinksConfig)\n          );\n        }\n        const currentUserConfig: ICurrentUserConfig = config.currentUser;\n        delete config.currentUser;\n        const homepageConfig: IHomepageConfig = config.home;\n        delete config.home;\n        const headerConfig: IHeaderConfig = config.header;\n        delete config.header;\n        const logoutDialogConfig: ILogoutDialogConfig = config.logoutDialog;\n        delete config.logoutDialog;\n        const genericErrorMessages: IGenericErrorMessagesConfig =\n          config.genericErrorMessages;\n        delete config.genericErrorMessages;\n        const genericAccessibility: IGenericAccessibilityConfig =\n          config.genericAccessibility;\n        delete config.genericAccessibility;\n        actions.push(\n          new User.SetCurrentUserConfig(currentUserConfig),\n          new Home.SetHomepageConfig(homepageConfig),\n          new Header.SetHeaderConfig(headerConfig),\n          new LogoutDialog.SetLogoutDialogConfig(logoutDialogConfig),\n          new Error.SetGenericErrorMessages(genericErrorMessages),\n          new Ui.SetGenericAccessibility(genericAccessibility),\n          new Configs.FetchConfigsSuccess({\n            configs: toJsTable<IConfig>(config as { [id: string]: IConfig }),\n          })\n        );\n        this._store$.dispatch(actions);\n      })\n    );\n  }\n\n  @Action(Configs.FetchConfigsSuccess)\n  fetchConfigsSuccess(\n    ctx: StateContext<ConfigsStateModel>,\n    action: Configs.FetchConfigsSuccess\n  ): void {\n    ctx.setState({\n      ...ctx.getState(),\n      ...mergeInto({ ...ctx.getState() }, action.payload.configs),\n      isFetchingConfigs: false,\n      isFetchingConfigsSuccess: true,\n    });\n  }\n\n  @Action(Configs.FetchConfigsError)\n  fetchConfigsError(ctx: StateContext<ConfigsStateModel>): void {\n    ctx.setState({\n      ...ctx.getState(),\n      ...emptyJsTable<IConfig>(),\n      isFetchingConfigs: false,\n      isFetchingConfigsError: true,\n    });\n  }\n}\n"]}