新增 有家相册 uni-app 前端（uniapp/youjiala，H5 / 微信小程序 / App 三端）

从旧 WebVue 移植的地基部分：
- 登录页（RSA+MD5 密码加密、redirect 回跳、中英文切换）与登录后落地页
- 401 / 403 / 404 错误页 + error-panel 通用外壳（文案走 ErrorPage 语言包）
- 登录守卫双链路：uni.addInterceptor 拦站内跳转，页面级 onShow 复核冷启动深链
- 单一请求链路 common/http.interceptor：JWT 唯一来源、401 并发刷新单例、
  业务异常识别、HTTP 403 跳无权限页
- H5 干净短地址：initRouter 前向 __uniRoutes 追加克隆记录（router/h5-clean-url）
- 路由登记表 router/routes.ts（PAGE_PATHS / pageUrl / PAGE_PERMISSIONS）
  与新增页面四步登记约定（src/md/page-routing.md）
- i18n：uView Pro 语言包 + 后端词条合并，双取值（后端 zh-cn/en，包名 zh-CN/en-US）
- 后端接口层 service/ 与数据模型 data/auto/ 为生成器产物，不手改

不入库的内容：
- 摘除脚手架残留的 Harmony 签名密码（manifest.json signingConfigs 与
  harmony-configs/build-profile.json5 的 keyPassword / storePassword 已置空）
- 忽略 node_modules、dist、unpackage、.hbuilderx、.agents、pnpm-lock.yaml
  及根目录临时截图

uniapp/youjiala/src/service/master/dmsFileService.ts

@@ -0,0 +1,352 @@
+import type { DmsFileDeleteLogEntity } from "@/data/auto/dmsFileDeleteLogEntity";
+import type { DmsFileEntity } from "@/data/auto/dmsFileEntity";
+import type { DmsFileResultData } from "@/data/auto/dmsFileResultData";
+import type { DmsFileSearchCriteria } from "@/data/auto/dmsFileSearchCriteria";
+import type { DmsFolderData } from "@/data/auto/dmsFolderData";
+import type { FamilyDmsFileViewEntity } from "@/data/auto/familyDmsFileViewEntity";
+import type { FamilyGroupFolderEntity } from "@/data/auto/familyGroupFolderEntity";
+import type { SelectOption } from "@/data/auto/selectOption";
+import { download, request } from "@/utils/request";
+
+class DmsFileService {
+  async FindByKey(data: number) {
+    return request<DmsFileEntity>(
+      {
+        url: `/DmsFile/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: DmsFileSearchCriteria) {
+    return request<DmsFileResultData>(
+      {
+        url: "/DmsFile/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDatasBySearchCriteria(data: DmsFileSearchCriteria) {
+    return request<DmsFileResultData>(
+      {
+        url: "/DmsFile/FindDatasBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDeleteLogBySearchCriteria(data: DmsFileSearchCriteria) {
+    return request<DmsFileResultData>(
+      {
+        url: "/DmsFile/FindDeleteLogBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindFamilyBySearchCriteria(data: DmsFileSearchCriteria) {
+    return request<DmsFileResultData>(
+      {
+        url: "/DmsFile/FindFamilyBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDmsFileDeleteLogByKey(data: number) {
+    return request<DmsFileDeleteLogEntity>(
+      {
+        url: `/DmsFile/FindDmsFileDeleteLogByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: DmsFileSearchCriteria) {
+    return download(
+      {
+        url: "/DmsFile/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "DmsFile",
+      },
+    );
+  };
+
+  async Insert(data: DmsFileEntity) {
+    return request<DmsFileEntity>(
+      {
+        url: "/DmsFile/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: DmsFileEntity) {
+    return request<DmsFileEntity>(
+      {
+        url: "/DmsFile/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: number) {
+    return request<any>(
+      {
+        url: `/DmsFile/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async RestoreDmsFile(data: number) {
+    return request<any>(
+      {
+        url: `/DmsFile/RestoreDmsFile?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteLog(data: number) {
+    return request<any>(
+      {
+        url: `/DmsFile/DeleteLog?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async CreateDmsFolder(data: DmsFileEntity) {
+    return request<string>(
+      {
+        url: "/DmsFile/CreateDmsFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteFamilyDmsFolder(data: FamilyDmsFileViewEntity) {
+    return request<any>(
+      {
+        url: "/DmsFile/DeleteFamilyDmsFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async CreateFamilyDmsFolder(data: FamilyDmsFileViewEntity) {
+    return request<any>(
+      {
+        url: "/DmsFile/CreateFamilyDmsFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async UpdateDmsFolder(data: DmsFileEntity) {
+    return request<any>(
+      {
+        url: "/DmsFile/UpdateDmsFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDmsFolders() {
+    return request<SelectOption[]>(
+      {
+        url: "/DmsFile/FindDmsFolders",
+        method: "post",
+      },
+    );
+  };
+
+  async FindDmsFolderDeleteLogs() {
+    return request<SelectOption[]>(
+      {
+        url: "/DmsFile/FindDmsFolderDeleteLogs",
+        method: "post",
+      },
+    );
+  };
+
+  async FindDmsFolderData() {
+    return request<DmsFolderData>(
+      {
+        url: "/DmsFile/FindDmsFolderData",
+        method: "post",
+      },
+    );
+  };
+
+  async MoveDmsFolder(data: DmsFileEntity) {
+    return request<any>(
+      {
+        url: "/DmsFile/MoveDmsFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async UploadFile() {
+    return request<any>(
+      {
+        url: "/DmsFile/UploadFile",
+        method: "post",
+      },
+    );
+  };
+
+  async UploadDmsFile() {
+    return request<any>(
+      {
+        url: "/DmsFile/UploadDmsFile",
+        method: "post",
+      },
+    );
+  };
+
+  async FindM3u8Path(data: number) {
+    return request<string>(
+      {
+        url: `/DmsFile/FindM3u8Path?fileId=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindSourceVideoPath(data: number) {
+    return request<string>(
+      {
+        url: `/DmsFile/FindSourceVideoPath?fileId=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDeleteLogM3u8Path(data: number) {
+    return request<string>(
+      {
+        url: `/DmsFile/FindDeleteLogM3u8Path?fileId=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DownloadFile(data: number) {
+    return request<any>(
+      {
+        url: `/DmsFile/DownloadFile?fileId=${data}`,
+        method: "post",
+        data,
+        responseType: "arraybuffer",
+      },
+    );
+  };
+
+  async DownloadFilePreview(data: DmsFileEntity) {
+    return request<any>(
+      {
+        url: "/DmsFile/DownloadFilePreview",
+        method: "post",
+        data,
+        responseType: "arraybuffer",
+      },
+    );
+  };
+
+  async DownloadFileCombine(data: string) {
+    return request<any>(
+      {
+        url: `/DmsFile/DownloadFileCombine?fileName=${data}`,
+        method: "post",
+        data,
+        responseType: "arraybuffer",
+      },
+    );
+  };
+
+  async FindFamilyDmsFolders() {
+    return request<SelectOption[]>(
+      {
+        url: "/DmsFile/FindFamilyDmsFolders",
+        method: "post",
+      },
+    );
+  };
+
+  async FindFamilyDmsFoldersByFamilyName(data: string) {
+    return request<SelectOption[]>(
+      {
+        url: `/DmsFile/FindFamilyDmsFoldersByFamilyName?familyName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDmsFolderMapByFolderName(data: string) {
+    return request<number>(
+      {
+        url: `/DmsFile/FindDmsFolderMapByFolderName?folderName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindFolderNameParentByFolderName(data: string) {
+    return request<string>(
+      {
+        url: `/DmsFile/FindFolderNameParentByFolderName?folderName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async CreateFamilyGroupFolder(data: FamilyGroupFolderEntity[]) {
+    return request<any>(
+      {
+        url: "/DmsFile/CreateFamilyGroupFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteFamilyGroupFolder(data: FamilyGroupFolderEntity[]) {
+    return request<any>(
+      {
+        url: "/DmsFile/DeleteFamilyGroupFolder",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const dmsFileService = new DmsFileService();
+export default dmsFileService;

uniapp/youjiala/src/service/master/familyGroupService.ts

@@ -0,0 +1,164 @@
+import type { FamilyFolderFavoriteEntity } from "@/data/auto/familyFolderFavoriteEntity";
+import type { FamilyGroupData } from "@/data/auto/familyGroupData";
+import type { FamilyGroupManagerEntity } from "@/data/auto/familyGroupManagerEntity";
+import type { FamilyGroupManagerUserSearchCriteria } from "@/data/auto/familyGroupManagerUserSearchCriteria";
+import type { FamilyGroupPermissionEntity } from "@/data/auto/familyGroupPermissionEntity";
+import type { FamilyGroupResultData } from "@/data/auto/familyGroupResultData";
+import type { FamilyGroupSearchCriteria } from "@/data/auto/familyGroupSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class FamilyGroupService {
+  async FindByKey(data: string) {
+    return request<FamilyGroupData>(
+      {
+        url: `/FamilyGroup/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: FamilyGroupSearchCriteria) {
+    return request<FamilyGroupResultData>(
+      {
+        url: "/FamilyGroup/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindFamilyUserBySearchCriteria(data: FamilyGroupManagerUserSearchCriteria) {
+    return request<FamilyGroupResultData>(
+      {
+        url: "/FamilyGroup/FindFamilyUserBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FamilyFolderFavoriteBySearchCriteria(data: FamilyGroupManagerUserSearchCriteria) {
+    return request<FamilyGroupResultData>(
+      {
+        url: "/FamilyGroup/FamilyFolderFavoriteBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: FamilyGroupSearchCriteria) {
+    return download(
+      {
+        url: "/FamilyGroup/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "FamilyGroup",
+      },
+    );
+  };
+
+  async Insert(data: FamilyGroupData) {
+    return request<FamilyGroupData>(
+      {
+        url: "/FamilyGroup/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: FamilyGroupData) {
+    return request<FamilyGroupData>(
+      {
+        url: "/FamilyGroup/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/FamilyGroup/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertFamilyGroupManager(data: FamilyGroupManagerEntity) {
+    return request<any>(
+      {
+        url: "/FamilyGroup/InsertFamilyGroupManager",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertFamilyGroupPermission(data: FamilyGroupPermissionEntity[]) {
+    return request<any>(
+      {
+        url: "/FamilyGroup/InsertFamilyGroupPermission",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async UpdateFamilyGroupManager(data: FamilyGroupManagerEntity) {
+    return request<any>(
+      {
+        url: "/FamilyGroup/UpdateFamilyGroupManager",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteFamilyGroupManager(data: FamilyGroupManagerEntity) {
+    return request<any>(
+      {
+        url: "/FamilyGroup/DeleteFamilyGroupManager",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertFamilyFolderFavorite(data: string) {
+    return request<any>(
+      {
+        url: `/FamilyGroup/InsertFamilyFolderFavorite?folderName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteFamilyFolderFavorite(data: string) {
+    return request<any>(
+      {
+        url: `/FamilyGroup/DeleteFamilyFolderFavorite?folderName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteFamilyFolderFavorites(data: FamilyFolderFavoriteEntity[]) {
+    return request<any>(
+      {
+        url: "/FamilyGroup/DeleteFamilyFolderFavorites",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const familyGroupService = new FamilyGroupService();
+export default familyGroupService;

uniapp/youjiala/src/service/master/familyPersonService.ts

@@ -0,0 +1,90 @@
+import type { FamilyPersonData } from "@/data/auto/familyPersonData";
+import type { FamilyPersonEntity } from "@/data/auto/familyPersonEntity";
+import type { FamilyPersonResultData } from "@/data/auto/familyPersonResultData";
+import type { FamilyPersonSearchCriteria } from "@/data/auto/familyPersonSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class FamilyPersonService {
+  async FindAll() {
+    return request<FamilyPersonEntity[]>(
+      {
+        url: "/FamilyPerson/FindAll",
+        method: "post",
+      },
+    );
+  };
+
+  async FindByKey(data: string) {
+    return request<FamilyPersonData>(
+      {
+        url: `/FamilyPerson/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: FamilyPersonSearchCriteria) {
+    return request<FamilyPersonResultData>(
+      {
+        url: "/FamilyPerson/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: FamilyPersonSearchCriteria) {
+    return download(
+      {
+        url: "/FamilyPerson/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "FamilyPerson",
+      },
+    );
+  };
+
+  async Insert(data: FamilyPersonData) {
+    return request<FamilyPersonData>(
+      {
+        url: "/FamilyPerson/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: FamilyPersonData) {
+    return request<FamilyPersonData>(
+      {
+        url: "/FamilyPerson/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/FamilyPerson/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/FamilyPerson/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const familyPersonService = new FamilyPersonService();
+export default familyPersonService;

uniapp/youjiala/src/service/master/familyTreeService.ts

@@ -0,0 +1,119 @@
+import type { FamilyTreeData } from "@/data/auto/familyTreeData";
+import type { FamilyTreeResultData } from "@/data/auto/familyTreeResultData";
+import type { FamilyTreeSearchCriteria } from "@/data/auto/familyTreeSearchCriteria";
+import { request } from "@/utils/request";
+
+class FamilyTreeService {
+  async FindAllByTreeId(data: string) {
+    return request<FamilyTreeData>(
+      {
+        url: `/FamilyTree/FindAllByTreeId?treeId=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByKey(data: string) {
+    return request<FamilyTreeData>(
+      {
+        url: `/FamilyTree/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByCurrentPerson(data: any) {
+    return request<FamilyTreeData>(
+      {
+        url: "/FamilyTree/FindByCurrentPerson",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: FamilyTreeSearchCriteria) {
+    return request<FamilyTreeResultData>(
+      {
+        url: "/FamilyTree/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Insert(data: FamilyTreeData) {
+    return request<FamilyTreeData>(
+      {
+        url: "/FamilyTree/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async RequestFamilyTreePermission(data: any) {
+    return request<any>(
+      {
+        url: "/FamilyTree/RequestFamilyTreePermission",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async ApproveFamilyTreePermission(data: any) {
+    return request<any>(
+      {
+        url: "/FamilyTree/ApproveFamilyTreePermission",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async RejectFamilyTreePermission(data: any) {
+    return request<any>(
+      {
+        url: "/FamilyTree/RejectFamilyTreePermission",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: FamilyTreeData) {
+    return request<FamilyTreeData>(
+      {
+        url: "/FamilyTree/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/FamilyTree/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/FamilyTree/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const familyTreeService = new FamilyTreeService();
+export default familyTreeService;

uniapp/youjiala/src/service/master/fileTypePolicyService.ts

@@ -0,0 +1,17 @@
+import type { SelectOption } from "@/data/auto/selectOption";
+import { request } from "@/utils/request";
+
+class FileTypePolicyService {
+  async FindSelectOption(data: any) {
+    return request<SelectOption[]>(
+      {
+        url: `/FileTypePolicy/FindSelectOption?blank=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const fileTypePolicyService = new FileTypePolicyService();
+export default fileTypePolicyService;

uniapp/youjiala/src/service/master/publishAudioService.ts

@@ -0,0 +1,90 @@
+import type { PublishAudioData } from "@/data/auto/publishAudioData";
+import type { PublishAudioResultData } from "@/data/auto/publishAudioResultData";
+import type { PublishAudioSearchCriteria } from "@/data/auto/publishAudioSearchCriteria";
+import type { PublishData } from "@/data/auto/publishData";
+import { download, request } from "@/utils/request";
+
+class PublishAudioService {
+  async FindByKey(data: string) {
+    return request<PublishAudioData>(
+      {
+        url: `/PublishAudio/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: PublishAudioSearchCriteria) {
+    return request<PublishAudioResultData>(
+      {
+        url: "/PublishAudio/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindPublishAudioDefault() {
+    return request<PublishAudioData>(
+      {
+        url: "/PublishAudio/FindPublishAudioDefault",
+        method: "post",
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: PublishAudioSearchCriteria) {
+    return download(
+      {
+        url: "/PublishAudio/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "PublishAudio",
+      },
+    );
+  };
+
+  async Insert(data: PublishAudioData) {
+    return request<PublishAudioData>(
+      {
+        url: "/PublishAudio/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: PublishAudioData) {
+    return request<PublishAudioData>(
+      {
+        url: "/PublishAudio/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/PublishAudio/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertPublishAudioDetail(data: PublishData) {
+    return request<any>(
+      {
+        url: "/PublishAudio/InsertPublishAudioDetail",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const publishAudioService = new PublishAudioService();
+export default publishAudioService;

uniapp/youjiala/src/service/master/publishPhotoService.ts

@@ -0,0 +1,111 @@
+import type { PublishData } from "@/data/auto/publishData";
+import type { PublishPhotoData } from "@/data/auto/publishPhotoData";
+import type { PublishPhotoDetailDisplayData } from "@/data/auto/publishPhotoDetailDisplayData";
+import type { PublishPhotoResultData } from "@/data/auto/publishPhotoResultData";
+import type { PublishPhotoSearchCriteria } from "@/data/auto/publishPhotoSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class PublishPhotoService {
+  async FindByKey(data: string) {
+    return request<PublishPhotoData>(
+      {
+        url: `/PublishPhoto/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: PublishPhotoSearchCriteria) {
+    return request<PublishPhotoResultData>(
+      {
+        url: "/PublishPhoto/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: PublishPhotoSearchCriteria) {
+    return download(
+      {
+        url: "/PublishPhoto/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "PublishPhoto",
+      },
+    );
+  };
+
+  async Insert(data: PublishPhotoData) {
+    return request<PublishPhotoData>(
+      {
+        url: "/PublishPhoto/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: PublishPhotoData) {
+    return request<PublishPhotoData>(
+      {
+        url: "/PublishPhoto/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/PublishPhoto/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindPublishPhotoDetailByPublishName(data: string) {
+    return request<PublishPhotoDetailDisplayData[]>(
+      {
+        url: `/PublishPhoto/FindPublishPhotoDetailByPublishName?publishName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindPublishPhotoDetail() {
+    return request<PublishPhotoDetailDisplayData[]>(
+      {
+        url: "/PublishPhoto/FindPublishPhotoDetail",
+        method: "post",
+      },
+    );
+  };
+
+  async InsertPublishPhotoDetail(data: PublishData) {
+    return request<any>(
+      {
+        url: "/PublishPhoto/InsertPublishPhotoDetail",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertPublishPhotoDetailByFamilyGroup(data: PublishData) {
+    return request<any>(
+      {
+        url: "/PublishPhoto/InsertPublishPhotoDetailByFamilyGroup",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const publishPhotoService = new PublishPhotoService();
+export default publishPhotoService;

uniapp/youjiala/src/service/master/publishVideoService.ts

@@ -0,0 +1,90 @@
+import type { PublishData } from "@/data/auto/publishData";
+import type { PublishVideoData } from "@/data/auto/publishVideoData";
+import type { PublishVideoResultData } from "@/data/auto/publishVideoResultData";
+import type { PublishVideoSearchCriteria } from "@/data/auto/publishVideoSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class PublishVideoService {
+  async FindByKey(data: string) {
+    return request<PublishVideoData>(
+      {
+        url: `/PublishVideo/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: PublishVideoSearchCriteria) {
+    return request<PublishVideoResultData>(
+      {
+        url: "/PublishVideo/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindPublishVideoDefault() {
+    return request<PublishVideoData>(
+      {
+        url: "/PublishVideo/FindPublishVideoDefault",
+        method: "post",
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: PublishVideoSearchCriteria) {
+    return download(
+      {
+        url: "/PublishVideo/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "PublishVideo",
+      },
+    );
+  };
+
+  async Insert(data: PublishVideoData) {
+    return request<PublishVideoData>(
+      {
+        url: "/PublishVideo/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: PublishVideoData) {
+    return request<PublishVideoData>(
+      {
+        url: "/PublishVideo/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/PublishVideo/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async InsertPublishVideoDetail(data: PublishData) {
+    return request<any>(
+      {
+        url: "/PublishVideo/InsertPublishVideoDetail",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const publishVideoService = new PublishVideoService();
+export default publishVideoService;

uniapp/youjiala/src/service/security/authService.ts

@@ -0,0 +1,141 @@
+import type { BiometricLoginChallengeDto } from "@/data/auto/biometricLoginChallengeDto";
+import type { BiometricRegistrationResultDto } from "@/data/auto/biometricRegistrationResultDto";
+import type { FinishBiometricLoginData } from "@/data/auto/finishBiometricLoginData";
+import type { FinishBiometricRegistrationData } from "@/data/auto/finishBiometricRegistrationData";
+import type { JwtInfo } from "@/data/auto/jwtInfo";
+import type { LoginData } from "@/data/auto/loginData";
+import type { LoginProfile } from "@/data/auto/loginProfile";
+import type { RegisterData } from "@/data/auto/registerData";
+import { request } from "@/utils/request";
+
+class AuthService {
+  async Login(data: LoginData) {
+    return request<LoginProfile>(
+      {
+        url: "/Auth/Login",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async LoginAgent(data: LoginData) {
+    return request<LoginProfile>(
+      {
+        url: "/Auth/LoginAgent",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Register(data: RegisterData) {
+    return request<string>(
+      {
+        url: "/Auth/Register",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async AmendPassword(data: LoginData) {
+    return request<LoginProfile>(
+      {
+        url: "/Auth/AmendPassword",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async GetRsaPublicKey() {
+    return request<string>(
+      {
+        url: "/Auth/GetRsaPublicKey",
+        method: "get",
+      },
+    );
+  };
+
+  async RefreshToken(data: JwtInfo) {
+    return request<JwtInfo>(
+      {
+        url: "/Auth/RefreshToken",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Logout() {
+    return request<any>(
+      {
+        url: "/Auth/Logout",
+        method: "post",
+      },
+    );
+  };
+
+  async ConfirmPassword(data: string) {
+    return request<any>(
+      {
+        url: `/Auth/ConfirmPassword?password=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async BeginBiometricRegistration(data: string) {
+    return request<string>(
+      {
+        url: `/Auth/BeginBiometricRegistration?deviceName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FinishBiometricRegistration(data: FinishBiometricRegistrationData) {
+    return request<BiometricRegistrationResultDto>(
+      {
+        url: "/Auth/FinishBiometricRegistration",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async BeginBiometricLogin(data: string) {
+    return request<BiometricLoginChallengeDto>(
+      {
+        url: `/Auth/BeginBiometricLogin?username=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FinishBiometricLogin(data: FinishBiometricLoginData) {
+    return request<LoginProfile>(
+      {
+        url: "/Auth/FinishBiometricLogin",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async RemoveBiometric() {
+    return request<any>(
+      {
+        url: "/Auth/RemoveBiometric",
+        method: "post",
+      },
+    );
+  };
+}
+
+const authService = new AuthService();
+export default authService;

uniapp/youjiala/src/service/security/localeService.ts

@@ -0,0 +1,100 @@
+import type { LocaleData } from "@/data/auto/localeData";
+import type { LocaleEntity } from "@/data/auto/localeEntity";
+import type { LocaleEntityKey } from "@/data/auto/localeEntityKey";
+import type { LocaleResultData } from "@/data/auto/localeResultData";
+import type { LocaleSearchCriteria } from "@/data/auto/localeSearchCriteria";
+import type { SelectOption } from "@/data/auto/selectOption";
+import { request } from "@/utils/request";
+
+class LocaleService {
+  async FindAll() {
+    return request<LocaleEntity[]>(
+      {
+        url: "/Locale/FindAll",
+        method: "get",
+      },
+    );
+  };
+
+  async FindSelectOption(data: any) {
+    return request<SelectOption[]>(
+      {
+        url: "/Locale/FindSelectOption",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: LocaleSearchCriteria) {
+    return request<LocaleResultData>(
+      {
+        url: "/Locale/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByKey(data: LocaleEntityKey) {
+    return request<LocaleEntity>(
+      {
+        url: "/Locale/FindByKey",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Insert(data: LocaleEntity) {
+    return request<LocaleEntity>(
+      {
+        url: "/Locale/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: LocaleEntity) {
+    return request<LocaleEntity>(
+      {
+        url: "/Locale/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async UpdateLocaleData(data: LocaleData) {
+    return request<any>(
+      {
+        url: "/Locale/UpdateLocaleData",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: LocaleEntityKey) {
+    return request<any>(
+      {
+        url: "/Locale/Delete",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Copy() {
+    return request<any>(
+      {
+        url: "/Locale/Copy",
+        method: "get",
+      },
+    );
+  };
+}
+
+const localeService = new LocaleService();
+export default localeService;

uniapp/youjiala/src/service/security/securityActorService.ts

@@ -0,0 +1,99 @@
+import type { SecurityActorData } from "@/data/auto/securityActorData";
+import type { SecurityActorEntity } from "@/data/auto/securityActorEntity";
+import type { SecurityActorResultData } from "@/data/auto/securityActorResultData";
+import type { SecurityActorSearchCriteria } from "@/data/auto/securityActorSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityActorService {
+  async FindByKey(data: string) {
+    return request<SecurityActorData>(
+      {
+        url: `/SecurityActor/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindAll() {
+    return request<SecurityActorEntity[]>(
+      {
+        url: "/SecurityActor/FindAll",
+        method: "post",
+      },
+    );
+  };
+
+  async FindAllByNoPermission() {
+    return request<SecurityActorEntity[]>(
+      {
+        url: "/SecurityActor/FindAllByNoPermission",
+        method: "post",
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityActorSearchCriteria) {
+    return request<SecurityActorResultData>(
+      {
+        url: "/SecurityActor/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityActorSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityActor/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityActor",
+      },
+    );
+  };
+
+  async Insert(data: SecurityActorData) {
+    return request<SecurityActorData>(
+      {
+        url: "/SecurityActor/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityActorData) {
+    return request<SecurityActorData>(
+      {
+        url: "/SecurityActor/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityActor/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/SecurityActor/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityActorService = new SecurityActorService();
+export default securityActorService;

uniapp/youjiala/src/service/security/securityFunctionService.ts

@@ -0,0 +1,101 @@
+import type { SecurityFunctionData } from "@/data/auto/securityFunctionData";
+import type { SecurityFunctionDisplayData } from "@/data/auto/securityFunctionDisplayData";
+import type { SecurityFunctionEntity } from "@/data/auto/securityFunctionEntity";
+import type { SecurityFunctionResultData } from "@/data/auto/securityFunctionResultData";
+import type { SecurityFunctionSearchCriteria } from "@/data/auto/securityFunctionSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityFunctionService {
+  async FindByKey(data: string) {
+    return request<SecurityFunctionData>(
+      {
+        url: `/SecurityFunction/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityFunctionSearchCriteria) {
+    return request<SecurityFunctionResultData>(
+      {
+        url: "/SecurityFunction/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityFunctionSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityFunction/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityFunction",
+      },
+    );
+  };
+
+  async Insert(data: SecurityFunctionData) {
+    return request<SecurityFunctionData>(
+      {
+        url: "/SecurityFunction/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityFunctionData) {
+    return request<SecurityFunctionData>(
+      {
+        url: "/SecurityFunction/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityFunction/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/SecurityFunction/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByFunctionName(data: string) {
+    return request<SecurityFunctionEntity>(
+      {
+        url: `/SecurityFunction/FindByFunctionName?functionName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindMenus() {
+    return request<SecurityFunctionDisplayData[]>(
+      {
+        url: "/SecurityFunction/FindMenus",
+        method: "post",
+      },
+    );
+  };
+}
+
+const securityFunctionService = new SecurityFunctionService();
+export default securityFunctionService;

uniapp/youjiala/src/service/security/securityGeneratorNumberService.ts

@@ -0,0 +1,70 @@
+import type { SecurityGeneratorNumberEntity } from "@/data/auto/securityGeneratorNumberEntity";
+import type { SecurityGeneratorNumberResultData } from "@/data/auto/securityGeneratorNumberResultData";
+import type { SecurityGeneratorNumberSearchCriteria } from "@/data/auto/securityGeneratorNumberSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityGeneratorNumberService {
+  async FindByKey(data: number) {
+    return request<SecurityGeneratorNumberEntity>(
+      {
+        url: `/SecurityGeneratorNumber/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityGeneratorNumberSearchCriteria) {
+    return request<SecurityGeneratorNumberResultData>(
+      {
+        url: "/SecurityGeneratorNumber/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityGeneratorNumberSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityGeneratorNumber/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityGeneratorNumber",
+      },
+    );
+  };
+
+  async Insert(data: SecurityGeneratorNumberEntity) {
+    return request<SecurityGeneratorNumberEntity>(
+      {
+        url: "/SecurityGeneratorNumber/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityGeneratorNumberEntity) {
+    return request<SecurityGeneratorNumberEntity>(
+      {
+        url: "/SecurityGeneratorNumber/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: number) {
+    return request<any>(
+      {
+        url: `/SecurityGeneratorNumber/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityGeneratorNumberService = new SecurityGeneratorNumberService();
+export default securityGeneratorNumberService;

uniapp/youjiala/src/service/security/securityGroupService.ts

@@ -0,0 +1,90 @@
+import type { SecurityGroupData } from "@/data/auto/securityGroupData";
+import type { SecurityGroupEntity } from "@/data/auto/securityGroupEntity";
+import type { SecurityGroupResultData } from "@/data/auto/securityGroupResultData";
+import type { SecurityGroupSearchCriteria } from "@/data/auto/securityGroupSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityGroupService {
+  async FindByKey(data: string) {
+    return request<SecurityGroupData>(
+      {
+        url: `/SecurityGroup/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindAll() {
+    return request<SecurityGroupEntity[]>(
+      {
+        url: "/SecurityGroup/FindAll",
+        method: "post",
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityGroupSearchCriteria) {
+    return request<SecurityGroupResultData>(
+      {
+        url: "/SecurityGroup/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityGroupSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityGroup/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityGroup",
+      },
+    );
+  };
+
+  async Insert(data: SecurityGroupData) {
+    return request<SecurityGroupData>(
+      {
+        url: "/SecurityGroup/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityGroupData) {
+    return request<SecurityGroupData>(
+      {
+        url: "/SecurityGroup/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityGroup/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/SecurityGroup/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityGroupService = new SecurityGroupService();
+export default securityGroupService;

uniapp/youjiala/src/service/security/securityHelpFunctionService.ts

@@ -0,0 +1,149 @@
+import type { SecurityFunctionDisplayData } from "@/data/auto/securityFunctionDisplayData";
+import type { SecurityHelpFeatureData } from "@/data/auto/securityHelpFeatureData";
+import type { SecurityHelpFunctionData } from "@/data/auto/securityHelpFunctionData";
+import type { SecurityHelpFunctionResultData } from "@/data/auto/securityHelpFunctionResultData";
+import type { SecurityHelpFunctionSearchCriteria } from "@/data/auto/securityHelpFunctionSearchCriteria";
+import { request } from "@/utils/request";
+
+class SecurityHelpFunctionService {
+  async FindByKey(data: string) {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: `/SecurityHelpFunction/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindAll() {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: "/SecurityHelpFunction/FindAll",
+        method: "post",
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityHelpFunctionSearchCriteria) {
+    return request<SecurityHelpFunctionResultData>(
+      {
+        url: "/SecurityHelpFunction/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindFeatureBySearchCriteria(data: SecurityHelpFunctionSearchCriteria) {
+    return request<SecurityHelpFunctionResultData>(
+      {
+        url: "/SecurityHelpFunction/FindFeatureBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Insert(data: SecurityHelpFunctionData) {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: "/SecurityHelpFunction/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityHelpFunctionData) {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: "/SecurityHelpFunction/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityHelpFunction/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByFunctionName(data: string) {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: `/SecurityHelpFunction/FindByFunctionName?functionName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async SaveFunction(data: SecurityHelpFunctionData) {
+    return request<SecurityHelpFunctionData>(
+      {
+        url: "/SecurityHelpFunction/SaveFunction",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteByFunctionName(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityHelpFunction/DeleteByFunctionName?functionName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByGroupCode(data: string) {
+    return request<SecurityHelpFeatureData>(
+      {
+        url: `/SecurityHelpFunction/FindByGroupCode?groupCode=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async SaveFeatureGroup(data: SecurityHelpFeatureData) {
+    return request<SecurityHelpFeatureData>(
+      {
+        url: "/SecurityHelpFunction/SaveFeatureGroup",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async DeleteByGroupCode(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityHelpFunction/DeleteByGroupCode?groupCode=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindFunctionNameOptions() {
+    return request<SecurityFunctionDisplayData[]>(
+      {
+        url: "/SecurityHelpFunction/FindFunctionNameOptions",
+        method: "post",
+      },
+    );
+  };
+}
+
+const securityHelpFunctionService = new SecurityHelpFunctionService();
+export default securityHelpFunctionService;

uniapp/youjiala/src/service/security/securityLockService.ts

@@ -0,0 +1,98 @@
+import type { SecurityLockEntity } from "@/data/auto/securityLockEntity";
+import type { SecurityLockEntityKey } from "@/data/auto/securityLockEntityKey";
+import { request } from "@/utils/request";
+
+class SecurityLockService {
+  async FindByKey(data: SecurityLockEntityKey) {
+    return request<SecurityLockEntity>(
+      {
+        url: "/SecurityLock/FindByKey",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Insert(data: SecurityLockEntity) {
+    return request<SecurityLockEntity>(
+      {
+        url: "/SecurityLock/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityLockEntity) {
+    return request<SecurityLockEntity>(
+      {
+        url: "/SecurityLock/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: SecurityLockEntityKey) {
+    return request<any>(
+      {
+        url: "/SecurityLock/Delete",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async IsLocked(data: any) {
+    return request<any>(
+      {
+        url: "/SecurityLock/IsLocked",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Lock(data: any) {
+    return request<any>(
+      {
+        url: "/SecurityLock/Lock",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async ForceLock(data: any) {
+    return request<any>(
+      {
+        url: "/SecurityLock/ForceLock",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async ConsumeLock(data: any) {
+    return request<any>(
+      {
+        url: "/SecurityLock/ConsumeLock",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async ClearLock(data: any) {
+    return request<any>(
+      {
+        url: "/SecurityLock/ClearLock",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityLockService = new SecurityLockService();
+export default securityLockService;

uniapp/youjiala/src/service/security/securityMasterService.ts

@@ -0,0 +1,90 @@
+import type { SecurityMasterEntity } from "@/data/auto/securityMasterEntity";
+import type { SecurityMasterEntityKey } from "@/data/auto/securityMasterEntityKey";
+import type { SecurityMasterResultData } from "@/data/auto/securityMasterResultData";
+import type { SecurityMasterSearchCriteria } from "@/data/auto/securityMasterSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityMasterService {
+  async FindByKey(data: SecurityMasterEntityKey) {
+    return request<SecurityMasterEntity>(
+      {
+        url: "/SecurityMaster/FindByKey",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindAll() {
+    return request<SecurityMasterEntity[]>(
+      {
+        url: "/SecurityMaster/FindAll",
+        method: "get",
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityMasterSearchCriteria) {
+    return request<SecurityMasterResultData>(
+      {
+        url: "/SecurityMaster/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityMasterSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityMaster/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityMaster",
+      },
+    );
+  };
+
+  async Insert(data: SecurityMasterEntity) {
+    return request<SecurityMasterEntity>(
+      {
+        url: "/SecurityMaster/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityMasterEntity) {
+    return request<SecurityMasterEntity>(
+      {
+        url: "/SecurityMaster/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: SecurityMasterEntityKey) {
+    return request<any>(
+      {
+        url: "/SecurityMaster/Delete",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: SecurityMasterEntity[]) {
+    return request<any>(
+      {
+        url: "/SecurityMaster/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityMasterService = new SecurityMasterService();
+export default securityMasterService;

uniapp/youjiala/src/service/security/securityPermissionService.ts

@@ -0,0 +1,100 @@
+import type { SecurityPermissionData } from "@/data/auto/securityPermissionData";
+import type { SecurityPermissionResultData } from "@/data/auto/securityPermissionResultData";
+import type { SecurityPermissionSearchCriteria } from "@/data/auto/securityPermissionSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityPermissionService {
+  async FindByKey(data: string) {
+    return request<SecurityPermissionData>(
+      {
+        url: `/SecurityPermission/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityPermissionSearchCriteria) {
+    return request<SecurityPermissionResultData>(
+      {
+        url: "/SecurityPermission/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDependentBySearchCriteria(data: SecurityPermissionSearchCriteria) {
+    return request<SecurityPermissionResultData>(
+      {
+        url: "/SecurityPermission/FindDependentBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindDependentsBySearchCriteria(data: SecurityPermissionSearchCriteria) {
+    return request<SecurityPermissionResultData>(
+      {
+        url: "/SecurityPermission/FindDependentsBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityPermissionSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityPermission/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityPermission",
+      },
+    );
+  };
+
+  async Insert(data: SecurityPermissionData) {
+    return request<SecurityPermissionData>(
+      {
+        url: "/SecurityPermission/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityPermissionData) {
+    return request<SecurityPermissionData>(
+      {
+        url: "/SecurityPermission/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityPermission/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/SecurityPermission/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityPermissionService = new SecurityPermissionService();
+export default securityPermissionService;

uniapp/youjiala/src/service/security/securityUserPreferenceService.ts

@@ -0,0 +1,70 @@
+import type { SecurityUserPreferenceEntity } from "@/data/auto/securityUserPreferenceEntity";
+import type { SecurityUserPreferenceEntityKey } from "@/data/auto/securityUserPreferenceEntityKey";
+import type { SecurityUserPreferenceSearchCriteria } from "@/data/auto/securityUserPreferenceSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityUserPreferenceService {
+  async FindByKey(data: SecurityUserPreferenceEntityKey) {
+    return request<SecurityUserPreferenceEntity>(
+      {
+        url: "/SecurityUserPreference/FindByKey",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityUserPreferenceSearchCriteria) {
+    return request<SecurityUserPreferenceEntity[]>(
+      {
+        url: "/SecurityUserPreference/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityUserPreferenceSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityUserPreference/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityUserPreference",
+      },
+    );
+  };
+
+  async Insert(data: SecurityUserPreferenceEntity) {
+    return request<SecurityUserPreferenceEntity>(
+      {
+        url: "/SecurityUserPreference/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityUserPreferenceEntity) {
+    return request<SecurityUserPreferenceEntity>(
+      {
+        url: "/SecurityUserPreference/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: SecurityUserPreferenceEntityKey) {
+    return request<any>(
+      {
+        url: "/SecurityUserPreference/Delete",
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityUserPreferenceService = new SecurityUserPreferenceService();
+export default securityUserPreferenceService;

uniapp/youjiala/src/service/security/securityUserService.ts

@@ -0,0 +1,120 @@
+import type { SecurityFunctionResultData } from "@/data/auto/securityFunctionResultData";
+import type { SecurityUserData } from "@/data/auto/securityUserData";
+import type { SecurityUserEntity } from "@/data/auto/securityUserEntity";
+import type { SecurityUserResultData } from "@/data/auto/securityUserResultData";
+import type { SecurityUserSearchCriteria } from "@/data/auto/securityUserSearchCriteria";
+import { download, request } from "@/utils/request";
+
+class SecurityUserService {
+  async FindByStaffId(data: string) {
+    return request<SecurityUserEntity>(
+      {
+        url: `/SecurityUser/FindByStaffId?staffid=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindByKey(data: string) {
+    return request<SecurityUserData>(
+      {
+        url: `/SecurityUser/FindByKey?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindAll() {
+    return request<SecurityUserEntity[]>(
+      {
+        url: "/SecurityUser/FindAll",
+        method: "post",
+      },
+    );
+  };
+
+  async FindBySearchCriteria(data: SecurityUserSearchCriteria) {
+    return request<SecurityUserResultData>(
+      {
+        url: "/SecurityUser/FindBySearchCriteria",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async PrintBySearchCriteria(data: SecurityUserSearchCriteria) {
+    return download(
+      {
+        url: "/SecurityUser/PrintBySearchCriteria",
+        method: "post",
+        data,
+        filename: "SecurityUser",
+      },
+    );
+  };
+
+  async Insert(data: SecurityUserData) {
+    return request<SecurityUserData>(
+      {
+        url: "/SecurityUser/Insert",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Update(data: SecurityUserData) {
+    return request<SecurityUserData>(
+      {
+        url: "/SecurityUser/Update",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Delete(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityUser/Delete?key=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async Deletes(data: string[]) {
+    return request<any>(
+      {
+        url: "/SecurityUser/Deletes",
+        method: "post",
+        data,
+      },
+    );
+  };
+
+  async FindMenuByUsername() {
+    return request<SecurityFunctionResultData>(
+      {
+        url: "/SecurityUser/FindMenuByUsername",
+        method: "post",
+      },
+    );
+  };
+
+  async UpdateLocalName(data: string) {
+    return request<any>(
+      {
+        url: `/SecurityUser/UpdateLocalName?localName=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const securityUserService = new SecurityUserService();
+export default securityUserService;

uniapp/youjiala/src/service/security/yesNoPolicyService.ts

@@ -0,0 +1,17 @@
+import type { SelectOption } from "@/data/auto/selectOption";
+import { request } from "@/utils/request";
+
+class YesNoPolicyService {
+  async FindSelectOption(data: any) {
+    return request<SelectOption[]>(
+      {
+        url: `/YesNoPolicy/FindSelectOption?blank=${data}`,
+        method: "post",
+        data,
+      },
+    );
+  };
+}
+
+const yesNoPolicyService = new YesNoPolicyService();
+export default yesNoPolicyService;