@piveau/dpi 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/data-provider-interface/store/modules/authStore.js

@@ -0,0 +1,301 @@
+import n from "axios";
+import { cloneDeep as u, get as T } from "lodash-es";
+import i from "../../../utils/draftApi.js";
+import f from "../../../utils/identifiersApi.js";
+import { decode as R } from "../../../utils/jwt.js";
+let _, A;
+const d = {
+  authenticated: !1,
+  rtptoken: "",
+  keycloak: null,
+  userData: {
+    authToken: "",
+    rtpToken: "",
+    userName: "",
+    permissions: [],
+    drafts: [],
+    roles: []
+  },
+  isEditMode: !1,
+  isDraft: !1
+}, U = {
+  securityAuth: (e) => e.authenticated,
+  getRTPToken: (e) => e.rtptoken,
+  getKeycloak: (e) => e.keycloak,
+  getUserData: (e) => e.userData,
+  getUserName: (e) => e.userData.userName,
+  /**
+   * @description Get all catalogs associated to the user where they have access to.
+   * @returns {Array} Array of catalogs
+   */
+  getUserCatalogs: (e) => e.userData.permissions.filter(
+    // User must have CRUD authorization
+    (t) => ["dataset:update", "dataset:delete", "dataset:create"].every(
+      (a) => t.scopes.includes(a)
+    )
+  ),
+  /**
+   * @description Get all catalog IDs associated to the user where they have access to.
+   */
+  getUserCatalogIds: (e, t) => t.getUserCatalogs.map((a) => a.rsname),
+  getUserDrafts: (e) => e.userData.drafts,
+  getUserDraftIds: (e) => e.userData.drafts.map((t) => t.id),
+  getIsEditMode: (e) => e.isEditMode,
+  getIsDraft: (e) => e.isDraft
+}, l = {
+  authLogin({ commit: e }, t) {
+    e("SECURITY_AUTH", t);
+  },
+  authLogout({ commit: e }) {
+    e("SECURITY_AUTH", !1), e("RTP_TOKEN", "");
+  },
+  rtpToken({ commit: e }, t) {
+    e("RTP_TOKEN", t);
+  },
+  setKeycloak({ commit: e }, t) {
+    e("SET_KEYCLOAK", t);
+  },
+  /**
+   * Updates user data according to an authentication token and by supplying neccessary
+   * information to retrieve tFhe user's permissions as well as their drafts.
+   * @param {*} commit
+   * @param {Object} params
+   * @returns {Promise<Object>}
+   */
+  async updateUserData({ commit: e, dispatch: t }, { authToken: a, rtpToken: s, hubUrl: r }) {
+    if (!a || !s)
+      return console.error("Missing authToken or rtpToken"), e("UPDATE_USER_DATA_ERROR"), {};
+    e("UPDATE_USER_DATA_PENDING");
+    try {
+      if (!s) throw new Error("Failed to retrieve RTP token");
+      const E = R(s), D = T(E, "authorization.permissions", []), o = T(E, "realm_access.roles", []);
+      e("SET_USER_DATA", {
+        authToken: a,
+        rtpToken: s,
+        userName: E.preferred_username,
+        permissions: D,
+        drafts: [],
+        roles: o
+      }), _ = i({ baseURL: r, authToken: s }), A = f({
+        baseURL: r,
+        authToken: s
+      }), t("updateUserDrafts"), e("UPDATE_USER_DATA_SUCCESS");
+    } catch (E) {
+      console.error(E), e("UPDATE_USER_DATA_ERROR");
+    }
+    return {};
+  },
+  async updateUserDrafts({ commit: e, state: t }) {
+    if (!t.userData.rtpToken) throw new Error("Requires RTP token");
+    const s = await _.getAllDatasetDrafts(), r = s.status === 200 && s.data;
+    e("SET_USER_DATA", { drafts: r });
+  },
+  async createDataset({ commit: e }, t) {
+    const a = {
+      method: "PUT",
+      url: t.url,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${t.token}`
+      },
+      data: t.body
+    };
+    console.log("############", a);
+    const s = await n.request(a);
+    (s.status === 201 || s.status === 204) && (e("CHANGE_IS_EDIT_MODE", !1), e("CHANGE_IS_DRAFT", !1));
+  },
+  /**
+   * Creates a draft dataset
+   * @param {*} commit
+   * @param {object} dataset - The dataset object
+   * @param {string} dataset.id - The ID of the dataset
+   * @param {string} dataset.catalog - The ID of the dataset
+   * @param {object} dataset.description - The description object of the dataset containing different locales
+   * @param {object} dataset.title - The title object of the dataset containing different locales
+   * @param {object} dataset.body - the JSON-LD representation of the dataset
+   * @returns {Promise<Object>}
+   */
+  async createUserDraft({ commit: e }, { id: t, catalog: a, description: s = { en: "" }, title: r = { en: "" }, body: E = {} }) {
+    if (!_) return {};
+    e("UPDATE_USER_DATA_PENDING");
+    let D;
+    try {
+      D = await _.createDatasetDraft({
+        id: t,
+        catalogue: a,
+        body: E
+      }), e("CREATE_USER_DRAFT", {
+        id: t,
+        catalog: a,
+        description: s,
+        title: r,
+        body: E
+      }), e("UPDATE_USER_DATA_SUCCESS");
+    } catch (o) {
+      throw e("UPDATE_USER_DATA_ERROR"), o;
+    }
+    return D;
+  },
+  async deleteUserDraftById({ commit: e, state: t }, { id: a, catalog: s }) {
+    if (console.log(a), !_) return {};
+    if (!t.userData.drafts.find((D) => D.id === a)) return {};
+    e("UPDATE_USER_DATA_PENDING");
+    let E;
+    try {
+      E = await _.deleteDatasetDraft({ id: a, catalogue: s }), e("DELETE_USER_DRAFT", a), e("UPDATE_USER_DATA_SUCCESS");
+    } catch (D) {
+      throw e("UPDATE_USER_DATA_ERROR"), D;
+    }
+    return E;
+  },
+  async publishUserDraftById({ commit: e, state: t }, { id: a, catalog: s, body: r = {} }) {
+    if (!_) return {};
+    if (!t.userData.drafts.find((o) => o.id === a)) return {};
+    e("UPDATE_USER_DATA_PENDING");
+    let D;
+    try {
+      D = await _.publishDatasetDraft({
+        id: a,
+        catalogue: s,
+        body: r
+      }), e("DELETE_USER_DRAFT", a), e("UPDATE_USER_DATA_SUCCESS"), e("CHANGE_IS_DRAFT", !1), e("CHANGE_IS_EDIT_MODE", !1);
+    } catch (o) {
+      throw console.log("error"), e("UPDATE_USER_DATA_ERROR"), o;
+    }
+    return D;
+  },
+  async duplicateDataset({ commit: e, state: t }, { id: a, newId: s, catalog: r, url: E }) {
+    console.log(a, r, E);
+    const D = {
+      method: "GET",
+      url: E + "drafts/datasets/" + a + ".nt?catalogue=" + r
+    };
+    await n.request(D);
+  },
+  async publishUserDraft({ dispatch: e }, { id: t, catalog: a, body: s }) {
+    return e("publishUserDraftById", { id: t, catalog: a, body: s });
+  },
+  async putDatasetToDraft({ commit: e }, { id: t, catalog: a, title: s, description: r }) {
+    if (!_) return {};
+    e("UPDATE_USER_DATA_PENDING");
+    let E;
+    try {
+      console.log(t, a, s, r), E = await _.putDatasetToDraft({ id: t, catalogue: a }), e("PUT_DATASET_TO_DRAFT", {
+        id: t,
+        catalog: a,
+        title: s,
+        description: r
+      }), e("UPDATE_USER_DATA_SUCCESS");
+    } catch (D) {
+      throw e("UPDATE_USER_DATA_ERROR"), D;
+    }
+    return E;
+  },
+  setIsEditMode({ commit: e }, t) {
+    e("CHANGE_IS_EDIT_MODE", t);
+  },
+  setIsDraft({ commit: e }, t) {
+    e("CHANGE_IS_DRAFT", t);
+  },
+  async createPersistentIdentifier({ commit: e }, { id: t, catalog: a, type: s = "mock" }) {
+    if (!A) return {};
+    e("UPDATE_USER_DATA_PENDING");
+    let r;
+    try {
+      r = await A.createPersistentIdentifier({
+        id: t,
+        catalogue: a,
+        type: s
+      }), e("UPDATE_USER_DATA_SUCCESS");
+    } catch (E) {
+      throw e("UPDATE_USER_DATA_ERROR"), E;
+    }
+    return r;
+  },
+  populateDraftAndEdit({ commit: e }) {
+    e("PREDEFINE_DRAFT_AND_EDIT");
+  },
+  async createCatalogue({ commit: e }, t) {
+    const a = {
+      method: "PUT",
+      url: t.url,
+      headers: {
+        "Content-Type": "text/turtle",
+        Authorization: `Bearer ${t.token}`
+      },
+      data: t.data
+    }, s = await n.request(a);
+    if (s.status === 201 | s.status === 204) {
+      e("CHANGE_IS_EDIT_MODE", !1), e("CHANGE_IS_DRAFT", !1);
+      const r = u(d.userData), E = {
+        rsid: "",
+        rsname: t.id,
+        scopes: ["dataset:update", "dataset:delete", "dataset:create"]
+      };
+      r.permissions.push(E), e("SET_USER_DATA", r);
+    }
+  }
+}, S = {
+  SECURITY_AUTH(e, t) {
+    e.authenticated = t;
+  },
+  RTP_TOKEN(e, t) {
+    e.rtptoken = t;
+  },
+  SET_KEYCLOAK(e, t) {
+    e.keycloak = t;
+  },
+  SET_USER_DATA(e, t) {
+    e.userData = { ...e.userData, ...t };
+  },
+  UPDATE_USER_DATA_PENDING(e) {
+    e.userData.pending = !0;
+  },
+  UPDATE_USER_DATA_SUCCESS(e) {
+    e.userData.pending = !1;
+  },
+  UPDATE_USER_DATA_ERROR(e) {
+    e.userData.pending = !1;
+  },
+  CREATE_USER_DRAFT(e, { id: t, catalog: a, title: s, description: r }) {
+    e.userData.drafts.push({
+      id: t,
+      catalog: a,
+      title: s,
+      description: r
+    });
+  },
+  PUT_DATASET_TO_DRAFT(e, { id: t, catalog: a, title: s, description: r }) {
+    e.userData.drafts.push({
+      id: t,
+      catalog: a,
+      title: s,
+      description: r
+    });
+  },
+  DELETE_USER_DRAFT(e, t) {
+    const a = e.userData.drafts.findIndex(
+      (s) => s.id === t
+    );
+    a > -1 && e.userData.drafts.splice(a, 1);
+  },
+  CHANGE_IS_EDIT_MODE(e, t) {
+    e.isEditMode = t, localStorage.setItem("dpi_editmode", t);
+  },
+  CHANGE_IS_DRAFT(e, t) {
+    e.isDraft = t, localStorage.setItem("dpi_draftmode", t);
+  },
+  PREDEFINE_DRAFT_AND_EDIT(e) {
+    const t = Object.keys(localStorage);
+    t.includes("dpi_editmode") && (e.isEditMode = JSON.parse(localStorage.getItem("dpi_editmode"))), t.includes("dpi_draftmode") && (e.isDraft = JSON.parse(localStorage.getItem("dpi_draftmode")));
+  }
+}, C = {
+  namespaced: !0,
+  state: d,
+  actions: l,
+  mutations: S,
+  getters: U
+};
+export {
+  C as default
+};

package/dist/data-provider-interface/store/modules/catalogueDetailsStore.js

@@ -0,0 +1,34 @@
+const l = {
+  catalog: {}
+}, g = {
+  getCatalog: (a) => a.catalog
+}, n = {
+  /**
+   * @description Loads details for the dataset with the given ID.
+   * @param commit
+   * @param state
+   * @param id {String} The dataset ID.
+   */
+  loadCatalog({ state: a, commit: o }, e) {
+    return new Promise((c, s) => {
+      this.$catalogService.getSingle(e).then((t) => {
+        o("SET_catalog", t), c(t);
+      }).catch((t) => {
+        console.error(t), s(t);
+      });
+    });
+  }
+}, r = {
+  SET_catalog(a, o) {
+    a.catalog = o;
+  }
+}, i = {
+  namespaced: !0,
+  state: l,
+  actions: n,
+  mutations: r,
+  getters: g
+};
+export {
+  i as default
+};

package/dist/data-provider-interface/store/modules/cataloguesStore.js

@@ -0,0 +1,256 @@
+const u = {
+  /**
+   * @property catalogs
+   * @type Array
+   * @description An array of catalogs.
+   */
+  catalogs: [],
+  datasetCounts: {},
+  loading: !1,
+  searchParameters: {
+    query: "",
+    fields: void 0,
+    limit: 10,
+    offset: 0,
+    facets: [],
+    facetOperator: "AND",
+    facetGroupOperator: "AND",
+    sort: "relevance+desc,modified+desc,title+asc"
+  },
+  availableFacets: [],
+  page: 1,
+  pageCount: 1,
+  catalogsCount: 0
+}, r = {
+  getCatalogs: (e) => e.catalogs,
+  getCatalogsCount: (e) => e.catalogsCount,
+  getQuery: (e) => e.searchParameters.query,
+  getFields: (e) => e.searchParameters.fields,
+  getLimit: (e) => e.searchParameters.limit,
+  getLoading: (e) => e.loading,
+  getOffset: (e) => e.searchParameters.offset,
+  getFacets: (e) => e.searchParameters.facets,
+  getFacetOperator: (e) => e.searchParameters.facetOperator,
+  getFacetGroupOperator: (e) => e.searchParameters.facetGroupOperator,
+  getAvailableFacets: (e) => [
+    ...e.availableFacets,
+    {
+      id: "erpd",
+      items: [
+        { count: void 0, id: "true", title: "yes" },
+        { count: void 0, id: "false", title: "no" }
+      ],
+      title: "ERPD"
+    }
+  ],
+  getPage: (e) => e.page,
+  getPageCount: (e) => e.pageCount,
+  getSort: (e) => e.searchParameters.sort
+}, E = {
+  /**
+   * @description Load all catalogs matching the given parameters.
+   * @param commit
+   * @param state
+   * @param options {Object} - Given search parameters
+   * @param options.query {String} - The given query string
+   * @param options.fields {String} - The given fields
+   * @param options.facets {Array} - The active facets
+   * @param options.limit {Number} - The maximum amount of catalogs to fetch
+   * @param options.page {Number} - The current page
+   * @param options.sort {String} - The sort method to use
+   * @param options.append {Boolean} - Decides whether current catalogs in state will be replaced or fetched catalogs appended.
+   */
+  loadCatalogs({ commit: e, state: a }, {
+    query: t = r.getQuery(a),
+    fields: o = r.getFields(a),
+    limit: c = r.getLimit(a),
+    page: l = r.getPage(a),
+    sort: g = r.getSort(a),
+    facetOperator: S = r.getFacetOperator(a),
+    facetGroupOperator: T = r.getFacetGroupOperator(a),
+    facets: _ = r.getFacets(a),
+    append: i = !1
+  }) {
+    return e("SET_LOADING", !0), new Promise((P, n) => {
+      this.$catalogService.get(t, o, c, l, g, S, T, _).then((s) => {
+        e("SET_FIEELDS", s.fields), e("SET_AVAILABLE_FACETS", s.availableFacets), e("SET_catalogS_COUNT", s.catalogsCount), e(i ? "ADD_catalogS" : "SET_catalogS", s.catalogs), e("SET_LOADING", !1), P();
+      }).catch((s) => {
+        console.error(s), e("SET_LOADING", !1), n(s);
+      });
+    });
+  },
+  /**
+   * @description Loads more catalogs.
+   * @param commit
+   * @param state
+   * @param {number} amount - The amount of catalogs to add.
+   */
+  loadAdditionalCatalogs({ commit: e, state: a }) {
+    const t = r.getPage(a);
+    E.loadCatalogs({ commit: e, state: a }, { page: t, append: !0 });
+  },
+  /**
+   * @description Autocomplete a query String by using a autocompletion service
+   * @param commit
+   * @param q {String} The Query to autocomplete
+   */
+  autocompleteQuery({ commit: e }, a) {
+    if (typeof this.$catalogService.autocomplete == "function")
+      return new Promise((t, o) => {
+        this.$catalogService.autocomplete(a).then((c) => {
+          t(c);
+        }).catch((c) => {
+          o(c);
+        });
+      });
+  },
+  /**
+   * @description Replace the current state facets by the given facets
+   * @param commit
+   * @param facets {Array} - The given facets
+   */
+  setFacets({ commit: e }, a) {
+    a && e("SET_FACETS", a);
+  },
+  /**
+   * @description Add the given facet to the states facets.
+   * @param commit
+   * @param params {Object} - The wrapped action parameters.
+   * @param params.field {String} - The field of the given facet
+   * @param params.facet {String} - The facet to add
+   */
+  addFacet({ commit: e }, { field: a, facet: t }) {
+    e("ADD_FACET", { field: a, facet: t });
+  },
+  /**
+   * @description Remove the given facet from the states facets.
+   * @param commit
+   * @param params {Object} - The wrapped action parameters.
+   * @param params.field {String} - The field of the given facet
+   * @param params.facet {String} - The facet to remove
+   */
+  removeFacet({ commit: e }, { field: a, facet: t }) {
+    e("REMOVE_FACET", { field: a, facet: t });
+  },
+  /**
+   * @description Remove the given facet from the states facets.
+   * @param commit
+   * @param operator {String} - The facet operator to set. Possible Operators : ['AND', 'OR'].
+   */
+  setFacetOperator({ commit: e }, a) {
+    e("SET_FACET_OPERATOR", a);
+  },
+  /**
+   * @description Remove the given facet from the states facets.
+   * @param commit
+   * @param operator {String} - The facet operator to set. Possible Operators : ['AND', 'OR'].
+   */
+  setFacetGroupOperator({ commit: e }, a) {
+    e("SET_FACET_GROUP_OPERATOR", a);
+  },
+  /**
+   * @description Handles page changes by through URL query.
+   * @param commit
+   * @param state
+   * @param page {String} The given page number as a String
+   */
+  setPage({ commit: e }, a) {
+    e("SET_PAGE", a);
+  },
+  setPageCount({ commit: e }, a) {
+    e("SET_PAGE_COUNT", a);
+  },
+  /**
+   * @description Replace the current state query by the given query
+   * @param commit
+   * @param query {String} - The given query
+   */
+  setQuery({ commit: e }, a) {
+    e("SET_QUERY", a);
+  },
+  setFields({ commit: e }, a) {
+    e("SET_FIELDS", a);
+  },
+  /**
+   * @description Replace the current sort method
+   * @param commit
+   * @param sort {String} - The given sort method to use now
+   */
+  setSort({ commit: e }, a) {
+    e("SET_SORT", a);
+  },
+  setLimit({ commit: e }, a = 10) {
+    e("SET_LIMIT", a);
+  },
+  setLoading({ commit: e }, a) {
+    e("SET_LOADING", a);
+  },
+  setCatalogs({ commit: e }, a) {
+    e("SET_catalogS", a);
+  },
+  setCatalogsCount({ commit: e }, a) {
+    e("SET_catalogS_COUNT", a);
+  }
+}, A = {
+  SET_catalogS(e, a) {
+    e.catalogs = a;
+  },
+  ADD_catalogS(e, a) {
+    e.catalogs = e.catalogs.concat(a);
+  },
+  SET_LIMIT(e, a) {
+    e.searchParameters.limit = a;
+  },
+  SET_OFFSET(e, a) {
+    e.searchParameters.offset = a;
+  },
+  SET_FACETS(e, a) {
+    e.searchParameters.facets = a;
+  },
+  ADD_FACET(e, { field: a, facet: t }) {
+    Object.prototype.hasOwnProperty.call(e.searchParameters.facets, a) ? e.searchParameters.facets[a].push(t) : e.searchParameters.facets[a] = [t];
+  },
+  REMOVE_FACET(e, { field: a, facet: t }) {
+    const o = e.searchParameters.facets[a].indexOf(t);
+    e.searchParameters.facets[a].splice(o, 1);
+  },
+  SET_AVAILABLE_FACETS(e, a) {
+    e.availableFacets = a;
+  },
+  SET_catalogS_COUNT(e, a) {
+    e.catalogsCount = a;
+  },
+  SET_FACET_OPERATOR(e, a) {
+    e.searchParameters.facetOperator = a;
+  },
+  SET_FACET_GROUP_OPERATOR(e, a) {
+    e.searchParameters.facetGroupOperator = a;
+  },
+  SET_PAGE(e, a) {
+    e.page = a;
+  },
+  SET_PAGE_COUNT(e, a) {
+    e.pageCount = a;
+  },
+  SET_QUERY(e, a) {
+    e.searchParameters.query = a;
+  },
+  SET_FIELDS(e, a) {
+    e.searchParameters.fields = a;
+  },
+  SET_SORT(e, a) {
+    e.searchParameters.sort = a;
+  },
+  SET_LOADING(e, a) {
+    e.loading = a;
+  }
+}, O = {
+  namespaced: !0,
+  state: u,
+  actions: E,
+  mutations: A,
+  getters: r
+};
+export {
+  O as default
+};