@gct-paas/core 0.1.4-dev.2 → 0.1.4-dev.3

package/es/modules/platform-config/useLoginSetting.mjs

@@ -0,0 +1,183 @@
+import { ref, reactive } from 'vue';
+import { PlatformSettingEnum } from './types.mjs';
+import { LoginTypeEnum, getLoginTypeOptions, SystemLoginKeys, OtherLoginKeys, LoginSortTypeEnum } from './constants.mjs';
+
+"use strict";
+const loginModeAuthTypes = ref([LoginTypeEnum.ACCOUNT]);
+const openIDOAuthAuthTypes = ref([]);
+const sysLoginSort = ref(getLoginTypeOptions(SystemLoginKeys));
+const openIDOAuthAuthSort = ref(getLoginTypeOptions(OtherLoginKeys));
+const loginSetting = reactive({
+  theme: "full",
+  title: "\u6B22\u8FCE\u767B\u5F55\u51A0\u9A8B\u4E91PaaS\u5E73\u53F0",
+  subtitle: "\u8BA9\u6570\u5B57\u5316\u8D4B\u80FD\u5BA2\u6237\u6210\u529F\uFF01",
+  logo: "",
+  banner: "",
+  loginModeConfigs: [],
+  openIDOAuthConfigs: [],
+  sortJson: "",
+  defaultAuthType: LoginTypeEnum.ACCOUNT
+});
+const loginModeConfig = reactive(
+  /* @__PURE__ */ new Map([
+    [
+      LoginTypeEnum.ACCOUNT,
+      {
+        address: "",
+        authType: LoginTypeEnum.ACCOUNT,
+        relationField: "",
+        enabled: 0
+      }
+    ],
+    [
+      LoginTypeEnum.DOMAIN_ACCOUNT,
+      {
+        address: "",
+        authType: LoginTypeEnum.DOMAIN_ACCOUNT,
+        relationField: "",
+        domainSuffix: "",
+        relationFieldName: "",
+        enabled: 0
+      }
+    ],
+    [
+      LoginTypeEnum.MOBILE,
+      {
+        smsServiceProvider: "",
+        // 短信服务商
+        smsKey: "",
+        // 授权key
+        smsKeySecret: "",
+        // 授权secret
+        smsTemplateCode: "",
+        // 模板代码
+        smsSignName: "",
+        // 短信签名
+        phoneNumb: "",
+        smsSdkAppId: "",
+        authType: LoginTypeEnum.MOBILE,
+        enabled: 0
+      }
+    ],
+    [
+      LoginTypeEnum.DINGDING,
+      {
+        appId: "",
+        authType: LoginTypeEnum.DINGDING,
+        secret: "",
+        redirectURL: "",
+        enabled: 0
+      }
+    ],
+    [
+      LoginTypeEnum.FEISHU,
+      {
+        appId: "",
+        authType: LoginTypeEnum.FEISHU,
+        secret: "",
+        redirectURL: "",
+        enabled: 0
+      }
+    ],
+    [
+      LoginTypeEnum.QIYEWEIXIN,
+      {
+        appId: "",
+        agentId: "",
+        authType: LoginTypeEnum.QIYEWEIXIN,
+        secret: "",
+        redirectURL: "",
+        enabled: 0,
+        certFileName: ""
+      }
+    ]
+  ])
+);
+const theme = ref([
+  {
+    imgUrl: "login-password.png",
+    value: "full",
+    label: "\u5168\u5C4F\u6A21\u5F0F"
+  },
+  {
+    imgUrl: "login.png",
+    value: "class",
+    label: "\u7ECF\u5178\u6A21\u5F0F"
+  }
+]);
+function useLoginSetting() {
+  const loadLoginSetting = async () => {
+    const res = await _api.platform.plat.getInfo({
+      configEnum: PlatformSettingEnum.LOGIN
+    });
+    setLoginSetting(res.data);
+  };
+  const postLoginSetting = async () => {
+    const enableTypes = [
+      ...loginModeAuthTypes.value,
+      ...openIDOAuthAuthTypes.value
+    ];
+    enableTypes.forEach((item) => {
+      const config = loginModeConfig.get(item);
+      if (config) {
+        config.enabled = 1;
+      }
+    });
+    loginSetting.loginModeConfigs = SystemLoginKeys.map((item) => {
+      return loginModeConfig.get(item);
+    }).filter((config) => config !== void 0);
+    loginSetting.openIDOAuthConfigs = OtherLoginKeys.map((item) => {
+      return loginModeConfig.get(item);
+    }).filter((config) => config !== void 0);
+    loginSetting.sortJson = JSON.stringify({
+      [LoginSortTypeEnum.SYSTEM]: sysLoginSort.value.map((item) => item.id),
+      [LoginSortTypeEnum.THIRD_PARTY]: openIDOAuthAuthSort.value.map(
+        (item) => item.id
+      )
+    });
+    await _api.platform.plat.postLogin(loginSetting);
+  };
+  const setLoginSetting = (config) => {
+    console.log("config", config);
+    if (config && config.value) {
+      const value = JSON.parse(config.value);
+      for (const k in value) {
+        if (k in loginSetting) {
+          loginSetting[k] = value[k];
+        }
+      }
+      loginSetting.loginModeConfigs?.forEach((item) => {
+        loginModeConfig.set(item.authType, { ...item, enabled: 0 });
+      });
+      const loginModeConfigs = loginSetting.loginModeConfigs?.filter((item) => {
+        return item.enabled;
+      }).map((i) => {
+        return i.authType;
+      }) || [];
+      loginModeConfigs.push(LoginTypeEnum.ACCOUNT);
+      loginModeAuthTypes.value = [...new Set(loginModeConfigs)];
+      loginSetting.openIDOAuthConfigs?.forEach((item) => {
+        loginModeConfig.set(item.authType, { ...item, enabled: 0 });
+      });
+      openIDOAuthAuthTypes.value = loginSetting.openIDOAuthConfigs?.filter((item) => {
+        return item.enabled;
+      }).map((i) => {
+        return i.authType;
+      }) || [];
+    }
+  };
+  return {
+    loginSetting,
+    loadLoginSetting,
+    postLoginSetting,
+    setLoginSetting,
+    theme,
+    loginModeAuthTypes,
+    openIDOAuthAuthTypes,
+    sysLoginSort,
+    openIDOAuthAuthSort,
+    loginModeConfig
+  };
+}
+
+export { useLoginSetting };

package/es/modules/platform-config/useOrgSetting.d.ts

@@ -0,0 +1,30 @@
+import { OrgConfig, SysConfigResponse } from '@gct-paas/api-platform';
+export declare function useOrgSetting(isPlatform?: boolean): {
+    orgSetting: OrgConfig;
+    loadOrgSetting: () => Promise<void>;
+    setOrgSetting: (data: SysConfigResponse) => void;
+    postOrgSetting: () => Promise<void>;
+    relationFields: import('vue').Ref<{
+        label: string;
+        value: string;
+        type: number;
+    }[], {
+        label: string;
+        value: string;
+        type: number;
+    }[] | {
+        label: string;
+        value: string;
+        type: number;
+    }[]>;
+    relationFiledsCopy: import('vue').Ref<{
+        label: string;
+        value: string;
+    }[], {
+        label: string;
+        value: string;
+    }[] | {
+        label: string;
+        value: string;
+    }[]>;
+};

package/es/modules/platform-config/useOrgSetting.mjs

@@ -0,0 +1,121 @@
+import { reactive, ref } from 'vue';
+import { PlatformSettingEnum } from './types.mjs';
+
+"use strict";
+const orgSetting = reactive({
+  initialPassword: "123456",
+  initialSignPassword: "12345678",
+  enableIdentifier: 1,
+  enableDeleteAccount: 1,
+  enableDeleteUser: 0,
+  requiredFields: [],
+  // supportLoginFields: ['username_', 'emp_no_'],
+  supportLoginFields: ["username_"],
+  extFieldConfigs: [],
+  orgExtFieldConfigs: []
+});
+const relationFields = ref([
+  {
+    label: "extString0_",
+    value: "ext0",
+    type: 1
+  },
+  {
+    label: "extString1_",
+    value: "ext1",
+    type: 1
+  },
+  {
+    label: "extString2_",
+    value: "ext2",
+    type: 1
+  },
+  {
+    label: "extString3_",
+    value: "ext3",
+    type: 1
+  },
+  {
+    label: "extString4_",
+    value: "ext4",
+    type: 1
+  },
+  {
+    label: "extInt5_",
+    value: "ext5",
+    type: 0
+  },
+  {
+    label: "extInt6_",
+    value: "ext6",
+    type: 0
+  },
+  {
+    label: "extInt7_",
+    value: "ext7",
+    type: 0
+  },
+  {
+    label: "extInt8_",
+    value: "ext8",
+    type: 0
+  },
+  {
+    label: "extInt9_",
+    value: "ext9",
+    type: 0
+  }
+]);
+const relationFiledsCopy = ref([]);
+function useOrgSetting(isPlatform = true) {
+  const postOrgSetting = async () => {
+    const setting = JSON.parse(JSON.stringify(orgSetting));
+    if (isPlatform) {
+      await _api.platform.plat.postOrg(setting);
+    } else {
+      await _api.apaas.plat.postOrg(setting);
+    }
+    await loadOrgSetting();
+  };
+  async function loadOrgSetting() {
+    const res = await _api.platform.plat.getInfo({
+      configEnum: PlatformSettingEnum.ORGANIZATION
+    });
+    if (res) {
+      setOrgSetting(res.data);
+    }
+  }
+  function setOrgSetting(data) {
+    const { value } = data;
+    if (!value) return;
+    try {
+      const setting = JSON.parse(value);
+      Object.assign(orgSetting, setting);
+      if (orgSetting.extFieldConfigs && orgSetting.extFieldConfigs.length) {
+        orgSetting.extFieldConfigs.forEach((element) => {
+          relationFields.value = relationFields.value.filter((i) => {
+            if (i.value == element.relationField) {
+              relationFiledsCopy.value.push(i);
+            }
+            return i.value !== element.relationField;
+          });
+        });
+      }
+      orgSetting.extFieldConfigs = JSON.parse(
+        JSON.stringify(setting.extFieldConfigs)
+      );
+    } catch (err) {
+      console.warn(err);
+    }
+  }
+  return {
+    orgSetting,
+    loadOrgSetting,
+    setOrgSetting,
+    postOrgSetting,
+    relationFields,
+    relationFiledsCopy
+  };
+}
+
+export { useOrgSetting };

package/es/modules/platform-config/useSecuritySetting.d.ts

@@ -0,0 +1,7 @@
+import { SecurityConfig, SysConfigResponse } from '@gct-paas/api-platform';
+export declare function useSecuritySetting(isPlatform?: boolean): {
+    securitySetting: SecurityConfig;
+    postSecuritySetting: () => Promise<void>;
+    loadSecuritySetting: () => Promise<void>;
+    setSecuritySetting: (data: SysConfigResponse) => void;
+};

package/es/modules/platform-config/useSecuritySetting.mjs

@@ -0,0 +1,71 @@
+import { reactive } from 'vue';
+import { PlatformSettingEnum } from './types.mjs';
+
+"use strict";
+const securitySetting = reactive({
+  durationHour: 2,
+  durationMinute: 0,
+  enableChangePassword: 1,
+  enableChangeSignPassword: 0,
+  enableSignPassword: 0,
+  enableKickOut: 1,
+  enablePassphrase: 1,
+  signEnablePassphrase: 1,
+  enableLockAccount: 1,
+  expiryDate: 30,
+  signExpiryDate: 30,
+  firstTimeChangePassword: 0,
+  signFirstTimeChangePassword: 0,
+  lockTimeout: 0,
+  loginKickOutMode: "SAME_END",
+  maxErrorTimes: 2,
+  passMinLength: 6,
+  signPassMinLength: 6,
+  passRule: ["NUMBER"],
+  signPassRule: ["NUMBER"],
+  signRepeatNum: 1,
+  repeatNum: 1,
+  timeUnit: "DAYS",
+  signTimeUnit: "DAYS",
+  noOpRetainHour: 8,
+  noOpRetainMinute: 0,
+  earlyAlarmMinute: 5,
+  earlyAlarmSecond: 0,
+  inapplicablePerson: [],
+  lockHourTimeout: 0,
+  lockMinTimeout: 5
+});
+function useSecuritySetting(isPlatform = true) {
+  const postSecuritySetting = async () => {
+    if (isPlatform) {
+      await _api.platform.plat.postSecurity(securitySetting);
+    } else {
+      await _api.apaas.plat.postSecurity(securitySetting);
+    }
+  };
+  async function loadSecuritySetting() {
+    const res = await _api.platform.plat.getInfo({
+      configEnum: PlatformSettingEnum.SECURITY
+    });
+    if (res) {
+      setSecuritySetting(res.data);
+    }
+  }
+  function setSecuritySetting(data) {
+    const { value } = data;
+    if (!value) return;
+    try {
+      Object.assign(securitySetting, JSON.parse(value));
+    } catch (err) {
+      console.warn(err);
+    }
+  }
+  return {
+    securitySetting,
+    postSecuritySetting,
+    loadSecuritySetting,
+    setSecuritySetting
+  };
+}
+
+export { useSecuritySetting };

package/es/modules/platform-config/useThemeSetting.d.ts

@@ -0,0 +1,13 @@
+import { ThemeSetting } from './types';
+import { SysConfigResponse } from '@gct-paas/api-platform';
+export declare function useThemeSetting(): {
+    themeSetting: ThemeSetting;
+    loadThemeSetting: () => Promise<void>;
+    setThemeSetting: (data: SysConfigResponse) => void;
+    postThemeSetting: () => Promise<void>;
+    menuCollapsed: import('vue').Ref<boolean, boolean>;
+    toggleMenuCollapsed: () => void;
+    menuCollapsedWidth: number;
+    menuWidthRange: number[];
+    themeColors: string[];
+};

package/es/modules/platform-config/useThemeSetting.mjs

@@ -0,0 +1,73 @@
+import { reactive, ref, watch } from 'vue';
+import './types.mjs';
+
+"use strict";
+const themeSetting = reactive({
+  darkMode: "light",
+  themeColor: "#026AC8",
+  // menuMode: 'mix-sider',
+  menuMode: "classic",
+  menuWidth: 232,
+  menuCollapsible: true,
+  menuSearchable: true,
+  menuFilter: false,
+  showLogo: true,
+  showBreadcrumb: false,
+  showBreadcrumbIcon: false,
+  showTabs: true,
+  pageProgress: true,
+  pageLoading: true,
+  colorMode: "normal"
+});
+const menuCollapsed = ref(false);
+const menuCollapsedWidth = 46;
+const menuWidthRange = [100, 1e3];
+const themeColors = ["#026AC8", "#0DAA9C"];
+const toggleColorMode = () => {
+  switch (themeSetting.colorMode) {
+    case "colorWeak":
+      break;
+    case "gray":
+      break;
+    default:
+  }
+};
+watch(
+  () => themeSetting.colorMode,
+  (value) => {
+    if (value) {
+      toggleColorMode();
+    }
+  }
+);
+function useThemeSetting() {
+  const postThemeSetting = async () => {
+  };
+  async function loadThemeSetting() {
+  }
+  function setThemeSetting(data) {
+    const { value } = data;
+    if (!value) return;
+    try {
+      Object.assign(themeSetting, JSON.parse(value));
+    } catch (err) {
+      console.warn(err);
+    }
+  }
+  function toggleMenuCollapsed() {
+    menuCollapsed.value = !menuCollapsed.value;
+  }
+  return {
+    themeSetting,
+    loadThemeSetting,
+    setThemeSetting,
+    postThemeSetting,
+    menuCollapsed,
+    toggleMenuCollapsed,
+    menuCollapsedWidth,
+    menuWidthRange,
+    themeColors
+  };
+}
+
+export { useThemeSetting };

package/es/modules/platform-config/useWatermarkSetting.d.ts

@@ -0,0 +1,18 @@
+import { SysConfigResponse } from '@gct-paas/api-platform';
+export declare function useWatermarkSetting(): {
+    watermarkSetting: {
+        openWatermark: boolean;
+        watermarkContent: string;
+        fontSize: number;
+        color: string;
+        verticalAlign: string;
+        textAlign: string;
+        text: string;
+        transparent: number;
+        width: number;
+        height: number;
+    };
+    loadWatermarkSetting: () => Promise<void>;
+    postWatermarkSetting: () => Promise<void>;
+    setWatermarkSetting: (data: SysConfigResponse) => void;
+};

package/es/modules/platform-config/useWatermarkSetting.mjs

@@ -0,0 +1,48 @@
+import { reactive } from 'vue';
+import { PlatformSettingEnum } from './types.mjs';
+
+"use strict";
+const initData = {
+  openWatermark: false,
+  watermarkContent: "custom",
+  fontSize: 16,
+  color: "#000000",
+  verticalAlign: "middle",
+  textAlign: "center",
+  text: "${username}",
+  transparent: 15,
+  width: 1600,
+  height: 1080
+};
+const watermarkSetting = reactive({ ...initData });
+function useWatermarkSetting() {
+  const postWatermarkSetting = async () => {
+    const value = JSON.stringify(watermarkSetting);
+    await _api.platform.plat.postWatermark({ value });
+  };
+  const loadWatermarkSetting = async () => {
+    const res = await _api.platform.plat.getInfo({
+      configEnum: PlatformSettingEnum.WATERMARK
+    });
+    if (res) {
+      setWatermarkSetting(res.data);
+    }
+  };
+  function setWatermarkSetting(data) {
+    const { value } = data;
+    if (!value) return;
+    try {
+      Object.assign(watermarkSetting, JSON.parse(value));
+    } catch (err) {
+      console.warn(err);
+    }
+  }
+  return {
+    watermarkSetting,
+    loadWatermarkSetting,
+    postWatermarkSetting,
+    setWatermarkSetting
+  };
+}
+
+export { useWatermarkSetting };

package/es/node_modules/.pnpm/@gct-paas_api-apaas@0.0.2-dev.4/node_modules/@gct-paas/api-apaas/es/index.mjs

@@ -0,0 +1,3 @@
+export { apiConfig } from './service/api-config.mjs';
+
+"use strict";