init

frontend/src/composables/auth/useUserAuth.ts

@@ -0,0 +1,71 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import useAuthStore from "../store/useAuthStore";
+import useUserStore from "../store/useUserStore";
+
+const useUserAuth = () => {
+	const isAuthenticated = ref(false);
+	const authStore = useAuthStore();
+	const userStore = useUserStore();
+
+	const queryCurrentUser = async () => {
+		const { data } = await client.GET("/iam/me");
+		return data;
+	};
+
+	const refreshCurrentUser = async () => {
+		const currentUser = await queryCurrentUser();
+		if (currentUser) {
+			userStore.set(currentUser);
+			isAuthenticated.value = true;
+		}
+	};
+
+	const upsertCurrentUser = async ({
+		username,
+		password,
+		enable,
+	}: {
+		username: string;
+		password?: string | null;
+		enable: boolean;
+	}) => {
+		await client.POST("/iam/me", {
+			body: {
+				username,
+				password: password ?? undefined,
+				enable,
+			},
+		});
+		await refreshCurrentUser();
+	};
+
+	const signIn = async (username: string, password: string) => {
+		const signInResponse = await client.POST("/auth/sign-in", {
+			body: {
+				username,
+				password,
+			},
+		});
+		authStore.set(
+			signInResponse.response.headers.get("authorization") ?? undefined,
+		);
+		await refreshCurrentUser();
+	};
+
+	const signOut = () => {
+		authStore.remove();
+		isAuthenticated.value = false;
+		userStore.remove();
+	};
+
+	return {
+		isAuthenticated,
+		signIn,
+		signOut,
+		queryCurrentUser,
+		upsertCurrentUser,
+	};
+};
+
+export default useUserAuth;

frontend/src/composables/department/useDepartmentBind.ts

@@ -0,0 +1,38 @@
+import client from "@/api/client";
+
+export function useDepartmentBind() {
+	const bindDepartment = async (userId: number, departmentIds: number[]) => {
+		try {
+			await client.POST("/iam/department/bind", {
+				body: {
+					userId,
+					departmentIds,
+				},
+			});
+			return true;
+		} catch (error) {
+			console.error("Error binding departments:", error);
+			return false;
+		}
+	};
+
+	const unbindDepartment = async (userId: number, departmentIds: number[]) => {
+		try {
+			await client.POST("/iam/department/unbind", {
+				body: {
+					userId,
+					departmentIds,
+				},
+			});
+			return true;
+		} catch (error) {
+			console.error("Error unbinding departments:", error);
+			return false;
+		}
+	};
+
+	return {
+		bindDepartment,
+		unbindDepartment,
+	};
+}

frontend/src/composables/department/useDepartmentDelete.ts

@@ -0,0 +1,18 @@
+import client from "@/api/client";
+
+export const useDepartmentDelete = () => {
+	const deleteDepartment = async (departmentId: number) => {
+		await client.DELETE("/department", {
+			params: {
+				query: {
+					id: departmentId,
+				},
+			},
+		});
+	};
+	return {
+		deleteDepartment,
+	};
+};
+
+export default useDepartmentDelete;

frontend/src/composables/department/useDepartmentQuery.ts

@@ -0,0 +1,45 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+
+export const useDepartmentQuery = () => {
+	const total = ref<number>(0);
+	const departments = ref<components["schemas"]["DepartmentRespDto"][]>([]);
+	const allDepartments = ref<components["schemas"]["Department"][]>([]);
+
+	const fetchAllDepartments = async () => {
+		const { data } = await client.GET("/department/query");
+		allDepartments.value = data ?? [];
+	};
+	const fetchDepartmentWith = async (
+		param: {
+			name?: string;
+			enable?: boolean;
+			userId?: number;
+			bindState?: "ALL" | "BIND" | "UNBIND";
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/department/page-query", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page,
+						size,
+					},
+					departmentQueryDto: param,
+				},
+			},
+		});
+		total.value = !data || !data.total ? 0 : data.total;
+		departments.value = data?.data ?? [];
+	};
+	return {
+		total,
+		departments,
+		allDepartments,
+		fetchDepartmentWith,
+		fetchAllDepartments,
+	};
+};

frontend/src/composables/department/useDepartmentUpsert.ts

@@ -0,0 +1,18 @@
+import client from "../../api/client";
+import type { DepartmentUpsertModel } from "../../types/department";
+
+export const useDepartmentUpsert = () => {
+	const upsertDepartment = async (department: DepartmentUpsertModel) => {
+		await client.POST("/department", {
+			body: {
+				id: department.id,
+				name: department.name,
+				parentId: department.parentId ?? undefined,
+			},
+		});
+	};
+
+	return {
+		upsertDepartment,
+	};
+};

frontend/src/composables/job/useJobControl.ts

@@ -0,0 +1,38 @@
+import client from "@/api/client";
+
+export const useJobControl = () => {
+	const resumeTrigger = async (trigger: {
+		triggerName: string;
+		triggerGroup: string;
+		jobQueryParam?: {
+			name?: string;
+		};
+	}) => {
+		await client.POST("/scheduler/trigger/resume", {
+			body: {
+				name: trigger.triggerName,
+				group: trigger.triggerGroup,
+			},
+		});
+	};
+
+	const pauseTrigger = async (trigger: {
+		triggerName: string;
+		triggerGroup: string;
+		jobQueryParam?: {
+			name?: string;
+		};
+	}) => {
+		await client.POST("/scheduler/trigger/pause", {
+			body: {
+				name: trigger.triggerName,
+				group: trigger.triggerGroup,
+			},
+		});
+	};
+
+	return {
+		pauseTrigger,
+		resumeTrigger,
+	};
+};

frontend/src/composables/job/useJobQuery.ts

@@ -0,0 +1,36 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+export const useJobsPaginationQuery = () => {
+	const total = ref<number>(0);
+	const jobs = ref<components["schemas"]["JobTriggerDto"][]>();
+	const fetchJobsWith = async (
+		queryParam?: {
+			name?: string;
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/scheduler/page-query", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page: page,
+						size: size,
+					},
+					queryDto: {
+						name: queryParam?.name,
+					},
+				},
+			},
+		});
+		total.value = !data || !data.total ? 0 : data.total;
+		jobs.value = data?.data ?? [];
+	};
+
+	return {
+		total,
+		jobs,
+		fetchJobsWith,
+	};
+};

frontend/src/composables/job/useJobUpdate.ts

@@ -0,0 +1,24 @@
+import client from "@/api/client";
+
+export const useJobUpdate = () => {
+	const updateCron = async (trigger: {
+		triggerName: string;
+		triggerGroup: string;
+		cron: string;
+	}) => {
+		await client.PUT("/scheduler/job/update", {
+			params: {
+				query: {
+					cron: trigger.cron,
+				},
+			},
+			body: {
+				name: trigger.triggerName,
+				group: trigger.triggerGroup,
+			},
+		});
+	};
+	return {
+		updateCron,
+	};
+};

frontend/src/composables/page.ts

@@ -0,0 +1,67 @@
+import { computed, ref } from "vue";
+
+export interface PaginationState {
+	currentPage: number;
+	pageSize: number;
+	total: number;
+}
+
+export interface UsePaginationOptions {
+	initialPage?: number;
+	initialPageSize?: number;
+	initialTotal?: number;
+}
+
+export function usePagination(options: UsePaginationOptions = {}) {
+	const { initialPage = 1, initialPageSize = 10, initialTotal = 0 } = options;
+
+	const currentPage = ref(initialPage);
+	const pageSize = ref(initialPageSize);
+	const total = ref(initialTotal);
+
+	const totalPages = computed(() => Math.ceil(total.value / pageSize.value));
+
+	const pageNumbers = computed(() => {
+		const pages = [];
+		for (let i = 1; i <= totalPages.value; i++) {
+			pages.push(i);
+		}
+		return pages;
+	});
+
+	const displayRange = computed(() => {
+		const start =
+			total.value === 0 ? 0 : (currentPage.value - 1) * pageSize.value + 1;
+		const end =
+			total.value === 0
+				? 0
+				: Math.min(currentPage.value * pageSize.value, total.value);
+		return { start, end };
+	});
+
+	const isFirstPage = computed(
+		() => total.value === 0 || currentPage.value === 1,
+	);
+
+	const isLastPage = computed(
+		() => total.value === 0 || currentPage.value === totalPages.value,
+	);
+
+	const updatePaginationState = (state: Partial<PaginationState>) => {
+		if (state.currentPage !== undefined) currentPage.value = state.currentPage;
+		if (state.pageSize !== undefined) pageSize.value = state.pageSize;
+		if (state.total !== undefined) total.value = state.total;
+	};
+
+	return {
+		currentPage,
+		pageSize,
+		total,
+		totalPages,
+		pageNumbers,
+		displayRange,
+		isFirstPage,
+		isLastPage,
+		updatePaginationState,
+	};
+}

frontend/src/composables/permission/usePermissionBind.ts

@@ -0,0 +1,36 @@
+import client from "@/api/client";
+export const usePermissionBind = () => {
+	const bindPermission = async ({
+		roleId,
+		permissionIds,
+	}: {
+		roleId: number;
+		permissionIds: number[];
+	}) => {
+		await client.POST("/iam/permission/bind", {
+			body: {
+				roleId,
+				permissionIds,
+			},
+		});
+	};
+
+	const unbindPermission = async ({
+		roleId,
+		permissionIds,
+	}: {
+		roleId: number;
+		permissionIds: number[];
+	}) => {
+		await client.POST("/iam/permission/unbind", {
+			body: {
+				roleId,
+				permissionIds,
+			},
+		});
+	};
+	return {
+		bindPermission,
+		unbindPermission,
+	};
+};

frontend/src/composables/permission/usePermissionDelete.ts

@@ -0,0 +1,19 @@
+import client from "@/api/client";
+
+const usePermissionDelete = () => {
+	const deletePermission = async (id: number) => {
+		await client.DELETE("/iam/permission", {
+			params: {
+				query: {
+					permissionId: id,
+				},
+			},
+		});
+	};
+
+	return {
+		deletePermission,
+	};
+};
+
+export default usePermissionDelete;

frontend/src/composables/permission/usePermissionQuery.ts

@@ -0,0 +1,48 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+
+const usePermissionsQuery = () => {
+	const total = ref<number>(0);
+	const permissions = ref<components["schemas"]["PermissionRespDto"][]>([]);
+	const fetchPermissionsWith = async (
+		query: {
+			name?: string;
+			roleId?: number;
+			bindState?: "BIND" | "ALL" | "UNBIND";
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/iam/permissions", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page,
+						size,
+					},
+					permissionQueryDto: {
+						permissionName: query.name,
+						roleId: query.roleId,
+						bindState: query.bindState,
+					},
+				},
+			},
+		});
+
+		if (!data) {
+			throw new Error("获取权限数据失败");
+		}
+
+		total.value = data.total ?? 0;
+		permissions.value = data.data ?? [];
+	};
+
+	return {
+		total,
+		permissions,
+		fetchPermissionsWith,
+	};
+};
+
+export default usePermissionsQuery;

frontend/src/composables/permission/usePermissionUpsert.ts

@@ -0,0 +1,19 @@
+import client from "../../api/client";
+import type { PermissionUpsertModel } from "../../types/permission";
+
+const usePermissionUpsert = () => {
+	const upsertPermission = async (permission: PermissionUpsertModel) => {
+		await client.POST("/iam/permission", {
+			body: {
+				id: permission.id,
+				name: permission.name,
+				code: permission.code,
+			},
+		});
+	};
+
+	return {
+		upsertPermission,
+	};
+};
+export default usePermissionUpsert;

frontend/src/composables/position/usePositionBind.ts

@@ -0,0 +1,38 @@
+import client from "@/api/client";
+
+export function usePositionBind() {
+	const bindPosition = async (userId: number, positionIds: number[]) => {
+		try {
+			await client.POST("/iam/position/bind", {
+				body: {
+					userId,
+					positionIds,
+				},
+			});
+			return true;
+		} catch (error) {
+			console.error("Error binding positions:", error);
+			return false;
+		}
+	};
+
+	const unbindPosition = async (userId: number, positionIds: number[]) => {
+		try {
+			await client.POST("/iam/position/unbind", {
+				body: {
+					userId,
+					positionIds,
+				},
+			});
+			return true;
+		} catch (error) {
+			console.error("Error unbinding positions:", error);
+			return false;
+		}
+	};
+
+	return {
+		bindPosition,
+		unbindPosition,
+	};
+}

frontend/src/composables/position/usePositionDelete.ts

@@ -0,0 +1,18 @@
+import client from "@/api/client";
+
+export const usePositionDelete = () => {
+	const deletePosition = async (positionId: number) => {
+		await client.DELETE("/position", {
+			params: {
+				query: {
+					id: positionId,
+				},
+			},
+		});
+	};
+	return {
+		deletePosition,
+	};
+};
+
+export default usePositionDelete;

frontend/src/composables/position/usePositionQuery.ts

@@ -0,0 +1,45 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+
+export const usePositionQuery = () => {
+	const total = ref<number>(0);
+	const positions = ref<components["schemas"]["PositionRespDto"][]>([]);
+	const allPositions = ref<components["schemas"]["Position"][]>([]);
+
+	const fetchAllPositions = async () => {
+		const { data } = await client.GET("/position/query");
+		allPositions.value = data ?? [];
+	};
+	const fetchPositionWith = async (
+		param: {
+			name?: string;
+			enable?: boolean;
+			userId?: number;
+			bindState?: "ALL" | "BIND" | "UNBIND";
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/position/page-query", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page,
+						size,
+					},
+					positionQueryDto: param,
+				},
+			},
+		});
+		total.value = !data || !data.total ? 0 : data.total;
+		positions.value = data?.data ?? [];
+	};
+	return {
+		total,
+		positions,
+		allPositions,
+		fetchPositionWith,
+		fetchAllPositions,
+	};
+};

frontend/src/composables/position/usePositionUpsert.ts

@@ -0,0 +1,16 @@
+import client from "../../api/client";
+import type { components } from "../../api/types/schema";
+
+export const usePositionUpsert = () => {
+	const upsertPosition = async (
+		position: components["schemas"]["Position"],
+	) => {
+		await client.POST("/position", {
+			body: position,
+		});
+	};
+
+	return {
+		upsertPosition,
+	};
+};

frontend/src/composables/role/useRoleBind.ts

@@ -0,0 +1,28 @@
+import client from "@/api/client";
+
+export const useRoleBind = () => {
+	const bindRole = async ({
+		userId,
+		roleIds,
+	}: { userId: number; roleIds: number[] }) => {
+		await client.POST("/iam/role/bind", {
+			body: {
+				userId,
+				roleIds,
+			},
+		});
+	};
+
+	const unbindRole = async (userId: number, roleIds: number[]) => {
+		await client.POST("/iam/role/unbind", {
+			body: {
+				userId,
+				roleIds,
+			},
+		});
+	};
+	return {
+		bindRole,
+		unbindRole,
+	};
+};

frontend/src/composables/role/useRoleDelete.ts

@@ -0,0 +1,19 @@
+import client from "../../api/client";
+
+const useRoleDelete = () => {
+	const deleteRole = async (roleId: number) => {
+		await client.DELETE("/iam/role", {
+			params: {
+				query: {
+					roleId,
+				},
+			},
+		});
+	};
+
+	return {
+		deleteRole,
+	};
+};
+
+export default useRoleDelete;

frontend/src/composables/role/useRoleUpsert.ts

@@ -0,0 +1,17 @@
+import client from "../../api/client";
+
+export const useRoleUpsert = () => {
+	const upsertRole = async (role: {
+		id?: number;
+		name: string;
+		code: string;
+	}) => {
+		await client.POST("/iam/role", {
+			body: role,
+		});
+	};
+
+	return {
+		upsertRole,
+	};
+};

frontend/src/composables/role/useRolesQuery.ts

@@ -0,0 +1,61 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+
+export const useRolesQuery = () => {
+	const total = ref<number>(0);
+	const roles = ref<components["schemas"]["RoleDto"][]>();
+	const roleWithDetail = ref<components["schemas"]["RoleDto"]>();
+
+	const getRoleWithDetail = async (roleId: number) => {
+		const { data } = await client.GET("/iam/role", {
+			params: {
+				query: {
+					roleId,
+				},
+			},
+		});
+		roleWithDetail.value = data;
+	};
+
+	const fetchRolesWith = async (
+		param: {
+			name?: string;
+			userId?: number;
+			bindState?: "BIND" | "ALL" | "UNBIND";
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/iam/roles", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page,
+						size,
+					},
+					roleQueryDto: {
+						roleName: param.name,
+						userId: param.userId,
+						bindState: param.bindState,
+					},
+				},
+			},
+		});
+
+		if (!data) {
+			throw new Error("获取角色数据失败");
+		}
+
+		total.value = data.total ?? 0;
+		roles.value = data.data ?? [];
+	};
+
+	return {
+		total,
+		roles,
+		roleWithDetail,
+		getRoleWithDetail,
+		fetchRolesWith,
+	};
+};

frontend/src/composables/store/useAlertStore.ts

@@ -0,0 +1,57 @@
+import { StorageSerializers, useStorage } from "@vueuse/core";
+import { defineStore } from "pinia";
+import { computed } from "vue";
+import type { AlertProps } from "../../types/alert";
+
+const useAlertStore = defineStore("alertStore", () => {
+	const alertStorage = useStorage<AlertProps>(
+		"alert-storage",
+		{
+			content: undefined,
+			level: undefined,
+			isShow: undefined,
+			timer: undefined,
+		},
+		localStorage,
+		{
+			serializer: StorageSerializers.object,
+		},
+	);
+
+	const showAlert = ({
+		content: newContent,
+		level: newLevel,
+	}: { content: string; level: "info" | "success" | "warning" | "error" }) => {
+		clearTimeout(alertStorage.value.timer);
+		alertStorage.value = {
+			content: newContent,
+			level: newLevel,
+			isShow: true,
+			timer: setTimeout(() => {
+				alertStorage.value.isShow = false;
+			}, 3000),
+		};
+	};
+
+	const levelClassName = computed(() => {
+		if (!alertStorage.value.level) {
+			return;
+		}
+		return {
+			info: "text-blue-800 bg-blue-50 dark:bg-gray-800 dark:text-blue-400 ",
+			success:
+				"text-green-800  bg-green-50 dark:bg-gray-800 dark:text-green-400",
+			warning:
+				"text-yellow-800  bg-yellow-50 dark:bg-gray-800 dark:text-yellow-300",
+			error: "text-red-800  bg-red-50 dark:bg-gray-800 dark:text-red-400",
+		}[alertStorage.value.level];
+	});
+
+	return {
+		alertStorage,
+		showAlert,
+		levelClassName,
+	};
+});
+
+export default useAlertStore;

frontend/src/composables/store/useAuthStore.ts

@@ -0,0 +1,28 @@
+import { StorageSerializers, useStorage } from "@vueuse/core";
+import { defineStore } from "pinia";
+
+const useAuthStore = defineStore("authStore", () => {
+	const tokenStore = useStorage<string>("auth-storage", null, localStorage, {
+		serializer: StorageSerializers.object,
+	});
+
+	const set = (token?: string) => {
+		tokenStore.value = token;
+	};
+
+	const get = () => {
+		return tokenStore.value;
+	};
+
+	const remove = () => {
+		tokenStore.value = undefined;
+	};
+
+	return {
+		set,
+		get,
+		remove,
+	};
+});
+
+export default useAuthStore;

frontend/src/composables/store/useUserStore.ts

@@ -0,0 +1,44 @@
+import { StorageSerializers, useStorage } from "@vueuse/core";
+import { defineStore } from "pinia";
+import { computed } from "vue";
+import type { components } from "../../api/types/schema";
+const useUserStore = defineStore("userStore", () => {
+	const user = useStorage<components["schemas"]["UserRolePermissionDto"]>(
+		"user-storage",
+		null,
+		localStorage,
+		{
+			serializer: StorageSerializers.object,
+		},
+	);
+
+	const set: (
+		userRolePermission?: components["schemas"]["UserRolePermissionDto"],
+	) => void = (userRolePermission) => {
+		user.value = userRolePermission;
+	};
+
+	function remove() {
+		user.value = null;
+	}
+
+	const roleCodes = computed(() => {
+		return user.value?.roles?.flatMap((role) => role.code);
+	});
+
+	const permissionCodes = computed(() => {
+		return user.value?.roles?.flatMap((role) =>
+			role.permissions?.map((permission) => permission.code),
+		);
+	});
+
+	return {
+		user,
+		set,
+		remove,
+		roleCodes,
+		permissionCodes,
+	};
+});
+
+export default useUserStore;

frontend/src/composables/user/useUserDelete.ts

@@ -0,0 +1,19 @@
+import { ref } from "vue";
+import client from "../../api/client";
+
+const useUserDelete = () => {
+	const deleteUser = async (userId: number) => {
+		await client.DELETE("/iam/user", {
+			params: {
+				query: {
+					userId,
+				},
+			},
+		});
+	};
+	return {
+		deleteUser,
+	};
+};
+
+export default useUserDelete;

frontend/src/composables/user/useUserQuery.ts

@@ -0,0 +1,50 @@
+import client from "@/api/client";
+import { ref } from "vue";
+import type { components } from "../../api/types/schema";
+
+export const useUserQuery = () => {
+	const total = ref<number>(0);
+	const users = ref<components["schemas"]["UserRolePermissionDto"][]>([]);
+	const user = ref<components["schemas"]["UserRolePermissionDto"]>();
+
+	const getUserWithDetail = async (userId: number) => {
+		const { data } = await client.GET("/iam/user", {
+			params: {
+				query: {
+					userId: userId,
+				},
+			},
+		});
+		user.value = data;
+	};
+
+	const fetchUsersWith = async (
+		param: {
+			username?: string;
+		},
+		page = 1,
+		size = 10,
+	) => {
+		const { data } = await client.GET("/iam/users", {
+			params: {
+				query: {
+					pageRequestDto: {
+						page,
+						size,
+					},
+					userQueryDto: param,
+				},
+			},
+		});
+		total.value = !data || !data.total ? 0 : data.total;
+		users.value = data?.data ?? [];
+	};
+
+	return {
+		total,
+		users,
+		user,
+		fetchUsersWith,
+		getUserWithDetail,
+	};
+};

frontend/src/composables/user/useUserUpsert.ts

@@ -0,0 +1,20 @@
+import { ref } from "vue";
+import client from "../../api/client";
+import type { UserUpsertSubmitModel } from "../../types/user";
+
+export const useUserUpsert = () => {
+	const upsertUser = async (user: UserUpsertSubmitModel) => {
+		const { data } = await client.POST("/iam/user", {
+			body: {
+				id: user.id,
+				username: user.username,
+				password: user.password,
+				enable: user.enable,
+			},
+		});
+	};
+
+	return {
+		upsertUser,
+	};
+};