@spartacus/core
Version:
Spartacus - the core framework
237 lines • 32.4 kB
JavaScript
import { Injectable } from '@angular/core';
import { select } from '@ngrx/store';
import { combineLatest, iif } from 'rxjs';
import { filter, map, switchMap, tap, withLatestFrom } from 'rxjs/operators';
import { ANONYMOUS_CONSENT_STATUS, } from '../../model/index';
import { AnonymousConsentsActions } from '../store/actions/index';
import { AnonymousConsentsSelectors } from '../store/selectors/index';
import * as i0 from "@angular/core";
import * as i1 from "@ngrx/store";
import * as i2 from "../../auth/user-auth/facade/auth.service";
export class AnonymousConsentsService {
constructor(store, authService) {
this.store = store;
this.authService = authService;
}
/**
* Retrieves the anonymous consent templates.
*/
loadTemplates() {
this.store.dispatch(new AnonymousConsentsActions.LoadAnonymousConsentTemplates());
}
/**
* Conditionally triggers the load of the anonymous consent templates if:
* - `loadIfMissing` parameter is set to `true`
* - the `templates` in the store are `undefined`
*
* Otherwise it just returns the value from the store.
*
* @param loadIfMissing setting to `true` will trigger the load of the templates if the currently stored templates are `undefined`
*/
getTemplates(loadIfMissing = false) {
return iif(() => loadIfMissing, this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesValue), withLatestFrom(this.getLoadTemplatesLoading()), filter(([_templates, loading]) => !loading), tap(([templates, _loading]) => {
if (!Boolean(templates)) {
this.loadTemplates();
}
}), filter(([templates, _loading]) => Boolean(templates)), map(([templates, _loading]) => templates)), this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesValue)));
}
/**
* Returns the anonymous consent templates with the given template code.
* @param templateCode a template code by which to filter anonymous consent templates.
*/
getTemplate(templateCode) {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplate(templateCode)));
}
/**
* Returns an indicator for the loading status for the anonymous consent templates.
*/
getLoadTemplatesLoading() {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesLoading));
}
/**
* Returns an indicator for the success status for the anonymous consent templates.
*/
getLoadTemplatesSuccess() {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesSuccess));
}
/**
* Returns an indicator for the error status for the anonymous consent templates.
*/
getLoadTemplatesError() {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesError));
}
/**
* Resets the loading, success and error indicators for the anonymous consent templates.
*/
resetLoadTemplatesState() {
this.store.dispatch(new AnonymousConsentsActions.ResetLoadAnonymousConsentTemplates());
}
/**
* Returns all the anonymous consents.
*/
getConsents() {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsents));
}
/**
* Puts the provided anonymous consents into the store.
*/
setConsents(consents) {
return this.store.dispatch(new AnonymousConsentsActions.SetAnonymousConsents(consents));
}
/**
* Returns the anonymous consent for the given template ID.
*
* As a side-effect, the method will call `getTemplates(true)` to load the templates if those are not present.
*
* @param templateId a template ID by which to filter anonymous consent templates.
*/
getConsent(templateId) {
return this.authService.isUserLoggedIn().pipe(filter((authenticated) => !authenticated), tap(() => this.getTemplates(true)), switchMap(() => this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentByTemplateCode(templateId)))));
}
/**
* Give a consent for the given `templateCode`
* @param templateCode for which to give the consent
*/
giveConsent(templateCode) {
this.store.dispatch(new AnonymousConsentsActions.GiveAnonymousConsent(templateCode));
}
/**
* Sets all the anonymous consents' state to given.
*/
giveAllConsents() {
return this.getTemplates(true).pipe(tap((templates) => templates.forEach((template) => this.giveConsent(template.id))));
}
/**
* Returns `true` if the provided `consent` is given.
* @param consent a consent to test
*/
isConsentGiven(consent) {
return consent && consent.consentState === ANONYMOUS_CONSENT_STATUS.GIVEN;
}
/**
* Withdraw a consent for the given `templateCode`
* @param templateCode for which to withdraw the consent
*/
withdrawConsent(templateCode) {
this.store.dispatch(new AnonymousConsentsActions.WithdrawAnonymousConsent(templateCode));
}
/**
* Sets all the anonymous consents' state to withdrawn.
*/
withdrawAllConsents() {
return this.getTemplates(true).pipe(tap((templates) => templates.forEach((template) => this.withdrawConsent(template.id))));
}
/**
* Returns `true` if the provided `consent` is withdrawn.
* @param consent a consent to test
*/
isConsentWithdrawn(consent) {
return (consent && consent.consentState === ANONYMOUS_CONSENT_STATUS.WITHDRAWN);
}
/**
* Toggles the dismissed state of the anonymous consents banner.
* @param dismissed the banner will be dismissed if `true` is passed, otherwise it will be visible.
*/
toggleBannerDismissed(dismissed) {
this.store.dispatch(new AnonymousConsentsActions.ToggleAnonymousConsentsBannerDissmissed(dismissed));
if (dismissed) {
this.toggleTemplatesUpdated(false);
}
}
/**
* Returns `true` if the banner was dismissed, `false` otherwise.
*/
isBannerDismissed() {
return this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentsBannerDismissed));
}
/**
* Returns `true` if the consent templates were updated on the back-end.
* If the templates are not present in the store, it triggers the load.
*/
getTemplatesUpdated() {
return this.getTemplates(true).pipe(switchMap(() => this.store.pipe(select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesUpdate))));
}
/**
* Toggles the `updated` slice of the state
* @param updated
*/
toggleTemplatesUpdated(updated) {
this.store.dispatch(new AnonymousConsentsActions.ToggleAnonymousConsentTemplatesUpdated(updated));
}
/**
* Returns `true` if either the banner is not dismissed or if the templates were updated on the back-end.
* Otherwise, it returns `false`.
*/
isBannerVisible() {
return combineLatest([
this.isBannerDismissed(),
this.getTemplatesUpdated(),
]).pipe(tap(() => this.checkConsentVersions()), map(([dismissed, updated]) => !dismissed || updated));
}
/**
* Dispatches an action to trigger the check
* whether the anonymous consent version have been updated
*/
checkConsentVersions() {
this.store.dispatch(new AnonymousConsentsActions.AnonymousConsentCheckUpdatedVersions());
}
/**
* Returns `true` if there's a mismatch in template versions between the provided `currentTemplates` and `newTemplates`
* @param currentTemplates current templates to check
* @param newTemplates new templates to check
*/
detectUpdatedTemplates(currentTemplates, newTemplates) {
if (newTemplates.length !== currentTemplates.length) {
return true;
}
for (let i = 0; i < newTemplates.length; i++) {
const newTemplate = newTemplates[i];
const currentTemplate = currentTemplates[i];
if (newTemplate.version !== currentTemplate.version) {
return true;
}
}
return false;
}
/**
* Serializes using `JSON.stringify()` and encodes using `encodeURIComponent()` methods
* @param consents to serialize and encode
*/
serializeAndEncode(consents) {
if (!consents) {
return '';
}
const serialized = JSON.stringify(consents);
const encoded = encodeURIComponent(serialized);
return encoded;
}
/**
* Decodes using `decodeURIComponent()` and deserializes using `JSON.parse()`
* @param rawConsents to decode an deserialize
*/
decodeAndDeserialize(rawConsents) {
const decoded = decodeURIComponent(rawConsents);
const unserialized = JSON.parse(decoded);
return unserialized;
}
/**
*
* Compares the given `newConsents` and `previousConsents` and returns `true` if there are differences (the `newConsents` are updates).
* Otherwise it returns `false`.
*
* @param newConsents new consents to compare
* @param previousConsents old consents to compare
*/
consentsUpdated(newConsents, previousConsents) {
const newRawConsents = this.serializeAndEncode(newConsents);
const previousRawConsents = this.serializeAndEncode(previousConsents);
return newRawConsents !== previousRawConsents;
}
}
AnonymousConsentsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AnonymousConsentsService, deps: [{ token: i1.Store }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
AnonymousConsentsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AnonymousConsentsService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: AnonymousConsentsService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AuthService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anonymous-consents.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/anonymous-consents/facade/anonymous-consents.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { select, Store } from '@ngrx/store';\nimport { combineLatest, iif, Observable } from 'rxjs';\nimport { filter, map, switchMap, tap, withLatestFrom } from 'rxjs/operators';\nimport { AuthService } from '../../auth/user-auth/facade/auth.service';\nimport {\n  AnonymousConsent,\n  ANONYMOUS_CONSENT_STATUS,\n  ConsentTemplate,\n} from '../../model/index';\nimport { AnonymousConsentsActions } from '../store/actions/index';\nimport { StateWithAnonymousConsents } from '../store/anonymous-consents-state';\nimport { AnonymousConsentsSelectors } from '../store/selectors/index';\n\n@Injectable({ providedIn: 'root' })\nexport class AnonymousConsentsService {\n  constructor(\n    protected store: Store<StateWithAnonymousConsents>,\n    protected authService: AuthService\n  ) {}\n\n  /**\n   * Retrieves the anonymous consent templates.\n   */\n  loadTemplates(): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.LoadAnonymousConsentTemplates()\n    );\n  }\n\n  /**\n   * Conditionally triggers the load of the anonymous consent templates if:\n   *   - `loadIfMissing` parameter is set to `true`\n   *   - the `templates` in the store are `undefined`\n   *\n   * Otherwise it just returns the value from the store.\n   *\n   * @param loadIfMissing setting to `true` will trigger the load of the templates if the currently stored templates are `undefined`\n   */\n  getTemplates(loadIfMissing = false): Observable<ConsentTemplate[]> {\n    return iif(\n      () => loadIfMissing,\n      this.store.pipe(\n        select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesValue),\n        withLatestFrom(this.getLoadTemplatesLoading()),\n        filter(([_templates, loading]) => !loading),\n        tap(([templates, _loading]) => {\n          if (!Boolean(templates)) {\n            this.loadTemplates();\n          }\n        }),\n        filter(([templates, _loading]) => Boolean(templates)),\n        map(([templates, _loading]) => templates)\n      ),\n      this.store.pipe(\n        select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesValue)\n      )\n    );\n  }\n\n  /**\n   * Returns the anonymous consent templates with the given template code.\n   * @param templateCode a template code by which to filter anonymous consent templates.\n   */\n  getTemplate(templateCode: string): Observable<ConsentTemplate> {\n    return this.store.pipe(\n      select(\n        AnonymousConsentsSelectors.getAnonymousConsentTemplate(templateCode)\n      )\n    );\n  }\n\n  /**\n   * Returns an indicator for the loading status for the anonymous consent templates.\n   */\n  getLoadTemplatesLoading(): Observable<boolean> {\n    return this.store.pipe(\n      select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesLoading)\n    );\n  }\n\n  /**\n   * Returns an indicator for the success status for the anonymous consent templates.\n   */\n  getLoadTemplatesSuccess(): Observable<boolean> {\n    return this.store.pipe(\n      select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesSuccess)\n    );\n  }\n\n  /**\n   * Returns an indicator for the error status for the anonymous consent templates.\n   */\n  getLoadTemplatesError(): Observable<boolean> {\n    return this.store.pipe(\n      select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesError)\n    );\n  }\n\n  /**\n   * Resets the loading, success and error indicators for the anonymous consent templates.\n   */\n  resetLoadTemplatesState(): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.ResetLoadAnonymousConsentTemplates()\n    );\n  }\n\n  /**\n   * Returns all the anonymous consents.\n   */\n  getConsents(): Observable<AnonymousConsent[]> {\n    return this.store.pipe(\n      select(AnonymousConsentsSelectors.getAnonymousConsents)\n    );\n  }\n\n  /**\n   * Puts the provided anonymous consents into the store.\n   */\n  setConsents(consents: AnonymousConsent[]): void {\n    return this.store.dispatch(\n      new AnonymousConsentsActions.SetAnonymousConsents(consents)\n    );\n  }\n\n  /**\n   * Returns the anonymous consent for the given template ID.\n   *\n   * As a side-effect, the method will call `getTemplates(true)` to load the templates if those are not present.\n   *\n   * @param templateId a template ID by which to filter anonymous consent templates.\n   */\n  getConsent(templateId: string): Observable<AnonymousConsent> {\n    return this.authService.isUserLoggedIn().pipe(\n      filter((authenticated) => !authenticated),\n      tap(() => this.getTemplates(true)),\n      switchMap(() =>\n        this.store.pipe(\n          select(\n            AnonymousConsentsSelectors.getAnonymousConsentByTemplateCode(\n              templateId\n            )\n          )\n        )\n      )\n    );\n  }\n\n  /**\n   * Give a consent for the given `templateCode`\n   * @param templateCode for which to give the consent\n   */\n  giveConsent(templateCode: string): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.GiveAnonymousConsent(templateCode)\n    );\n  }\n\n  /**\n   * Sets all the anonymous consents' state to given.\n   */\n  giveAllConsents(): Observable<ConsentTemplate[]> {\n    return this.getTemplates(true).pipe(\n      tap((templates) =>\n        templates.forEach((template) => this.giveConsent(template.id))\n      )\n    );\n  }\n\n  /**\n   * Returns `true` if the provided `consent` is given.\n   * @param consent a consent to test\n   */\n  isConsentGiven(consent: AnonymousConsent): boolean {\n    return consent && consent.consentState === ANONYMOUS_CONSENT_STATUS.GIVEN;\n  }\n\n  /**\n   * Withdraw a consent for the given `templateCode`\n   * @param templateCode for which to withdraw the consent\n   */\n  withdrawConsent(templateCode: string): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.WithdrawAnonymousConsent(templateCode)\n    );\n  }\n\n  /**\n   * Sets all the anonymous consents' state to withdrawn.\n   */\n  withdrawAllConsents(): Observable<ConsentTemplate[]> {\n    return this.getTemplates(true).pipe(\n      tap((templates) =>\n        templates.forEach((template) => this.withdrawConsent(template.id))\n      )\n    );\n  }\n\n  /**\n   * Returns `true` if the provided `consent` is withdrawn.\n   * @param consent a consent to test\n   */\n  isConsentWithdrawn(consent: AnonymousConsent): boolean {\n    return (\n      consent && consent.consentState === ANONYMOUS_CONSENT_STATUS.WITHDRAWN\n    );\n  }\n\n  /**\n   * Toggles the dismissed state of the anonymous consents banner.\n   * @param dismissed the banner will be dismissed if `true` is passed, otherwise it will be visible.\n   */\n  toggleBannerDismissed(dismissed: boolean): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.ToggleAnonymousConsentsBannerDissmissed(\n        dismissed\n      )\n    );\n    if (dismissed) {\n      this.toggleTemplatesUpdated(false);\n    }\n  }\n\n  /**\n   * Returns `true` if the banner was dismissed, `false` otherwise.\n   */\n  isBannerDismissed(): Observable<boolean> {\n    return this.store.pipe(\n      select(AnonymousConsentsSelectors.getAnonymousConsentsBannerDismissed)\n    );\n  }\n\n  /**\n   * Returns `true` if the consent templates were updated on the back-end.\n   * If the templates are not present in the store, it triggers the load.\n   */\n  getTemplatesUpdated(): Observable<boolean> {\n    return this.getTemplates(true).pipe(\n      switchMap(() =>\n        this.store.pipe(\n          select(AnonymousConsentsSelectors.getAnonymousConsentTemplatesUpdate)\n        )\n      )\n    );\n  }\n\n  /**\n   * Toggles the `updated` slice of the state\n   * @param updated\n   */\n  toggleTemplatesUpdated(updated: boolean): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.ToggleAnonymousConsentTemplatesUpdated(\n        updated\n      )\n    );\n  }\n\n  /**\n   * Returns `true` if either the banner is not dismissed or if the templates were updated on the back-end.\n   * Otherwise, it returns `false`.\n   */\n  isBannerVisible(): Observable<boolean> {\n    return combineLatest([\n      this.isBannerDismissed(),\n      this.getTemplatesUpdated(),\n    ]).pipe(\n      tap(() => this.checkConsentVersions()),\n      map(([dismissed, updated]) => !dismissed || updated)\n    );\n  }\n\n  /**\n   * Dispatches an action to trigger the check\n   * whether the anonymous consent version have been updated\n   */\n  private checkConsentVersions(): void {\n    this.store.dispatch(\n      new AnonymousConsentsActions.AnonymousConsentCheckUpdatedVersions()\n    );\n  }\n\n  /**\n   * Returns `true` if there's a mismatch in template versions between the provided `currentTemplates` and `newTemplates`\n   * @param currentTemplates current templates to check\n   * @param newTemplates new templates to check\n   */\n  detectUpdatedTemplates(\n    currentTemplates: ConsentTemplate[],\n    newTemplates: ConsentTemplate[]\n  ): boolean {\n    if (newTemplates.length !== currentTemplates.length) {\n      return true;\n    }\n\n    for (let i = 0; i < newTemplates.length; i++) {\n      const newTemplate = newTemplates[i];\n      const currentTemplate = currentTemplates[i];\n      if (newTemplate.version !== currentTemplate.version) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Serializes using `JSON.stringify()` and encodes using `encodeURIComponent()` methods\n   * @param consents to serialize and encode\n   */\n  serializeAndEncode(consents: AnonymousConsent[]): string {\n    if (!consents) {\n      return '';\n    }\n    const serialized = JSON.stringify(consents);\n    const encoded = encodeURIComponent(serialized);\n    return encoded;\n  }\n\n  /**\n   * Decodes using `decodeURIComponent()` and deserializes using `JSON.parse()`\n   * @param rawConsents to decode an deserialize\n   */\n  decodeAndDeserialize(rawConsents: string): AnonymousConsent[] {\n    const decoded = decodeURIComponent(rawConsents);\n    const unserialized = JSON.parse(decoded) as AnonymousConsent[];\n    return unserialized;\n  }\n\n  /**\n   *\n   * Compares the given `newConsents` and `previousConsents` and returns `true` if there are differences (the `newConsents` are updates).\n   * Otherwise it returns `false`.\n   *\n   * @param newConsents new consents to compare\n   * @param previousConsents old consents to compare\n   */\n  consentsUpdated(\n    newConsents: AnonymousConsent[],\n    previousConsents: AnonymousConsent[]\n  ): boolean {\n    const newRawConsents = this.serializeAndEncode(newConsents);\n    const previousRawConsents = this.serializeAndEncode(previousConsents);\n    return newRawConsents !== previousRawConsents;\n  }\n}\n"]}