adminforth 1.3.55-next.0 → 1.3.55

package/dist/spa/src/stores/core.ts

@@ -0,0 +1,148 @@
+import { ref, computed } from 'vue'
+import { defineStore } from 'pinia'
+import { callAdminForthApi } from '@/utils';
+import type { AdminForthResource, AdminForthResourceColumn } from '@/types/AdminForthConfig';
+import type { Ref } from 'vue'
+
+export const useCoreStore = defineStore('core', () => {
+  const resourceById: Ref<Object> = ref({});
+  const menu = ref([]);
+  const config = ref({});
+  const record: Ref<any | null> = ref({});
+  const resource: Ref<AdminForthResource | null> = ref(null);
+
+  const resourceColumnsWithFilters = computed(() => {
+    if (!resource.value) {
+      return [];
+    }
+    return resource.value.columns.filter((col: AdminForthResourceColumn) => col.showIn?.includes('filter'));
+  })
+
+  const resourceOptions = ref(null);
+  const resourceColumnsError = ref('');
+  const resourceColumnsId = ref(null);
+  const adminUser = ref(null);
+
+  async function fetchMenuAndResource() {
+    const resp = await callAdminForthApi({
+      path: '/get_base_config',
+      method: 'GET',
+    });
+    if(!resp){
+      return
+    }
+    menu.value = resp.menu;
+    resourceById.value = resp.resources.reduce((acc: Object, resource: AdminForthResource) => {
+      acc[resource.resourceId] = resource;
+      return acc;
+    }, {});
+    config.value = resp.config;
+    adminUser.value = resp.user;
+    console.log('🌍 AdminForth v', resp.version);
+  }
+
+  async function fetchRecord({ resourceId, primaryKey }) {
+    record.value = null;
+    
+    if (!resource.value) {
+      throw new Error('Columns not fetched yet');
+    }
+    const col = resource.value.columns.find((col: AdminForthResourceColumn) => col.primaryKey);
+    if (!col) {
+      throw new Error(`Primary key not found in resource ${resourceId}`);
+    }
+
+    const respData = await callAdminForthApi({
+      path: '/get_resource_data',
+      method: 'POST',
+      body: {
+        source: 'show',
+        resourceId: resourceId,
+        filters: [
+          {
+            field: col.name,
+            operator: 'eq',
+            value: primaryKey
+          }
+        ],
+        sort: [],
+        limit: 1,
+        offset: 0
+      }
+    });
+
+    if (respData.error) {
+      window.adminforth.alert({
+        message: respData.error,
+        variant: 'danger',
+        timeout: 30,
+      });
+      record.value = {};
+    } else {
+      record.value = respData.data[0];
+    }
+
+  }
+
+  async function fetchResourceFull({ resourceId }: { resourceId: string }) {
+    if (resourceColumnsId.value === resourceId && resource.value) {
+      // already fetched
+      return;
+    }
+    resourceColumnsId.value = resourceId;
+    resourceColumnsError.value = '';
+    const res = await callAdminForthApi({
+      path: '/get_resource',
+      method: 'POST',
+      body: {
+        resourceId,
+      }
+    });
+    if (res.error) {
+      resourceColumnsError.value = res.error;
+    } else {
+      resourceById.value[resourceId] = res.resource;
+      resource.value = res.resource;
+      resourceOptions.value = res.resource.options;
+    }
+  }
+
+  async function getPublicConfig() {
+    const res = await callAdminForthApi({
+      path: '/get_public_config',
+      method: 'GET',
+    });
+    config.value = {...config.value, ...res};
+  }
+
+ 
+
+  const username = computed(() => {
+    const usernameField = config.value.usernameField;
+    return adminUser.value && adminUser.value[usernameField];
+  });
+
+  const userFullname = computed(() => {
+    const userFullnameField = config.value.userFullnameField;
+    return adminUser.value && adminUser.value[userFullnameField];
+  })
+
+
+  return { 
+    config,
+    resourceById, 
+    menu, 
+    username,
+    userFullname,
+    getPublicConfig,
+    fetchMenuAndResource, 
+    fetchRecord, 
+    record, 
+    fetchResourceFull, 
+    resourceColumnsError,
+    resourceOptions,
+    resource,
+    adminUser,
+    resourceColumnsWithFilters
+  }
+})

package/dist/spa/src/stores/filters.ts

@@ -0,0 +1,27 @@
+import { ref, type Ref } from 'vue';
+import { defineStore } from 'pinia';
+
+export const useFiltersStore = defineStore('filters', () => {
+    const filters: Ref<any[]> = ref([]);
+    const sort: Ref<any> = ref({});
+
+    const setSort = (s: any) => {
+        sort.value = s;
+    }
+    const getSort = () => {
+        return sort.value;
+    }
+    const setFilter = (filter: any) => {
+        filters.value.push(filter);
+    }
+    const setFilters = (f: any) => {
+        filters.value = f;
+    }
+    const getFilters = () => {
+        return filters.value;
+    }
+    const clearFilters = () => {
+        filters.value = [];
+    }
+    return {setFilter, getFilters, clearFilters, filters, setFilters, setSort, getSort}
+})

package/dist/spa/src/stores/modal.ts

@@ -0,0 +1,48 @@
+import { ref } from 'vue'
+import { defineStore } from 'pinia'
+
+ type ModalContentType = {
+  title?: string;
+  content?: string;
+  acceptText?: string;
+  cancelText?: string;
+ }
+
+
+export const useModalStore = defineStore('modal', () => {
+  const modalContent = ref({
+    title: 'title',
+    content: 'content',
+    acceptText: 'acceptText',
+    cancelText: 'cancelText',
+  });  
+  const isOpened = ref(false);
+  const onAcceptFunction: any = ref(()=>{});
+  const onCancelFunction: any = ref(()=>{});
+  function togleModal() {
+    isOpened.value = !isOpened.value;
+  }
+  function setOnAcceptFunction(func: Function) {
+    onAcceptFunction.value = func;
+  }
+  function setOnCancelFunction(func: Function) {
+    onCancelFunction.value = func;
+  }
+  function setModalContent(content: ModalContentType) {
+    modalContent.value = content;
+  }
+  function resetmodalState() {
+    isOpened.value = false;
+    modalContent.value = {
+      title: 'title',
+      content: 'content',
+      acceptText: 'acceptText',
+      cancelText: 'cancelText',
+    };
+    setOnAcceptFunction(()=>{});
+
+  }
+    
+  return {isOpened, setModalContent,onCancelFunction, togleModal,modalContent, setOnAcceptFunction, onAcceptFunction,resetmodalState,setOnCancelFunction} 
+   
+})

package/dist/spa/src/stores/toast.ts

@@ -0,0 +1,31 @@
+import { ref, watch, type Ref } from 'vue'
+import { defineStore } from 'pinia'
+import { v1 as uuid } from 'uuid';
+import { useRoute } from 'vue-router';
+
+
+
+export const useToastStore = defineStore('toast', () => {
+    const toasts: Ref<any[]> = ref([]);
+    const route = useRoute();
+
+    watch(route, () => {
+        console.log('route changed 121');
+        // on route change clear all toasts older then 5 seconds
+        const now = +new Date();
+        toasts.value = toasts.value.filter((t) => now - t.createdAt < 5000);
+    });
+
+    const addToast = (toast: { message: string; variant: string }) => {
+        const toastId = uuid();
+        toasts.value.push({
+            ...toast,
+            id: toastId,
+            createdAt: +new Date(),
+        });
+    };
+    const removeToast = (toast: { id: string }) => {
+        toasts.value = toasts.value.filter((t) => t.id !== toast.id);
+    };
+    return { toasts, addToast, removeToast };
+});

package/dist/spa/src/stores/user.ts

@@ -0,0 +1,72 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import { callAdminForthApi } from '@/utils';
+import { initFlowbite } from 'flowbite'
+import { useRouter } from 'vue-router';
+import { useCoreStore } from './core';
+import router from '@/router';
+
+
+
+export const useUserStore = defineStore('user', () => {
+    const isAuthorized = ref(false);
+
+    function authorize() {
+        isAuthorized.value = true;
+        localStorage.setItem('isAuthorized', 'true');
+    }
+
+    function unauthorize() {
+        isAuthorized.value = false;
+        localStorage.setItem('isAuthorized', 'false');
+    }
+
+    async function finishLogin() {
+        const coreStore = useCoreStore();
+        authorize(); // TODO not sure we need this approach with localStorage
+        await router.push('/');
+        await router.isReady();
+        await coreStore.fetchMenuAndResource();
+        setTimeout(() => {
+            initFlowbite();
+        }); 
+    }
+
+    async function logout() {
+        await callAdminForthApi({
+          path: '/logout',
+          method: 'POST',
+        });
+        unauthorize();
+      }
+
+    // async function checkAuth( skipApiCall = false){
+    //      console.log('checkAuth', isAuthorized.value, skipApiCall)
+    //     if(isAuthorized.value) {
+    //         return true}
+    //     else {
+    //         if(skipApiCall) return false;
+    //         const resp = await callAdminForthApi({
+    //             path: '/check_auth',
+    //             method: 'POST',
+    //         });
+    //         if (resp.status !== 401) {
+    //             authorize();
+    //             return true;
+    //         }
+    //         else {
+    //             unauthorize();
+    //             return false;}
+    //     }
+        
+    // }
+
+    return {
+        isAuthorized,
+        authorize,
+        unauthorize,
+        logout,
+        finishLogin
+    }
+
+});