Initial commit

lib/assets/javascripts/new-dashboard/store/modules/apps/connected/index.js

@@ -0,0 +1,37 @@
+import * as AppsMutations from '../../../mutations/apps';
+import * as AppsActions from '../../../actions/apps';
+
+const connectedApps = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isErrored: false,
+    error: [],
+    list: {}
+  },
+  computed: {},
+  getters: {},
+  mutations: {
+    setApps: AppsMutations.setApps,
+    setRequestError: AppsMutations.setRequestError,
+    setFetchingState: AppsMutations.setFetchingState
+  },
+  actions: {
+    fetch: AppsActions.fetch('getConnectedApps'),
+
+    revoke (context, app) {
+      const { api_key: apiKey } = context.rootState.user;
+
+      return new Promise((resolve, reject) => {
+        context.rootState.client.revokeOAuthApp(apiKey, app, function (err, _, data) {
+          if (err) {
+            return reject(data.responseJSON.errors);
+          }
+          resolve();
+        });
+      });
+    }
+  }
+};
+
+export default connectedApps;

lib/assets/javascripts/new-dashboard/store/modules/apps/oAuth/index.js

@@ -0,0 +1,43 @@
+import * as AppsMutations from '../../../mutations/apps';
+import * as AppsActions from '../../../actions/apps';
+
+const oAuthApps = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isErrored: false,
+    error: [],
+    list: {}
+  },
+  computed: {},
+  getters: {},
+  mutations: {
+    setApps: AppsMutations.setApps,
+    addApp: AppsMutations.addApp,
+    setFetchingState: AppsMutations.setFetchingState,
+    setRequestError: AppsMutations.setRequestError,
+    updateOAuthApp: AppsMutations.updateOAuthApp
+  },
+  actions: {
+    fetch: AppsActions.fetch('getOAuthApps'),
+    create: AppsActions.createOAuth,
+    update: AppsActions.updateOAuth,
+    setApps: AppsMutations.setApps,
+    regenerateCredentials: AppsActions.regenerateCredentials,
+
+    delete (context, app) {
+      const { api_key: apiKey } = context.rootState.user;
+
+      return new Promise((resolve, reject) => {
+        context.rootState.client.deleteApp(apiKey, app, function (err, _, data) {
+          if (err) {
+            return reject(data.responseJSON.errors);
+          }
+          resolve();
+        });
+      });
+    }
+  }
+};
+
+export default oAuthApps;

lib/assets/javascripts/new-dashboard/store/modules/config/index.js

@@ -0,0 +1,24 @@
+import getCARTOData from 'new-dashboard/store/utils/getCARTOData';
+
+// Data coming from Static Page Loading,
+// which requests user and config data from
+// /me API endpoint.
+const CARTOData = getCARTOData();
+const CARTOUserData = CARTOData.user_data;
+
+const config = {
+  namespaced: true,
+  state: {
+    ...CARTOData.config,
+    base_url: CARTOUserData.base_url,
+    default_fallback_basemap: CARTOData.default_fallback_basemap,
+    isFirstTimeViewingDashboard: CARTOData.is_first_time_viewing_dashboard,
+    url_prefix: CARTOUserData.base_url,
+    plan_url: CARTOData.plan_url
+  },
+  getters: {},
+  mutations: {},
+  actions: {}
+};
+
+export default config;

lib/assets/javascripts/new-dashboard/store/modules/data/catalog/index.js

@@ -0,0 +1,48 @@
+import * as CatalogActions from '../../../actions/catalog';
+import * as CatalogMutations from '../../../mutations/catalog';
+
+const DEFAULT_VALUES = {
+  order: '',
+  orderDirection: ''
+};
+
+const catalog = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isErrored: false,
+    error: [],
+    list: [],
+    categories: [],
+    countries: [],
+    page: 1,
+    numPages: 1,
+    resultsPerPage: 12,
+    order: DEFAULT_VALUES.order,
+    orderDirection: DEFAULT_VALUES.orderDirection
+  },
+  computed: {},
+  getters: {},
+  mutations: {
+    setDatasets: CatalogMutations.setDatasets,
+    setCategories: CatalogMutations.setCategories,
+    setCountries: CatalogMutations.setCountries,
+    setFetchingState: CatalogMutations.setFetchingState,
+    setRequestError: CatalogMutations.setRequestError,
+    setPagination: CatalogMutations.setPagination,
+    setResultsPerPage: CatalogMutations.setResultsPerPage,
+    setOrder: CatalogMutations.setOrder(DEFAULT_VALUES),
+    orderDatasets: CatalogMutations.orderDatasets
+  },
+  actions: {
+    setURLOptions: CatalogActions.setURLOptions,
+    order: CatalogActions.order,
+    fetchCountries: CatalogActions.fetchCountries,
+    fetchDatasets: CatalogActions.fetchDatasets,
+    clearList: CatalogActions.clearList,
+    fetchCategories: CatalogActions.fetchCategories,
+    requestDataset: CatalogActions.requestDataset
+  }
+};
+
+export default catalog;

lib/assets/javascripts/new-dashboard/store/modules/data/datasets/index.js

@@ -0,0 +1,65 @@
+import Filters from 'new-dashboard/core/configuration/filters';
+
+import * as VisualizationActions from '../../../actions/visualizations';
+import * as VisualizationMutations from '../../../mutations/visualizations';
+
+const DEFAULT_VALUES = {
+  filter: 'mine',
+  order: 'favorited,updated_at',
+  orderDirection: 'desc,desc'
+};
+
+const datasets = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isFiltered: false,
+    isErrored: false,
+    error: {},
+    filterType: DEFAULT_VALUES.filter,
+    order: DEFAULT_VALUES.order,
+    orderDirection: DEFAULT_VALUES.orderDirection,
+    list: {},
+    metadata: {},
+    page: 1,
+    numPages: 1,
+    resultsPerPage: 1
+  },
+  mutations: {
+    setFetchingState: VisualizationMutations.setFetchingState,
+    setFilterType: VisualizationMutations.setFilterType,
+    setOrder: VisualizationMutations.setOrder(DEFAULT_VALUES),
+    setPagination: VisualizationMutations.setPagination,
+    setResultsPerPage: VisualizationMutations.setResultsPerPage,
+    setRequestError: VisualizationMutations.setRequestError,
+    setVisualizations: VisualizationMutations.setVisualizations,
+    updateNumberLikes: VisualizationMutations.updateNumberLikes,
+    updateVisualization: VisualizationMutations.updateVisualization
+  },
+  actions: {
+    deleteLike: VisualizationActions.deleteLike,
+    filter: VisualizationActions.filter,
+    like: VisualizationActions.like,
+    order: VisualizationActions.order,
+    resetFilters: VisualizationActions.resetFilters(DEFAULT_VALUES),
+    setResultsPerPage: VisualizationActions.setResultsPerPage,
+    setURLOptions: VisualizationActions.setURLOptions,
+    updateVisualization: VisualizationActions.updateVisualization,
+
+    fetch (context) {
+      const params = {
+        ...Filters[context.state.filterType],
+        types: 'table',
+        page: context.state.page,
+        order: context.state.order,
+        order_direction: context.state.orderDirection,
+        per_page: context.state.resultsPerPage,
+        with_dependent_visualizations: 10
+      };
+
+      VisualizationActions.fetchVisualizations(context, params);
+    }
+  }
+};
+
+export default datasets;

lib/assets/javascripts/new-dashboard/store/modules/maps/featured-favorited-maps.js

@@ -0,0 +1,72 @@
+import CartoNode from 'carto-node';
+import toObject from 'new-dashboard/utils/to-object';
+import { defaultParams as filtersDefaultParams } from 'new-dashboard/core/configuration/filters';
+
+const client = new CartoNode.AuthenticatedClient();
+
+const featuredFavoritedMaps = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isFiltered: false,
+    isErrored: false,
+    error: {},
+    list: {},
+    metadata: {},
+    order: 'updated_at',
+    params: {
+      per_page: 2,
+      only_liked: true
+    }
+  },
+  getters: {},
+  mutations: {
+    setRequestError (state, error) {
+      state.isFetching = false;
+      state.isErrored = true;
+      state.error = error;
+    },
+
+    setFeaturedFavoritedMaps (state, maps) {
+      state.list = toObject(maps.visualizations, 'id');
+      state.metadata = {
+        total_entries: maps.total_entries,
+        total_likes: maps.total_likes,
+        total_shared: maps.total_shared,
+        total_user_entries: maps.total_user_entries
+      };
+      state.isFetching = false;
+    },
+
+    setFetchingState (state) {
+      state.isFetching = true;
+      state.isErrored = false;
+      state.error = {};
+    }
+  },
+  actions: {
+    fetchMaps (context) {
+      const favoritedParams = {
+        ...filtersDefaultParams,
+        ...context.state.params,
+        order: context.state.order
+      };
+
+      context.commit('setFetchingState');
+
+      client.getVisualization('',
+        favoritedParams,
+        function (err, _, data) {
+          if (err) {
+            context.commit('setRequestError', err);
+            return;
+          }
+
+          context.commit('setFeaturedFavoritedMaps', data);
+        }
+      );
+    }
+  }
+};
+
+export default featuredFavoritedMaps;

lib/assets/javascripts/new-dashboard/store/modules/maps/index.js

@@ -0,0 +1,70 @@
+
+import featuredFavoritedMaps from 'new-dashboard/store/modules/maps/featured-favorited-maps';
+import Filters from 'new-dashboard/core/configuration/filters';
+
+import * as VisualizationActions from '../../actions/visualizations';
+import * as VisualizationMutations from '../../mutations/visualizations';
+
+const DEFAULT_VALUES = {
+  filter: 'mine',
+  order: 'favorited,updated_at',
+  orderDirection: 'desc,desc'
+};
+
+const maps = {
+  namespaced: true,
+  modules: {
+    featuredFavoritedMaps
+  },
+  state: {
+    isFetching: false,
+    isFiltered: false,
+    isErrored: false,
+    error: {},
+    filterType: DEFAULT_VALUES.filter,
+    order: DEFAULT_VALUES.order,
+    orderDirection: DEFAULT_VALUES.orderDirection,
+    list: {},
+    metadata: {},
+    page: 1,
+    numPages: 1,
+    resultsPerPage: 12
+  },
+  getters: {},
+  mutations: {
+    setFetchingState: VisualizationMutations.setFetchingState,
+    setFilterType: VisualizationMutations.setFilterType,
+    setOrder: VisualizationMutations.setOrder(DEFAULT_VALUES),
+    setPagination: VisualizationMutations.setPagination,
+    setResultsPerPage: VisualizationMutations.setResultsPerPage,
+    setRequestError: VisualizationMutations.setRequestError,
+    setVisualizations: VisualizationMutations.setVisualizations,
+    updateNumberLikes: VisualizationMutations.updateNumberLikes,
+    updateVisualization: VisualizationMutations.updateVisualization
+  },
+  actions: {
+    deleteLike: VisualizationActions.deleteLike,
+    filter: VisualizationActions.filter,
+    like: VisualizationActions.like,
+    order: VisualizationActions.order,
+    resetFilters: VisualizationActions.resetFilters(DEFAULT_VALUES),
+    setResultsPerPage: VisualizationActions.setResultsPerPage,
+    setURLOptions: VisualizationActions.setURLOptions,
+    updateVisualization: VisualizationActions.updateVisualization,
+
+    fetch (context) {
+      const params = {
+        ...Filters[context.state.filterType],
+        types: 'derived',
+        page: context.state.page,
+        order: context.state.order,
+        order_direction: context.state.orderDirection,
+        per_page: context.state.resultsPerPage
+      };
+
+      VisualizationActions.fetchVisualizations(context, params);
+    }
+  }
+};
+
+export default maps;

lib/assets/javascripts/new-dashboard/store/modules/notifications/index.js

@@ -0,0 +1,59 @@
+const notifications = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isErrored: false,
+    error: {},
+    notifications: []
+  },
+  computed: {},
+  getters: {},
+  mutations: {
+    setNotifications (state, notifications) {
+      state.notifications = notifications;
+      state.isFetching = false;
+      state.isErrored = false;
+      state.error = [];
+    },
+
+    setRequestError (state, error) {
+      state.isFetching = false;
+      state.isErrored = true;
+      state.error = error;
+      state.notifications = [];
+    },
+
+    setFetchingState (state) {
+      state.isFetching = true;
+      state.isErrored = false;
+      state.error = [];
+      state.notifications = [];
+    }
+  },
+  actions: {
+    fetchNotifications (context, options) {
+      context.commit('setFetchingState');
+      context.rootState.client.getConfig(function (err, _, data) {
+        if (err) {
+          context.commit('setRequestError', err);
+          return;
+        }
+
+        context.commit('setNotifications', data.unfiltered_organization_notifications);
+        context.dispatch('markNotificationsAsRead', options);
+      });
+    },
+    markNotificationsAsRead (context, options) {
+      const nowString = new Date().toISOString();
+      context.state.notifications.forEach(notification => {
+        const { userId, apiKey } = options;
+        if (!notification.read_at) {
+          const notificationCopy = { ...notification, read_at: nowString };
+          context.rootState.client.updateNotification(userId, apiKey, notificationCopy, () => {});
+        }
+      });
+    }
+  }
+};
+
+export default notifications;

lib/assets/javascripts/new-dashboard/store/modules/recent-content/index.js

@@ -0,0 +1,67 @@
+import { defaultParams as filtersDefaultParams } from 'new-dashboard/core/configuration/filters';
+import toObject from 'new-dashboard/utils/to-object';
+
+import * as VisualizationActions from '../../actions/visualizations';
+import * as VisualizationMutations from '../../mutations/visualizations';
+
+const recentContent = {
+  namespaced: true,
+  state: {
+    isFetching: false,
+    isErrored: false,
+    error: {},
+    list: {},
+    metadata: {
+      total_entries: 0
+    }
+  },
+  getters: {
+    hasRecentContent (state) {
+      return state.metadata.total_entries > 0;
+    }
+  },
+  mutations: {
+    setFetchingState: VisualizationMutations.setFetchingState,
+    setRequestError: VisualizationMutations.setRequestError,
+    updateNumberLikes: VisualizationMutations.updateNumberLikes,
+    updateVisualization: VisualizationMutations.updateVisualization,
+
+    setRecentContent (state, recentContent) {
+      state.list = toObject(recentContent.visualizations, 'id');
+      state.metadata = { total_entries: recentContent.total_entries };
+      state.isFetching = false;
+    }
+  },
+  actions: {
+    like: VisualizationActions.like,
+    deleteLike: VisualizationActions.deleteLike,
+    updateVisualization: VisualizationActions.updateVisualization,
+
+    fetch (context) {
+      context.commit('setFetchingState');
+
+      const params = {
+        ...filtersDefaultParams,
+        order: 'updated_at',
+        order_direction: 'desc',
+        types: 'table,derived',
+        per_page: 3,
+        page: 1
+      };
+
+      context.rootState.client.getVisualization('',
+        params,
+        function (err, _, data) {
+          if (err) {
+            context.commit('setRequestError', err);
+            return;
+          }
+
+          context.commit('setRecentContent', data);
+        }
+      );
+    }
+  }
+};
+
+export default recentContent;

lib/assets/javascripts/new-dashboard/store/modules/search/index.js

@@ -0,0 +1,213 @@
+import toObject from 'new-dashboard/utils/to-object';
+import * as VisualizationActions from '../../actions/visualizations';
+
+const search = {
+  namespaced: true,
+  state: {
+    searchTerm: '',
+    tag: '',
+    resultsPerPage: 6,
+    maps: {
+      isFetching: false,
+      isErrored: false,
+      results: {},
+      error: {},
+      page: 1,
+      numPages: 1,
+      numResults: 0
+    },
+    datasets: {
+      isFetching: false,
+      isErrored: false,
+      results: {},
+      error: {},
+      page: 1,
+      numPages: 1,
+      numResults: 0
+    },
+    tags: {
+      isFetching: false,
+      isErrored: false,
+      results: [],
+      error: {},
+      page: 1,
+      numPages: 1,
+      numResults: 0
+    }
+  },
+  getters: {
+    requestParameters (state) {
+      const parameters = {
+        per_page: state.resultsPerPage,
+        shared: 'yes',
+        exclude_shared: false
+      };
+
+      if (state.searchTerm) {
+        parameters.q = state.searchTerm;
+      }
+
+      if (state.tag) {
+        parameters.tags = state.tag;
+      }
+
+      return parameters;
+    }
+  },
+  mutations: {
+    updatePage (state, { section, page }) {
+      state[section].page = page;
+    },
+    updateSearchTerm (state, { query, tag }) {
+      state.searchTerm = query;
+      state.tag = tag;
+    },
+    setFetchingState (state, section) {
+      state[section].isFetching = true;
+    },
+    setRequestError (state, { requestType, error }) {
+      state[requestType].error = error;
+    },
+    setMaps (state, maps) {
+      state.maps.results = toObject(maps.visualizations, 'id');
+      state.maps.numResults = maps.total_entries;
+      state.maps.numPages = Math.ceil(maps.total_entries / state.resultsPerPage);
+
+      state.maps.isFetching = false;
+    },
+    setDatasets (state, datasets) {
+      state.datasets.results = toObject(datasets.visualizations, 'id');
+      state.datasets.numResults = datasets.total_entries;
+      state.datasets.numPages = Math.ceil(datasets.total_entries / state.resultsPerPage);
+
+      state.datasets.isFetching = false;
+    },
+    setTags (state, tags) {
+      state.tags.results = tags.result;
+      state.tags.numResults = tags.total;
+      state.tags.numPages = Math.ceil(tags.total / state.resultsPerPage);
+
+      state.tags.isFetching = false;
+    },
+    updateNumberLikes () {
+      // NOOP. This method avoids action not finding mutation.
+    },
+    updateVisualization (state, { visualizationId, visualizationAttributes }) {
+      const visualization = state.maps.results[visualizationId] || state.datasets.results[visualizationId];
+
+      if (visualization) {
+        Object.assign(visualization, visualizationAttributes);
+      }
+    },
+    resetState (state) {
+      state.searchTerm = '';
+      state.tag = '';
+
+      state.maps = {
+        isFetching: false,
+        isErrored: false,
+        results: {},
+        error: {},
+        page: 1,
+        numPages: 1,
+        numResults: 0
+      };
+
+      state.datasets = {
+        isFetching: false,
+        isErrored: false,
+        results: {},
+        error: {},
+        page: 1,
+        numPages: 1,
+        numResults: 0
+      };
+
+      state.tags = {
+        isFetching: false,
+        isErrored: false,
+        results: [],
+        error: {},
+        page: 1,
+        numPages: 1,
+        numResults: 0
+      };
+    }
+  },
+  actions: {
+    deleteLike: VisualizationActions.deleteLike,
+    like: VisualizationActions.like,
+    doSearch (context, searchParameters) {
+      context.commit('updateSearchTerm', searchParameters);
+      context.commit('setFetchingState', 'maps');
+      context.commit('setFetchingState', 'datasets');
+
+      context.dispatch('fetchMaps', context.getters.requestParameters);
+      context.dispatch('fetchDatasets', context.getters.requestParameters);
+
+      if (searchParameters.query) {
+        context.dispatch('fetchTags', context.getters.requestParameters);
+        context.commit('setFetchingState', 'tags');
+      }
+    },
+    changeSectionPage (context, pageOptions) {
+      context.commit('setFetchingState', pageOptions.section);
+
+      const sectionCapitalized = pageOptions.section[0].toUpperCase() + pageOptions.section.substr(1);
+      context.commit('updatePage', pageOptions);
+
+      context.dispatch(`fetch${sectionCapitalized}`, context.getters.requestParameters);
+    },
+    fetchMaps (context, parameters) {
+      context.rootState.client.getVisualization('',
+        { ...parameters,
+          type: 'derived',
+          page: context.state.maps.page },
+        function (error, _, data) {
+          if (error) {
+            return context.commit('setRequestError', { requestType: 'maps', error });
+          }
+
+          context.commit('setMaps', data);
+        }
+      );
+    },
+    fetchDatasets (context, parameters) {
+      context.rootState.client.getVisualization('',
+        { ...parameters,
+          type: 'table',
+          page: context.state.datasets.page,
+          with_dependent_visualizations: 10
+        },
+        function (error, _, data) {
+          if (error) {
+            return context.commit('setRequestError', { requestType: 'datasets', error });
+          }
+
+          context.commit('setDatasets', data);
+        }
+      );
+    },
+    fetchTags (context, parameters) {
+      context.rootState.client.getTags(
+        { ...parameters,
+          types: 'table,derived',
+          page: context.state.tags.page,
+          include_shared: true
+        },
+        function (error, _, data) {
+          if (error) {
+            return context.commit('setRequestError', { requestType: 'tags', error });
+          }
+
+          context.commit('setTags', data);
+        }
+      );
+    },
+    resetState (context) {
+      context.commit('resetState');
+    }
+  }
+};
+
+export default search;

lib/assets/javascripts/new-dashboard/store/modules/user/getters.js

@@ -0,0 +1,59 @@
+export function canCreateDatasets (state) {
+  if (!state.remaining_byte_quota || state.remaining_byte_quota <= 0 || isOutOfDatasetsQuota(state)) {
+    return false;
+  }
+
+  return hasCreateDatasetsFeature(state);
+}
+
+export function hasCreateDatasetsFeature (state) {
+  return isBuilder(state);
+}
+
+export function isBuilder (state) {
+  return !isViewer(state);
+}
+
+export function isViewer (state) {
+  return state.viewer === true;
+}
+
+export function hasEngine (state) {
+  return state.actions.engine_enabled === true;
+}
+
+export function isNotificationVisible (state) {
+  return state.notification && state.showNotification;
+}
+
+export function userNotification (state) {
+  return state.notification ? state.notification : null;
+}
+
+export function getPublicMapsCount (state) {
+  return (state.link_privacy_map_count + state.password_privacy_map_count + state.public_privacy_map_count) || 0;
+}
+
+export function getPublicMapsQuota (state) {
+  return state.public_map_quota;
+}
+
+export function isOutOfPublicMapsQuota (state) {
+  return getPublicMapsQuota(state) && getPublicMapsCount(state) >= getPublicMapsQuota(state);
+}
+
+export function getDatasetsCount (state) {
+  return state.table_count;
+}
+
+export function getDatasetsQuota (state) {
+  return state.table_quota;
+}
+
+export function isOutOfDatasetsQuota (state) {
+  return getDatasetsQuota(state) && getDatasetsCount(state) >= getDatasetsQuota(state);
+}
+
+export function isOrganizationUser (state) {
+  return Boolean(state.organization);
+}

lib/assets/javascripts/new-dashboard/store/modules/user/index.js

@@ -0,0 +1,70 @@
+import CartoNode from 'carto-node';
+import getCARTOData from 'new-dashboard/store/utils/getCARTOData';
+
+import * as getters from './getters';
+
+const client = new CartoNode.AuthenticatedClient();
+
+// Data coming from Static Page Loading,
+// which requests user and config data from
+// /me API endpoint.
+const CARTOData = getCARTOData();
+
+const user = {
+  namespaced: true,
+  state: {
+    ...CARTOData.user_data,
+    organizationNotifications: CARTOData.organization_notifications || [],
+    showNotification: true
+  },
+  getters: {
+    canCreateDatasets: getters.canCreateDatasets,
+    isViewer: getters.isViewer,
+    hasEngine: getters.hasEngine,
+    userNotification: getters.userNotification,
+    isNotificationVisible: getters.isNotificationVisible,
+    publicMapsCount: getters.getPublicMapsCount,
+    publicMapsQuota: getters.getPublicMapsQuota,
+    isOutOfPublicMapsQuota: getters.isOutOfPublicMapsQuota,
+    datasetsCount: getters.getDatasetsCount,
+    datasetsQuota: getters.getDatasetsQuota,
+    isOutOfDatasetsQuota: getters.isOutOfDatasetsQuota,
+    isOrganizationUser: getters.isOrganizationUser
+  },
+  mutations: {
+    setUserData (state, userData) {
+      Object.assign(state, userData);
+    },
+    setOrganizationNotifications (state, organizationNotifications) {
+      state.organizationNotifications = organizationNotifications;
+    },
+    setShowNotification (state, showNotification) {
+      state.showNotification = showNotification;
+    },
+    updateTableCount (state, newTableCount) {
+      state.table_count = newTableCount;
+    }
+  },
+  actions: {
+    updateData (context) {
+      client.getConfig(function (err, _, data) {
+        if (err) {
+          return;
+        }
+
+        context.commit('setUserData', data.user_data);
+      });
+    },
+    resetOrganizationNotifications (context) {
+      context.commit('setOrganizationNotifications', []);
+    },
+    hideUserNotification (context) {
+      context.commit('setShowNotification', false);
+    },
+    updateTableCount (context, newTableCount) {
+      context.commit('updateTableCount', newTableCount);
+    }
+  }
+};
+
+export default user;