@arkxos/arkos-system 0.1.0

package/src/mobile/router.js

@@ -0,0 +1,101 @@
+import { createRouter, createWebHashHistory } from 'vue-router';
+import { useNProgress } from '@/utils/progress';
+import { useUserStore } from '@/pinia/modules/user';
+import { useMobileStore } from '@/pinia/modules/mobile';
+import { ElMessage } from 'element-plus';
+import { store as pinia } from '@/pinia';
+
+const { start, done } = useNProgress();
+const routes = [{
+  name: 'notfound',
+  path: '/:pathMatch(.*)',
+  text: '访问地址不存在',
+  meta: {
+    title: '访问地址不存在',
+  },
+  component: () => import('@/error/404.vue')
+}, {
+  name: 'mobile',
+  path: '/page/:pageId',
+  text: '移动端',
+  meta: {
+    title: '移动端',
+  },
+  component: () => import('@/mobile/home/index.vue')
+}];
+
+const router = createRouter({
+  history: createWebHashHistory(import.meta.env.VITE_WEB_PATH || '/'),
+  routes
+});
+
+const handleKeepAlive = async(to) => {
+  if (to.matched.some(item => item.meta.keepAlive)) {
+    if (to.matched && to.matched.length > 2) {
+      for (let i = 1; i < to.matched.length; i++) {
+        const element = to.matched[i - 1];
+        if (typeof element.components.default === 'function') {
+          await element.components.default();
+          await handleKeepAlive(to);
+        }
+      }
+    }
+  }
+};
+
+let isInitRouter = false;
+router.beforeEach(async(to) => {
+  start();
+  const userStore = useUserStore(pinia);
+  to.meta.matched = [...to.matched];
+  await handleKeepAlive(to);
+
+  if (userStore.getToken()) {
+    if (!isInitRouter) {
+      isInitRouter = true;
+      await userStore.initUserInfo();
+    }
+    if (to.path === '/') {
+      const mobileStore = useMobileStore(pinia);
+      const mobile = await mobileStore.getMobile();
+      if (mobile.homeId) {
+        return { path: '/page/' + mobile.homeId };
+      } else {
+        const page = mobile.pageList ? mobile.pageList[0] : null;
+        if (page) {
+          return { path: '/page/' + page.id };
+        } else {
+          ElMessage.error('未配置首页！');
+          return false;
+        }
+      }
+    } else if (to.matched.length) {
+      return true;
+    } else {
+      return { name: 'notfound' };
+    }
+  } else {
+    const mobileStore = useMobileStore(pinia);
+    const mobile = await mobileStore.getMobile();
+    if (mobile.loginId) {
+      if (to.path === '/page/' + mobile.loginId) {
+        return true;
+      } else {
+        return { path: '/page/' + mobile.loginId };
+      }
+    } else {
+      ElMessage.error('未配置登录页面！');
+      return false;
+    }
+  }
+});
+
+router.afterEach(() => {
+  done();
+});
+
+router.onError(() => {
+  done();
+});
+
+export default router;

package/src/mobile/view/page.vue

@@ -0,0 +1,99 @@
+<template>
+  <div
+    v-if="!initializing"
+    ref="pageRef"
+    class="vc-page"
+    :style="visual.parseStyle(pageNode.currStyle)"
+  >
+    <component
+      v-for="child in pageNode.children"
+      :key="child.id"
+      :is="'vc-' + child.type"
+      :ref="el => setRefs(el, child)"
+      :node="child"
+      :inputParam="visual.getInputParam(child, props.inputParam)"
+    />
+  </div>
+</template>
+
+<script setup>
+import { onMounted, ref, provide, getCurrentInstance, nextTick } from 'vue';
+import visual from '@/visual/js/visual';
+import { useMobileStore } from '@/pinia/modules/mobile';
+import { ElMessage } from 'element-plus';
+import EventHandler from '@/visual/js/event';
+
+const props = defineProps({
+  pageId: String,
+  inputParam: Object
+});
+
+const initializing = ref(true);
+const pageRef = ref();
+const pageNode = ref({});
+const mobileStore = useMobileStore();
+const pageCompRefs = ref({});
+const pageData = ref({});
+const eventHandler = new EventHandler(null, getCurrentInstance(), pageNode.value);
+
+provide('pageData', pageData);
+provide('eventHandler', eventHandler);
+
+const setRefs = (el, comp) => {
+  if (el) {
+    pageCompRefs.value[comp.id] = el;
+  }
+};
+
+const getData = () => {
+  return {
+    ...pageData.value,
+    inputParam: props.inputParam || {}
+  };
+};
+
+onMounted(async() => {
+  initializing.value = true;
+  const page = await mobileStore.getPage(props.pageId);
+  if (!page || !page.jsonText) {
+    ElMessage.error('页面配置不正确！');
+    return;
+  }
+  pageNode.value = JSON.parse(page.jsonText);
+  if (!pageNode.value.currStyle &&
+    pageNode.value.styleList &&
+    pageNode.value.styleList.length > 0) {
+    pageNode.value.currStyle = pageNode.value.styleList[0].style || {};
+  }
+  eventHandler.setNode(pageNode.value);
+  eventHandler.initInputParam();
+
+  const dataList = (await visual.loadData(
+    pageNode.value.compData,
+    eventHandler,
+    getData(),
+    pageNode.value)).data || [];
+  const data = dataList.length > 0 ? dataList[0] : {};
+
+  const globalParam = {};
+  (pageNode.value.compData.fieldList || []).forEach(field => {
+    globalParam[field.id] = data[field.name] || '';
+  });
+  Object.assign(globalParam, props.inputParam);
+  pageData.value['inputParam'] = Object.assign({}, globalParam);
+  eventHandler.setGlobalParam(globalParam);
+  await nextTick(() => initializing.value = false);
+});
+</script>
+
+<style>
+#app {
+  box-sizing: border-box;
+}
+</style>
+<style scoped>
+.mobile-page-container {
+  box-sizing: border-box;
+  height: 100%;
+}
+</style>

package/src/pinia/index.js

@@ -0,0 +1,5 @@
+import { createPinia } from 'pinia';
+
+const store = createPinia();
+
+export { store };

package/src/pinia/modules/dataField.js

@@ -0,0 +1,77 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useDataFieldStore = defineStore('dataField', () => {
+  const dataFieldList = ref([]);
+  const dataFieldMap = ref([]);
+  const loading = ref(false);
+
+  const setByModelId = (modelId, list) => {
+    if (!list) return;
+    dataFieldMap.value[modelId] = list;
+    (list || []).forEach(item => {
+      if (!dataFieldList.value[item.id]) {
+        dataFieldList.value[item.id] = item;
+      }
+    });
+  };
+
+  const getByModelId = async(modelId) => {
+    if (dataFieldMap.value[modelId] && dataFieldMap.value[modelId].length > 0) {
+      return dataFieldMap.value[modelId] || [];
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getByModelId(modelId);
+    }
+
+    loading.value = true;
+    try {
+      const res = await api.post('/business/data-field/list/' + modelId);
+      loading.value = false;
+      setByModelId(modelId, res.data);
+      return dataFieldMap.value[modelId] || [];
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  const setById = (id, data) => {
+    if (!data) return;
+    dataFieldList.value[id] = data;
+  };
+
+  const getById = async(id) => {
+    if (dataFieldList.value[id]) {
+      return dataFieldList.value[id] || {};
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getById(id);
+    }
+
+    loading.value = true;
+    try {
+      const res = await api.post('/business/data-field/' + id);
+      loading.value = false;
+      setById(id, res.data);
+      return dataFieldList.value[id] || {};
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d))
+  };
+
+  const clearData = () => {
+    dataFieldList.value = [];
+    dataFieldMap.value = [];
+  };
+
+  return { getById, getByModelId, clearData };
+});

package/src/pinia/modules/dataForm.js

@@ -0,0 +1,46 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useDataFormStore = defineStore('dataForm', () => {
+  const dataFormList = ref([]);
+  const loading = ref(false);
+
+  const setById = (id, data) => {
+    if (!data) return;
+    dataFormList.value[id] = data;
+  };
+
+  const getById = async(id) => {
+    if (!id) return {};
+
+    if (dataFormList.value[id]) {
+      return dataFormList.value[id] || {};
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getById(id);
+    }
+
+    loading.value = true;
+    try {
+      const res = await api.post('/business/data-form/' + id);
+      loading.value = false;
+      setById(id, res.data);
+      return dataFormList.value[id] || {};
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d))
+  };
+
+  const clearData = () => {
+    dataFormList.value = [];
+  };
+
+  return { getById, clearData };
+});

package/src/pinia/modules/dataTable.js

@@ -0,0 +1,46 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useDataTableStore = defineStore('dataTable', () => {
+  const dataTableList = ref([]);
+  const loading = ref(false);
+
+  const setById = (id, data) => {
+    if (!data) return;
+    dataTableList.value[id] = data;
+  };
+
+  const getById = async(id) => {
+    if (!id) return {};
+
+    if (dataTableList.value[id]) {
+      return dataTableList.value[id] || {};
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getById(id);
+    }
+
+    loading.value = true;
+    try {
+      const res = await api.post('/business/data-table/' + id);
+      loading.value = false;
+      setById(id, res.data);
+      return dataTableList.value[id] || {};
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d))
+  };
+
+  const clearData = () => {
+    dataTableList.value = [];
+  };
+
+  return { getById, clearData };
+});

package/src/pinia/modules/dictionary.js

@@ -0,0 +1,66 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useDictionaryStore = defineStore('dictionary', () => {
+  const dictionaryMap = ref({});
+  const loading = ref(false);
+
+  const clearDictionary = () => {
+    dictionaryMap.value = {};
+  };
+
+  const setDictionaryMap = (dictionaryRes) => {
+    dictionaryMap.value = { ...dictionaryRes };
+  };
+
+  const getDictionary = async(dictCode) => {
+    if (!dictCode) return [];
+
+    if (dictionaryMap.value[dictCode] && dictionaryMap.value[dictCode].length) {
+      return dictionaryMap.value[dictCode];
+    } else {
+      return await loadDictionary(dictCode);
+    }
+  };
+
+  const getDictValue = async(dictCode, dictKey) => {
+    const dictionary = await getDictionary(dictCode);
+    return ((dictionary || []).find(item => item.key === dictKey) || {})['value'];
+  };
+
+  const loadDictionary = async(dictCode) => {
+    if (dictionaryMap.value[dictCode] && dictionaryMap.value[dictCode].length) {
+      loading.value = false;
+      return dictionaryMap.value[dictCode];
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await loadDictionary(dictCode);
+    }
+
+    loading.value = true;
+    if (dictionaryMap.value[dictCode] && dictionaryMap.value[dictCode].length) {
+      loading.value = false;
+      return dictionaryMap.value[dictCode];
+    } else {
+      const res = await api.post('/business/dictionary/all-dict-data');
+      loading.value = false;
+      if (res.code === '1') {
+        setDictionaryMap(res.data);
+        return dictionaryMap.value[dictCode];
+      }
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d));
+  };
+
+  return {
+    clearDictionary,
+    getDictionary,
+    getDictValue
+  };
+});

package/src/pinia/modules/employee.js

@@ -0,0 +1,46 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useEmployeeStore = defineStore('employee', () => {
+  const employees = ref([]);
+  const loading = ref(false);
+
+  const setEmployee = (tree) => {
+    employees.value = tree && tree.children || [];
+  };
+
+  const clearEmployee = () => {
+    employees.value = [];
+  };
+
+  const getEmployee = async() => {
+    if (employees.value && employees.value.length) {
+      return employees.value;
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getEmployee();
+    }
+
+    loading.value = true;
+    const res = await api.post('/business/employee/tree').catch(() => {
+      loading.value = false
+    });
+    if (res.code === '1') {
+      loading.value = false;
+      setEmployee(res.data);
+      return employees.value;
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d))
+  };
+
+  return {
+    getEmployee,
+    clearEmployee
+  };
+});

package/src/pinia/modules/icon.js

@@ -0,0 +1,46 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import api from '@/http/api';
+
+export const useIconStore = defineStore('icon', () => {
+  const iconList = ref([]);
+  const loading = ref(false);
+
+  const setIconList = (list) => {
+    iconList.value = list;
+  };
+
+  const clearIconList = () => {
+    iconList.value = [];
+  };
+
+  const getIconList = async() => {
+    if (iconList.value && iconList.value.length > 0) {
+      return iconList.value;
+    }
+
+    if (loading.value) {
+      await sleep(100);
+      return await getIconList();
+    }
+
+    loading.value = true;
+    const res = await api.post('/icon/list').catch(() => {
+      loading.value = false
+    });
+    if (res.code === '1') {
+      loading.value = false;
+      setIconList(res.data);
+      return iconList.value;
+    }
+  };
+
+  const sleep = async (d) => {
+    return new Promise((resolve) => setTimeout(resolve, d))
+  };
+
+  return {
+    getIconList,
+    clearIconList
+  };
+});

package/src/pinia/modules/keepAlive.js

@@ -0,0 +1,35 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+
+export const useKeepAlive = defineStore('keepAlive', () => {
+  const includes = ref([]);
+
+  const addItem = (item) => {
+    if (!item) {
+      return;
+    }
+
+    if (includes.value.indexOf(item) <= 0) {
+      includes.value.push(item);
+    }
+  };
+
+  const delItem = (item) => {
+    if (!item && includes.value.length === 0) {
+      return;
+    }
+
+    includes.value = includes.value.filter(include => include !== item);
+  };
+
+  const resetItems = (items) => {
+    includes.value = items || [];
+  };
+
+  return {
+    includes,
+    addItem,
+    delItem,
+    resetItems
+  };
+});