zmdms-utils 0.0.4 → 0.0.6

package/src/math.ts

@@ -0,0 +1,90 @@
+type numType = "number" | "string";
+/**
+ * 加法
+ */
+export function plus(num1: numType, num2: numType) {
+  try {
+    const _num1 = Number(num1);
+    const _num2 = Number(num2);
+    return (isNaN(_num1) ? 0 : _num1) + (isNaN(_num2) ? 0 : _num2);
+  } catch (err) {
+    console.error("计算加法出错", err);
+    return 0;
+  }
+}
+
+/**
+ * 减法
+ */
+export function minus(num1: numType, num2: numType) {
+  try {
+    const _num1 = Number(num1);
+    const _num2 = Number(num2);
+    return (isNaN(_num1) ? 0 : _num1) - (isNaN(_num2) ? 0 : _num2);
+  } catch (err) {
+    console.error("计算减法出错", err);
+    return 0;
+  }
+}
+
+/**
+ * 乘法
+ */
+export function times(num1: numType, num2: numType) {
+  try {
+    const _num1 = Number(num1);
+    const _num2 = Number(num2);
+    return (isNaN(_num1) ? 0 : _num1) * (isNaN(_num2) ? 0 : _num2);
+  } catch (err) {
+    console.error("计算乘法出错", err);
+    return 0;
+  }
+}
+
+/**
+ * 除法
+ */
+export function divide(num1: numType, num2: numType) {
+  try {
+    const _num1 = Number(num1);
+    const _num2 = Number(num2);
+    return (isNaN(_num1) ? 0 : _num1) / (isNaN(_num2) ? 0 : _num2);
+  } catch (err) {
+    console.error("计算除法出错", err);
+    return 0;
+  }
+}
+
+/**
+ * 四舍五入保留小数
+ */
+export function exactRound(num: numType, ratio: number) {
+  try {
+    return Number(num).toFixed(ratio);
+  } catch (err) {
+    return num;
+  }
+}
+
+/**
+ * 将字节数加上合适的单位
+ * @param numBytes 字节数
+ * @returns
+ */
+export function formatUnit(numBytes: number) {
+  let _numBytes = Number(numBytes);
+
+  if (isNaN(_numBytes)) {
+    return numBytes;
+  }
+
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let unitIndex = 0;
+
+  while (_numBytes >= 1024 && unitIndex < units.length - 1) {
+    _numBytes /= 1024;
+    unitIndex++;
+  }
+
+  return _numBytes.toFixed(2) + units[unitIndex];
+}

package/src/passwordValidate.ts

@@ -0,0 +1,196 @@
+const alphabet1 = [
+  "abcdefghijklmnopqrstuvwxyz",
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  "0123456789",
+];
+const alphabet2 = ["qwertyuiop", "asdfghjkl", "zxcvbnm"];
+const alphabet3 = ["qaz", "wsx", "edc", "rfv", "tgb", "yhn", "ujm"];
+
+function isConsecutiveChars(
+  char1: string,
+  char2: string,
+  alphabetArr: string[]
+) {
+  // const lowerCaseAlphabet = 'abcdefghijklmnopqrstuvwxyz'; // 小写字母
+  // const upperCaseAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; // 大写字母
+  // const numeric = '0123456789'; // 数字
+
+  // 找到包含两个字符的字符集
+  const alphabet = alphabetArr.find(
+    (alph: string) => alph.includes(char1) && alph.includes(char2)
+  );
+
+  if (!alphabet) {
+    return false; // 如果两个字符不在同一字符集中，那么它们不可能连续
+  }
+
+  const index1 = alphabet.indexOf(char1);
+  const index2 = alphabet.indexOf(char2);
+
+  // return Math.abs(index1 - index2) === 1; // 如果两个字符在字符集中的位置相邻，那么它们是连续的
+  return index1 - index2;
+}
+
+export function validatePassword(password: string, username: string) {
+  // 用正则表达式检查密码基本规则
+  const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).{8,50}$/;
+  if (!regex.test(password)) {
+    return {
+      result: false,
+      message:
+        "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!",
+    };
+  }
+
+  // 检查密码是否与用户名相同
+  if (password === username) {
+    return {
+      result: false,
+      message: "密码与用户名相同!",
+    };
+  }
+
+  // 检查密码中是否有相同且连续的字符 超过三次
+  let count1 = 0;
+  for (let i = 0; i < password.length - 1; i++) {
+    if (password[i] === password[i + 1]) {
+      count1++;
+      if (count1 >= 2) {
+        return {
+          result: false,
+          message: "密码中有相同且连续超过三次的字符!",
+        };
+      }
+    } else {
+      count1 = 0;
+    }
+  }
+
+  // 检查密码中是否有连续的字母或数字 连续超过三次
+  let count = 0;
+  let startChart = 0;
+  let currentConsecutiveCount = 0; // 记录上次是递增还是递减
+
+  // 第一次循环 找出 连续字母 数字
+  for (let i = 0; i < password.length - 1; i++) {
+    const consecutiveCount = isConsecutiveChars(
+      password[i],
+      password[i + 1],
+      alphabet1
+    );
+    // 是递增 还是 递减
+    if (consecutiveCount === 1 || consecutiveCount === -1) {
+      if (currentConsecutiveCount === 0) {
+        currentConsecutiveCount = consecutiveCount;
+      }
+      if (count === 0) {
+        startChart = i;
+      }
+      // 如果记录到上次跟本次的连续规则相同
+      if (currentConsecutiveCount === consecutiveCount) {
+        count++;
+        if (count >= 2) {
+          // 密码中不应含有连续的字母或数字
+          return {
+            result: false,
+            message: `从第${startChart + 1}个字符开始，有连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母或数字!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+  // 第二次循环 找出键盘连续横排字母
+  for (let i = 0; i < password.length - 1; i++) {
+    const consecutiveCount = isConsecutiveChars(
+      password[i],
+      password[i + 1],
+      alphabet2
+    );
+    // 是递增 还是 递减
+    if (consecutiveCount === 1 || consecutiveCount === -1) {
+      if (currentConsecutiveCount === 0) {
+        currentConsecutiveCount = consecutiveCount;
+      }
+      if (count === 0) {
+        startChart = i;
+      }
+      // 如果记录到上次跟本次的连续规则相同
+      if (currentConsecutiveCount === consecutiveCount) {
+        count++;
+        if (count >= 2) {
+          // 密码中不应含有连续的字母或数字
+          return {
+            result: false,
+            message: `从第${startChart + 1}个字符开始，有按键盘横向连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+  // 第三次循环 找出键盘连续竖排字母
+  for (let i = 0; i < password.length - 1; i++) {
+    const consecutiveCount = isConsecutiveChars(
+      password[i],
+      password[i + 1],
+      alphabet3
+    );
+    // 是递增 还是 递减
+    if (consecutiveCount === 1 || consecutiveCount === -1) {
+      if (currentConsecutiveCount === 0) {
+        currentConsecutiveCount = consecutiveCount;
+      }
+      if (count === 0) {
+        startChart = i;
+      }
+      // 如果记录到上次跟本次的连续规则相同
+      if (currentConsecutiveCount === consecutiveCount) {
+        count++;
+        if (count >= 2) {
+          // 密码中不应含有连续的字母或数字
+          return {
+            result: false,
+            message: `从第${startChart + 1}个字符开始，有按键盘竖向连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母或数字!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+
+  // 如果通过了所有的检查，则返回true
+  return {
+    result: true,
+  };
+}

package/src/request.ts

@@ -1,6 +1,7 @@
 // 请求方法
 import axios, { AxiosRequestConfig } from "axios";
-import { getToken } from "./index";
+import { getToken, removeToken } from "./auth";
+import { Crypto } from "./crypto";
 
 const defaultOptions: IOtherOptions = {
   TenantId: "000000",
@@ -10,12 +11,44 @@ const defaultOptions: IOtherOptions = {
 
 export class AxiosRequest {
   private otherOptions: IOtherOptions;
+  private crypto: IOtherOptions["crypto"]; // 加密方法处理
+  private jumpCallback: IOtherOptions["jumpCallback"]; // 需要做的跳转处理
+  // 登录是否过期 这个变量是为了让弹出提示只展示一次
+  private isExpired: boolean = false;
+  // 被挤下线 定义变量的目的同上
+  private isOffline: boolean = false;
+  // 404
+  private isNotFound: boolean = false;
+  // timeout
+  private isTimeout: boolean = false;
+  // 是否需要超时 弹框提示
+  private isTimeoutConfirm?: IOtherOptions["isTimeoutConfirm"];
+  private isTimeoutConfirmStr?: IOtherOptions["isTimeoutConfirmStr"];
+  // messageWarning 方法
+  private messageWarning?: IOtherOptions["messageWarning"];
+  // modalConfirm 方法
+  private modalConfirm?: IOtherOptions["modalConfirm"];
 
   constructor(otherOptions: IOtherOptions) {
-    this.otherOptions = { ...defaultOptions, ...otherOptions };
+    const {
+      crypto,
+      jumpCallback,
+      isTimeoutConfirm,
+      isTimeoutConfirmStr,
+      messageWarning,
+      modalConfirm,
+      ...resetOtherOptions
+    } = otherOptions;
+    this.otherOptions = { ...defaultOptions, ...resetOtherOptions };
+    this.crypto = crypto;
+    this.isTimeoutConfirm = isTimeoutConfirm;
+    this.isTimeoutConfirmStr = isTimeoutConfirmStr;
+    this.jumpCallback = jumpCallback;
+    this.messageWarning = messageWarning;
+    this.modalConfirm = modalConfirm;
     this.defaultSetting();
     this.interceptorsRequest();
-    this.interceptorsReponse();
+    this.interceptorsResponse();
   }
 
   // 设置axios方法默认值
@@ -43,27 +76,117 @@ export class AxiosRequest {
   }
 
   // 拦截响应
-  private interceptorsReponse() {
+  private interceptorsResponse() {
     axios.interceptors.response.use(
       (response) => {
-        if (response.status === 200) {
-          if (response.data.code === 200) {
-            return Promise.resolve(response.data);
-          }
-        } else if (response.status === 201) {
-          return Promise.resolve(response);
+        console.log(response);
+        // 对返回数据进行解密后 返回给客户端
+        if ((response.config as any)?.isCrypto) {
         }
         return response;
       },
       (error) => {
+        console.log(error);
+        // 统一处理响应异常
+        this.responseError(error);
         return Promise.reject(error);
       }
     );
   }
 
+  // 响应错误处理
+  private responseError(error: any = {}) {
+    const { response } = error;
+    // 处理token失效
+    // TODO: 刷新token逻辑
+    if (response?.status === 401) {
+      removeToken();
+      if (!this.isExpired) {
+        this.isExpired = true;
+        this.messageWarning?.("登录过期", 3.5, () => {
+          this.isExpired = false;
+        });
+        this.logoutHandle(response.status);
+      }
+      return;
+    }
+    // 处理被挤下线逻辑
+    if (response?.status === 501) {
+      removeToken();
+      if (!this.isOffline) {
+        this.isOffline = true;
+        this.messageWarning?.("你的账号已在其他地方登录！", 3.5, () => {
+          this.isOffline = false;
+        });
+        this.logoutHandle(response.status);
+      }
+      return;
+    }
+    // 处理404逻辑
+    if (response?.status === 404) {
+      if (!this.isNotFound) {
+        this.isNotFound = true;
+        this.messageWarning?.(
+          `接口：${response.config.url} 未找到！`,
+          3.5,
+          () => {
+            this.isNotFound = false;
+          }
+        );
+      }
+      return;
+    }
+    // 处理接口超时逻辑
+    if (
+      this.isTimeoutConfirm &&
+      error?.config?.method?.toUpperCase?.() === "POST" &&
+      !response &&
+      error.code === "ECONNABORTED" &&
+      error.message?.indexOf?.(`${error.config.timeout}ms`) !== -1
+    ) {
+      if (!this.isTimeout) {
+        this.isTimeout = true;
+        this.modalConfirm?.(
+          `${
+            this.isTimeoutConfirmStr
+              ? this.isTimeoutConfirmStr
+              : "请求超时，请稍后再试，或联系相关人员确认后处理！"
+          }
+          接口地址: ${error?.config?.url}
+          请求方式: ${error?.config?.method}
+          请求超时时间: ${error?.config?.timeout / 1000}秒
+        `,
+          () => {
+            this.isTimeout = false;
+          }
+        );
+      }
+      return;
+    }
+    // 提示业务错误
+    if (error?.config?.isErrorMessage) {
+      // 详细信息 再开发模式开启 之后上到别的环境会去掉
+      this.modalConfirm?.(`${error?.response?.data?.msg || "服务器异常"}
+        接口地址: ${error?.config?.url}
+        响应状态码: ${error?.response?.status}
+        请求方式: ${error?.config?.method}
+      `);
+      return;
+    }
+  }
+
+  // 跳转逻辑处理
+  private logoutHandle(status: number) {
+    // 自定义跳转
+    if (this.jumpCallback) {
+      this.jumpCallback(status);
+    } else {
+      window.location.href = "/login";
+    }
+  }
+
   // 实例方法
   public request(options: IOptions) {
-    const token = getToken();
     const { isFormData, isAuth = true, ...resetOptions } = options;
 
     const newOptions = resetOptions;
@@ -73,20 +196,10 @@ export class AxiosRequest {
       newOptions.headers = {};
     }
     if (isAuth) {
+      const token = getToken();
       newOptions.headers["Zmdms-Auth"] = `bearer ${token}`;
     }
 
-    // 处理url
-    if (newOptions.baseURL?.endsWith("/")) {
-      newOptions.url = newOptions.url?.startsWith("/")
-        ? newOptions.url?.slice(1)
-        : newOptions.url;
-    } else {
-      newOptions.url = newOptions.url?.startsWith("/")
-        ? newOptions.url
-        : `/${newOptions.url}`;
-    }
-
     // 遍历params，将undefined值 转为null值
     if (newOptions.data) {
       newOptions.data = transformData(newOptions.data);
@@ -120,6 +233,32 @@ export class AxiosRequest {
     }
 
     // 数据加密处理 TODO:
+    // 将参数进行aes加密
+    if (newOptions.isCrypto === true || newOptions.isCrypto === "aes") {
+      if (newOptions.data) {
+        newOptions.data = this.crypto?.encrypt?.(
+          JSON.stringify(newOptions.data)
+        );
+      }
+      if (newOptions.params) {
+        newOptions.params = this.crypto?.encrypt?.(
+          JSON.stringify(newOptions.params)
+        );
+      }
+    }
+    // 将参数进行des加密
+    if (newOptions.isCrypto === "des") {
+      if (newOptions.data) {
+        newOptions.data = this.crypto?.encrypt_des?.(
+          JSON.stringify(newOptions.data)
+        );
+      }
+      if (newOptions.params) {
+        newOptions.params = this.crypto?.encrypt_des?.(
+          JSON.stringify(newOptions.params)
+        );
+      }
+    }
 
     return axios(newOptions);
   }
@@ -149,13 +288,24 @@ function transformData(data?: any): any {
 
 export interface IOptions extends AxiosRequestConfig {
   isFormData?: boolean;
-  isAuth?: boolean; // 是否需要携带请求头
+  isAuth?: boolean; // 是否需要携带请求头 默认携带
+  isCrypto?: boolean | "aes" | "des"; // 是否对传输数据开启加密模式
+  isErrorMessage?: boolean; // 是否交给实例处理异常
 }
 
 export interface IOtherOptions {
-  jumpCallback?: () => void; // token过期等 需要跳转到登录页
-  TenantId?: string;
+  jumpCallback?: (status: number) => void; // token过期等 需要跳转到登录页
+  messageWarning?: (
+    msg: string,
+    duration: number,
+    callback?: () => void
+  ) => void; // 提示方法 外部传入
+  modalConfirm?: (msg: string, callback?: () => void) => void;
+  TenantId?: string; // token相关值
   Authorization?: string; // auth值
-  timeout?: number;
-  baseURL?: string;
+  timeout?: number; // 超时时间
+  baseURL?: string; // 基础url
+  crypto?: Crypto; // 加密实例方法
+  isTimeoutConfirm?: boolean; // 超时是否需要弹框
+  isTimeoutConfirmStr?: string; // 超时弹框提示内容
 }

package/src/validate.ts

@@ -0,0 +1,45 @@
+export const strLenValidate = (type: "s" | "m" | "l" | "ml" = "s") => {
+  if (type === "m") {
+    return {
+      regex: /^\s*([\s\S]{0,400})\s*$/,
+      message: `超过最大字符长度400!`,
+    };
+  }
+  if (type === "l") {
+    return {
+      regex: /^\s*([\s\S]{0,600})\s*$/,
+      message: `超过最大字符长度600!`,
+    };
+  }
+  if (type === "ml") {
+    return {
+      regex: /^\s*([\s\S]{0,5000})\s*$/,
+      message: `超过最大字符长度5000!`,
+    };
+  }
+  return {
+    regex: /^\s*([\s\S]{0,200})\s*$/,
+    message: `超过最大字符长度200!`,
+  };
+};
+
+export const phoneValidate = {
+  regex: /^(?:\+?86-?)?(?:(?:0\d{2,3}-?)?[1-9]\d{6,7}|1[3-9]\d{9})$/,
+  message: "请输入正确的手机号!",
+};
+export const morePhoneValidate = {
+  regex:
+    /^(?:(?:\+?86-?)?(?:(?:0\d{2,3}-?)?[1-9]\d{6,7}|1[3-9]\d{9})(?:,\s?)?)+$/,
+  message: "请检查输入的电话号码中是否有不符合规则的号码!",
+};
+
+export const idCardValidate = {
+  regex:
+    /^[1-9]\d{5}(?:19|20)\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[1-2]\d|3[0-1])\d{3}[\dX]$/i,
+  message: "请输入正确的身份证号!",
+};
+
+export const emailValidate = {
+  regex: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+  message: "请输入正确的邮箱!",
+};