初始化

frontend/src/api/activate/index.ts

@@ -0,0 +1,13 @@
+import http from '@/api'
+
+export const generateApplicationCode = () => {
+    return http.post(`/activate/generateApplicationCode`)
+}
+
+export const verifyActivationCode = (activationCode: string) => {
+    return http.post(`/activate/verifyActivationCode`, { activationCode })
+}
+
+export const getLicense = () => {
+    return http.post(`/activate/getLicense`)
+}

frontend/src/api/activate/interface/index.ts

@@ -0,0 +1,16 @@
+// 激活模块
+export namespace Activate {
+    export interface ActivateModule {
+        /**
+         * 是否永久激活，1 表示永久激活
+         */
+        permanently: number;
+    }
+
+    export type ActivationCodePlaintext = Record<string, ActivateModule>;
+
+    export interface ActivationModuleStatus extends ActivateModule {
+        key: string;
+        label: string;
+    }
+}

frontend/src/api/helper/axiosCancel.ts

@@ -0,0 +1,47 @@
+// ? 暂未使用，目前使用全局 Loading 来控制重复请求
+import { CustomAxiosRequestConfig } from "../index";
+import qs from "qs";
+
+// 声明一个 Map 用于存储每个请求的标识 和 取消函数
+let pendingMap = new Map<string, AbortController>();
+
+// 序列化参数
+export const getPendingUrl = (config: CustomAxiosRequestConfig) =>
+  [config.method, config.url, qs.stringify(config.data), qs.stringify(config.params)].join("&");
+
+export class AxiosCanceler {
+  /**
+   * @description: 添加请求
+   * @param {Object} config
+   * @return void
+   */
+  addPending(config: CustomAxiosRequestConfig) {
+    // 在请求开始前，对之前的请求做检查取消操作
+    this.removePending(config);
+    const url = getPendingUrl(config);
+    const controller = new AbortController();
+    config.signal = controller.signal;
+    pendingMap.set(url, controller);
+  }
+
+  /**
+   * @description: 移除请求
+   * @param {Object} config
+   */
+  removePending(config: CustomAxiosRequestConfig) {
+    const url = getPendingUrl(config);
+    // 如果在 pending 中存在当前请求标识，需要取消当前请求
+    const controller = pendingMap.get(url);
+    controller && controller.abort();
+  }
+
+  /**
+   * @description: 清空所有pending
+   */
+  removeAllPending() {
+    pendingMap.forEach(controller => {
+      controller && controller.abort();
+    });
+    pendingMap.clear();
+  }
+}

frontend/src/api/helper/checkStatus.ts

@@ -0,0 +1,43 @@
+import { ElMessage } from "element-plus";
+
+/**
+ * @description: 校验网络请求状态码
+ * @param {Number} status
+ * @return void
+ */
+export const checkStatus = (status: number) => {
+  switch (status) {
+    case 400:
+      ElMessage.error("请求失败！请您稍后重试");
+      break;
+    // case 401:
+    //   ElMessage.error("登录失效！请您重新登录");
+    //   break;
+    case 403:
+      ElMessage.error("当前账号无权限访问！");
+      break;
+    case 404:
+      ElMessage.error("你所访问的资源不存在！");
+      break;
+    case 405:
+      ElMessage.error("请求方式错误！请您稍后重试");
+      break;
+    case 408:
+      ElMessage.error("请求超时！请您稍后重试");
+      break;
+    case 500:
+      ElMessage.error("服务异常！");
+      break;
+    case 502:
+      ElMessage.error("网关错误！");
+      break;
+    case 503:
+      ElMessage.error("服务不可用！");
+      break;
+    case 504:
+      ElMessage.error("网关超时！");
+      break;
+    default:
+      ElMessage.error("请求失败！");
+  }
+};

frontend/src/api/index.ts

@@ -0,0 +1,242 @@
+import { ElMessage } from 'element-plus'
+import axios, {
+    AxiosError,
+    type AxiosInstance,
+    type AxiosRequestConfig,
+    type AxiosResponse,
+    type InternalAxiosRequestConfig
+} from 'axios'
+import { showFullScreenLoading, tryHideFullScreenLoading } from '@/components/Loading/fullScreen'
+import { LOGIN_URL } from '@/config'
+import { type ResultData } from '@/api/interface'
+import { ResultEnum } from '@/enums/httpEnum'
+import { checkStatus } from './helper/checkStatus'
+import { useUserStore } from '@/stores/modules/user'
+import router from '@/routers'
+import { refreshToken } from '@/api/user/login'
+import { EventSourcePolyfill } from 'event-source-polyfill'
+
+export interface CustomAxiosRequestConfig extends InternalAxiosRequestConfig {
+    loading?: boolean
+}
+
+const config = {
+    // 默认地址请求地址，可在 .env 开头文件中修改
+    baseURL: import.meta.env.VITE_API_URL as string,
+    // 设置超时时间（60s）
+    timeout: 60000,
+    // 跨域时候允许携带凭证
+    withCredentials: true,
+    // post请求指定数据类型以及编码
+    headers: { 'Content-Type': 'application/json;charset=utf-8' }
+}
+
+class RequestHttp {
+    service: AxiosInstance
+
+    public constructor(config: AxiosRequestConfig) {
+        // 创建实例
+        this.service = axios.create(config)
+
+        /**
+         * @description 请求拦截器
+         * 客户端发送请求 -> [请求拦截器] -> 服务器
+         * token校验(JWT) : 接受服务器返回的 token,存储到 vuex/pinia/本地储存当中
+         */
+        this.service.interceptors.request.use(
+            (config: CustomAxiosRequestConfig) => {
+                isFirst = true
+                const userStore = useUserStore()
+                // 当前请求不需要显示 loading，在 api 服务中通过指定的第三个参数: { loading: false } 来控制
+                config.loading ?? (config.loading = true)
+                config.loading && showFullScreenLoading()
+                if (config.headers && typeof config.headers.set === 'function') {
+                    config.headers.set('Authorization', 'Bearer ' + userStore.accessToken)
+                    config.headers.set('Is-Refresh-Token', userStore.isRefreshToken + '')
+                }
+                return config
+            },
+            (error: AxiosError) => {
+                return Promise.reject(error)
+            }
+        )
+
+        let isFirst = true
+        /**
+         * @description 响应拦截器
+         *  服务器换返回信息 -> [拦截统一处理] -> 客户端JS获取到信息
+         */
+        this.service.interceptors.response.use(
+            async (response: AxiosResponse) => {
+                const { data } = response
+                const userStore = useUserStore()
+                tryHideFullScreenLoading()
+
+                if (data.code === ResultEnum.ACCESSTOKEN_EXPIRED) {
+                    // 用长token去换短token
+                    userStore.setAccessToken(userStore.refreshToken)
+                    userStore.setIsRefreshToken(true)
+                    const result = await refreshToken()
+                    if (result) {
+                        //获取新token成功的话
+                        // 有新的token后，重新请求
+                        userStore.setAccessToken(result.data.accessToken)
+                        userStore.setRefreshToken(result.data.refreshToken)
+                        userStore.setIsRefreshToken(false)
+                        userStore.setExp(Date.now() + 1000 * 60 * 60 * 24 * 30)
+                        response.config.headers.Authorization = `Bearer ${result.data.accessToken}` //重新请求前需要将更新后的新token更换掉之前无效的token,不然会死循环
+                        const resp = await this.service.request(response.config)
+                        return resp
+                    } else {
+                        // 刷新失效，跳转登录页
+                    }
+                }
+                // 登陆失效
+                if (data.code === ResultEnum.OVERDUE) {
+                    //console.log('登陆失效')
+                    userStore.setAccessToken('')
+                    userStore.setRefreshToken('')
+                    userStore.setIsRefreshToken(false)
+                    userStore.setUserInfo({ id: '', name: '' })
+                    userStore.setExp(0)
+                    await router.replace(LOGIN_URL)
+                    if (isFirst) {
+                        //临时处理token失效弹窗多次
+                        ElMessage.error(data.message)
+                        isFirst = false
+                    }
+                    return Promise.reject(data)
+                }
+                // 全局错误信息拦截（防止下载文件的时候返回数据流，没有 code 直接报错）
+                if (data.code && data.code !== ResultEnum.SUCCESS) {
+                    if (data.message.includes('&')) {
+                        let formattedMessage = data.message.split('&').join('<br>')
+                        if (data.message.includes(':')) {
+                            formattedMessage = formattedMessage.replace(':', '')
+                        }
+                        ElMessage.error({ message: formattedMessage, dangerouslyUseHTMLString: true })
+                        return Promise.reject(data)
+                    }
+
+                    ElMessage.error(data.message)
+                    return Promise.reject(data)
+                }
+                // 成功请求（在页面上除非特殊情况，否则不用处理失败逻辑）
+
+                if (userStore.exp <= Date.now() && userStore.exp !== 0) {
+                    userStore.setAccessToken('')
+                    userStore.setRefreshToken('')
+                    userStore.setIsRefreshToken(false)
+                    userStore.setUserInfo({ id: '', name: '' })
+                    userStore.setExp(0)
+                    ElMessage.error('登录已过期，请重新登录!')
+                    await router.replace(LOGIN_URL)
+                    return Promise.reject(data)
+                }
+                // 对于blob类型的响应，返回完整的response对象以保留响应头
+                if (response.config.responseType === 'blob') {
+                    return response
+                }
+                return data
+            },
+            async (error: AxiosError) => {
+                const { response } = error
+                tryHideFullScreenLoading()
+                //console.log('error', error.message)
+                // 请求超时 && 网络错误单独判断，没有 response
+                if (error.message.indexOf('timeout') !== -1) ElMessage.error('请求超时！请您稍后重试')
+                if (error.message.indexOf('Network Error') !== -1) ElMessage.error('网络错误！请您稍后重试')
+                // 根据服务器响应的错误状态码，做不同的处理
+                if (response) checkStatus(response.status)
+                // 服务器结果都没有返回(可能服务器错误可能客户端断网)，断网处理:可以跳转到断网页面
+                if (!window.navigator.onLine) router.replace('/500')
+                return Promise.reject(error)
+            }
+        )
+    }
+
+    /**
+     * @description 常用请求方法封装
+     */
+    get<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
+        return this.service.get(url, { params, ..._object })
+    }
+
+    post<T>(url: string, params?: object | string, _object = {}): Promise<ResultData<T>> {
+        return this.service.post(url, params, _object)
+    }
+
+    put<T>(url: string, params?: object, _object = {}): Promise<ResultData<T>> {
+        return this.service.put(url, params, _object)
+    }
+
+    delete<T>(url: string, params?: any, _object = {}): Promise<ResultData<T>> {
+        return this.service.delete(url, { params, ..._object })
+    }
+
+    download(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service.post(url, params, { ..._object, responseType: 'blob' }).then(res => res.data)
+    }
+
+    downloadWithHeaders(url: string, params?: object, _object = {}): Promise<AxiosResponse<Blob>> {
+        return this.service.post(url, params, { ..._object, responseType: 'blob' })
+    }
+
+    upload(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service.post(url, params, {
+            ..._object,
+            headers: { 'Content-Type': 'multipart/form-data' }
+        })
+    }
+
+    /**
+     * 针对excel的上传，默认返回的是blob类型，Excel没问题时返回json特殊处理
+     */
+    uploadExcel(url: string, params?: object, _object = {}): Promise<BlobPart> {
+        return this.service
+            .post(url, params, {
+                ..._object,
+                headers: { 'Content-Type': 'multipart/form-data' },
+                responseType: 'blob'
+            })
+            .then(res => res.data)
+    }
+
+    // 添加SSE连接方法
+    sse(url: string, params?: any): EventSource {
+        const userStore = useUserStore()
+        // 构造带参数的URL
+        let requestUrl = config.baseURL + url
+        if (params) {
+            const searchParams = new URLSearchParams()
+            for (const key in params) {
+                if (Object.prototype.hasOwnProperty.call(params, key)) {
+                    searchParams.append(key, String(params[key]))
+                }
+            }
+            requestUrl += '?' + searchParams.toString()
+        }
+
+        // 创建EventSource连接
+        const eventSource = new EventSourcePolyfill(requestUrl, {
+            headers: {
+                Authorization: 'Bearer ' + userStore.accessToken
+            },
+            // 增加超时时间到1200秒
+            heartbeatTimeout: 1200000
+        })
+
+        // 设置默认的Authorization头部
+        eventSource.addEventListener('open', function () {
+            //console.log('SSE连接已建立')
+        })
+        // 添加错误处理
+        eventSource.addEventListener('error', function (err) {
+            console.error('SSE连接错误:', err)
+        })
+
+        return eventSource
+    }
+}
+
+export default new RequestHttp(config)

frontend/src/api/interface/index.ts

@@ -0,0 +1,58 @@
+import { storeToRefs } from 'pinia';
+/**
+ * 该接口声明文件用来声明通用的接口定义，比如 请求参数Base、响应Base、分页等
+ */
+
+/**
+ * 请求响应参数（不包含data）
+ */
+export interface Result {
+  code: string;
+  message: string;
+}
+
+/**
+ * 请求响应参数（包含data）
+ */
+export interface ResultData<T = any> extends Result {
+  map(arg0: (item: any) => { label: any; value: any; }): { label: string; value: string; }[] | { label: string; value: string; }[];
+  data: T;
+}
+
+
+/**
+ * 分页请求参数
+ */
+export interface ReqPage {
+  pageNum?: number;
+  pageSize?: number;
+}
+
+/**
+ * 分页响应参数
+ */
+export interface ResPage<T> {
+  records: T[];
+  current: number;
+  size: number;
+  total: number;
+}
+
+/**
+ *  Dict 字典属性
+ *  id: 唯一标识
+ *  label: 名称
+ *  code: 类型下唯一标识
+ */
+export interface Dict {
+  id: string;
+  name: string;
+  code: string;
+  value?: string;
+  sort?:number;
+  algoDescribe?: string;
+  children?: Dict[];
+}
+
+
+

frontend/src/api/system/config/serviceName.ts

@@ -0,0 +1,9 @@
+
+// 系统模块前缀
+export const ADMIN = "/admin";
+
+// 用户模块前缀
+export const USER = "/user-boot";
+
+
+// todo... 其他业务模块前缀

frontend/src/api/system/dictionary/dictData/index.ts

@@ -0,0 +1,33 @@
+import http from '@/api'
+import {type Dict} from '@/api/system/dictionary/interface'
+
+//获取字典数据
+export const getDictDataListByTypeId = (params: Dict.ReqDictDataParams) => {
+    return http.post(`/dictData/listByTypeId`, params)
+}
+
+//添加字典数据
+export const addDictData = (params: Dict.ResDictData) => {
+    return http.post(`/dictData/add`, params)
+}
+
+//编辑字典数据
+export const updateDictData = (params: Dict.ResDictData) => {
+    return http.post(`/dictData/update`, params)
+}
+
+//删除字典数据
+export const deleteDictData = (params: string[]) => {
+    return http.post(`/dictData/delete`, params)
+}
+
+export const getDicDataById = (params: string) => {
+    return http.post('/dictData/getDicDataById', params)
+}
+
+//导出字典数据
+export const exportDictData = (params: Dict.ReqDictDataParams) => {
+    return http.download(`/dictData/export`, params)
+}
+
+

frontend/src/api/system/dictionary/dictTree/index.ts

@@ -0,0 +1,29 @@
+import http from '@/api'
+import { type Dict } from '@/api/system/dictionary/interface'
+import { c } from 'vite/dist/node/types.d-aGj9QkWt'
+
+//获取字典类型
+export const getDictTreeByCode = (params: Dict.ResDictTree) => {
+    const code = params.code || ''
+    return http.get(`/dictTree/getTreeByCode?code=${code}`, { loading: true })
+}
+
+export const getDictTreeByName = (params: Dict.ResDictTree) => {
+    const name = params.name || ''
+    return http.get(`/dictTree/getTreeByName?name=${name}`)
+}
+
+//添加字典类型
+export const addDictTree = (params: Dict.ResDictTree) => {
+    return http.post(`/dictTree/add`, params)
+}
+
+//编辑字典类型
+export const updateDictTree = (params: Dict.ResDictTree) => {
+    return http.post(`/dictTree/update`, params)
+}
+
+//删除字典类型
+export const deleteDictTree = (params: Dict.ResDictTree) => {
+    return http.post(`/dictTree/delete?id=${params.id}`)
+}

frontend/src/api/system/dictionary/dictType/index.ts

@@ -0,0 +1,27 @@
+import http from '@/api'
+import { type Dict } from '@/api/system/dictionary/interface'
+
+//获取字典类型
+export const getDictTypeList = (params: Dict.ReqDictTypeParams) => {
+    return http.post(`/dictType/list`, params)
+}
+
+//添加字典类型
+export const addDictType = (params: Dict.ResDictType) => {
+    return http.post(`/dictType/add`, params)
+}
+
+//编辑字典类型
+export const updateDictType = (params: Dict.ResDictType) => {
+    return http.post(`/dictType/update`, params)
+}
+
+//删除字典类型
+export const deleteDictType = (params: string[]) => {
+    return http.post(`/dictType/delete`, params)
+}
+
+//导出字典类型
+export const exportDictType=(params: Dict.ReqDictTypeParams)=>{
+    return http.download(`/dictType/export`, params)
+}

frontend/src/api/system/dictionary/interface/index.ts

@@ -0,0 +1,169 @@
+import type { ReqPage, ResPage } from '@/api/interface'
+
+export namespace Dict {
+
+  /**
+   * 一个单表的CRUD需要申明一下几个对象
+   * 1、表格分页查询对象，字段：查询字段?、页码、每页条数；
+   * 2、新增、修改、根据id查询返回的对象；
+   * 3、表格查询分页返回的对象；
+   */
+
+  /**
+   * 字典类型表格分页查询参数
+   */
+  export interface ReqDictTypeParams extends ReqPage{
+    name?: string; // 名称
+    code?: string; // 编码
+  }
+
+  /**
+   * 字典类型新增、修改、根据id查询返回的对象
+   */
+  export interface ResDictType {
+    id: string; // 字典类型表Id
+    name: string; // 名称
+    code: string; // 编码
+    sort: number; // 排序
+    openLevel: number; // 开启等级：0-不开启；1-开启，默认不开启
+    openDescribe: number; // 开启描述：0-不开启；1-开启，默认不开启
+    remark?: string | null; // 描述
+    state: number; // 状态：0-删除 1-正常
+    createBy?: string | null; // 创建用户
+    createTime?: string | null; // 创建时间
+    updateBy?: string | null; // 更新用户
+    updateTime?: string | null; // 更新时间
+  }
+
+  /**
+   * 字典类型表格查询分页返回的对象；
+   */
+  export interface ResDictTypePage extends ResPage<ResDictType> {
+
+  }
+
+
+
+  /**
+   * 字典数据表格分页查询参数
+   */
+  export interface ReqDictDataParams extends ReqPage{
+    typeId: string; // 类型id 必填
+    name?: string; // 名称
+    code?: string; // 编码
+  }
+
+  /**
+   * 字典数据新增、修改、根据id查询返回的对象
+   */
+  export interface ResDictData {
+    id: string; // 字典数据表Id
+    typeId: string; // 字典类型表Id
+    name: string; // 名称
+    code: string; // 编码
+    sort: number; // 排序
+    openValue?: number | null;
+    level?: number | null; // 事件等级：0-普通；1-中等；2-严重 (默认为0)
+    algoDescribe?: number | null; // 与高级算法内部Id描述对应
+    value?: string | null; // 字典针对电压等级
+    dictValue?:string|null;
+    state: number; // 状态：0-删除 1-正常
+    createBy?: string | null; // 创建用户
+    createTime?: string | null; // 创建时间
+    updateBy?: string | null; // 更新用户
+    updateTime?: string | null; // 更新时间
+  }
+
+  /**
+   * 字典数据表格查询分页返回的对象；
+   */
+  export interface ResDictDataPage extends ResPage<ResDictData> {
+
+  }
+
+
+
+  /**
+   * 电能质量指标字典数据表格分页查询参数
+   */
+  export interface ReqDictPqParams extends ReqPage{
+    id: string; // 类型id 必填
+    name?: string; // 名称
+    phase?: string;//相别
+    dataType?: string;//数据模型(epd、pqd...)
+  }
+
+  /**
+   * 电能质量指标字典数据新增、修改、根据id查询返回的对象
+   */
+  export interface ResDictPq {
+      id: string;//指标字典表Id
+      name: string;//指标名称
+      phase: string;//相别
+      dataType: string;//数据模型(epd、pqd...)
+      otherName?: string ;//别名（默认与Name相同，主要是为了适配不同数据库里面字段）
+      showName?:string | null;//显示名称
+      sort:number;//排序
+      type?: string | null;//指标数据类型（整型、浮点型、枚举型这些的）
+      unit?: string | null;//单位
+      harmStart?:number | null;//起始次数
+      harmEnd?:number | null;//结束次数
+      classId: string ;//数据表表名
+      statMethod?:string;//数据统计类型（最大、最小、平均、CP95）
+      systemType?:string | null;//系统类别（区分用能/电能）
+      tranFlag?:number ;//数据是否上送（0:不上送 1:上送）
+      tranRule?:string | null;//上送规则 变化:“change”周期 :“ period”
+      eventType?:string | null;//evt的事件类别 "1"、"2"；
+      storeFlag?:string ;//sts、di的是否存储 1:存储 0:不存 储；
+      curSts?:number | null;//sts、do的当前值；
+      ctlSts?:number;//do的是否可远程控制 1:是 0:否；
+      maxNum?:number | null;//设置最大值
+      minNum?: number| null;//设置最小值
+      setValue?:string | null;//参数为enum可设置的所有值序列
+      strlen?:number | null;//参数string可设置字符串的长度上 限
+      defaultValue?:string | null;  //参数缺省值、告警code值
+      resourcesId?:string ;  //报表数据来源(统计表表名)
+      limitName?:string | null;  //限值字段名称
+      limitTable?:string | null;//限值表名
+      formula?:string ;//超标判断方式
+      primaryFormula?:string | null;//二次值转一次值公式
+      state:number;//状态：0-删除 1-正常
+      createBy?:string | null;//创建用户
+      createTime?:string | null;//创建时间
+      updateBy?:string | null;//更新用户
+      updateTime?:string | null;//更新时间
+  }
+
+  /**
+   * 电能质量指标字典数据表格查询分页返回的对象；
+   */
+  export interface ResDictPqPage extends ResPage<ResDictPq> {
+
+  }
+
+
+  
+    /**
+     * 树形字典数据新增、修改、根据id查询返回的对象
+     */
+    export interface ResDictTree {
+        id: string;//指标字典表Id
+        pid: string;//
+        pids: string;//
+        name:string;//
+        code:string;//
+        sort:number;//
+        remark?:string;//
+        state?:number;//'状态(字典 0正常 1停用 2删除)
+        createBy?:string | null;//
+        createTime?:string | null;//
+        updateBy?:string | null;//
+        updateTime?:string | null;//
+        level?:number | null;//
+        extend?:string | null;//对应type，不同类型可自定义配置
+        type?:number | null;//用于区分多种类型的字典树 0.台账对象类型 1.自定义报表指标类型
+        children?: ResDictTree[];
+    }
+
+  
+}

frontend/src/api/system/log/index.ts

@@ -0,0 +1,16 @@
+import type {AuditLog  } from '@/api/system/log/interface/log.ts'
+import http from '@/api'
+
+/**
+ * @name 审计日志管理模块
+ */
+
+//获取审计日志
+export const getAuditLog = (params: AuditLog.ReqAuditLogParams) => {
+  return http.post(`/sysLog/list`, params)
+}
+
+
+export const exportCsv = (params: AuditLog.ReqAuditLogParams) => {
+  return http.download(`/sysLog/exportCSV`, params)
+}

frontend/src/api/system/log/interface/log.ts

@@ -0,0 +1,34 @@
+import type { ReqPage, ResPage } from '@/api/interface'
+
+// 审计日志管理模块
+export namespace AuditLog {
+  /**
+   * 审计日志分页查询参数
+   */
+  export interface ReqAuditLogParams extends ReqPage {
+    id: string; //审计日志Id 必填
+    createTime?: string; //创建时间
+  }
+
+  /**
+   * 审计日志详情
+   */
+  export interface ResAuditLog {
+    id: string;//审计日志Id
+    operate_Type:string;//操作类型
+    ip:string;//操作IP
+    result: string;//事件结果
+    remark: string;//事件描述
+    level:number;//告警等级
+    warn:number;//告警标志
+    create_By:string;//创建用户
+    create_Time:string;//创建时间
+    sort:number;//排序
+  }
+
+  /**
+   * 审计日志分页结果
+   */
+  export interface ResAuditLogPage extends ResPage<ResAuditLog> {
+  }
+}

frontend/src/api/user/function/index.ts

@@ -0,0 +1,35 @@
+import http from "@/api";
+import type { Function } from "@/api/user/interface/function";
+
+
+
+// 获取资源
+export const getFunctionList = (params:Function.ResFunction) => {
+  const name = params.name || '';
+  return http.get<Function.ResFunction>(`/sysFunction/getTree?keyword=${name}`)
+}
+
+
+// 获取资源不包括按钮
+export const getFunctionListNoButton = () => {
+  return http.get<Function.ResFunction>(`/sysFunction/functionTreeNoButton`)
+}
+
+
+  //添加菜单列表
+  export const addFunction = (params: Function.ResFunction) => {
+    return http.post(`/sysFunction/add`,params);
+  };
+  
+  //删除菜单列表
+  export const deleteFunction = (params: Function.ResFunction) => {
+    return http.post(`/sysFunction/delete?id=${params.id}`);
+  };
+  
+  //编辑菜单列表
+  export const updateFunction = (params: Function.ResFunction) => {
+    return http.post(`/sysFunction/update`, params);
+  };
+  
+  
+

frontend/src/api/user/interface/function.ts

@@ -0,0 +1,45 @@
+import type { ReqPage, ResPage } from '@/api/interface'
+
+// 菜单管理模块
+export namespace Function {
+
+  /**
+   * 菜单管理表格分页查询参数
+   */
+  export interface ReqFunctionParams extends ReqPage{
+    name?: string; // 名称
+    code?: string; // 编码
+  }
+
+
+   /**
+   * 菜单管理新增、修改、根据id查询返回的对象
+   */
+  export interface ResFunction {
+    id: string;//资源表Id
+    pid:string;//节点（0为根节点）
+    pids?:string | null;//节点上层所有节点
+    name: string;//名称
+    code:string;//资源标识
+    path:string;//路由路径
+    component:string ;//组件地址
+    icon?:string;//图标
+    sort:number;//排序
+    type:number;//资源类型0-菜单、1-按钮、2-公共资源、3-服务间调用资源
+    remark?: string | null;//权限资源描述
+    state:number;//权限资源状态
+    create_By?:string | null;//创建人
+    create_Time?:string | null;//创建时间
+    update_By?:string | null;//更新人
+    update_Time?:string | null;//更新时间
+    children?: ResFunction[] | null;
+  }
+
+
+   /**
+   * 菜单管理表格查询分页返回的对象；
+   */
+   export interface ResFunctionPage extends ResPage<ResFunction> {
+
+   }
+}

frontend/src/api/user/interface/role.ts

@@ -0,0 +1,93 @@
+import type { ReqPage, ResPage } from '@/api/interface'
+
+// 角色管理模块
+export namespace Role {
+
+
+    /**
+     * 用户数据表格分页查询参数
+     */
+    export interface ReqRoleParams extends ReqPage{
+      id: string; // 装置序号用户ID 必填
+      name?: string;     //用户名(别名)
+      code?: string;   //角色代码
+    }
+    //角色接口
+    export interface RoleBO {
+      id: string;     //角色类型ID
+      name: string;   //角色类型名称
+      code: string;   //角色代码
+      type: number;   //角色类型
+      remark?:string;   //角色描述
+      state:number;
+      createBy?:string; //
+      createTime?: string; // 创建时间
+      updateBy?: string; //
+      updateTime?: string; // 更新时间
+    }
+
+      //角色接口
+      export interface RoleFunctionId {
+        id: string[];     //菜单id
+      }
+
+ /**
+   * 用户表格查询分页返回的对象；
+   */
+ export interface ResRolePage extends ResPage<RoleBO> {
+
+ }
+
+
+
+
+
+    // export interface Permission{
+    //     key: string;             //权限名称
+    //     label: string;           //权限ID
+    //     disabled:boolean; //是否拥有该权限
+    // }
+
+    // 角色列表
+    // export interface ResRoleList {
+    //     id: string;     //角色类型ID
+    //     rolename: string;   //角色类型名称
+    //     status: number;  //角色类型状态
+    //     describe:string;                //角色描述
+    //     permissionList?:Permission[];   //角色权限列表
+    // }
+  
+
+
+
+    // export interface ReqRoleParams extends ReqPage {
+    //     id: string;     //角色类型ID
+    //     rolename: string;   //角色类型名称
+    //     status: number;  //角色类型状态
+    //     describe:string;                //角色描述
+    //     permissionList?:Permission[];   //角色权限列表
+    // }
+    // 角色字典
+    // export interface ResStatus {
+    //   roleLabel: string;
+    //   roleValue: number;
+    // }
+  
+    // export interface ResGender {
+    //   genderLabel: string;
+    //   genderValue: number;
+    // }
+  
+    //角色权限列表
+    // export interface ResPermissionList {
+    //   key: string;
+    //   label: string;
+    //   disable?: Permission[];
+    // }
+  
+    // export interface ResRole {
+    //   id: string;
+    //   name: string;
+    //   children?: ResDepartment[];
+    // }
+  }

frontend/src/api/user/interface/user.ts

@@ -0,0 +1,79 @@
+// 登录模块
+import type { ReqPage, ResPage } from '@/api/interface'
+
+export namespace Login {
+    export interface ReqLoginForm {
+        username: string
+        password: string
+        checked: boolean
+    }
+    export interface ResLogin {
+        accessToken: string
+        refreshToken: string
+        userInfo: {
+            id: string
+            name: string
+        }
+    }
+    export interface ResAuthButtons {
+        [key: string]: string[]
+    }
+}
+
+
+// 用户管理模块
+export namespace User {
+
+   /**
+   * 用户数据表格分页查询参数
+   */
+   export interface ReqUserParams extends ReqPage{
+    id: string; // 装置序号用户ID 必填
+    name?: string;     //用户名(别名)
+    loginTime?: string;//最后一次登录时间
+  }
+
+  // 用户接口
+  export interface ResUser {
+    id: string;       //用户ID，作为唯一标识
+    name: string;     //用户名(别名)
+    loginName: string;//登录名
+    deptId?: number;//部门ID
+    password: string; //密码
+    phone?: string;    //手机号
+    email?: string;    //邮箱
+    loginTime?: string;//最后一次登录时间
+    loginErrorTimes: number;//登录错误次数
+    lockTime?: string; //用户密码错误锁定时间
+    state:number;//0-删除;1-正常;2-锁定;3-待审核;4-休眠;5-密码过期
+    createBy?: string;//创建用户
+    createTime?: string;//创建时间
+    updateBy?: string;//更新用户
+    updateTime?: string;//更新时间
+    roleIds?: string[]; // 
+    roleNames?:string[]; //
+    roleCodes?:string[]; //
+    disabled?: boolean;
+  }
+
+  // 用户接口
+  export interface ResPassWordUser {
+    id: string;       //用户ID，作为唯一标识
+    oldPassword: string; //密码
+    newPassword: string; //新密码
+    surePassword:string;
+  }
+
+
+  /**
+   * 用户表格查询分页返回的对象；
+   */
+       export interface ResUserPage extends ResPage<ResUser> {
+
+       }
+  //  // 用户+分页
+  //  export interface ReqUserParams extends ReqPage,UserBO {
+
+  //  }
+}
+

frontend/src/api/user/login/index.ts

@@ -0,0 +1,47 @@
+import type {Login} from '@/api/user/interface/user'
+import {ADMIN as rePrefix} from '@/api/system/config/serviceName'
+import http from '@/api'
+import type {Dict} from '@/api/interface'
+
+/**
+ * @name 登录模块
+ */
+// 用户登录
+export const loginApi = (params: { username: string; password: string}) => {
+    return http.post<Login.ResLogin>(`${rePrefix}/login`, params, {loading: false})
+    // return http.post<Login.ResLogin>(`/Register1`, params, { loading: false })
+}
+// 获取菜单列表
+export const getAuthMenuListApi = () => {
+    return http.get<Menu.MenuOptions[]>(`/sysFunction/getMenu`, {}, {loading: false})
+    //  return http.post<Menu.MenuOptions[]>(`/Register2`, {}, { loading: false })
+}
+// 获取按钮权限
+export const getAuthButtonListApi = () => {
+    return http.get<Login.ResAuthButtons>(`/sysFunction/getButton`, {}, {loading: false})
+    //  return http.post<Login.ResAuthButtons>(`/Register3`, {}, { loading: false })
+}
+// 用户退出登录
+export const logoutApi = () => {
+    return http.post(`${rePrefix}/logout`)
+}
+
+//获取下拉框列表
+export const getDictList = () => {
+    return http.get<Dict>('/dictData/dictDataCache')
+}
+
+//token刷新
+export const refreshToken = () => {
+    return http.get<Login.ResLogin>(`${rePrefix}/refreshToken`,
+        {},
+        {loading: false}
+    )
+}
+
+/**
+ * 获取RSA公钥
+ */
+export const getPublicKey = (username: string) => {
+    return http.get(`/admin/getPublicKey?username=${username}`, {}, {loading: false})
+}

frontend/src/api/user/role/index.ts

@@ -0,0 +1,46 @@
+import type { Role } from '@/api/user/interface/role'
+import type { Function } from '@/api/user/interface/function'
+import http from '@/api'
+
+/**
+ * @name 角色管理模块
+ */
+// 获取角色列表
+export const getRoleList = (params: Role.ReqRoleParams) => {
+    return http.post(`/sysRole/list`, params)
+
+  //  return http.post<ResPage<Role.ResRoleList>>(`/RoleList_Post`, params)
+  // return http.post<ResPage<Role.ResRoleList>>(`${rePrefix}/role/list`, params)
+}
+
+// 新增角色
+export const addRole = (params: Role.RoleBO) => {
+  return http.post(`/sysRole/add`, params)
+}
+
+// 编辑角色
+export const editRole = (params: Role.RoleBO) => {
+  return http.post(`/sysRole/update`, params)
+}
+
+// 删除角色
+export const deleteRole = (params: { id: string[] }) => {
+  return http.post(`/sysRole/delete`, params)
+}
+
+
+// 获取资源
+export const getFunctionList = () => {
+  return http.get<Function.ResFunction>(`/sysFunction/getTree?keyword=`)
+}
+
+
+//获取角色id绑定的菜单
+export const getRoleFunction = (params:Role.RoleBO) => {
+  return http.post(`/sysFunction/getFunctionsByRoleId?id=${params.id}`)
+}
+
+//角色分配菜单
+export const assignFunction = (params:Role.RoleBO,param:Role.RoleFunctionId) => {
+  return http.post(`/sysFunction/assignFunctionByRoleId`,{ roleId: params.id,functionIds:param.id })
+}

frontend/src/api/user/user/index.ts

@@ -0,0 +1,43 @@
+import type { Role } from '@/api/user/interface/role'
+import type { User } from '@/api/user/interface/user'
+import http from '@/api'
+
+/**
+ * @name 用户管理模块
+ */
+// 获取用户列表
+export const getUserList = (params: User.ReqUserParams) => {
+  return http.post(`/sysUser/list`, params)
+}
+
+
+// 新增用户
+export const addUser = (params: User.ResUser) => {
+  return http.post(`/sysUser/add`, params)
+}
+
+// 编辑用户
+export const updateUser = (params: User.ResUser) => {
+  return http.post(`/sysUser/update`, params)
+}
+
+// 删除用户
+export const deleteUser = (params:  string[] ) => {
+  return http.post(`/sysUser/delete`, params)
+}
+
+
+// 获取角色列表
+export const getRoleList = () => {
+  return http.get<Role.RoleBO>(`/sysRole/simpleList`)
+}
+
+//修改密码
+export const updatePassWord = (params: User.ResPassWordUser) => {
+  return http.post(`/sysUser/updatePassword`,params)
+}
+
+// 获取所有用户
+export const getAllUser= () => {
+  return http.get(`/sysUser/getAll`)
+}