@rancher/shell 3.0.7 → 3.0.8-rc.10

package/utils/dynamic-content/index.ts

@@ -0,0 +1,277 @@
+/**
+ * This is the main dynamic content file that provides the 'fetchAndProcessDynamicContent' function
+ *
+ * This is the main entry point for reading and processing dynamic content
+ */
+
+import day from 'dayjs';
+import * as jsyaml from 'js-yaml';
+import semver from 'semver';
+import { isAdminUser } from '@shell/store/type-map';
+import { getVersionData } from '@shell/config/version';
+import { processReleaseVersion } from './new-release';
+import { processSupportNotices } from './support-notice';
+import { Context, DynamicContent, VersionInfo } from './types';
+import { createLogger, LOCAL_STORAGE_CONTENT_DEBUG_LOG } from './util';
+import { getConfig } from './config';
+import { SystemInfoProvider } from './info';
+import { processAnnouncements } from './announcement';
+
+const FETCH_DELAY = 3 * 1000; // Short delay to let UI settle before we fetch the updates document
+const FETCH_REQUEST_TIMEOUT = 15000; // Time out the request after 15 seconds
+const FETCH_CONCURRENT_SECONDS = 30; // Time to wait to ignore another in-progress fetch (seconds)
+
+export const UPDATE_DATE_FORMAT = 'YYYY-MM-DD'; // Format of the fetch date
+
+const LOCAL_STORAGE_UPDATE_FETCH_DATE = 'rancher-updates-fetch-next'; // Local storage setting that holds the date when we should next try and fetch content
+const LOCAL_STORAGE_UPDATE_CONTENT = 'rancher-updates-last-content'; // Local storage setting that holds the last fetched content
+const LOCAL_STORAGE_UPDATE_ERRORS = 'rancher-updates-fetch-errors'; // Local storage setting that holds the count of contiguous errors
+const LOCAL_STORAGE_UPDATE_FETCHING = 'rancher-updates-fetching'; // Local storage setting that holds the date and time of the last fetch that was started
+
+const BACKOFFS = [1, 1, 1, 2, 2, 3, 5]; // Backoff in days for the contiguous number of errors (i.e. after 1 errors, we wait 1 day, after 3 errors, we wait 2 days, etc.)
+
+const DEFAULT_RELEASE_NOTES_URL = 'https://github.com/rancher/rancher/releases/tag/v$version'; // Default release notes URL
+
+/**
+ * Fetch dynamic content if needed and process it if it has changed since we last checked
+ */
+export async function fetchAndProcessDynamicContent(dispatch: Function, getters: any, axios: any) {
+  // Check that the product is Rancher
+  // => Check that we are NOT in single product mode (e.g. Harvester)
+  const isSingleProduct = getters['isSingleProduct'];
+
+  if (!!isSingleProduct) {
+    return;
+  }
+
+  const config = getConfig(getters);
+
+  // If not enabled via the configuration, then just return
+  if (!config.enabled) {
+    console.log('Dynamic content disabled through configuration'); // eslint-disable-line no-console
+
+    return;
+  }
+
+  const logger = createLogger(config);
+
+  // Common context to pass through to functions for store access, logging, etc
+  const context: Context = {
+    dispatch,
+    getters,
+    axios,
+    logger,
+    config,
+    isAdmin:  isAdminUser(getters),
+    settings: {
+      releaseNotesUrl: DEFAULT_RELEASE_NOTES_URL,
+      suseExtensions:  [],
+    }
+  };
+
+  logger.debug('Read configuration', context.config);
+
+  try {
+    // Fetch the dynamic content if required, otherwise return the cached content or empty object if no content available
+    const content = await fetchDynamicContent(context);
+
+    // Version metadata
+    const versionData = getVersionData();
+    const version = semver.coerce(versionData.Version);
+
+    if (!version || !content) {
+      return;
+    }
+
+    const versionInfo: VersionInfo = {
+      version: version as semver.SemVer, // Will be defined, can not be null here
+      isPrime: config.prime,
+    };
+
+    // If not logging, then clear out any log data from local storage
+    if (!config.log) {
+      window.localStorage.removeItem(LOCAL_STORAGE_CONTENT_DEBUG_LOG);
+    }
+
+    if (content?.settings) {
+      // Update the settings data from the content, so that it is has the settings with their defaults or values from the dynamic content payload
+      context.settings = {
+        ...context.settings,
+        ...content.settings
+      };
+    }
+
+    // If the cached content has a debug version then use that as an override for the current version number
+    // This is only for debug and testing purposes
+    if (content.settings?.debugVersion) {
+      versionInfo.version = semver.coerce(content.settings.debugVersion) || version;
+      logger.debug(`Overriding version number to ${ content.settings.debugVersion }`);
+    }
+
+    // We always process the content in case the Rancher version has changed or the date means that an announcement/notification should now be shown
+
+    // New release notifications and support notifications are shown to ALL community users, but only to admin users when Prime
+    if (!config.prime || context.isAdmin) {
+    // New release notifications
+      processReleaseVersion(context, content.releases, versionInfo);
+
+      // EOM, EOL notifications
+      processSupportNotices(context, content.support, versionInfo);
+    }
+
+    // Announcements - processed for all users
+    processAnnouncements(context, content.announcements, versionInfo);
+  } catch (e) {
+    logger.error('Error reading or processing dynamic content', e);
+  }
+}
+
+/**
+ * We use a signal to timeout the connection
+ * For air-gapped environments, this ensures the request will timeout after FETCH_REQUEST_TIMEOUT
+ * This timeout is set relatively low (15s). The default, otherwise, is 2 minutes.
+ *
+ * @param timeoutMs Time in milliseconds after which the abort signal should signal
+ */
+function newRequestAbortSignal(timeoutMs: number) {
+  const abortController = new AbortController();
+
+  setTimeout(() => abortController.abort(), timeoutMs || 0);
+
+  return abortController.signal;
+}
+
+/**
+ * Update the local storage data that tracks when to next fetch content and how many consecutive errors we have had
+ *
+ * @param didError Indicates if we should update to record content retrieved without error or with error
+ */
+function updateFetchInfo(didError: boolean) {
+  if (!didError) {
+    // No error, so check again tomorrow and remove the backoff setting, so it will get its default next time
+    const nextFetch = day().add(1, 'day');
+    const nextFetchString = nextFetch.format(UPDATE_DATE_FORMAT);
+
+    window.localStorage.setItem(LOCAL_STORAGE_UPDATE_FETCH_DATE, nextFetchString);
+    window.localStorage.removeItem(LOCAL_STORAGE_UPDATE_ERRORS);
+  } else {
+    // Did error, read the backoff, increase and add to the date
+    const contiguousErrorsString = window.localStorage.getItem(LOCAL_STORAGE_UPDATE_ERRORS) || '0';
+
+    let contiguousErrors = parseInt(contiguousErrorsString, 10);
+
+    // Increase the number of errors that have happened in a row
+    contiguousErrors++;
+
+    // Once we reach the max backoff, just stick with it
+    if (contiguousErrors >= BACKOFFS.length ) {
+      contiguousErrors = BACKOFFS.length - 1;
+    }
+
+    // Now find the backoff (days) given the error count and calculate the date of the next fetch
+    const daysToAdd = BACKOFFS[contiguousErrors];
+    const nextFetch = day().add(daysToAdd, 'day');
+    const nextFetchString = nextFetch.format(UPDATE_DATE_FORMAT);
+
+    window.localStorage.setItem(LOCAL_STORAGE_UPDATE_FETCH_DATE, nextFetchString);
+    window.localStorage.setItem(LOCAL_STORAGE_UPDATE_ERRORS, contiguousErrors.toString());
+  }
+}
+
+/**
+ * Fetch dynamic content (if needed)
+ */
+export async function fetchDynamicContent(context: Context): Promise<Partial<DynamicContent> | undefined> {
+  const { getters, logger, config } = context;
+
+  // Check if we already have done an update check today
+  let content: Partial<DynamicContent> = {};
+
+  try {
+    const today = day();
+    const todayString = today.format(UPDATE_DATE_FORMAT);
+    const nextFetch = window.localStorage.getItem(LOCAL_STORAGE_UPDATE_FETCH_DATE) || todayString;
+
+    // Read the cached content from local storage if possible
+    content = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_UPDATE_CONTENT) || '{}');
+
+    const nextFetchDay = day(nextFetch);
+
+    // Just in case next day gets reset to the past or corrupt, otherwise next fetch needs to not be in the future
+    if (!nextFetchDay.isValid() || !nextFetchDay.isAfter(today)) {
+      logger.info(`Performing update check on ${ todayString }`);
+      logger.debug(`Performing update check on ${ todayString }`);
+
+      const activeFetch = window.localStorage.getItem(LOCAL_STORAGE_UPDATE_FETCHING);
+
+      if (activeFetch) {
+        const activeFetchDate = day(activeFetch);
+
+        if (activeFetchDate.isValid() && today.diff(activeFetchDate, 'second') < FETCH_CONCURRENT_SECONDS) {
+          logger.debug('Already fetching dynamic content in another tab (or previous tab closed while fetching) - skipping');
+
+          return content;
+        }
+      }
+
+      // Set the local storage key that indicates a tab is fetching the content - prevents other tabs doing so at the same time
+      window.localStorage.setItem(LOCAL_STORAGE_UPDATE_FETCHING, today.toString());
+
+      // Wait a short while before fetching dynamic content
+      await new Promise((resolve) => setTimeout(resolve, FETCH_DELAY));
+
+      const systemData = new SystemInfoProvider(getters, content?.settings || {});
+      const qs = systemData.buildQueryString();
+      const distribution = config.prime ? 'prime' : 'community';
+      const url = `${ config.endpoint.replace('$dist', distribution) }?${ qs }`;
+
+      logger.debug(`Fetching dynamic content from: ${ url.split('?')[0] }`, url);
+
+      // We use axios directly so that we can pass in the abort signal to implement the connection timeout
+      const res = await context.axios({
+        url,
+        method:          'get',
+        timeout:         FETCH_REQUEST_TIMEOUT,
+        noApiCsrf:       true,
+        withCredentials: false,
+        signal:          newRequestAbortSignal(FETCH_REQUEST_TIMEOUT),
+        responseType:    'text' // We always want the raw text back - otherwise YAML gives text and JSON gives object
+      });
+
+      // The data should be YAML (or JSON) in the 'data' attribute
+      if (res?.data) {
+        try {
+          content = jsyaml.load(res.data) as any;
+
+          window.localStorage.setItem(LOCAL_STORAGE_UPDATE_CONTENT, JSON.stringify(content));
+
+          // Update the last date now
+          updateFetchInfo(false);
+        } catch (e) {
+          logger.error('Failed to parse YAML/JSON from dynamic content package', e);
+        }
+      } else {
+        logger.error('Error fetching dynamic content package (unexpected data)');
+      }
+    } else {
+      logger.info(`Skipping update check for dynamic content - next check due on ${ nextFetch } (today is ${ todayString })`);
+
+      // If debug mode, then wait a bit to simulate the delay we would have had if we were fetching
+      if (config.debug) {
+        await new Promise((resolve) => setTimeout(resolve, FETCH_DELAY));
+      }
+    }
+  } catch (e) {
+    logger.error('Error occurred reading dynamic content', e);
+
+    // We had an error, so update data in local storage so that we try again appropriately next time
+    updateFetchInfo(true);
+  }
+
+  logger.debug('End fetchDynamicContent');
+
+  // Remove the local storage key that indicates a tab is fetching the content
+  window.localStorage.removeItem(LOCAL_STORAGE_UPDATE_FETCHING);
+
+  return content;
+}

package/utils/dynamic-content/info.ts

@@ -0,0 +1,261 @@
+/**
+ * Helper for collecting system information and formatting into to a query string
+ */
+
+import { sha256 } from '@shell/utils/crypto';
+import {
+  COUNT,
+  MANAGEMENT,
+} from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
+import { getVersionData } from '@shell/config/version';
+import { SettingsInfo } from '@shell/utils/dynamic-content/types';
+import { STEVE_CACHE } from '@shell/store/features';
+
+const QS_VERSION = 'v1'; // Include a version number in the query string in case we want to version the set of params we are sending
+const UNKNOWN = 'unknown';
+
+// List of known UI extensions from SUSE
+const SUSE_EXTENSIONS = [
+  'capi',
+  'elemental',
+  'harvester',
+  'kubewarden',
+  'neuvector-ui-ext',
+  'observability',
+  'supportability-review-app',
+  'virtual-clusters'
+];
+
+type FeatureFlagInfos = {
+  [id: string]: {
+    /**
+     * Query param, in format `ff-<param>`
+     */
+    param: string,
+    /**
+      * The actual value used by the UI, roughly spec.value || status.default
+      */
+    value: string,
+  }
+};
+
+/**
+ * Explicit ff's to send
+ */
+const ffs: FeatureFlagInfos = {
+  [STEVE_CACHE]: {
+    param: 'usc',
+    value: '',
+  }
+};
+
+/**
+ * System information that is collected and which can then be encoded into a query string in the dyanmic content request
+ */
+type SystemInfo = {
+  systemUUID: string;
+  systemHash: string;
+  serverVersionType: string;
+  userHash: string;
+  version: string;
+  isDeveloperVersion: boolean;
+  isPrime: boolean;
+  isLTS: boolean;
+  clusterCount: number;
+  localCluster: any;
+  extensions?: {
+    knownInstalled: string[];
+    customCount: number;
+  };
+  browserSize: string;
+  screenSize: string;
+  language: string;
+  featureFlags: FeatureFlagInfos
+};
+
+/**
+ * Helper that will gather system information and provided the `buildQueryString` method to format as a query string
+ */
+export class SystemInfoProvider {
+  private info: SystemInfo;
+
+  constructor(getters: any, settings: Partial<SettingsInfo>) {
+    this.info = this.getSystemData(getters, settings);
+  }
+
+  /**
+   * Get the data that we need from the system
+   * @param getters Store getters to access the store
+   * @returns System data
+   */
+  private getSystemData(getters: any, settingsInfo: Partial<SettingsInfo>): SystemInfo {
+    let url;
+    let systemUUID = UNKNOWN;
+    let serverVersionType = UNKNOWN;
+
+    const serverUrlSetting = getters['management/byId'](MANAGEMENT.SETTING, SETTING.SERVER_URL);
+
+    // Server URL
+    if (serverUrlSetting) {
+      url = serverUrlSetting.value || UNKNOWN;
+    }
+
+    // UUID
+    const uuidSetting = getters['management/byId'](MANAGEMENT.SETTING, 'install-uuid');
+
+    if (uuidSetting) {
+      systemUUID = uuidSetting.value || UNKNOWN;
+    }
+
+    // Server Version Type
+    const serverVersionTypeSetting = getters['management/byId'](MANAGEMENT.SETTING, 'server-version-type');
+
+    if (serverVersionTypeSetting) {
+      serverVersionType = serverVersionTypeSetting.value || UNKNOWN;
+    }
+
+    // Otherwise, use the window location's host
+    url = url || window.location?.host;
+
+    // System and User hashes
+    const systemHash = (sha256(url, 'hex') as string).substring(0, 32);
+    const currentPrincipal = getters['auth/principalId'] || UNKNOWN;
+    const userHash = (sha256(currentPrincipal, 'hex') as string).substring(0, 32);
+
+    // Version info
+    const versionData = getVersionData();
+    const vers = versionData.Version.split('-');
+
+    // General stats that can help us shape content delivery
+
+    // High-level information from clusters
+    const counts = this.getAll(getters, COUNT)?.[0]?.counts || {};
+    const clusterCount = counts[MANAGEMENT.CLUSTER] || {};
+    const localCluster = getters['localCluster'];
+
+    // Stats for installed extensions
+    const uiExtensionList = getters['uiplugins/plugins'];
+    let extensions;
+
+    if (uiExtensionList) {
+      const suseExtensions = [
+        ...SUSE_EXTENSIONS,
+        ...settingsInfo?.suseExtensions || []
+      ];
+      const notBuiltIn = uiExtensionList.filter((e: any) => !e.builtin);
+      const suseNames = notBuiltIn.filter((e: any) => suseExtensions.includes(e.name)).map((e: any) => e.name);
+      const customCount = notBuiltIn.length - suseNames.length;
+
+      extensions = {
+        knownInstalled: suseNames,
+        customCount,
+      };
+    }
+
+    const screenSize = `${ window.screen?.width || '?' }x${ window.screen?.height || '?' }`;
+    const browserSize = `${ window.innerWidth }x${ window.innerHeight }`;
+
+    const safeFfs = Object.entries(ffs).reduce((res, [id, ff]) => {
+      try {
+        res[id] = {
+          param: ff.param,
+          value: getters['features/get'](id),
+        };
+      } catch (e) {
+        console.debug(`Cannot include Feature Flag "${ id }" in dynamic feature request: `, e); // eslint-disable-line no-console
+      }
+
+      return res;
+    }, {} as FeatureFlagInfos);
+
+    return {
+      systemUUID,
+      userHash,
+      systemHash,
+      serverVersionType,
+      version:            vers[0],
+      isDeveloperVersion: vers.length > 1,
+      isPrime:            versionData.RancherPrime === 'true',
+      isLTS:              false,
+      clusterCount:       clusterCount?.summary?.count,
+      localCluster,
+      extensions,
+      screenSize,
+      browserSize,
+      language:           window.navigator?.language,
+      featureFlags:       safeFfs,
+    };
+  }
+
+  // Helper to get all resources of a type only if they are available
+  private getAll(getters: any, typeName: string): any {
+    if (getters['management/typeRegistered'](typeName)) {
+      return getters['management/all'](typeName);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Build query string of params to send so that we can deliver better content
+   */
+  public buildQueryString(): string {
+    const systemData = this.info;
+    const params = [`dcv=${ QS_VERSION }`];
+
+    // System and User
+    params.push(`s=${ systemData.systemHash }`);
+    params.push(`u=${ systemData.userHash }`);
+
+    // Install UUID
+    if (systemData.systemUUID !== UNKNOWN) {
+      params.push(`uuid=${ systemData.systemUUID }`);
+    }
+
+    // Server Version Type
+    if (systemData.serverVersionType !== UNKNOWN) {
+      params.push(`svt=${ systemData.serverVersionType }`);
+    }
+
+    // Version info
+    params.push(`v=${ systemData.version }`);
+    params.push(`dev=${ systemData.isDeveloperVersion }`);
+    params.push(`p=${ systemData.isPrime }`);
+
+    // Remove LTS for now, until we can determine LTS status
+    // params.push(`lts=${ systemData.isLTS }`);
+
+    // Clusters
+    params.push(`cc=${ systemData.clusterCount }`);
+
+    if (systemData.localCluster) {
+      params.push(`lkv=${ systemData.localCluster.kubernetesVersionBase || UNKNOWN }`);
+      params.push(`lcp=${ systemData.localCluster.provisioner || UNKNOWN }`);
+      params.push(`lnc=${ systemData.localCluster.status.nodeCount || 0 }`);
+    }
+
+    // Extensions
+    if (systemData.extensions) {
+      params.push(`xkn=${ systemData.extensions.knownInstalled.join(',') }`);
+      params.push(`xcc=${ systemData.extensions.customCount }`);
+    }
+
+    // Browser Language
+    params.push(`bl=${ systemData.language }`);
+
+    // Browser size
+    params.push(`bs=${ systemData.browserSize }`);
+
+    // Screen size
+    if (systemData.screenSize !== '?x?') {
+      params.push(`ss=${ systemData.screenSize }`);
+    }
+
+    Object.values(systemData.featureFlags).forEach((ff) => {
+      params.push(`ff-` + `${ ff.param }=${ ff.value }`);
+    });
+
+    return params.join('&');
+  }
+}

package/utils/dynamic-content/new-release.ts

@@ -0,0 +1,126 @@
+/**
+ *
+ * The code in this file is responsible for adding New Release notifications driven off of the dynamic content metadata
+ *
+ * We handle two cases:
+ *
+ * 1. There is a new patch release available for the current Rancher version (e.g. user is in 2.12.0 and we release 2.12.1)
+ * 2. There is a new patch release available for the current Rancher version AND there is a newer version for a high minor releases
+ *    > this often occurs because we release monthly releases in parallel with the new minor releases
+ *
+ * We show slightly different messages in these 2 cases.
+ *
+ */
+
+import semver from 'semver';
+import { NotificationLevel } from '@shell/types/notifications';
+import { READ_NEW_RELEASE } from '@shell/store/prefs';
+import { Context, ReleaseInfo, VersionInfo } from './types';
+import { removeMatchingNotifications } from './util';
+
+export async function processReleaseVersion(context: Context, releaseInfo: ReleaseInfo[] | undefined, versionInfo: VersionInfo) {
+  if (!releaseInfo || !versionInfo?.version || !Array.isArray(releaseInfo)) {
+    return;
+  }
+
+  const { version } = versionInfo;
+  const versions = releaseInfo.map((v: any) => semver.coerce(v.name));
+
+  // Sort the versions, so that the newest is first in the list
+  versions.sort((a: any, b: any) => semver.rcompare(a, b));
+
+  // Find first newer version
+  const newer = versions.find((v: any) => semver.gt(v, version));
+
+  // Find newest patch version for the current version (if available)
+  const newerPatch = versions.find((v: any) => {
+    const newVersion = semver.coerce(v);
+
+    return newVersion && newVersion.major === version.major && newVersion.minor === version.minor && semver.gt(v, version);
+  });
+
+  if (newer) {
+    context.logger.info(`Found a newer release: ${ newer.version }`);
+
+    if (newerPatch && newer !== newerPatch) {
+      context.logger.info(`Also found a newer patch release: ${ newerPatch.version }`);
+      // There is a new patch release and a newer release
+      await addNewMultipleReleasesNotification(context, newerPatch.version, newer.version);
+    } else {
+      // There is a new release (but no newer patch release)
+      await addNewReleaseNotification(context, newer.version);
+    }
+  }
+}
+
+async function addNewReleaseNotification(context: Context, version: string) {
+  const prefix = 'new-release-';
+  const releaseNotesUrl = context.settings.releaseNotesUrl.replace('$version', version);
+  const { dispatch, getters, logger } = context;
+
+  // TODO: Get the preference
+  const lastReadVersion = getters['prefs/get'](READ_NEW_RELEASE) || '';
+  const t = getters['i18n/t'];
+
+  // Delete notification(s) for old release notes
+  // This shouldn't happen normally, as we release less often than notifications should expire
+  if (!await removeMatchingNotifications(context, prefix, version) && lastReadVersion !== version) {
+    logger.debug(`Adding new release notification for ${ version } because one did not exist`);
+
+    const notification = {
+      id:         `${ prefix }${ version }`,
+      level:      NotificationLevel.Announcement,
+      title:      t('dynamicContent.newRelease.title', { version }),
+      message:    t('dynamicContent.newRelease.message', { version }),
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: version
+      },
+      primaryAction: {
+        label:  t('dynamicContent.newRelease.moreInfo'),
+        target: releaseNotesUrl
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}
+
+async function addNewMultipleReleasesNotification(context: Context, version1: string, version2: string) {
+  const prefix = 'new-release-';
+  const key = `${ version1 }-${ version2 }`;
+  const releaseNotesUrl1 = context.settings.releaseNotesUrl.replace('$version', version1);
+  const releaseNotesUrl2 = context.settings.releaseNotesUrl.replace('$version', version2);
+  const { dispatch, getters, logger } = context;
+
+  // TODO: Get the preference
+  const lastReadVersion = getters['prefs/get'](READ_NEW_RELEASE) || '';
+  const t = getters['i18n/t'];
+
+  // Delete notification(s) for old release notes
+  // This shouldn't happen normally, as we release less often than notifications should expire
+  if (!await removeMatchingNotifications(context, prefix, key) && lastReadVersion !== key) {
+    logger.info(`Adding new multiple release notification for ${ version1 } and ${ version2 }`);
+
+    const notification = {
+      id:         `${ prefix }${ key }`,
+      level:      NotificationLevel.Announcement,
+      title:      t('dynamicContent.multipleNewReleases.title'),
+      message:    t('dynamicContent.multipleNewReleases.message', { version1, version2 }),
+      preference: {
+        key:   READ_NEW_RELEASE,
+        value: key
+      },
+      primaryAction: {
+        label:  t('dynamicContent.multipleNewReleases.moreInfo', { version: version1 }),
+        target: releaseNotesUrl1
+      },
+      secondaryAction: {
+        label:  t('dynamicContent.multipleNewReleases.moreInfo', { version: version2 }),
+        target: releaseNotesUrl2
+      }
+    };
+
+    await dispatch('notifications/add', notification);
+  }
+}