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

package/dist/data-provider-interface/composables/useDpiEditMode.js

@@ -1,13 +1,13 @@
-import { useRoute as y } from "vue-router";
+import { useRoute as g } from "vue-router";
 import { useDpiContext as j } from "./useDpiContext.js";
 import { computed as o, toValue as n, watchEffect as R, watch as U } from "vue";
-import { useStore as g } from "vuex";
+import { useStore as D } from "vuex";
 import { useRuntimeEnv as A } from "../../composables/useRuntimeEnv.js";
 import { useAsyncState as k } from "@vueuse/core";
 import L from "axios";
 import { useDpiSimpleLoader as Q } from "./useDpiSimpleLoader.js";
 function _(u) {
-  const s = y(), a = g(), d = A(), m = o(() => {
+  const s = g(), a = D(), d = A(), m = o(() => {
     var e, i;
     return ((i = (e = n(u)) == null ? void 0 : e.edit) == null ? void 0 : i.enabled) ?? s.query.edit === "true";
   }), l = o(() => {
@@ -19,10 +19,10 @@ function _(u) {
   });
   m.value && (localStorage.setItem("dpi_editmode", "false"), a.dispatch("auth/setIsEditMode", !1));
   const t = o(() => {
-    var v;
-    const e = c.value, i = (v = a.getters["auth/getUserData"]) == null ? void 0 : v.rtpToken, $ = s.params.property, M = s.params.id;
+    var y;
+    const e = c.value, i = (y = a.getters["auth/getUserData"]) == null ? void 0 : y.rtpToken, $ = s.params.property, M = s.params.id;
     return { endpoint: e ? `${d.api.hubUrl}drafts/datasets/${l.value}.jsonld?catalogue=${s.query.catalog}` : s.params.property === "catalogues" ? `${d.api.hubUrl}catalogues/${s.query.catalog}.jsonld` : `${d.api.hubUrl}datasets/${l.value}.jsonld?useNormalizedId=true`, token: i, property: $, id: M };
-  }), { state: r, execute: D, isLoading: b, error: E } = k(
+  }), { state: r, execute: b, isLoading: f, error: E } = k(
     async () => (await L.get(t.value.endpoint, {
       headers: {
         Accept: "application/ld+json",
@@ -41,28 +41,30 @@ function _(u) {
   U(p, () => {
     if (!p.value) return;
     const e = c.value;
-    a.dispatch("auth/setIsEditMode", !0), a.dispatch("auth/setIsDraft", e), D();
+    a.dispatch("auth/setIsEditMode", !0), a.dispatch("auth/setIsDraft", e), b();
   }, { immediate: !0 });
-  const { isReady: f, result: I, isMaterialized: h, errors: q } = Q(r, {
+  const { isReady: h, result: I, isMaterialized: v, errors: q } = Q(r, {
     enabled: p,
     hubSearchUrl: d.api.baseUrl
   }), S = o(() => {
     var e;
-    return (e = n(u).edit) != null && e.enabled ? !!a.getters["dpiStore/getSpecificationName"] && !b.value && f.value && h.value : !0;
+    return (e = n(u).edit) != null && e.enabled ? !!a.getters["dpiStore/getSpecificationName"] && !f.value && h.value && v.value : !0;
   });
   return o(() => {
   }), {
     inEditModeAndRptAvailable: p,
     isReady: S,
     result: I,
-    isSimpleLoaderReady: f,
-    isMaterialized: h,
+    isSimpleLoaderReady: h,
+    isMaterialized: v,
     fetchError: E,
-    parsingErrors: q
+    parsingErrors: q,
+    isLoading: f,
+    jsonld: r
   };
 }
 function G() {
-  const u = y(), s = g(), a = j(), d = o(() => {
+  const u = g(), s = D(), a = j(), d = o(() => {
     var t, r;
     return ((r = (t = n(a)) == null ? void 0 : t.edit) == null ? void 0 : r.id) ?? u.query.id;
   }), m = o(() => {

package/dist/data-provider-interface/composables/useDpiSimpleLoader.js

@@ -1,4 +1,4 @@
-import { toRef as O, toValue as x, ref as E, computed as T, watch as F } from "vue";
+import { toRef as O, ref as E, toValue as F, computed as T, watch as x } from "vue";
 import { useAsyncState as C } from "@vueuse/core";
 import { defineJsonldResolver as M, dcatDatasetTransformer as k, datasetResolvers as G } from "@piveau/jsonld";
 import { isEmpty as N } from "lodash-es";
@@ -16,7 +16,7 @@ function $(e) {
   return Object.fromEntries(Object.entries(e).filter(([i, t]) => t != null && !N(t)));
 }
 function ce(e, i) {
-  const { enabled: t, hubSearchUrl: r } = i, n = O(x(t) ?? !1), { safeTransform: f } = M({
+  const { enabled: t, hubSearchUrl: r } = i, n = O(t), { safeTransform: f } = M({
     baseUrl: r,
     resolvers: G(),
     transformer: k
@@ -29,7 +29,7 @@ function ce(e, i) {
   } = C(
     async () => {
       var I;
-      const c = await f(x(e));
+      const c = await f(F(e));
       if (c.error)
         return p.value.push({
           code: "transform_failed",
@@ -53,12 +53,12 @@ function ce(e, i) {
     var c;
     return (c = m.value) == null ? void 0 : c.data;
   });
-  return F(
-    () => x(e),
+  return x(
+    () => F(e),
     (c) => c && n.value ? R() : null
-  ), F(A, (c) => {
+  ), x(A, (c) => {
     console.log("jsonld resolved result:", c);
-  }), F(v, (c) => {
+  }), x(v, (c) => {
     console.log("jsonld error:", c);
   }), {
     processedInput: m,

package/dist/data-provider-interface/store/index.js

@@ -0,0 +1,32 @@
+import { createStore as o } from "vuex";
+import r from "./modules/cataloguesStore.js";
+import e from "./modules/catalogueDetailsStore.js";
+import m from "./modules/datasetsStore.js";
+import a from "./modules/datasetDetailsStore.js";
+import s from "./modules/authStore.js";
+import i from "./modules/snackbarStore.js";
+import u from "./modules/dpiStore.js";
+const l = {}, d = {}, c = {}, p = {
+  /**
+   * @description Returns the current route (name).
+   * @param state
+   */
+  getCurrentRoute: (t) => t.route
+}, k = o({
+  state: l,
+  actions: d,
+  mutations: c,
+  getters: p,
+  modules: {
+    catalogs: r,
+    catalogDetails: e,
+    datasets: m,
+    datasetDetails: a,
+    dpiStore: u,
+    auth: s,
+    snackbar: i
+  }
+});
+export {
+  k as default
+};

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

@@ -0,0 +1,301 @@
+import o 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", []), n = T(E, "realm_access.roles", []);
+      e("SET_USER_DATA", {
+        authToken: a,
+        rtpToken: s,
+        userName: E.preferred_username,
+        permissions: D,
+        drafts: [],
+        roles: n
+      }), _ = 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 o.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 (n) {
+      throw e("UPDATE_USER_DATA_ERROR"), n;
+    }
+    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((n) => n.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 (n) {
+      throw e("UPDATE_USER_DATA_ERROR"), n;
+    }
+    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 o.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 o.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
+};