xieyinlu/zhilu-admin
1
0
Fork 0
mirror of https://github.com/ccmjga/zhilu-admin synced 2026-03-27 05:43:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Chuck1sn
2025-05-14 10:16:48 +08:00
commit 3cd59337e7
220 changed files with 23768 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
backend/src/main/java/com/zl/mjga/repository/DepartmentRepository.java Normal file
View File

@@ -0,0 +1,67 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.Tables.*;
import static org.jooq.impl.DSL.noCondition;
import static org.jooq.impl.DSL.noField;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.department.DepartmentQueryDto;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.mjga.tables.Department;
import org.jooq.generated.mjga.tables.daos.DepartmentDao;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class DepartmentRepository extends DepartmentDao {
@Autowired
public DepartmentRepository(Configuration configuration) {
super(configuration);
}
public Result<Record> pageFetchBy(
PageRequestDto pageRequestDto, DepartmentQueryDto departmentQueryDto) {
Department parent = DEPARTMENT.as("parent");
return ctx()
.select(
DEPARTMENT.asterisk(),
parent.NAME.as("parent_name"),
departmentQueryDto.getUserId() != null
? DSL.when(
DEPARTMENT.ID.in(selectUsersDepartment(departmentQueryDto.getUserId())),
true)
.otherwise(false)
.as("is_bound")
: noField(),
DSL.count().over().as("total_department").convertFrom(Long::valueOf))
.from(DEPARTMENT)
.leftJoin(parent)
.on(parent.ID.eq(DEPARTMENT.PARENT_ID))
.where(
switch (departmentQueryDto.getBindState()) {
case BIND -> DEPARTMENT.ID.in(selectUsersDepartment(departmentQueryDto.getUserId()));
case UNBIND ->
DEPARTMENT.ID.notIn(selectUsersDepartment(departmentQueryDto.getUserId()));
case ALL -> noCondition();
})
.and(
StringUtils.isNotEmpty(departmentQueryDto.getName())
? DEPARTMENT.NAME.like("%" + departmentQueryDto.getName() + "%")
: noCondition())
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
private SelectConditionStep<Record1<Long>> selectUsersDepartment(Long userId) {
return DSL.select(USER.department().ID)
.from(USER)
.innerJoin(USER.department())
.where(USER.ID.eq(userId));
}
}

81
backend/src/main/java/com/zl/mjga/repository/PermissionRepository.java Normal file
View File

@@ -0,0 +1,81 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.tables.Permission.PERMISSION;
import static org.jooq.generated.mjga.tables.Role.ROLE;
import static org.jooq.impl.DSL.*;
import static org.jooq.impl.DSL.noField;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.urp.PermissionQueryDto;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.mjga.tables.daos.PermissionDao;
import org.jooq.generated.mjga.tables.pojos.Permission;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class PermissionRepository extends PermissionDao {
@Autowired
public PermissionRepository(Configuration configuration) {
super(configuration);
}
public Result<Record> pageFetchBy(
PageRequestDto pageRequestDto, PermissionQueryDto permissionQueryDto) {
return ctx()
.select(
asterisk(),
permissionQueryDto.getRoleId() != null
? when(
PERMISSION.ID.in(selectRolesPermissionIds(permissionQueryDto.getRoleId())),
true)
.otherwise(false)
.as("is_bound")
: noField(),
DSL.count().over().as("total_permission"))
.from(PERMISSION)
.where(
switch (permissionQueryDto.getBindState()) {
case BIND ->
PERMISSION.ID.in(selectRolesPermissionIds(permissionQueryDto.getRoleId()));
case UNBIND ->
PERMISSION.ID.notIn(selectRolesPermissionIds(permissionQueryDto.getRoleId()));
case ALL -> noCondition();
})
.and(
permissionQueryDto.getPermissionId() == null
? noCondition()
: PERMISSION.ID.eq(permissionQueryDto.getPermissionId()))
.and(
StringUtils.isEmpty(permissionQueryDto.getPermissionName())
? noCondition()
: PERMISSION.NAME.like("%" + permissionQueryDto.getPermissionName() + "%"))
.and(
StringUtils.isEmpty(permissionQueryDto.getPermissionName())
? noCondition()
: PERMISSION.CODE.eq(permissionQueryDto.getPermissionCode()))
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
private SelectConditionStep<Record1<Long>> selectRolesPermissionIds(Long roleId) {
return DSL.select(ROLE.permission().ID)
.from(ROLE)
.leftJoin(ROLE.permission())
.where(ROLE.ID.eq(roleId));
}
public List<Permission> selectByPermissionIdIn(List<Long> permissionIdList) {
return ctx()
.selectFrom(PERMISSION)
.where(PERMISSION.ID.in(permissionIdList))
.fetchInto(Permission.class);
}
}

60
backend/src/main/java/com/zl/mjga/repository/PositionRepository.java Normal file
View File

@@ -0,0 +1,60 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.Tables.*;
import static org.jooq.impl.DSL.noCondition;
import static org.jooq.impl.DSL.noField;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.position.PositionQueryDto;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.mjga.tables.daos.PositionDao;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class PositionRepository extends PositionDao {
@Autowired
public PositionRepository(Configuration configuration) {
super(configuration);
}
public Result<Record> pageFetchBy(
PageRequestDto pageRequestDto, PositionQueryDto positionQueryDto) {
return ctx()
.select(
POSITION.asterisk(),
positionQueryDto.getUserId() != null
? DSL.when(POSITION.ID.in(selectUsersPosition(positionQueryDto.getUserId())), true)
.otherwise(false)
.as("is_bound")
: noField(),
DSL.count().over().as("total_position").convertFrom(Long::valueOf))
.from(POSITION)
.where(
switch (positionQueryDto.getBindState()) {
case BIND -> POSITION.ID.in(selectUsersPosition(positionQueryDto.getUserId()));
case UNBIND -> POSITION.ID.notIn(selectUsersPosition(positionQueryDto.getUserId()));
case ALL -> noCondition();
})
.and(
StringUtils.isNotEmpty(positionQueryDto.getName())
? POSITION.NAME.like("%" + positionQueryDto.getName() + "%")
: noCondition())
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
private SelectConditionStep<Record1<Long>> selectUsersPosition(Long userId) {
return ctx()
.select(USER.position().ID)
.from(USER)
.innerJoin(USER.position())
.where(USER.ID.eq(userId));
}
}

46
backend/src/main/java/com/zl/mjga/repository/QrtzJobRepository.java Normal file
View File

@@ -0,0 +1,46 @@
package com.zl.mjga.repository;
import static org.jooq.generated.public_.Tables.*;
import static org.jooq.impl.DSL.noCondition;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.scheduler.QueryDto;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.public_.tables.daos.QrtzJobDetailsDao;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class QrtzJobRepository extends QrtzJobDetailsDao {
@Autowired
public QrtzJobRepository(Configuration configuration) {
super(configuration);
}
public Result<Record> fetchPageWithJobAndTriggerBy(
PageRequestDto pageRequestDto, QueryDto queryDto) {
return ctx()
.select(
QRTZ_JOB_DETAILS.asterisk(),
QRTZ_JOB_DETAILS.qrtzTriggers().asterisk(),
QRTZ_JOB_DETAILS.qrtzTriggers().qrtzCronTriggers().asterisk(),
QRTZ_JOB_DETAILS.qrtzTriggers().qrtzSimpleTriggers().asterisk(),
DSL.count().over().as("total_job"))
.from(QRTZ_JOB_DETAILS)
.leftJoin(QRTZ_JOB_DETAILS.qrtzTriggers())
.leftJoin(QRTZ_JOB_DETAILS.qrtzTriggers().qrtzCronTriggers())
.leftJoin(QRTZ_JOB_DETAILS.qrtzTriggers().qrtzSimpleTriggers())
.where(
StringUtils.isNotEmpty(queryDto.name())
? QRTZ_JOB_DETAILS.SCHED_NAME.eq(queryDto.name())
: noCondition())
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
}

33
backend/src/main/java/com/zl/mjga/repository/RolePermissionMapRepository.java Normal file
View File

@@ -0,0 +1,33 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.tables.RolePermissionMap.ROLE_PERMISSION_MAP;
import java.util.List;
import org.jooq.Configuration;
import org.jooq.generated.mjga.tables.daos.RolePermissionMapDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
public class RolePermissionMapRepository extends RolePermissionMapDao {
@Autowired
public RolePermissionMapRepository(Configuration configuration) {
super(configuration);
}
@Transactional
public void deleteByRoleId(Long roleId) {
ctx().deleteFrom(ROLE_PERMISSION_MAP).where(ROLE_PERMISSION_MAP.ROLE_ID.eq(roleId)).execute();
}
@Transactional
public void deleteBy(Long roleId, List<Long> permissionIdList) {
ctx()
.deleteFrom(ROLE_PERMISSION_MAP)
.where(ROLE_PERMISSION_MAP.ROLE_ID.eq(roleId))
.and(ROLE_PERMISSION_MAP.PERMISSION_ID.in(permissionIdList))
.execute();
}
}

84
backend/src/main/java/com/zl/mjga/repository/RoleRepository.java Normal file
View File

@@ -0,0 +1,84 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.Tables.USER;
import static org.jooq.generated.mjga.tables.Role.ROLE;
import static org.jooq.impl.DSL.*;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.urp.RoleQueryDto;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.mjga.tables.daos.RoleDao;
import org.jooq.generated.mjga.tables.pojos.Permission;
import org.jooq.generated.mjga.tables.pojos.Role;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class RoleRepository extends RoleDao {
@Autowired
public RoleRepository(Configuration configuration) {
super(configuration);
}
public List<Role> selectByRoleCodeIn(List<String> roleCodeList) {
return ctx().selectFrom(ROLE).where(ROLE.CODE.in(roleCodeList)).fetchInto(Role.class);
}
public List<Role> selectByRoleIdIn(List<Long> roleIdList) {
return ctx().selectFrom(ROLE).where(ROLE.ID.in(roleIdList)).fetchInto(Role.class);
}
public Result<Record> pageFetchBy(PageRequestDto pageRequestDto, RoleQueryDto roleQueryDto) {
return ctx()
.select(
asterisk(),
roleQueryDto.getUserId() != null
? when(ROLE.ID.in(selectUsersRoleIds(roleQueryDto.getUserId())), true)
.otherwise(false)
.as("is_bound")
: noField(),
multiset(select(ROLE.permission().asterisk()).from(ROLE.permission()))
.convertFrom(r -> r.into(Permission.class))
.as("permissions"),
DSL.count(ROLE.ID).over().as("total_role"))
.from(ROLE)
.where(
switch (roleQueryDto.getBindState()) {
case BIND -> ROLE.ID.in(selectUsersRoleIds(roleQueryDto.getUserId()));
case UNBIND -> ROLE.ID.notIn(selectUsersRoleIds(roleQueryDto.getUserId()));
case ALL -> noCondition();
})
.and(
roleQueryDto.getRoleId() == null ? noCondition() : ROLE.ID.eq(roleQueryDto.getRoleId()))
.and(
StringUtils.isEmpty(roleQueryDto.getRoleName())
? noCondition()
: ROLE.NAME.like("%" + roleQueryDto.getRoleName() + "%"))
.and(
StringUtils.isEmpty(roleQueryDto.getRoleCode())
? noCondition()
: ROLE.CODE.eq(roleQueryDto.getRoleCode()))
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
private SelectConditionStep<Record1<Long>> selectUsersRoleIds(Long userId) {
return DSL.select(USER.role().ID).from(USER).innerJoin(USER.role()).where(USER.ID.eq(userId));
}
public Result<Record> fetchUniqueRoleWithPermission(Long roleId) {
return ctx()
.select(ROLE.asterisk(), ROLE.permission().asterisk())
.from(ROLE, ROLE.permission())
.where(ROLE.ID.eq(roleId))
.orderBy(ROLE.ID)
.fetch();
}
}

14
backend/src/main/java/com/zl/mjga/repository/UserDepartmentMapRepository.java Normal file
View File

@@ -0,0 +1,14 @@
package com.zl.mjga.repository;
import org.jooq.Configuration;
import org.jooq.generated.mjga.tables.daos.UserDepartmentMapDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class UserDepartmentMapRepository extends UserDepartmentMapDao {
@Autowired
public UserDepartmentMapRepository(Configuration configuration) {
super(configuration);
}
}

14
backend/src/main/java/com/zl/mjga/repository/UserPositionMapRepository.java Normal file
View File

@@ -0,0 +1,14 @@
package com.zl.mjga.repository;
import org.jooq.Configuration;
import org.jooq.generated.mjga.tables.daos.UserPositionMapDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class UserPositionMapRepository extends UserPositionMapDao {
@Autowired
public UserPositionMapRepository(Configuration configuration) {
super(configuration);
}
}

151
backend/src/main/java/com/zl/mjga/repository/UserRepository.java Normal file
View File

@@ -0,0 +1,151 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.Tables.*;
import static org.jooq.generated.mjga.tables.User.USER;
import static org.jooq.impl.DSL.*;
import com.zl.mjga.dto.PageRequestDto;
import com.zl.mjga.dto.urp.PermissionRespDto;
import com.zl.mjga.dto.urp.RoleDto;
import com.zl.mjga.dto.urp.UserQueryDto;
import com.zl.mjga.dto.urp.UserRolePermissionDto;
import org.apache.commons.lang3.StringUtils;
import org.jooq.*;
import org.jooq.Record;
import org.jooq.generated.mjga.tables.daos.*;
import org.jooq.generated.mjga.tables.pojos.User;
import org.jooq.impl.DSL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
public class UserRepository extends UserDao {
@Autowired
public UserRepository(Configuration configuration) {
super(configuration);
}
@Transactional
public void mergeWithoutNullFieldBy(User user) {
ctx()
.mergeInto(USER)
.using(
select(
value(user.getId()).as("id"),
value(user.getUsername()).as("username"),
value(user.getPassword()).as("password"),
value(user.getEnable()).as("enable"))
.asTable("newUser"))
.on(USER.ID.eq(DSL.field(DSL.name("newUser", "id"), Long.class)))
.whenMatchedThenUpdate()
.set(USER.USERNAME, DSL.field(DSL.name("newUser", "username"), String.class))
.set(
USER.PASSWORD,
StringUtils.isNotEmpty(user.getPassword())
? DSL.field(DSL.name("newUser", "password"), String.class)
: USER.PASSWORD)
.set(USER.ENABLE, DSL.field(DSL.name("newUser", "enable"), Boolean.class))
.whenNotMatchedThenInsert(USER.USERNAME, USER.PASSWORD, USER.ENABLE)
.values(
DSL.field(DSL.name("newUser", "username"), String.class),
DSL.field(DSL.name("newUser", "password"), String.class),
DSL.field(DSL.name("newUser", "enable"), Boolean.class))
.execute();
}
public Result<Record> pageFetchBy(PageRequestDto pageRequestDto, UserQueryDto userQueryDto) {
return ctx()
.select(asterisk(), DSL.count().over().as("total_user"))
.from(USER)
.where(
userQueryDto.getUsername() != null
? USER.USERNAME.like("%" + userQueryDto.getUsername() + "%")
: noCondition())
.orderBy(pageRequestDto.getSortFields())
.limit(pageRequestDto.getSize())
.offset(pageRequestDto.getOffset())
.fetch();
}
public UserRolePermissionDto fetchUniqueUserDtoWithNestedRolePermissionBy(Long userId) {
return ctx()
.select(
USER.asterisk(),
multiset(
select(
USER.role().asterisk(),
multiset(
select(USER.role().permission().asterisk())
.from(USER.role().permission()))
.convertFrom(
r -> r.map((record) -> record.into(PermissionRespDto.class)))
.as("permissions"))
.from(USER.role()))
.convertFrom(r -> r.map((record) -> record.into(RoleDto.class)))
.as("roles"))
.from(USER)
.where(USER.ID.eq(userId))
.fetchOneInto(UserRolePermissionDto.class);
}
// public UserRolePermissionDto fetchUniqueUserDtoWithNestedRolePermissionBy(Long roleId) {
// return ctx()
// .select(
// USER.asterisk(),
// multiset(
// select(
// ROLE.asterisk(),
// multiset(
// select(PERMISSION.asterisk())
// .from(ROLE_PERMISSION_MAP)
// .leftJoin(PERMISSION)
// .on(ROLE_PERMISSION_MAP.PERMISSION_ID.eq(PERMISSION.ID))
// .where(ROLE_PERMISSION_MAP.ROLE_ID.eq(ROLE.ID)))
// .convertFrom(
// r -> r.map((record) ->
// record.into(PermissionRespDto.class)))
// .as("permissions"))
// .from(USER_ROLE_MAP)
// .leftJoin(ROLE)
// .on(USER_ROLE_MAP.ROLE_ID.eq(ROLE.ID))
// .where(USER.ID.eq(USER_ROLE_MAP.USER_ID)))
// .convertFrom(r -> r.map((record) -> record.into(RoleDto.class)))
// .as("roles"))
// .from(USER)
// .where(USER.ID.eq(roleId))
// .fetchOneInto(UserRolePermissionDto.class);
// }
public Result<Record> fetchUniqueUserWithRolePermissionBy(Long userId) {
return ctx()
.select(USER.asterisk(), USER.role().asterisk(), USER.role().permission().asterisk())
.from(USER)
.leftJoin(USER.role())
.leftJoin(USER.role().permission())
.where(USER.ID.eq(userId))
.fetch();
}
// public Result<Record> fetchUniqueUserWithRolePermissionBy(Long roleId) {
// return ctx()
// .select()
// .from(USER)
// .leftJoin(USER_ROLE_MAP)
// .on(USER.ID.eq(USER_ROLE_MAP.USER_ID))
// .leftJoin(ROLE)
// .on(USER_ROLE_MAP.ROLE_ID.eq(ROLE.ID))
// .leftJoin(ROLE_PERMISSION_MAP)
// .on(ROLE.ID.eq(ROLE_PERMISSION_MAP.ROLE_ID))
// .leftJoin(PERMISSION)
// .on(ROLE_PERMISSION_MAP.PERMISSION_ID.eq(PERMISSION.ID))
// .where(USER.ID.eq(roleId))
// .fetch();
// }
@Transactional
public void deleteByUsername(String username) {
ctx().delete(USER).where(USER.USERNAME.eq(username)).execute();
}
}

33
backend/src/main/java/com/zl/mjga/repository/UserRoleMapRepository.java Normal file
View File

@@ -0,0 +1,33 @@
package com.zl.mjga.repository;
import static org.jooq.generated.mjga.tables.UserRoleMap.USER_ROLE_MAP;
import java.util.List;
import org.jooq.Configuration;
import org.jooq.generated.mjga.tables.daos.UserRoleMapDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
public class UserRoleMapRepository extends UserRoleMapDao {
@Autowired
public UserRoleMapRepository(Configuration configuration) {
super(configuration);
}
@Transactional
public void deleteByUserId(Long userId) {
ctx().deleteFrom(USER_ROLE_MAP).where(USER_ROLE_MAP.USER_ID.eq(userId)).execute();
}
@Transactional
public void deleteBy(Long userId, List<Long> roleIdList) {
ctx()
.deleteFrom(USER_ROLE_MAP)
.where(USER_ROLE_MAP.USER_ID.eq(userId))
.and(USER_ROLE_MAP.ROLE_ID.in(roleIdList))
.execute();
}
}