feat:Init project

src/main/java/com/sjmresorts/opsapp/MainApplication.java

@@ -0,0 +1,20 @@
+package com.sjmresorts.opsapp;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.ServletComponentScan;
+import org.springframework.data.web.config.EnableSpringDataWebSupport;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@SpringBootApplication
+@ServletComponentScan
+@EnableScheduling
+@EnableAsync
+@EnableSpringDataWebSupport(pageSerializationMode = EnableSpringDataWebSupport.PageSerializationMode.VIA_DTO)
+public class MainApplication{
+
+    public static void main( String[] args )  {
+    	SpringApplication.run(MainApplication.class, args);
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminDevicesController.java

@@ -0,0 +1,94 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.appsetting.AdminDevicesInfoPageRequest;
+import com.sjmresorts.opsapp.admin.dtos.appsetting.AdminDevicesInfoPageResponse;
+import com.sjmresorts.opsapp.admin.dtos.appsetting.AdminGetClientInfosResponse;
+import com.sjmresorts.opsapp.admin.dtos.appsetting.ClientInfosDto;
+import com.sjmresorts.opsapp.admin.services.AdminDevicesService;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@Tag(name = "CMS", description = "APIs for Admin Devices functions")
+@RestController
+@RequestMapping("/api/v1/admin")
+public class AdminDevicesController {
+
+	@Resource
+	private AdminDevicesService adminDeviceService;
+
+	@Operation(
+			summary = "Query CMS devices info page",
+			description = "API for query CMS devices info page"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS devices info page queried successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/devices/queryPage", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<AdminDevicesInfoPageResponse> getAppDevicesByPage(HttpServletRequest request,
+
+			@RequestBody(required = true) AdminDevicesInfoPageRequest pageRequest) {
+
+		DataTableResult<ClientInfosDto> devicesInfoList = adminDeviceService.getDevicesInfoListByPage(pageRequest);
+		AdminDevicesInfoPageResponse devicesInfoResponse = new AdminDevicesInfoPageResponse();
+		devicesInfoResponse.setCode("200");
+		devicesInfoResponse.setSuccess(true);
+		devicesInfoResponse.setMessage("Query Successfully");
+		devicesInfoResponse.setData(devicesInfoList);
+		return ResponseEntity.status(HttpStatus.OK).body(devicesInfoResponse);
+	}
+
+	@Operation(
+			summary = "Update CMS devices info",
+			description = "API for CMS devices info update"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS devices info updated successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/devices/update", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<BaseApiResponse> updateDevice(
+			HttpServletRequest request,
+			@RequestBody ClientInfosDto requestData) {
+		LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+		if (loginUserInfo == null) {
+			return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+		} else {
+			BaseApiResponse responseData = adminDeviceService.updateDevice(requestData, loginUserInfo);
+			return ResponseEntity.status(HttpStatus.OK).body(responseData);
+		}
+	}
+
+	@Operation(
+			summary = "Get one CMS devices info",
+			description = "API for get one CMS devices info"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS devices info got successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@GetMapping(value = "/devices/{deviceId}", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<AdminGetClientInfosResponse> getAppDeviceById(
+			@PathVariable(name = "deviceId", required = true) @NotNull Long deviceId) {
+
+		AdminGetClientInfosResponse responseData = new AdminGetClientInfosResponse();
+		ClientInfosDto deviceDto = adminDeviceService.queryDeviceById(deviceId);
+		responseData.setCode("200");
+		responseData.setSuccess(deviceDto != null);
+		responseData.setMessage(deviceDto != null ? "Query Successfully" : "Device does not exists");
+		responseData.setData(deviceDto);
+		return ResponseEntity.status(HttpStatus.OK).body(responseData);
+	}
+}

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminLoginController.java

@@ -0,0 +1,158 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.login.AdminLoginRequest;
+import com.sjmresorts.opsapp.admin.dtos.system.login.AdminLoginResponse;
+import com.sjmresorts.opsapp.admin.dtos.system.login.AdminLogoutResponse;
+import com.sjmresorts.opsapp.admin.dtos.system.login.CmsLoginInfo;
+import com.sjmresorts.opsapp.admin.services.AdminLoginService;
+import com.sjmresorts.opsapp.common.constants.AppConstants;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.dtos.RefreshTokenResponse;
+import com.sjmresorts.opsapp.authentication.models.UserToken;
+import com.sjmresorts.opsapp.authentication.services.UserTokenService;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Base64;
+
+@Tag(name = "CMS", description = "APIs for CMS administration")
+@RestController
+@RequestMapping("/api/v1/admin")
+@CrossOrigin(origins = "*")
+public class AdminLoginController {
+
+    @Resource
+    private AdminLoginService adminLoginService;
+    @Resource
+    private UserTokenService userTokenService;
+
+    @Operation(
+            summary = "CMS Login",
+            description = "API for CMS login with input ad account and password"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check ad login success")
+    })
+    @PostMapping(value="/login",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminLoginResponse> cmsLogin(
+            HttpServletRequest request,
+            @Parameter(description = "login request info", required = true) @Valid @RequestBody AdminLoginRequest requestData){
+        AdminLoginResponse result = new AdminLoginResponse();
+        String passwordVal = requestData.getPassword();
+        if(StringUtils.isNotBlank(passwordVal)) {
+            passwordVal =new String(Base64.getDecoder().decode(passwordVal.getBytes()));
+        }
+        int isCheckLogin;
+        try{
+            isCheckLogin = adminLoginService.checkLoginByLoginIdAndPassword(requestData.getUserCode(), passwordVal);
+        } catch (Exception e) {
+            result.setSuccess(false);
+            result.setCode("500");
+            result.setMessage(e.getCause().toString());
+            return ResponseEntity.status(HttpStatus.OK).body(result);
+        }
+
+        if (isCheckLogin >= 1) {
+            CmsLoginInfo loginInfo;
+            try{
+                loginInfo = adminLoginService.getLoginUserInfoByEmployeeId(requestData.getUserCode());
+            } catch (Exception e) {
+                result.setSuccess(false);
+                result.setCode("500");
+                result.setMessage(e.getCause().toString());
+                return ResponseEntity.status(HttpStatus.OK).body(result);
+            }
+            if (loginInfo != null && loginInfo.getLoginUser()!=null) {
+                userTokenService.clearUserTokenByType(AppConstants.CMS_API_ACCESS_TOKEN_TYPE,requestData.getUserCode());
+                userTokenService.clearUserTokenByType(AppConstants.CMS_REFRESH_TOKEN_TYPE,requestData.getUserCode());
+                LoginUserInfo loginUser = loginInfo.getLoginUser();
+                loginUser.setLoginSource("cms_login");
+                UserToken accessToken = JwtTokenUtil.generateTokenByLoginUser(AppConstants.CMS_API_ACCESS_TOKEN_TYPE,loginUser);
+                userTokenService.saveUserToken(accessToken);
+                UserToken refreshToken = JwtTokenUtil.generateTokenByLoginUser(AppConstants.CMS_REFRESH_TOKEN_TYPE,loginUser);
+                userTokenService.saveUserToken(refreshToken);
+                loginInfo.setAccessToken(accessToken.getTokenValue());
+                loginInfo.setRefreshToken(refreshToken.getTokenValue());
+                result.setSuccess(true);
+                result.setCode("200");
+                result.setMessage("User "+requestData.getUserCode() + " login CMS successful.");
+                result.setLoginInfo(loginInfo);
+            } else {
+                result.setSuccess(false);
+                result.setMessage("User "+requestData.getUserCode()+" not found.");
+            }
+        } else if (isCheckLogin == -2) {
+            result.setSuccess(false);
+            result.setMessage(requestData.getUserCode() + " has been locked.");
+        }  else if (isCheckLogin == -3) {
+            result.setSuccess(false);
+            result.setMessage(requestData.getUserCode() + " has been disabled.");
+        } else {
+            result.setSuccess(false);
+            result.setMessage("Incorrect login ID or password.");
+        }
+        return ResponseEntity.status(HttpStatus.OK).body(result);
+    }
+
+    @PostMapping(value="/verifyToken",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<String> verifyToken(
+            HttpServletRequest request,
+            HttpServletResponse response) {
+        return ResponseEntity.status(HttpStatus.OK).body("Token Verified");
+    }
+
+    @PostMapping(value="/logout",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminLogoutResponse> processLogout(
+            HttpServletRequest request,
+            HttpServletResponse response) {
+        AdminLogoutResponse result = new AdminLogoutResponse();
+        LoginUserInfo loginUser = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUser!=null){
+            adminLoginService.processLogout(loginUser);
+            result.setSuccess(true);
+            result.setCode("200");
+            result.setMessage("Logout successful.");
+        }else{
+            result.setSuccess(false);
+            result.setCode("401");
+            result.setMessage("Unauthorized logout");
+        }
+        return ResponseEntity.status(HttpStatus.OK).body(result);
+    }
+
+    @Operation(
+            summary = "Renew API token by refresh token",
+            description = "API to renew access token"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Access Token refreshed successful")
+    })
+    @PostMapping(value="/refreshToken",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<RefreshTokenResponse> refreshToken(
+            HttpServletRequest request,
+            HttpServletResponse response)  {
+        RefreshTokenResponse responseData = new RefreshTokenResponse();
+        LoginUserInfo loginUser = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUser!=null){
+            responseData = adminLoginService.refreshToken(loginUser);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }else{
+            responseData.setSuccess(false);
+            responseData.setCode("401");
+            responseData.setMessage("Unauthorized operation");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(responseData);
+        }
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminMenusController.java

@@ -0,0 +1,48 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenuStatusRequest;
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenuStatusResponse;
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenusListResponse;
+import com.sjmresorts.opsapp.admin.services.AdminMenusService;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@Tag(name = "CMS", description = "APIs for CMS sidebar menus")
+@RestController
+@RequestMapping("/api/v1/admin")
+@CrossOrigin(origins = "*")
+public class AdminMenusController {
+
+    @Resource
+    private AdminMenusService adminMenusService;
+
+    @Operation(summary = "List CMS sidebar menus with visibility status")
+    @PostMapping(value = "/menu/list", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminMenusListResponse> listMenus(HttpServletRequest request) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if (loginUserInfo == null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }
+        return ResponseEntity.ok(adminMenusService.listMenus());
+    }
+
+    @Operation(summary = "Update CMS sidebar menu visibility (sys_routers.status)")
+    @PostMapping(value = "/menu/update_status", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminMenuStatusResponse> updateStatus(
+            HttpServletRequest request,
+            @Valid @RequestBody AdminMenuStatusRequest body) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if (loginUserInfo == null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }
+        return ResponseEntity.ok(adminMenusService.updateStatus(body, loginUserInfo));
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminRoleUsersController.java

@@ -0,0 +1,101 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminAssignGroupPermissionRequest;
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminAssignGroupPermissionResponse;
+import com.sjmresorts.opsapp.admin.dtos.roleUsers.AdminGetRoleUsersRequest;
+import com.sjmresorts.opsapp.admin.dtos.roleUsers.AdminGetRoleUsersResponse;
+import com.sjmresorts.opsapp.admin.services.AdminPermissionService;
+import com.sjmresorts.opsapp.admin.services.AdminUserService;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.models.User;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Tag(name = "CMS", description = "APIs for CMS RoleUser")
+@RestController
+@RequestMapping("/api/v1/admin")
+@CrossOrigin(origins = "*")
+public class AdminRoleUsersController {
+
+    @Resource
+    private AdminUserService adminUserService;
+
+    @Resource
+    private AdminPermissionService adminPermissionService;
+
+    @Operation(
+            summary = "CMS Get Role And User Status",
+            description = "API for CMS Get Role And User Status"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Get Role And User Status Success")
+    })
+    @PostMapping(value = "/role/get_role_user_status", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminGetRoleUsersResponse> cmsGetRoleUserStatus(
+            HttpServletRequest request,
+            @RequestBody(required = true) AdminGetRoleUsersRequest pageRequest) {
+        AdminGetRoleUsersResponse Requestresult = new AdminGetRoleUsersResponse();
+        Map<String, List<User>> serviceResult = new HashMap<>();
+        List<User> assignUsers = adminUserService.listUser(pageRequest,"USER_ROLE");
+        List<User> unassignUsers = adminUserService.listUser(pageRequest,"UNASSIGN_USER");
+        serviceResult.put("assignUser", assignUsers);
+        serviceResult.put("unassignUser", unassignUsers);
+
+        if (serviceResult != null) {
+            Requestresult.setSuccess(true);
+            Requestresult.setMessage("CMS Get Roles Success");
+            Requestresult.setData(serviceResult);
+            Requestresult.setCode("200");
+        }else{
+            Requestresult.setCode("401");
+            Requestresult.setMessage("CMS Get Roles Failed");
+            Requestresult.setSuccess(false);
+        }
+        return ResponseEntity.status(HttpStatus.OK).body(Requestresult);
+    }
+
+    @Operation(
+            summary = "CMS Assign Role Permissions",
+            description = "API for CMS Assign Role Permissions"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "CMS Assign Role Permissions")
+    })
+    @PostMapping(value = "/role/assign_permission", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminAssignGroupPermissionResponse> cmsAssignRolePermissions(
+            HttpServletRequest request,
+            @Parameter(description = "CMS Assign Role Permissions", required = true) @Valid @RequestBody AdminAssignGroupPermissionRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            boolean success = adminPermissionService.assginPermission(requestData);
+            AdminAssignGroupPermissionResponse responseData = new AdminAssignGroupPermissionResponse();
+            if(success) {
+                responseData.setCode("200");
+                responseData.setSuccess(true);
+                responseData.setMessage("CMS Assign Role Permissions Success");
+            }else{
+                responseData.setSuccess(false);
+                responseData.setMessage("CMS Assign Role Permissions Failed");
+            }
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+}
+
+

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminRolesController.java

@@ -0,0 +1,203 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminListPermissionSettingRequest;
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminListPermissionSettingResponse;
+import com.sjmresorts.opsapp.admin.dtos.roles.*;
+import com.sjmresorts.opsapp.admin.services.AdminPermissionService;
+import com.sjmresorts.opsapp.admin.services.AdminRolesService;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@Tag(name = "CMS", description = "APIs for CMS Roles")
+@RestController
+@RequestMapping("/api/v1/admin")
+@CrossOrigin(origins = "*")
+public class AdminRolesController {
+    @Resource
+    private AdminRolesService adminRolesService;
+    @Resource
+    private AdminPermissionService adminPermissionService;
+
+    @Operation(
+            summary = "CMS Get Roles",
+            description = "API for CMS Get Roles"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Get Roles success")
+    })
+    @PostMapping(value = "/role/get_roles", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminGetRolesResponse> cmsGetRoles(
+            HttpServletRequest request,
+            @RequestBody(required = true) AdminGetRolesRequest pageRequest) {
+        AdminGetRolesResponse Requestresult = new AdminGetRolesResponse();
+        DataTableResult<AdminRoleDto> serviceResult = adminRolesService.getRoleInfoListByPage(pageRequest);
+
+        if (serviceResult != null) {
+            Requestresult.setSuccess(true);
+            Requestresult.setMessage("CMS Get Roles Success");
+            Requestresult.setData(serviceResult);
+            Requestresult.setCode("200");
+        }else{
+            Requestresult.setCode("401");
+            Requestresult.setMessage("CMS Get Roles Failed");
+            Requestresult.setSuccess(false);
+        }
+        return ResponseEntity.status(HttpStatus.OK).body(Requestresult);
+    }
+
+
+    @Operation(
+            summary = "CMS Create Role",
+            description = "API for CMS Create Role"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Create Role success")
+    })
+    @PostMapping(value = "/role/create_role", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<BaseApiResponse> cmsCreateRole(
+            HttpServletRequest request,
+            @Parameter(description = "CMS Create Role info", required = true) @Valid @RequestBody AdminCreateRoleRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            BaseApiResponse responseData = adminRolesService.createRole(requestData, loginUserInfo);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+
+
+    @Operation(
+            summary = "CMS Delete Role",
+            description = "API for CMS Delete Role"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Delete Role success")
+    })
+    @PostMapping(value = "/role/delete_role", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<BaseApiResponse> cmsDeleteRole(
+            HttpServletRequest request,
+            @Parameter(description = "CMS Delete Role info", required = true) @Valid @RequestBody AdminDeleteRoleRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            BaseApiResponse responseData = adminRolesService.deleteRole(requestData, loginUserInfo);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+
+
+    @Operation(
+            summary = "CMS Modify Role",
+            description = "API for CMS Modify Role"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Modify Role success")
+    })
+    @PostMapping(value = "/role/modify_role", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<BaseApiResponse> cmsmodifyRole(
+            HttpServletRequest request,
+            @Parameter(description = "CMS modify Role info", required = true) @Valid @RequestBody AdminModifyRoleRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            BaseApiResponse responseData = adminRolesService.modifyRole(requestData, loginUserInfo);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+
+    @Operation(
+            summary = "CMS Get Role By Id",
+            description = "API for CMS Get Role By Id"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Check CMS Get Role success")
+    })
+    @PostMapping(value = "/role/get_role_by_id", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminGetRoleByIdResponse> cmsGetRoleById(
+            HttpServletRequest request,
+            @Parameter(description = "CMS modify Role info", required = true) @Valid @RequestBody AdminGetRoleByIdRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            AdminGetRoleByIdResponse responseData = adminRolesService.getRoleById(requestData);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+
+
+    @Operation(
+            summary = "CMS Set Assign Users",
+            description = "API for CMS Set Assign Users"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "CMS Set Assign Users")
+    })
+    @PostMapping(value = "/role/assign_users", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminRoleAssignUsersResponse> cmsSetAssignUsers(
+            HttpServletRequest request,
+            @Parameter(description = "CMS modify Role info", required = true) @Valid @RequestBody AdminRoleAssignUsersRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            AdminRoleAssignUsersResponse responseData = new AdminRoleAssignUsersResponse();
+            Boolean serviceResult = adminRolesService.updateGroupAssignUser(requestData,loginUserInfo);
+            if(serviceResult) {
+                responseData.setCode("200");
+                responseData.setSuccess(true);
+                responseData.setMessage("CMS Set Assign Users Success");
+            }else{
+                responseData.setSuccess(false);
+                responseData.setMessage("CMS Set Assign Users Failed");
+            }
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+
+    @Operation(
+            summary = "CMS Get Permission",
+            description = "API for CMS Get Permission"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "CMS Get Permission")
+    })
+    @PostMapping(value = "/role/list_permission_setting", produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AdminListPermissionSettingResponse> cmsGetListPermission(
+            HttpServletRequest request,
+            @Parameter(description = "CMS Get Permission", required = true) @Valid @RequestBody AdminListPermissionSettingRequest requestData) {
+        LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUserInfo==null) {
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }else{
+            AdminListPermissionSettingResponse responseData = adminPermissionService.getPermissionById(requestData);
+            if(responseData!=null) {
+                responseData.setCode("200");
+                responseData.setSuccess(true);
+                responseData.setMessage("CMS Get Permission Success");
+            }else{
+                responseData.setSuccess(false);
+                responseData.setMessage("CMS Get Permission Failed");
+            }
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }
+    }
+}
+
+

src/main/java/com/sjmresorts/opsapp/admin/controllers/AdminUserController.java

@@ -0,0 +1,137 @@
+package com.sjmresorts.opsapp.admin.controllers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsAppUserPageRequest;
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsUserDto;
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsUserInfoResponse;
+import com.sjmresorts.opsapp.admin.dtos.system.user.GetCmsUserResponse;
+import com.sjmresorts.opsapp.admin.services.AdminUserService;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.constraints.NotNull;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@Tag(name = "CMS", description = "APIs for Admin User functions")
+@RestController
+@RequestMapping("/api/v1/admin")
+public class AdminUserController {
+
+	@Resource
+	private AdminUserService adminUserService;
+
+	@Operation(
+			summary = "Query CMS user info page",
+			description = "API for query CMS user info page"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS user info page queried successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/user/queryPage", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<CmsUserInfoResponse> getAppUserByPage(
+			HttpServletRequest request,
+			@RequestBody(required = true) CmsAppUserPageRequest pageRequest) {
+
+		DataTableResult<CmsUserDto> userInfoList = adminUserService.getUserInfoListByPage(pageRequest);
+		CmsUserInfoResponse cmsUserInfoResponse = new CmsUserInfoResponse();
+		cmsUserInfoResponse.setCode("200");
+		cmsUserInfoResponse.setSuccess(true);
+		cmsUserInfoResponse.setMessage("Query Successfully");
+		cmsUserInfoResponse.setData(userInfoList);
+		return ResponseEntity.status(HttpStatus.OK).body(cmsUserInfoResponse);
+	}
+
+	@Operation(
+			summary = "Create CMS user",
+			description = "API for CMS user creation"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS user created successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/user/create", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<BaseApiResponse> createUser(
+			HttpServletRequest request,
+			@RequestBody CmsUserDto requestData) {
+		LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+		if (loginUserInfo == null) {
+			return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+		} else {
+			BaseApiResponse responseData = adminUserService.createUser(requestData, loginUserInfo);
+			return ResponseEntity.status(HttpStatus.OK).body(responseData);
+		}
+	}
+
+	@Operation(
+			summary = "Update CMS user status",
+			description = "API for CMS user status update"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS user status updated successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/user/updateStatus", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<BaseApiResponse> updateStatus(
+			HttpServletRequest request,
+			@RequestBody CmsUserDto requestData) {
+
+		LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+		if (loginUserInfo == null) {
+			return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+		} else {
+			BaseApiResponse responseData = adminUserService.updateStatus(requestData, loginUserInfo);
+			return ResponseEntity.status(HttpStatus.OK).body(responseData);
+		}
+	}
+
+	@Operation(
+			summary = "Update CMS user info",
+			description = "API for CMS user info update"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS user info updated successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@PostMapping(value = "/user/update", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<BaseApiResponse> updateUser(
+			HttpServletRequest request,
+			@RequestBody CmsUserDto requestData) {
+		LoginUserInfo loginUserInfo = JwtTokenUtil.parseUserFromRequest(request);
+		if (loginUserInfo == null) {
+			return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+		} else {
+			BaseApiResponse responseData = adminUserService.updateUser(requestData, loginUserInfo);
+			return ResponseEntity.status(HttpStatus.OK).body(responseData);
+		}
+	}
+
+	@Operation(
+			summary = "Get one CMS user info",
+			description = "API for get one CMS user info"
+	)
+	@ApiResponses({
+			@ApiResponse(responseCode = "200", description = "CMS user info got successful"),
+			@ApiResponse(responseCode  = "400", description = "Invalid request data")
+	})
+	@GetMapping(value = "/user/{userId}", produces = "application/json;charset=UTF-8")
+	public ResponseEntity<GetCmsUserResponse> getUserById(
+			@PathVariable(name = "userId", required = true) @NotNull Long userId) {
+
+		GetCmsUserResponse responseData = new GetCmsUserResponse();
+		CmsUserDto userDto = adminUserService.queryCmsUserById(userId);
+		responseData.setCode("200");
+		responseData.setSuccess(userDto != null);
+		responseData.setMessage(userDto != null ? "Query Successfully" : "User does not exists");
+		responseData.setData(userDto);
+		return ResponseEntity.status(HttpStatus.OK).body(responseData);
+	}
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/AdminDevicesInfoPageRequest.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import com.sjmresorts.opsapp.common.dtos.BasePageRequest;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Get Admin Devices Info Page Request")
+public class AdminDevicesInfoPageRequest extends BasePageRequest {
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/AdminDevicesInfoPageResponse.java

@@ -0,0 +1,18 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Get Admin Devices Info Page Response")
+public class AdminDevicesInfoPageResponse extends BaseApiResponse {
+
+    @Schema(description = "Match Devices Info items")
+    private DataTableResult<ClientInfosDto> data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/AdminGetClientInfosRequest.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS get device Request")
+public class AdminGetClientInfosRequest {
+    @Schema(description = "Device ID of Clients Info")
+    @NotBlank(message = "Device Id must not be blank")
+    private String deviceId;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/AdminGetClientInfosResponse.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS get device Response")
+public class AdminGetClientInfosResponse extends BaseApiResponse {
+
+    @Schema(description = "Match Device items")
+    private ClientInfosDto data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/ClientInfosDto.java

@@ -0,0 +1,26 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import lombok.Data;
+
+import java.time.Instant;
+
+@Data
+public class ClientInfosDto {
+
+    private Long id;
+
+    private Boolean isLatest;
+
+    private Boolean isActive;
+
+    private String clientName;
+
+    private String clientVersion;
+
+    private String deviceFuid;
+
+    private String casinoCode;
+
+    private Instant updatedAt;
+}
+

src/main/java/com/sjmresorts/opsapp/admin/dtos/appsetting/GetAppSettingRequest.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.admin.dtos.appsetting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS get App Setting Request")
+public class GetAppSettingRequest {
+    @Schema(description = "App setting keys to retrieve")
+    @NotNull(message = "App setting keys must not be empty")
+    private List<String> appSettingKeys;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/menus/AdminMenuItemDto.java

@@ -0,0 +1,20 @@
+package com.sjmresorts.opsapp.admin.dtos.menus;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class AdminMenuItemDto {
+    private String id;
+    private String parentId;
+    private String heading;
+    private String sectionTitle;
+    private String route;
+    private String fontIcon;
+    private Integer sortNo;
+    /** 1=显示，0=隐藏 */
+    private Integer status;
+    /** 不可关闭（避免锁死后台） */
+    private boolean locked;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/menus/AdminMenuStatusRequest.java

@@ -0,0 +1,16 @@
+package com.sjmresorts.opsapp.admin.dtos.menus;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class AdminMenuStatusRequest {
+    @NotBlank
+    private String routerId;
+    /** 1=显示，0=隐藏 */
+    @NotNull
+    private Integer status;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/menus/AdminMenuStatusResponse.java

@@ -0,0 +1,18 @@
+package com.sjmresorts.opsapp.admin.dtos.menus;
+
+import com.sjmresorts.opsapp.admin.dtos.system.router.UserRouterDto;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@NoArgsConstructor
+public class AdminMenuStatusResponse extends BaseApiResponse {
+    /** 更新后当前登录用户侧栏菜单（可立刻刷新） */
+    private List<UserRouterDto> userRouters = new ArrayList<>();
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/menus/AdminMenusListResponse.java

@@ -0,0 +1,16 @@
+package com.sjmresorts.opsapp.admin.dtos.menus;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@NoArgsConstructor
+public class AdminMenusListResponse extends BaseApiResponse {
+    private List<AdminMenuItemDto> data = new ArrayList<>();
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/permissions/AdminAssignGroupPermissionRequest.java

@@ -0,0 +1,22 @@
+package com.sjmresorts.opsapp.admin.dtos.permissions;
+
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Assign Role Permission Request")
+public class AdminAssignGroupPermissionRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+    @Schema(description = "Router Operation",example="200")
+    private List<RouterPermission> assignRouterOperation;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/permissions/AdminAssignGroupPermissionResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.permissions;
+
+import com.sjmresorts.opsapp.admin.models.GroupPermissionObject;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Delete Role")
+public class AdminAssignGroupPermissionResponse {
+    @Schema(description = "Indicate CMS delete roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private GroupPermissionObject data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/permissions/AdminListPermissionSettingRequest.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.permissions;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Delete Role Request")
+public class AdminListPermissionSettingRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/permissions/AdminListPermissionSettingResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.permissions;
+
+import com.sjmresorts.opsapp.admin.models.GroupPermissionObject;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Delete Role")
+public class AdminListPermissionSettingResponse {
+    @Schema(description = "Indicate CMS delete roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private GroupPermissionObject data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roleUsers/AdminGetRoleUsersRequest.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.admin.dtos.roleUsers;
+
+import com.sjmresorts.opsapp.common.dtos.BasePageRequest;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS Get Role Uers Status Request")
+public class AdminGetRoleUsersRequest extends BasePageRequest {
+
+    private Long searchRoleId;
+
+    private String searchRoleName;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roleUsers/AdminGetRoleUsersResponse.java

@@ -0,0 +1,30 @@
+package com.sjmresorts.opsapp.admin.dtos.roleUsers;
+
+import com.sjmresorts.opsapp.authentication.models.User;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Role Users Status")
+public class AdminGetRoleUsersResponse {
+    @Schema(description = "Indicate CMS get roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Map<String, List<User>> data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roleUsers/AdminRoleUsersDto.java

@@ -0,0 +1,13 @@
+package com.sjmresorts.opsapp.admin.dtos.roleUsers;
+
+import lombok.Data;
+import org.mapstruct.Mapper;
+
+@Data
+@Mapper(componentModel = "spring")
+public class AdminRoleUsersDto {
+
+    private Long id;
+    private Long roleId;
+    private Long userId;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminCreateRoleRequest.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Create Role Request")
+public class AdminCreateRoleRequest {
+    @Schema(description = "Role Name",example="200")
+    private String roleName;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminCreateRoleResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Create Role")
+public class AdminCreateRoleResponse {
+    @Schema(description = "Indicate CMS create roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Role data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminDeleteRoleRequest.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Delete Role Request")
+public class AdminDeleteRoleRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+    @Schema(description = "Role Name",example="200")
+    private String roleName;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminDeleteRoleResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Delete Role")
+public class AdminDeleteRoleResponse {
+    @Schema(description = "Indicate CMS delete roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Role data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminGetRoleByIdRequest.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Modify Role Request")
+public class AdminGetRoleByIdRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminGetRoleByIdResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Get Role By Id")
+public class AdminGetRoleByIdResponse {
+    @Schema(description = "Indicate CMS get roles by id success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Role data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminGetRolesRequest.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.common.dtos.BasePageRequest;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS Roles Request")
+public class AdminGetRolesRequest extends BasePageRequest {
+
+    private String searchRoleName;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminGetRolesResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Roles")
+public class AdminGetRolesResponse {
+    @Schema(description = "Indicate CMS get roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private DataTableResult<AdminRoleDto> data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminModifyRoleRequest.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Modify Role Request")
+public class AdminModifyRoleRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+    @Schema(description = "Role Name",example="200")
+    private String roleName;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminModifyRoleResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Modify Role")
+public class AdminModifyRoleResponse {
+    @Schema(description = "Indicate CMS modify roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Role data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminRoleAssignUsersRequest.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = " Delete Role Request")
+public class AdminRoleAssignUsersRequest {
+    @Schema(description = "Role Id",example="200")
+    private Long roleId;
+    @Schema(description = "Role Name",example="200")
+    private List<String> employeeIds;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminRoleAssignUsersResponse.java

@@ -0,0 +1,27 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS Delete Role")
+public class AdminRoleAssignUsersResponse {
+    @Schema(description = "Indicate CMS delete roles success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Get roles successfully")
+    private String message;
+
+    @Schema(description = "data of result")
+    private Role data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/roles/AdminRoleDto.java

@@ -0,0 +1,11 @@
+package com.sjmresorts.opsapp.admin.dtos.roles;
+
+import lombok.Data;
+import org.mapstruct.Mapper;
+
+@Data
+@Mapper(componentModel = "spring")
+public class AdminRoleDto {
+    private Long roleId;
+    private String roleName;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/login/AdminLoginRequest.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.admin.dtos.system.login;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "CMS LoginRequest")
+public class AdminLoginRequest {
+
+    @Schema(description = "AD Account of Employee")
+    @NotBlank(message = "Employee Id must not be blank")
+    private String userCode;
+
+    @Schema(description = "Password of AD Account")
+    @NotBlank(message = "Password must not be blank")
+    private String password;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/login/AdminLoginResponse.java

@@ -0,0 +1,28 @@
+package com.sjmresorts.opsapp.admin.dtos.system.login;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS login with AD")
+public class AdminLoginResponse {
+
+    @Schema(description = "Indicate CMS login authorization success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Login successfully")
+    private String message;
+
+    @Schema(description = "Login Info of response")
+    private CmsLoginInfo loginInfo;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/login/AdminLogoutResponse.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.admin.dtos.system.login;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of CMS logout")
+public class AdminLogoutResponse {
+
+    @Schema(description = "Indicate CMS logout success status")
+    private boolean success=false;
+
+    @Schema(description = "Status Code of response",example="200")
+    private String code;
+
+    @Schema(description = "Description of result",example="Logout successfully")
+    private String message;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/login/CmsLoginInfo.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.admin.dtos.system.login;
+
+import com.sjmresorts.opsapp.admin.dtos.system.router.RouterPermissionDto;
+import com.sjmresorts.opsapp.admin.dtos.system.router.UserRouterDto;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+public class CmsLoginInfo {
+    private String accessToken;
+    private String refreshToken;
+    private String defaultRouter;
+    private LoginUserInfo loginUser;
+    private List<UserRouterDto> userRouters;
+    private Map<String, List<RouterPermissionDto>> userPermissions;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/router/RouterPermissionDto.java

@@ -0,0 +1,16 @@
+package com.sjmresorts.opsapp.admin.dtos.system.router;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+public class RouterPermissionDto {
+    private String id;
+    private String routerId;
+    private String permissionName;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/router/UserRouterDto.java

@@ -0,0 +1,24 @@
+package com.sjmresorts.opsapp.admin.dtos.system.router;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+public class UserRouterDto {
+    private String parentId;
+    private String heading;
+    private String sectionTitle;
+    private String route;
+    private String svgIcon;
+    private String fontIcon;
+    private Integer sortNo;
+    private Integer status;
+    private List<UserRouterDto> sub;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/user/CmsAppUserPageRequest.java

@@ -0,0 +1,14 @@
+package com.sjmresorts.opsapp.admin.dtos.system.user;
+
+import com.sjmresorts.opsapp.common.dtos.BasePageRequest;
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class CmsAppUserPageRequest extends BasePageRequest {
+
+    private String searchAccount;
+    private String searchUserName;
+
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/user/CmsUserDto.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.admin.dtos.system.user;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.Instant;
+
+@Data
+@NoArgsConstructor
+public class CmsUserDto {
+
+    private Long userId;
+    private String userCode;
+    private String userName;
+    private String email;
+    private Integer status;
+    private Instant updatedAt;
+    private Instant createdAt;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/user/CmsUserInfoResponse.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.dtos.system.user;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "User Info List")
+public class CmsUserInfoResponse extends BaseApiResponse {
+    private DataTableResult<CmsUserDto> data;
+}

src/main/java/com/sjmresorts/opsapp/admin/dtos/system/user/GetCmsUserResponse.java

@@ -0,0 +1,15 @@
+package com.sjmresorts.opsapp.admin.dtos.system.user;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of getting CMS User")
+public class GetCmsUserResponse extends BaseApiResponse {
+    private CmsUserDto data;
+}

src/main/java/com/sjmresorts/opsapp/admin/mappers/ClientInfosMapper.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.appsetting.ClientInfosDto;
+import com.sjmresorts.opsapp.authentication.models.ClientInfo;
+import org.mapstruct.Mapper;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface ClientInfosMapper {
+
+	ClientInfosDto toClientInfosDto(ClientInfo device);
+
+	List<ClientInfosDto> toClientInfosDtoList(List<ClientInfo> content);
+
+
+}

src/main/java/com/sjmresorts/opsapp/admin/mappers/CmsLoginRouterMapper.java

@@ -0,0 +1,41 @@
+package com.sjmresorts.opsapp.admin.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.router.RouterPermissionDto;
+import com.sjmresorts.opsapp.admin.dtos.system.router.UserRouterDto;
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Component
+@RequiredArgsConstructor
+public class CmsLoginRouterMapper {
+    private final SysRouterMapper routerMapper;
+    private final RouterPermissionMapper routerPermissionMapper;
+
+    public List<UserRouterDto> toRouterDtoListWithChildren(List<SysRouter> sysRouters) {
+        List<UserRouterDto> routerDtos = new ArrayList<UserRouterDto>();
+        routerMapper.toUserRouterDtoList(sysRouters);
+        for(SysRouter sysRouter:sysRouters){
+            UserRouterDto routerDto = routerMapper.toUserRouterDto(sysRouter);
+            if(sysRouter.getSub()!=null && !sysRouter.getSub().isEmpty()){
+                routerDto.setSub(toRouterDtoListWithChildren(sysRouter.getSub()));
+            }
+            routerDtos.add(routerDto);
+        }
+        return routerDtos;
+    }
+
+    public Map<String, List<RouterPermissionDto>> toRouterPermissionMap(Map<String, List<RouterPermission>> userPermissions) {
+        Map<String, List<RouterPermissionDto>> permissionMap = new HashMap<String, List<RouterPermissionDto>>();
+        userPermissions.forEach((key, value) -> {
+            permissionMap.put(key, routerPermissionMapper.toRouterPermissionDtoList(value));
+        });
+        return permissionMap;
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/mappers/RouterPermissionMapper.java

@@ -0,0 +1,15 @@
+package com.sjmresorts.opsapp.admin.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.router.RouterPermissionDto;
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import org.mapstruct.Mapper;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface RouterPermissionMapper {
+
+    RouterPermissionDto toRouterPermissionDto(RouterPermission entity);
+
+    List<RouterPermissionDto> toRouterPermissionDtoList(List<RouterPermission> routerPermissions);
+}

src/main/java/com/sjmresorts/opsapp/admin/mappers/SysRouterMapper.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.router.UserRouterDto;
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface SysRouterMapper {
+
+    @Mapping(target = "sub", ignore = true)
+    UserRouterDto toUserRouterDto(SysRouter sysRouter);
+
+    List<UserRouterDto> toUserRouterDtoList(List<SysRouter> sysRouters);
+}

src/main/java/com/sjmresorts/opsapp/admin/models/GroupPermissionObject.java

@@ -0,0 +1,17 @@
+package com.sjmresorts.opsapp.admin.models;
+
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+@NoArgsConstructor
+public class GroupPermissionObject {
+    private Long groupId;
+    private String groupName;
+    private List<SysRouter> groupRouterSetting;
+}

src/main/java/com/sjmresorts/opsapp/admin/repositories/RoleUsersRepository.java

@@ -0,0 +1,18 @@
+package com.sjmresorts.opsapp.admin.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.RoleUsers;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface RoleUsersRepository extends JpaRepository<RoleUsers, Long> {
+
+
+    List<RoleUsers> findAllByRoleId(Long roleId);
+
+    @Query(value = "select roleUser.roleId from RoleUsers roleUser where employeeId=?1 ")
+    List<Long> findRoleIdListByEmployeeId(String employeeId);
+}

src/main/java/com/sjmresorts/opsapp/admin/repositories/RolesRepository.java

@@ -0,0 +1,23 @@
+package com.sjmresorts.opsapp.admin.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.Role;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface RolesRepository extends JpaRepository<Role, Long> {
+
+    Page<Role> findAll(Specification<Role> listSpec, Pageable pageable);
+
+    Role getRoleByRoleId(Long roleId);
+
+    @Query(value="select r.roleId from Role r where r.roleName = ?1")
+    List<Long> queryRoleIdByRoleName(String roleName);
+
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminDevicesService.java

@@ -0,0 +1,108 @@
+package com.sjmresorts.opsapp.admin.services;
+
+import com.sjmresorts.opsapp.admin.dtos.appsetting.AdminDevicesInfoPageRequest;
+import com.sjmresorts.opsapp.admin.dtos.appsetting.ClientInfosDto;
+import com.sjmresorts.opsapp.admin.mappers.ClientInfosMapper;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.models.ClientInfo;
+import com.sjmresorts.opsapp.authentication.repositories.DeviceInfoRepository;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.BasePageRequest;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.DaoUtil;
+import com.sjmresorts.opsapp.logging.models.AuditLog;
+import com.sjmresorts.opsapp.logging.services.AuditLogService;
+import jakarta.persistence.criteria.Predicate;
+import jakarta.validation.constraints.NotBlank;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class AdminDevicesService {
+
+	private final DeviceInfoRepository deviceInfoRepository;
+	private final AuditLogService auditLogService;
+	private final ClientInfosMapper clientInfosMapper;
+	private final DeviceInfoRepository deviceRepository;
+
+	public DataTableResult<ClientInfosDto> getDevicesInfoListByPage(AdminDevicesInfoPageRequest pageRequest) {
+
+		Specification<ClientInfo> listSpec = buildSpecificationByPageRequest(pageRequest);
+		int pageSize = pageRequest.getPageSize();
+		int pageStart = pageRequest.getStartRow() / pageSize;
+		Sort sort = DaoUtil.buildSortByString(pageRequest.getSortOrder(), "id");
+		Pageable pageable = PageRequest.of(pageStart, pageSize, sort);
+		Page<ClientInfo> resultPage = deviceInfoRepository.findAll(listSpec, pageable);
+		List<ClientInfosDto> resultList = clientInfosMapper.toClientInfosDtoList(resultPage.getContent());
+		DataTableResult<ClientInfosDto> dataResult = new DataTableResult<>();
+		dataResult.setTotalRecords(resultPage.getTotalElements());
+		dataResult.setPageSize(pageSize);
+		if (resultList == null) {
+			resultList = new ArrayList<>();
+		}
+		dataResult.setRowData(resultList);
+		return dataResult;
+	}
+
+	private Specification<ClientInfo> buildSpecificationByPageRequest(BasePageRequest pageRequest) {
+
+		return ((root, criteriaQuery, cb) -> {
+			List<Predicate> list = new ArrayList<>();
+//			if (StringUtils.isNotBlank(pageRequest.getSearchUserName())) {
+//				list.add(cb.like(cb.upper(root.get("userName")),
+//						"%" + pageRequest.getSearchUserName().toUpperCase() + "%"));
+//			}
+//			if (StringUtils.isNotBlank(pageRequest.getSearchAccount())) {
+//				list.add(cb.like(cb.upper(root.get("employeeId")),
+//						"%" + pageRequest.getSearchAccount().toUpperCase() + "%"));
+//			}
+			Predicate[] predicates = new Predicate[list.size()];
+			criteriaQuery.where(list.toArray(predicates));
+			return cb.and(list.toArray(predicates));
+		});
+	}
+
+	public BaseApiResponse updateDevice(ClientInfosDto deviceDto, LoginUserInfo loginUserInfo) {
+		BaseApiResponse result = new BaseApiResponse();
+		AuditLog auditLog = auditLogService.createAuditLog("Update Device", "Update Device from AdminDevicesService.updateDevice()", loginUserInfo);
+		ClientInfo device = deviceRepository.findById(deviceDto.getId()).orElse(null);
+		Instant currentTime = Instant.now();
+		if (device != null) {
+			auditLogService.setLogOldValue(auditLog, device);
+			device.setCasinoCode(deviceDto.getCasinoCode());
+			device.setUpdatedAt(currentTime);
+			deviceRepository.save(device);
+			auditLogService.setLogNewValue(auditLog, device);
+			auditLogService.saveAuditLog(auditLog);
+			result.setSuccess(true);
+			result.setCode("200");
+			result.setMessage("Updated Successfully");
+		} else {
+			result.setSuccess(false);
+			result.setCode("400");
+			result.setMessage("User does not exists");
+		}
+		return result;
+	}
+
+
+	public ClientInfosDto queryDeviceById(@NotBlank long deviceId) {
+		ClientInfosDto deviceDto = null;
+		ClientInfo device = deviceRepository.findById(deviceId).orElse(null);
+
+		if (device != null) {
+			deviceDto = clientInfosMapper.toClientInfosDto(device);
+		}
+		return deviceDto;
+	}
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminLoginService.java

@@ -0,0 +1,163 @@
+package com.sjmresorts.opsapp.admin.services;
+
+import com.sjmresorts.opsapp.admin.dtos.system.login.CmsLoginInfo;
+import com.sjmresorts.opsapp.admin.mappers.CmsLoginRouterMapper;
+import com.sjmresorts.opsapp.admin.repositories.RoleUsersRepository;
+import com.sjmresorts.opsapp.admin.repositories.RolesRepository;
+import com.sjmresorts.opsapp.common.constants.AppConstants;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.dtos.RefreshTokenResponse;
+import com.sjmresorts.opsapp.authentication.mappers.UserMapper;
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import com.sjmresorts.opsapp.authentication.models.User;
+import com.sjmresorts.opsapp.authentication.models.UserToken;
+import com.sjmresorts.opsapp.authentication.repositories.RouterPermissionRepository;
+import com.sjmresorts.opsapp.authentication.repositories.UserRepository;
+import com.sjmresorts.opsapp.authentication.services.RolePermissionService;
+import com.sjmresorts.opsapp.authentication.services.SysRouterService;
+import com.sjmresorts.opsapp.authentication.services.UserTokenService;
+import com.sjmresorts.opsapp.common.dtos.LDAP.ADAccountInfo;
+import com.sjmresorts.opsapp.common.utils.AESUtil;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import com.sjmresorts.opsapp.common.utils.LDAPUtil;
+import jakarta.transaction.Transactional;
+import jakarta.validation.constraints.NotBlank;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.dao.OptimisticLockingFailureException;
+import org.springframework.retry.annotation.Backoff;
+import org.springframework.retry.annotation.Retryable;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+public class AdminLoginService {
+
+    private final UserRepository userRepository;
+    private final RoleUsersRepository roleUsersRepository;
+    private final UserMapper userMapper;
+    private final CmsLoginRouterMapper cmsLoginRouterMapper;
+    private final SysRouterService sysRouterService;
+    private final RolePermissionService rolePermissionService;
+    private final UserTokenService userTokenService;
+    private final LDAPUtil ldapUtil;
+    private final RolesRepository rolesRepository;
+    private final RouterPermissionRepository routerPermissionRepository;
+
+    // -3=disabled, -2=locked, -1 or 0=incorrect loginId or password,  1=success
+    public int checkLoginByLoginIdAndPassword(String employeeId, String password) {
+        int checkPassed = -1;
+        if(AppConstants.SUPER_ADMIN_ID.equalsIgnoreCase(employeeId)) {
+            User user = userRepository.findByEmployeeId(employeeId).orElse(null);
+            if (user != null) {
+                if(user.getStatus()==null || user.getStatus()==0){
+                    return -3; // user disabled by app
+                }else if(user.getStatus()==2) {
+                    return -2; // user locked
+                }
+                String encryptPassword = AESUtil.sha256(password);
+                checkPassed = userRepository.countByEmployeeIdAndPassword(employeeId.toUpperCase(), encryptPassword);
+            }
+        }else{
+            //Check AD
+            boolean adResult = ldapUtil.authenticate(employeeId, password);
+            if(adResult) checkPassed = 1;
+        }
+        return checkPassed;
+    }
+
+    @Retryable(retryFor = OptimisticLockingFailureException.class,
+            maxAttempts = 3,
+            backoff = @Backoff(delay = 100))
+    @Transactional
+    public CmsLoginInfo getLoginUserInfoByEmployeeId(@NotBlank(message = "Employee Id must not be blank") String employeeId) {
+        CmsLoginInfo result = null;
+        if(AppConstants.SUPER_ADMIN_ID.equalsIgnoreCase(employeeId)) {
+            User user = userRepository.findByEmployeeId(employeeId).orElse(null);
+            if(user!=null){
+                user.setCmsLastLogin(Instant.now());
+                userRepository.save(user);
+                result = new CmsLoginInfo();
+                LoginUserInfo loginUser = userMapper.toLoginUser(user);
+                result.setLoginUser(loginUser);
+                Map<String, List<RouterPermission>> userPermissions = new HashMap<String, List<RouterPermission>>();
+                userPermissions = rolePermissionService.getFullRouterPermissions();
+                List<SysRouter> routers = sysRouterService.getRoutersByPermission("0",userPermissions);
+                result.setUserRouters(cmsLoginRouterMapper.toRouterDtoListWithChildren(routers));
+                result.setUserPermissions(cmsLoginRouterMapper.toRouterPermissionMap(userPermissions));
+            }
+        }else{
+            ADAccountInfo adResult = ldapUtil.getAccountInfo(employeeId);
+            if(adResult!=null){
+                result = new CmsLoginInfo();
+                LoginUserInfo loginUser = new LoginUserInfo();
+                loginUser.setUserName(adResult.getDisplayName());
+                loginUser.setEmployeeId(employeeId);
+                loginUser.setEmail(adResult.getMail());
+                loginUser.setUserCode(employeeId);
+                result.setLoginUser(loginUser);
+                Map<String, List<RouterPermission>> userPermissions = new HashMap<String, List<RouterPermission>>();
+                List<Long> userRoleIds = getUserRoleIds(adResult.getDirectGroups());
+                userPermissions = rolePermissionService.getRouterPermissionsByGroupIds(userRoleIds);
+                List<SysRouter> routers = sysRouterService.getRoutersByPermission("0",userPermissions);
+                result.setUserRouters(cmsLoginRouterMapper.toRouterDtoListWithChildren(routers));
+                result.setUserPermissions(cmsLoginRouterMapper.toRouterPermissionMap(userPermissions));
+            }
+        }
+
+        return result;
+    }
+
+    public void processLogout(LoginUserInfo loginUser) {
+        if(loginUser!=null){
+            userTokenService.clearUserTokenByType(AppConstants.CMS_API_ACCESS_TOKEN_TYPE,loginUser.getEmployeeId());
+            userTokenService.clearUserTokenByType(AppConstants.CMS_REFRESH_TOKEN_TYPE,loginUser.getEmployeeId());
+        }
+    }
+
+    public RefreshTokenResponse refreshToken(LoginUserInfo loginUser) {
+        RefreshTokenResponse result = new RefreshTokenResponse();
+        UserToken accessToken = null;
+        UserToken refreshToken = null;
+        if(loginUser!=null){
+            accessToken= JwtTokenUtil.generateTokenByLoginUser(AppConstants.CMS_API_ACCESS_TOKEN_TYPE,loginUser);
+            userTokenService.saveUserToken(accessToken);
+            refreshToken=JwtTokenUtil.generateTokenByLoginUser(AppConstants.CMS_REFRESH_TOKEN_TYPE,loginUser);
+            userTokenService.saveUserToken(refreshToken);
+            if(StringUtils.isNotBlank(loginUser.getTokenUuid())){
+                userTokenService.removeTokenByUniqueId(loginUser.getTokenUuid());
+            }
+        }
+
+        if(accessToken!=null){
+            result.setSuccess(true);
+            result.setCode("200");
+            result.setAccessToken(accessToken.getTokenValue());
+            result.setRefreshToken(refreshToken.getTokenValue());
+            result.setMessage("Token renew successful.");
+        }else{
+            result.setSuccess(false);
+            result.setCode("200");
+            result.setMessage("Token failed.");
+        }
+        return result;
+    }
+
+    private List<Long> getUserRoleIds(List<String> groupName) {
+        List<Long> roleIdList = new ArrayList<>();
+        if(groupName!=null&&!groupName.isEmpty()){
+            for(String roleName : groupName){
+                List<Long> roleIds = rolesRepository.queryRoleIdByRoleName(roleName);
+                roleIdList.addAll(roleIds);
+            }
+        }
+        return roleIdList;
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminMenusService.java

@@ -0,0 +1,113 @@
+package com.sjmresorts.opsapp.admin.services;
+
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenuItemDto;
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenuStatusRequest;
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenuStatusResponse;
+import com.sjmresorts.opsapp.admin.dtos.menus.AdminMenusListResponse;
+import com.sjmresorts.opsapp.admin.dtos.system.router.UserRouterDto;
+import com.sjmresorts.opsapp.admin.mappers.CmsLoginRouterMapper;
+import com.sjmresorts.opsapp.admin.repositories.RoleUsersRepository;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import com.sjmresorts.opsapp.authentication.repositories.SysRouterRepository;
+import com.sjmresorts.opsapp.authentication.services.RolePermissionService;
+import com.sjmresorts.opsapp.authentication.services.SysRouterService;
+import com.sjmresorts.opsapp.common.constants.AppConstants;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Service
+@RequiredArgsConstructor
+public class AdminMenusService {
+
+    private static final Set<String> LOCKED_ROUTER_IDS = Set.of(
+            "ESIGN_DASHBOARD",
+            "ESIGN_SYSTEM",
+            "ESIGN_SYS_USERS",
+            "ESIGN_SYS_ROLES",
+            "ESIGN_SYS_MENUS");
+
+    private final SysRouterRepository sysRouterRepository;
+    private final SysRouterService sysRouterService;
+    private final RolePermissionService rolePermissionService;
+    private final RoleUsersRepository roleUsersRepository;
+    private final CmsLoginRouterMapper cmsLoginRouterMapper;
+
+    public AdminMenusListResponse listMenus() {
+        AdminMenusListResponse response = new AdminMenusListResponse();
+        List<SysRouter> routers = sysRouterRepository.queryAllRoutersOrderBySort();
+        for (SysRouter router : routers) {
+            AdminMenuItemDto item = new AdminMenuItemDto();
+            item.setId(router.getId());
+            item.setParentId(router.getParentId());
+            item.setHeading(router.getHeading());
+            item.setSectionTitle(router.getSectionTitle());
+            item.setRoute(router.getRoute());
+            item.setFontIcon(router.getFontIcon());
+            item.setSortNo(router.getSortNo());
+            item.setStatus(router.getStatus() == null ? 1 : router.getStatus());
+            item.setLocked(LOCKED_ROUTER_IDS.contains(router.getId()));
+            response.getData().add(item);
+        }
+        response.setSuccess(true);
+        response.setCode("200");
+        response.setMessage("ok");
+        return response;
+    }
+
+    @Transactional
+    public AdminMenuStatusResponse updateStatus(AdminMenuStatusRequest request, LoginUserInfo loginUser) {
+        AdminMenuStatusResponse response = new AdminMenuStatusResponse();
+        if (request == null || StringUtils.isBlank(request.getRouterId()) || request.getStatus() == null) {
+            response.setSuccess(false);
+            response.setCode("400");
+            response.setMessage("routerId and status required");
+            return response;
+        }
+        int status = request.getStatus() == 0 ? 0 : 1;
+        if (LOCKED_ROUTER_IDS.contains(request.getRouterId()) && status == 0) {
+            response.setSuccess(false);
+            response.setCode("400");
+            response.setMessage("This menu cannot be hidden");
+            return response;
+        }
+        SysRouter router = sysRouterRepository.findById(request.getRouterId()).orElse(null);
+        if (router == null) {
+            response.setSuccess(false);
+            response.setCode("404");
+            response.setMessage("menu not found");
+            return response;
+        }
+        router.setStatus(status);
+        sysRouterRepository.save(router);
+
+        response.setUserRouters(buildUserRouters(loginUser));
+        response.setSuccess(true);
+        response.setCode("200");
+        response.setMessage("saved");
+        return response;
+    }
+
+    private List<UserRouterDto> buildUserRouters(LoginUserInfo loginUser) {
+        if (loginUser == null || StringUtils.isBlank(loginUser.getEmployeeId())) {
+            return List.of();
+        }
+        Map<String, List<RouterPermission>> userPermissions;
+        if (AppConstants.SUPER_ADMIN_ID.equalsIgnoreCase(loginUser.getEmployeeId())) {
+            userPermissions = rolePermissionService.getFullRouterPermissions();
+        } else {
+            List<Long> roleIds = roleUsersRepository.findRoleIdListByEmployeeId(loginUser.getEmployeeId());
+            userPermissions = rolePermissionService.getRouterPermissionsByGroupIds(
+                    roleIds != null ? roleIds : List.of());
+        }
+        List<SysRouter> routers = sysRouterService.getRoutersByPermission("0", userPermissions);
+        return cmsLoginRouterMapper.toRouterDtoListWithChildren(routers);
+    }
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminPermissionService.java

@@ -0,0 +1,109 @@
+package com.sjmresorts.opsapp.admin.services;
+
+
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminAssignGroupPermissionRequest;
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminAssignGroupPermissionResponse;
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminListPermissionSettingRequest;
+import com.sjmresorts.opsapp.admin.dtos.permissions.AdminListPermissionSettingResponse;
+import com.sjmresorts.opsapp.admin.models.GroupPermissionObject;
+import com.sjmresorts.opsapp.authentication.models.*;
+import com.sjmresorts.opsapp.authentication.repositories.RolePermissionRepository;
+import com.sjmresorts.opsapp.authentication.repositories.RouterPermissionRepository;
+import com.sjmresorts.opsapp.authentication.repositories.SysRouterRepository;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+@Service
+@RequiredArgsConstructor
+public class AdminPermissionService {
+    private final SysRouterRepository sysRouterRepository;
+    private final RouterPermissionRepository routerPermissionRepository;
+    private final RolePermissionRepository rolePermissionRepository;
+
+
+    public AdminListPermissionSettingResponse getPermissionById(AdminListPermissionSettingRequest request) {
+        AdminListPermissionSettingResponse result = new AdminListPermissionSettingResponse();
+        GroupPermissionObject newObject = new GroupPermissionObject();
+
+//        获取路由信息,路由权限,权限组权限
+        List<SysRouter> listRouter = sysRouterRepository.getAllChildrenRoutes();
+        List<RouterPermission> listPermission = routerPermissionRepository.findAll();
+        List<RolePermission> listRolePermission = rolePermissionRepository.getAllPermissionByRoleId(request.getRoleId());
+//        判断权限组是否有权限,并将selectAble属性加入返回数据
+        if (listRolePermission.size() > 0) {
+            for(int i=0; i<listPermission.size(); i++) {
+                RouterPermission rolePermission = listPermission.get(i);
+                for (RolePermission permission : listRolePermission) {
+                    Long permissionId = permission.getPermissionId();
+                    if(permissionId==rolePermission.getId()){
+//                        如果权限组有对应权限将selected设置为true
+                        rolePermission.setSelected(true);
+                        listRolePermission.remove(permission);
+                        break;
+                    }
+
+                }
+            }
+        }
+        for (int i=0;i<listRouter.size();i++) {
+            SysRouter sysRouter = listRouter.get(i);
+            for (int j=0;j<listPermission.size();j++) {
+                RouterPermission permission = listPermission.get(j);
+//                将权限信息放入返回数据中
+                if(StringUtils.equals(sysRouter.getId(),permission.getRouterId())) {
+                    sysRouter.getRoutePermissions().add(permission);
+                    listPermission.remove(j);
+                    j--;
+                }
+            }
+        }
+
+        newObject.setGroupId(request.getRoleId());
+        newObject.setGroupRouterSetting(listRouter);
+        result.setData(newObject);
+        result.setSuccess(true);
+        result.setCode("200");
+        result.setMessage("Get List Permission By Id Successfully");
+        return result;
+    }
+
+    public Boolean assginPermission(AdminAssignGroupPermissionRequest request) {
+        AdminAssignGroupPermissionResponse result = new AdminAssignGroupPermissionResponse();
+        List<RolePermission> permissionToDelete = rolePermissionRepository.getAllPermissionByRoleId(request.getRoleId());
+        if(request.getAssignRouterOperation()!=null &&request.getAssignRouterOperation().size()>0){
+            List<RouterPermission> assignRouterOperation = request.getAssignRouterOperation();
+            List<RolePermission>saveData = new ArrayList<>();
+            for(int i =0;i<assignRouterOperation.size();i++){
+                RouterPermission permission = assignRouterOperation.get(i);
+                boolean existItem = false;
+                for(int j=0;j<permissionToDelete.size();j++){
+                    RolePermission rolePermission = permissionToDelete.get(j);
+                    if(permission.getId()==rolePermission.getPermissionId()){
+                        existItem = true;
+                        permissionToDelete.remove(j);
+                        break;
+                    }
+                }
+                if(!existItem){
+                    RolePermission rolePermission = new RolePermission();
+                    rolePermission.setRoleId(request.getRoleId());
+                    rolePermission.setPermissionId(permission.getId());
+                    saveData.add(rolePermission);
+                }
+            }
+            if(!saveData.isEmpty()){
+                rolePermissionRepository.saveAll(saveData);
+            }
+            if(!permissionToDelete.isEmpty()){
+                rolePermissionRepository.deleteAll(permissionToDelete);
+            }
+        }
+        return true;
+    }
+
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminRoleUsersService.java

@@ -0,0 +1,14 @@
+package com.sjmresorts.opsapp.admin.services;
+
+
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+
+@Service
+@RequiredArgsConstructor
+public class AdminRoleUsersService {
+
+
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminRolesService.java

@@ -0,0 +1,174 @@
+package com.sjmresorts.opsapp.admin.services;
+
+
+import com.sjmresorts.opsapp.admin.dtos.roles.*;
+import com.sjmresorts.opsapp.admin.repositories.RoleUsersRepository;
+import com.sjmresorts.opsapp.admin.repositories.RolesRepository;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.mappers.RoleMapper;
+import com.sjmresorts.opsapp.authentication.models.*;
+import com.sjmresorts.opsapp.authentication.repositories.RolePermissionRepository;
+import com.sjmresorts.opsapp.authentication.repositories.RouterPermissionRepository;
+import com.sjmresorts.opsapp.authentication.repositories.SysRouterRepository;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.DaoUtil;
+import com.sjmresorts.opsapp.logging.models.AuditLog;
+import com.sjmresorts.opsapp.logging.services.AuditLogService;
+import jakarta.persistence.criteria.Predicate;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+@Service
+@RequiredArgsConstructor
+public class AdminRolesService {
+
+    private final RolesRepository rolesRepository;
+    private final AuditLogService auditLogService;
+    private final RoleUsersRepository roleUsersRepository;
+    private final RoleMapper roleMapper;
+    private final SysRouterRepository sysRouterRepository;
+    private final RouterPermissionRepository routerPermissionRepository;
+    private final RolePermissionRepository rolePermissionRepository;
+
+    public List<Role> getAllRoles() {
+        return rolesRepository.findAll();
+    }
+
+    public DataTableResult<AdminRoleDto> getRoleInfoListByPage(AdminGetRolesRequest pageRequest) {
+
+        Specification<Role> listSpec = buildSpecificationByPageRequest(pageRequest);
+        int pageSize = pageRequest.getPageSize();
+        int pageStart = pageRequest.getStartRow() / pageSize;
+        Sort sort = DaoUtil.buildSortByString(pageRequest.getSortOrder(), "roleId");
+        Pageable pageable = PageRequest.of(pageStart, pageSize, sort);
+        Page<Role> resultPage = rolesRepository.findAll(listSpec,pageable);
+        List<AdminRoleDto> resultList = roleMapper.toAdminRoleDto(resultPage.getContent());
+        DataTableResult<AdminRoleDto> dataResult = new DataTableResult<>();
+        dataResult.setTotalRecords(resultPage.getTotalElements());
+        dataResult.setPageSize(pageSize);
+        if (resultList == null) {
+            resultList = new ArrayList<>();
+        }
+        dataResult.setRowData(resultList);
+        return dataResult;
+    }
+
+
+    public BaseApiResponse createRole(AdminCreateRoleRequest request, LoginUserInfo loginUserInfo) {
+        BaseApiResponse result = new BaseApiResponse();
+        AuditLog auditLog = auditLogService.createAuditLog("Create Role", "Create a new Role from AdminRolesService.createRole()", loginUserInfo);
+        Role newRole = new Role();
+        newRole.setRoleName(request.getRoleName());
+        auditLogService.setLogOldValue(auditLog,null);
+        rolesRepository.save(newRole);
+        auditLogService.setLogNewValue(auditLog,newRole);
+        auditLogService.saveAuditLog(auditLog);
+        result.setSuccess(true);
+        result.setCode("200");
+        result.setMessage("Created Successfully");
+        return result;
+    }
+
+    public BaseApiResponse deleteRole(AdminDeleteRoleRequest request, LoginUserInfo loginUserInfo) {
+        BaseApiResponse result = new BaseApiResponse();
+        AuditLog auditLog = auditLogService.createAuditLog("Delete Role", "Delete a Role from AdminRolesService.deleteRole()", loginUserInfo);
+        auditLogService.setLogOldValue(auditLog,request.getRoleName());
+        rolesRepository.deleteById(request.getRoleId());
+        auditLogService.setLogNewValue(auditLog,"");
+        auditLogService.saveAuditLog(auditLog);
+        result.setSuccess(true);
+        result.setCode("200");
+        result.setMessage("Created Successfully");
+        return result;
+    }
+
+    public BaseApiResponse modifyRole(AdminModifyRoleRequest request, LoginUserInfo loginUserInfo) {
+        BaseApiResponse result = new BaseApiResponse();
+        AuditLog auditLog = auditLogService.createAuditLog("Modify Role", "Modify a Role from AdminRolesService.deleteRole()", loginUserInfo);
+        auditLogService.setLogOldValue(auditLog,request.getRoleName());
+        Role oRole =  rolesRepository.getRoleByRoleId((request.getRoleId()));
+        oRole.setRoleName(request.getRoleName());
+        rolesRepository.save(oRole);
+        auditLogService.setLogNewValue(auditLog,"");
+        auditLogService.saveAuditLog(auditLog);
+        result.setSuccess(true);
+        result.setCode("200");
+        result.setMessage("Modify Successfully");
+        return result;
+    }
+
+    public AdminGetRoleByIdResponse getRoleById(AdminGetRoleByIdRequest request) {
+        AdminGetRoleByIdResponse result = new AdminGetRoleByIdResponse();
+        Role getRole = rolesRepository.findById(request.getRoleId()).orElse(null);
+        result.setData(getRole);
+        result.setSuccess(true);
+        result.setCode("200");
+        result.setMessage("Get Role By Id Successfully");
+        return result;
+    }
+
+
+    private Specification<Role> buildSpecificationByPageRequest(AdminGetRolesRequest pageRequest) {
+
+        return ((root, criteriaQuery, cb) -> {
+            List<Predicate> list = new ArrayList<>();
+            if (StringUtils.isNotBlank(pageRequest.getSearchRoleName())) {
+                list.add(cb.like(cb.upper(root.get("roleName")),
+                        "%" + pageRequest.getSearchRoleName().toUpperCase() + "%"));
+            }
+            Predicate[] predicates = new Predicate[list.size()];
+            criteriaQuery.where(list.toArray(predicates));
+            return cb.and(list.toArray(predicates));
+        });
+    }
+
+    public boolean updateGroupAssignUser(AdminRoleAssignUsersRequest request, LoginUserInfo loginUserInfo) {
+        Long roleId = request.getRoleId();
+        List<String> employeeIdList = request.getEmployeeIds();
+        List<RoleUsers> dataToDelete =roleUsersRepository.findAllByRoleId(roleId);
+        AuditLog auditLog = auditLogService.createAuditLog("Update Group Assign Users", "Update Group Assign Users from AdminRolesService.updateGroupAssignUser()", loginUserInfo);
+        auditLogService.setLogOldValue(auditLog,dataToDelete);
+        if(employeeIdList!=null) {
+            List<RoleUsers> saveData = new ArrayList<>();
+            for(int i=0; i<employeeIdList.size();i++) {
+                String employeeId = employeeIdList.get(i);
+                boolean isExist = false;
+                for(int j=0;j<dataToDelete.size();j++) {
+                    RoleUsers existItem = dataToDelete.get(j);
+                    if(existItem.getEmployeeId().equals(employeeId)) {
+                        isExist = true;
+                        dataToDelete.remove(j);
+                        break;
+                    }
+                }
+                if(isExist==false) {
+                    RoleUsers userItem = new RoleUsers();
+                    userItem.setRoleId(roleId);
+                    userItem.setEmployeeId(employeeId);
+                    saveData.add(userItem);
+                }
+            }
+            if(saveData.size()>0) {
+                roleUsersRepository.saveAll(saveData);
+            }
+        }
+        if(dataToDelete.size()>0) {
+            roleUsersRepository.deleteAll(dataToDelete);
+        }
+        auditLogService.setLogNewValue(auditLog,request);
+        auditLogService.saveAuditLog(auditLog);
+        return true;
+    }
+
+}

src/main/java/com/sjmresorts/opsapp/admin/services/AdminUserService.java

@@ -0,0 +1,180 @@
+package com.sjmresorts.opsapp.admin.services;
+
+import com.sjmresorts.opsapp.admin.dtos.roleUsers.AdminGetRoleUsersRequest;
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsAppUserPageRequest;
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsUserDto;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.mappers.UserMapper;
+import com.sjmresorts.opsapp.authentication.models.RoleUsers;
+import com.sjmresorts.opsapp.authentication.models.User;
+import com.sjmresorts.opsapp.authentication.repositories.UserRepository;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.dtos.DataTableResult;
+import com.sjmresorts.opsapp.common.utils.DaoUtil;
+import com.sjmresorts.opsapp.logging.models.AuditLog;
+import com.sjmresorts.opsapp.logging.services.AuditLogService;
+import jakarta.persistence.criteria.*;
+import jakarta.validation.constraints.NotBlank;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class AdminUserService {
+
+	private final UserRepository userRepository;
+	private final AuditLogService auditLogService;
+	private final UserMapper userMapper;
+
+	public DataTableResult<CmsUserDto> getUserInfoListByPage(CmsAppUserPageRequest pageRequest) {
+
+		Specification<User> listSpec = buildSpecificationByPageRequest(pageRequest);
+		int pageSize = pageRequest.getPageSize();
+		int pageStart = pageRequest.getStartRow() / pageSize;
+		Sort sort = DaoUtil.buildSortByString(pageRequest.getSortOrder(), "userId");
+		Pageable pageable = PageRequest.of(pageStart, pageSize, sort);
+		Page<User> resultPage = userRepository.findAll(listSpec, pageable);
+		List<CmsUserDto> resultList = userMapper.toCmsUserDtoList(resultPage.getContent());
+		DataTableResult<CmsUserDto> dataResult = new DataTableResult<>();
+		dataResult.setTotalRecords(resultPage.getTotalElements());
+		dataResult.setPageSize(pageSize);
+		if (resultList == null) {
+			resultList = new ArrayList<>();
+		}
+		dataResult.setRowData(resultList);
+		return dataResult;
+	}
+
+	private Specification<User> buildSpecificationByPageRequest(CmsAppUserPageRequest pageRequest) {
+
+		return ((root, criteriaQuery, cb) -> {
+			List<Predicate> list = new ArrayList<>();
+			if (StringUtils.isNotBlank(pageRequest.getSearchUserName())) {
+				list.add(cb.like(cb.upper(root.get("userName")),
+						"%" + pageRequest.getSearchUserName().toUpperCase() + "%"));
+			}
+			if (StringUtils.isNotBlank(pageRequest.getSearchAccount())) {
+				list.add(cb.like(cb.upper(root.get("employeeId")),
+						"%" + pageRequest.getSearchAccount().toUpperCase() + "%"));
+			}
+			Predicate[] predicates = new Predicate[list.size()];
+			criteriaQuery.where(list.toArray(predicates));
+			return cb.and(list.toArray(predicates));
+		});
+	}
+
+	public List<User> listUser(AdminGetRoleUsersRequest request, String searchType) {
+		Specification<User> listSpec = buildSpecificationByRequest(request,searchType);
+		Sort sort = DaoUtil.buildSortByString(request.getSortOrder(), "employeeId");
+		List<User> resultList = userRepository.findAll(listSpec,sort);
+		return resultList;
+	}
+
+	private Specification<User> buildSpecificationByRequest(AdminGetRoleUsersRequest request, String searchType) {
+		Specification<User> SysUserpec = new Specification<User>() {
+			@Override
+			public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
+				List<Predicate> list = new ArrayList<>();
+				if (StringUtils.equals(searchType, "USER_ROLE") && request.getSearchRoleId() != null) {
+					Subquery<String> groupSubQuery = criteriaQuery.subquery(String.class);
+					Root<RoleUsers> subQueryRoot = groupSubQuery.from(RoleUsers.class);
+					groupSubQuery.select(subQueryRoot.get("employeeId"));
+					List<Predicate> subQueryPredicates = new ArrayList<>();
+					subQueryPredicates.add(cb.equal(subQueryRoot.get("roleId"), request.getSearchRoleId()));
+					groupSubQuery.where(subQueryPredicates.toArray(new Predicate[] {}));
+					list.add(cb.in(root.get("employeeId")).value(groupSubQuery));
+				} else if (StringUtils.equals(searchType, "UNASSIGN_USER")) {
+					Subquery<Long> groupSubQuery = criteriaQuery.subquery(Long.class);
+					Root<RoleUsers> subQueryRoot = groupSubQuery.from(RoleUsers.class);
+					groupSubQuery.select(cb.literal(1L));
+					List<Predicate> subQueryPredicates = new ArrayList<>();
+					subQueryPredicates.add(cb.equal(subQueryRoot.get("employeeId"), root.get("employeeId")));
+					groupSubQuery.where(subQueryPredicates.toArray(new Predicate[] {}));
+					list.add(cb.not(cb.exists(groupSubQuery)));
+				}
+				Predicate[] predicates = new Predicate[list.size()];
+				criteriaQuery.where(list.toArray(predicates));
+				return cb.and(list.toArray(predicates));
+			}
+		};
+		return SysUserpec;
+	}
+
+
+
+	public BaseApiResponse createUser(CmsUserDto userDto, LoginUserInfo loginUserInfo) {
+		BaseApiResponse result = new BaseApiResponse();
+		AuditLog auditLog = auditLogService.createAuditLog("Create User", "Create a new User from AdminUserService.createUser()", loginUserInfo);
+		User user = userMapper.toUserEntity(userDto);
+		user.setCasinoCode("");
+		auditLogService.setLogOldValue(auditLog, null);
+		userRepository.save(user);
+		auditLogService.setLogNewValue(auditLog, user);
+		auditLogService.saveAuditLog(auditLog);
+		result.setSuccess(true);
+		result.setCode("200");
+		result.setMessage("Created Successfully");
+		return result;
+	}
+
+	public BaseApiResponse updateUser(CmsUserDto userDto, LoginUserInfo loginUserInfo) {
+		BaseApiResponse result = new BaseApiResponse();
+		AuditLog auditLog = auditLogService.createAuditLog("Update User", "Update User from AdminUserService.updateUser()", loginUserInfo);
+		User user = userRepository.findById(userDto.getUserId()).orElse(null);
+		if (user != null) {
+			auditLogService.setLogOldValue(auditLog, user);
+			userMapper.updateUserFromCmsUserDto(userDto, user);
+			userRepository.save(user);
+			auditLogService.setLogNewValue(auditLog, user);
+			auditLogService.saveAuditLog(auditLog);
+			result.setSuccess(true);
+			result.setCode("200");
+			result.setMessage("Updated Successfully");
+		} else {
+			result.setSuccess(false);
+			result.setCode("400");
+			result.setMessage("User does not exists");
+		}
+		return result;
+	}
+
+	public BaseApiResponse updateStatus(CmsUserDto userDto, LoginUserInfo loginUserInfo) {
+		BaseApiResponse result = new BaseApiResponse();
+		AuditLog auditLog = auditLogService.createAuditLog("Update User Status", "Update User status from AdminUserService.updateStatus()", loginUserInfo);
+		User user = userRepository.findById(userDto.getUserId()).orElse(null);
+		if (user != null) {
+			auditLogService.setLogOldValue(auditLog, user);
+			user.setStatus(userDto.getStatus());
+			userRepository.save(user);
+			auditLogService.setLogNewValue(auditLog, user);
+			auditLogService.saveAuditLog(auditLog);
+			result.setSuccess(true);
+			result.setCode("200");
+			result.setMessage("Status Updated Successfully");
+		} else {
+			result.setSuccess(false);
+			result.setCode("400");
+			result.setMessage("User does not exists");
+		}
+		return result;
+	}
+
+	public CmsUserDto queryCmsUserById(@NotBlank long userId) {
+		CmsUserDto userDto = null;
+		User user = userRepository.findById(userId).orElse(null);
+
+		if (user != null) {
+			userDto = userMapper.toCmsUserDto(user);
+		}
+		return userDto;
+	}
+}

src/main/java/com/sjmresorts/opsapp/authentication/controllers/MobileAuthorizationController.java

@@ -0,0 +1,147 @@
+package com.sjmresorts.opsapp.authentication.controllers;
+
+import com.sjmresorts.opsapp.authentication.dtos.*;
+import com.sjmresorts.opsapp.authentication.services.AdAuthorizeService;
+import com.sjmresorts.opsapp.authentication.services.LoginService;
+import com.sjmresorts.opsapp.common.constants.AppConstants;
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.validation.Valid;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@Tag(name = "Authorization", description = "APIs relate with ad login authorization")
+@RestController
+@RequestMapping("/api/v1/authorization")
+@CrossOrigin(origins = "*")
+public class MobileAuthorizationController {
+	@Resource
+	private LoginService loginService;
+	@Resource
+	private AdAuthorizeService adAuthService;
+
+    @Operation(
+            summary = "appLogout",
+            description = "API for app logout process"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "App logout successful")
+    })
+    @PostMapping(value="/logout",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<AppLogoutResponse> deviceLogin(
+            HttpServletRequest request) {
+
+        AppLogoutResponse result = new AppLogoutResponse();
+        LoginUserInfo loginUser = JwtTokenUtil.parseUserFromRequest(request);
+        if(loginUser!=null){
+            loginService.processLogout(loginUser);
+            result.setSuccess(true);
+            result.setCode("200");
+            result.setMessage("Logout successful.");
+            return ResponseEntity.status(HttpStatus.OK).body(result);
+        }else{
+            result.setSuccess(false);
+            result.setCode("401");
+            result.setMessage("Unauthorized logout");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(result);
+        }
+    }
+	
+	
+	@Operation(
+	        summary = "Register Pits info for tracking",
+	        description = "API for location tracking registration"
+	)
+	@ApiResponses({
+        @ApiResponse(responseCode = "200", description = "Register Pits successful"),
+        @ApiResponse(responseCode  = "400", description = "Invalid request data")
+    })
+	@PostMapping(value="/register_track_pits",produces = "application/json;charset=UTF-8")
+	public ResponseEntity<RegisterTrackInfoResponse> registerTrackScope(
+			HttpServletRequest request,
+			@Parameter(description = "Register request for pits tracking", required = true) @Valid @RequestBody RegisterTrackInfoRequest requestData) {
+		RegisterTrackInfoResponse responseData = loginService.registerTrackPits(requestData.getData());
+		return ResponseEntity.status(HttpStatus.OK).body(responseData);
+	}
+
+    @Operation(
+            summary = "Third Party Authorization",
+            description = "API to retrieve access token for third party caller, such as Service Button"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Access Token generated successful"),
+            @ApiResponse(responseCode  = "401", description = "Authorization key not math")
+    })
+    @PostMapping(value="/getAccessToken",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<GetAuthTokenResponse> getApiAccessToken(
+            HttpServletRequest request,
+            @Parameter(description = "Third party requestor info", required = true) @Valid @RequestBody GetAuthTokenRequest requestData) {
+        String authorizationKey = request.getHeader("Authorization");
+        if(authorizationKey!=null && authorizationKey.equals(JwtTokenUtil.getThirdPartySecretKey())){
+            GetAuthTokenResponse responseData = loginService.assignAccessToken(AppConstants.THIRD_PARTY_TOKEN_TYPE,requestData.getData());
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }else{
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
+        }
+    }
+
+    @Operation(
+            summary = "Renew API token by non-expired token",
+            description = "API to renew access token"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Access Token refreshed successful")
+    })
+    @PostMapping(value="/refreshToken",produces = "application/json;charset=UTF-8")
+    public ResponseEntity<RefreshTokenResponse> refreshToken(
+            HttpServletRequest request,
+            HttpServletResponse response)  {
+        RefreshTokenResponse responseData = new RefreshTokenResponse();
+        LoginUserInfo loginUser = JwtTokenUtil.parseUserFromRequest(request);
+        boolean isRenewRefreshToken = (!"false".equalsIgnoreCase(request.getParameter("isRenewRefreshToken")));
+        if(loginUser!=null){
+            responseData = loginService.refreshToken(loginUser,isRenewRefreshToken);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }else{
+            responseData.setSuccess(false);
+            responseData.setCode("401");
+            responseData.setMessage("Unauthorized operation");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(responseData);
+        }
+    }
+
+    @Operation(
+            summary = "Heart-beat API",
+            description = "API to register last heart-beat time for login user"
+    )
+    @ApiResponses({
+            @ApiResponse(responseCode = "200", description = "Access Token refreshed successful")
+    })
+    @GetMapping(value="/appHeartBeat")
+    public ResponseEntity<BaseApiResponse> sendHeartBeat(
+            HttpServletRequest request,
+            HttpServletResponse response)  {
+        LoginUserInfo loginUser = JwtTokenUtil.parseUserFromRequest(request);
+        BaseApiResponse responseData = new BaseApiResponse();
+        if(loginUser!=null){
+            boolean registerSuccess = loginService.registerHeartBeat(loginUser);
+            responseData.setSuccess(registerSuccess);
+            return ResponseEntity.status(HttpStatus.OK).body(responseData);
+        }else{
+            responseData.setSuccess(false);
+            responseData.setCode("401");
+            responseData.setMessage("Unauthorized operation");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(responseData);
+        }
+    }
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AdAuthorizeResponse.java

@@ -0,0 +1,19 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+public class AdAuthorizeResponse {
+	
+	private boolean success=false;
+	private String code;
+	private String message;
+	private AdUserInfo userInfo;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AdLoginData.java

@@ -0,0 +1,42 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Data field of AdLoginRequest")
+public class AdLoginData {
+	@Schema(description = "AD Account of Employee", example = "XXX")
+	@NotBlank(message = "Employee Id must not be blank")
+	private String employeeId;
+	
+	@Schema(description = "Password of AD Account", nullable = false)
+	@NotBlank(message = "Password must not be blank")
+	private String password;
+	
+	@Schema(description = "UUID of user login device")
+	private String deviceId;
+	
+	@Schema(description = "FCM token of current login device")
+	private String deviceToken;
+	
+	@Schema(description = "Device name of user login")
+	private String deviceName;
+	
+	@Schema(description = "Device version of user login")
+	private String deviceVersion;
+
+    @Schema(description = "App version of current using")
+    private String appVersion;
+
+	@Schema(description = "Is Mockup Login")
+	private Boolean isMock;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AdLoginRequest.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import com.sjmresorts.opsapp.common.dtos.SchemaEntry;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Request info of AD login with password")
+public class AdLoginRequest {
+	@Schema(description = "Schema field of request")
+	@NotNull(message = "Schema attribute must not be null")
+	private SchemaEntry schema;
+	
+	@Schema(description = "Data field of request")
+	@NotNull(message = "Data attribute must not be null")
+	private AdLoginData data;
+	
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AdLoginResponse.java

@@ -0,0 +1,47 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Set;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of AD login with password")
+public class AdLoginResponse {
+	
+	@Schema(description = "Indicate AD authorization success status")
+	private boolean success=false;
+	
+	@Schema(description = "Status Code of response",example="200")
+	private String code;
+	
+	@Schema(description = "Description of result",example="Login successfully")
+	private String message;
+	
+	@Schema(description = "JWT token assign for login user")
+	private String accessToken;
+
+    @Schema(description = "JWT refresh token assign for login user")
+    private String refreshToken;
+	
+	@Schema(description = "AD account of login user")
+	private String employeeId;
+	
+	@Schema(description = "User name of login user")
+	private String userName;
+	
+	@Schema(description = "User Id of login user")
+	private Long userId;
+	
+	@Schema(description = "Available access property of login user")
+	private String casinoCode;
+
+	@Schema(description = "Permission Group of login user")
+	private Set<String> permissionGroup;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AdUserInfo.java

@@ -0,0 +1,20 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+public class AdUserInfo {
+
+	private String employeeId;
+	private String userName;
+	private List<String> adGroup;
+	private String role;
+	private String email;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/AppLogoutResponse.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of App logout")
+public class AppLogoutResponse {
+
+	@Schema(description = "Indicate app logout success status")
+	private boolean success=false;
+	
+	@Schema(description = "Status Code of response",example="200")
+	private String code;
+	
+	@Schema(description = "Description of result",example="Device logout successfully")
+	private String message;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/DeviceLoginData.java

@@ -0,0 +1,45 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Data field of DeviceLoginRequest")
+public class DeviceLoginData {
+	@Schema(description = "Security content provide by SJM launcher")
+	private String securityContent;
+	
+	@Schema(description = "UUID of user login device")
+	private String deviceId;
+	
+	@Schema(description = "FCM token of current login device")
+	private String deviceToken;
+
+    @Schema(description = "Device name of user login")
+    private String deviceName;
+
+    @Schema(description = "Device version of user login")
+    private String deviceVersion;
+
+    @Schema(description = "Employee ID from Launcher", example = "000001")
+    @NotBlank(message = "Employee Id must not be blank")
+    private String employeeId;
+
+    @Schema(description = "User Name from Launcher", example = "XXX")
+    @NotBlank(message = "User Name must not be blank")
+    private String userName;
+
+    @Schema(description = "Property code from Launcher", example = "GLC")
+    private String casinoCode;
+
+    @Schema(description = "App version of current using")
+    private String appVersion;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/DeviceLoginRequest.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import com.sjmresorts.opsapp.common.dtos.SchemaEntry;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Login request info of SJM launcher")
+public class DeviceLoginRequest {	
+	@Schema(description = "Schema field of request")
+	private SchemaEntry schema;
+	
+	@Schema(description = "Data field of request")
+	private DeviceLoginData data;	
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/DeviceLoginResponse.java

@@ -0,0 +1,47 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Set;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of SJM launcher login with AD content")
+public class DeviceLoginResponse {
+
+	@Schema(description = "Indicate AD authorization success status")
+	private boolean success=false;
+	
+	@Schema(description = "Status Code of response",example="200")
+	private String code;
+	
+	@Schema(description = "Description of result",example="Device login successfully")
+	private String message;
+	
+	@Schema(description = "JWT API token assign for this login")
+	private String accessToken;
+
+    @Schema(description = "JWT Refresh token assign for this login")
+    private String refreshToken;
+	
+	@Schema(description = "AD account of login user")
+    private String employeeId;
+
+    @Schema(description = "User name of login user")
+    private String userName;
+
+    @Schema(description = "User Id of login user")
+    private Long userId;
+
+    @Schema(description = "Available access property of login user")
+    private String casinoCode;
+
+    @Schema(description = "Permission Group of login user")
+    private Set<String> permissionGroup;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/GetAuthTokenData.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Data field of GetAuthToken request")
+public class GetAuthTokenData {
+	@Schema(description = "Requester ID of notification API caller", example = "ELO_XXXX")
+	@NotBlank(message = "Requester Id must not be blank")
+	private String requesterId;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/GetAuthTokenRequest.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import com.sjmresorts.opsapp.common.dtos.SchemaEntry;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Request to get notification API access token")
+public class GetAuthTokenRequest {
+	@Schema(description = "Schema field of request")
+	@NotNull(message = "Schema attribute must not be null")
+	private SchemaEntry schema;
+	
+	@Schema(description = "Data field of request")
+	@NotNull(message = "Data attribute must not be null")
+	private GetAuthTokenData data;
+	
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/GetAuthTokenResponse.java

@@ -0,0 +1,28 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of notification API access token")
+public class GetAuthTokenResponse {
+	
+	@Schema(description = "Indicate access token generated success status")
+	private boolean success=false;
+	
+	@Schema(description = "Status Code of response",example="200")
+	private String code;
+	
+	@Schema(description = "Description of result",example="Access token generated successfully")
+	private String message;
+	
+	@Schema(description = "JWT token assign for service button")
+	private String accessToken;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/LoginUserInfo.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+public class LoginUserInfo {
+    private Long userId;
+    private String employeeId;
+    private String userCode;
+    private String userName;
+    private String adGroup;
+    private String role;
+    private String email;
+    private String loginSource;
+    private String tokenUuid;
+    private String appVersion;
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/RefreshTokenResponse.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import com.sjmresorts.opsapp.common.dtos.BaseApiResponse;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of refreshing App access token")
+public class RefreshTokenResponse extends BaseApiResponse {
+
+	@Schema(description = "New API JWT token generated")
+	private String accessToken;
+
+    @Schema(description = "New Refresh JWT token generated")
+    private String refreshToken;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/RegisterTrackInfoData.java

@@ -0,0 +1,26 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Data field of RegisterTrackInfoRequest")
+public class RegisterTrackInfoData {
+	@Schema(description = "Employee ID of current user")
+	private String employeeId;
+	
+	@Schema(description = "Casino code of user selected")
+	private String casinoCode;
+	
+	@Schema(description = "Pits code of user selected")
+	private List<String> pitCodes; 
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/RegisterTrackInfoRequest.java

@@ -0,0 +1,22 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+import com.sjmresorts.opsapp.common.dtos.SchemaEntry;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Request info of Track pits registeration")
+public class RegisterTrackInfoRequest {
+	@Schema(description = "Schema field of request")
+	private SchemaEntry schema;
+	
+	@Schema(description = "Data field of request")
+	private RegisterTrackInfoData data;
+	
+}

src/main/java/com/sjmresorts/opsapp/authentication/dtos/RegisterTrackInfoResponse.java

@@ -0,0 +1,26 @@
+package com.sjmresorts.opsapp.authentication.dtos;
+
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@Schema(description = "Response info of Track pits registeration")
+public class RegisterTrackInfoResponse {
+	
+	@Schema(description = "Indicate success status")
+	private boolean success=false;
+	
+	@Schema(description = "Status Code of response",example="200")
+	private String code;
+	
+	@Schema(description = "Description of result",example="Pits are registered successfully")
+	private String message;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/filters/JwtAuthFilter.java

@@ -0,0 +1,111 @@
+package com.sjmresorts.opsapp.authentication.filters;
+
+import com.auth0.jwt.JWTVerifier;
+import com.auth0.jwt.exceptions.TokenExpiredException;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.services.UserTokenService;
+import com.sjmresorts.opsapp.common.utils.JwtTokenUtil;
+import com.sjmresorts.opsapp.common.utils.NetworkUtil;
+import jakarta.annotation.Resource;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.NonNull;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.AntPathMatcher;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.util.List;
+
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+    private final AntPathMatcher pathMatcher = new AntPathMatcher();
+    private final Logger logger = LoggerFactory.getLogger(JwtAuthFilter.class);
+    @Setter
+    private List<String> excludePatterns;
+
+    @Setter
+    private List<String> verifyAppVersionList;
+
+    @Setter
+    @Resource
+    private UserTokenService userTokenService;
+
+    @Override
+    protected void doFilterInternal(
+            @NonNull HttpServletRequest request,
+            @NonNull HttpServletResponse response,
+            @NonNull FilterChain filterChain
+    ) throws ServletException, IOException{
+
+        NetworkUtil.checkAndSetAllowOrigin(request,response);
+        NetworkUtil.setSecurityHeaders(request,response);
+        String token = request.getHeader("Authorization");
+        String uri = request.getRequestURI();
+        if(StringUtils.isNotBlank(token) && token.startsWith("Bearer ")){
+            token = token.substring(7);
+        }
+        if(StringUtils.isNotBlank(token)) {
+            JWTVerifier jwtVerifier = JwtTokenUtil.getJwtVerifier();
+            try {
+                jwtVerifier.verify(token);
+            }catch (TokenExpiredException e) {
+                sendErrorResponse(response,HttpServletResponse.SC_UNAUTHORIZED,"Token Expired");
+                request.setAttribute("AUTH_EXCEPTION","Token Expired");
+                return;
+            }catch (Exception e) {
+                sendErrorResponse(response,HttpServletResponse.SC_UNAUTHORIZED,"Unauthorized");
+                request.setAttribute("AUTH_EXCEPTION","Unauthorized");
+                return;
+            }
+            LoginUserInfo loginInfo = JwtTokenUtil.parseUserFromToken(token);
+            if(loginInfo==null){
+                sendErrorResponse(response,HttpServletResponse.SC_UNAUTHORIZED,"Unauthorized");
+                request.setAttribute("AUTH_EXCEPTION","Invalid token");
+                return;
+            }else{
+                if(!userTokenService.checkUserTokenValid(loginInfo.getTokenUuid())){
+                    sendErrorResponse(response,HttpServletResponse.SC_UNAUTHORIZED,"Not Existing Token");
+                    request.setAttribute("AUTH_EXCEPTION","Not Existing Token");
+                    return;
+                }
+            }
+
+        }else if(!"OPTIONS".equals(request.getMethod())) {
+            sendErrorResponse(response,HttpServletResponse.SC_UNAUTHORIZED,"Unauthorized");
+            request.setAttribute("AUTH_EXCEPTION","Unauthorized");
+            return;
+        }
+        filterChain.doFilter(request, response);
+    }
+
+
+    @Override
+    protected boolean shouldNotFilter(@NonNull HttpServletRequest request) {
+        if (excludePatterns == null) {
+            return false;
+        }
+        return excludePatterns.stream()
+              .anyMatch(pattern -> pathMatcher.match(pattern, request.getRequestURI()));
+    }
+
+    private boolean needCheckAppVersion(@NonNull HttpServletRequest request){
+        if(verifyAppVersionList==null || verifyAppVersionList.isEmpty()){
+            return false;
+        }
+        return verifyAppVersionList.stream()
+                .anyMatch(pattern -> pathMatcher.match(pattern, request.getRequestURI()));
+    }
+
+    private void sendErrorResponse(HttpServletResponse response, int errorCode, String errorMessage) throws IOException {
+        response.setStatus(errorCode);
+        response.setContentType("application/text");
+        response.setCharacterEncoding("UTF-8");
+        response.getWriter().write(errorMessage);
+    }
+}

src/main/java/com/sjmresorts/opsapp/authentication/mappers/RoleMapper.java

@@ -0,0 +1,14 @@
+package com.sjmresorts.opsapp.authentication.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.roles.AdminRoleDto;
+import com.sjmresorts.opsapp.authentication.models.Role;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface RoleMapper {
+    @Mapping(source = "roleId", target = "roleName")
+    List<AdminRoleDto> toAdminRoleDto(List<Role> roles);
+}

src/main/java/com/sjmresorts/opsapp/authentication/mappers/UserMapper.java

@@ -0,0 +1,31 @@
+package com.sjmresorts.opsapp.authentication.mappers;
+
+import com.sjmresorts.opsapp.admin.dtos.system.user.CmsUserDto;
+import com.sjmresorts.opsapp.authentication.dtos.LoginUserInfo;
+import com.sjmresorts.opsapp.authentication.models.User;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+
+import java.util.List;
+
+@Mapper(componentModel = "spring")
+public interface UserMapper {
+
+    @Mapping(source = "ldapGroup", target = "adGroup")
+    @Mapping(source = "employeeId", target = "userCode")
+    LoginUserInfo toLoginUser(User user);
+
+    @Mapping(source = "employeeId", target = "userCode")
+    CmsUserDto toCmsUserDto(User user);
+
+    @Mapping(source = "employeeId", target = "userCode")
+    List<CmsUserDto> toCmsUserDtoList(List<User> users);
+
+    @Mapping(source = "userCode", target = "employeeId")
+    User toUserEntity(CmsUserDto userDto);
+
+    @Mapping(target = "userId", ignore = true)
+    @Mapping(source = "userCode", target = "employeeId")
+    void updateUserFromCmsUserDto(CmsUserDto dto, @MappingTarget User entity);
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/ClientInfo.java

@@ -0,0 +1,50 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.Instant;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="client_infos")
+public class ClientInfo {			
+
+	@Id
+	@Column(name = "id",nullable = false)
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+			
+	@Column(name = "is_latest")
+	private Boolean isLatest;
+	
+	@Column(name = "is_active")
+	private Boolean isActive;
+	
+	@Column(name = "current_login_user")
+	private String currentLoginUser;
+	
+	@Column(name = "client_version")
+	private String clientVersion;
+	
+	@Column(name = "device_fuid")
+	private String deviceFuid;
+	
+	@Column(name = "client_name")
+	private String clientName;
+	
+	@Column(name = "casino_code")
+	private String casinoCode;
+		
+	@Column(name = "created_at")
+	private Instant createdAt;
+	
+	@Column(name = "updated_at")
+	private Instant updatedAt;
+	
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/Role.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="roles")
+public class Role {
+    @Id
+    @Column(name = "role_id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long roleId;
+
+    @Column(name = "role_name")
+    private String roleName;
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/RolePermission.java

@@ -0,0 +1,24 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="role_permissions")
+public class RolePermission {
+    @Id
+    @Column(name = "id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "role_id")
+    private Long roleId;
+
+    @Column(name = "permission_id")
+    private Long permissionId;
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/RoleUsers.java

@@ -0,0 +1,24 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="role_users")
+public class RoleUsers {
+    @Id
+    @Column(name = "id")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "role_id")
+    private Long roleId;
+
+    @Column(name = "employee_id")
+    private String employeeId;
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/RouterPermission.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="permissions")
+public class RouterPermission {
+    @Id
+    @Column(name = "permission_id")
+    private Long id;
+    @Column(name = "router_id")
+    private String routerId;
+    @Column(name = "permission_name")
+    private String permissionName;
+    @Transient
+    private boolean selected=false;
+    @Transient
+    private String dataPermissionTag;
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/SimpleUser.java

@@ -0,0 +1,30 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="users")
+public class SimpleUser {
+	@Id
+	@Column(name = "user_id")
+	private Long userId;
+	
+	@Column(name = "employee_id")
+	private String employeeId;
+	
+	@Column(name = "username")
+	private String userName;
+	
+	@Column(name = "email")
+	private String email;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/SysRouter.java

@@ -0,0 +1,45 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="sys_routers")
+public class SysRouter {
+    @Id
+    @Column(name = "id")
+    private String id;
+    @Column(name="parent_id")
+    private String parentId;
+    @Column(name="heading")
+    private String heading;
+    @Column(name="section_title")
+    private String sectionTitle;
+    @Column(name="route")
+    private String route;
+    @Column(name="svg_icon")
+    private String svgIcon;
+    @Column(name="font_icon")
+    private String fontIcon;
+    @Column(name="sort_no")
+    private Integer sortNo;
+    @Column(name="status")
+    private Integer status;
+
+    @Transient
+    private List<SysRouter> sub;
+
+    @Transient
+    private List<RouterPermission> routePermissions=new ArrayList<RouterPermission>();
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/User.java

@@ -0,0 +1,81 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.SQLDelete;
+import org.hibernate.annotations.SQLRestriction;
+
+import java.time.Instant;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="users")
+@SQLDelete(sql = "UPDATE users SET deleted_at = CURRENT_TIMESTAMP WHERE user_id = ?")
+@SQLRestriction("deleted_at IS NULL")
+public class User {
+
+	@Id
+	@Column(name = "user_id",nullable = false)
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long userId;
+	
+	@Column(name = "employee_id",nullable = false)
+	private String employeeId;
+	
+	@Column(name = "username")
+	private String userName;	
+	
+	@Column(name = "ldap_group")
+	private String ldapGroup;
+	
+	@Column(name = "role")
+	private String role;
+	
+	@Column(name = "casino_code",nullable = false)
+	private String casinoCode;
+	
+	@Column(name = "pits")
+	private String pitCodes;
+	
+	@Column(name = "device_id")
+	private String deviceId;
+	
+	@Column(name = "device_token")
+	private String deviceToken;
+	
+	@Column(name = "online_status")
+	private Boolean onlineStatus;
+	
+	@Column(name = "last_heartbeat")
+	private Instant lastHeartbeat;
+	
+	@Column(name = "email")
+	private String email;
+
+    @Column(name = "password")
+    private String password;
+
+    @Column(name = "status")
+    private Integer status;
+	
+	@Column(name = "last_login")
+	private Instant lastLogin;
+
+    @Column(name = "cms_last_login")
+    private Instant cmsLastLogin;
+	
+	@Column(name = "is_deleted")
+	private Boolean deleted;
+	
+	@Column(name = "deleted_at")
+	private Instant deletedAt;
+	
+	@Version
+	@Column(name="version")
+	private Long version;	
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/UserRole.java

@@ -0,0 +1,25 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="user_roles")
+public class UserRole {
+
+    @Id
+    @Column(name = "id",nullable = false)
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "user_id")
+    private Long userId;
+
+    @Column(name = "role_id")
+    private Long roleId;
+}

src/main/java/com/sjmresorts/opsapp/authentication/models/UserToken.java

@@ -0,0 +1,40 @@
+package com.sjmresorts.opsapp.authentication.models;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.Instant;
+import java.util.Date;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@Entity
+@Table(name="user_tokens")
+public class UserToken {
+    @Id
+    @Column(name = "token_id",nullable = false)
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long tokenId;
+
+    @Column(name = "user_code",nullable = false)
+    private String userCode;
+
+    @Column(name = "token_type",nullable = false)
+    private String tokenType;
+
+    @Column(name = "token_value",nullable = false)
+    private String tokenValue;
+
+    @Column(name = "token_uuid")
+    private String tokenUniqueId;
+
+    @Column(name = "created_at")
+    private Instant createdAt;
+
+    @Column(name = "expiry_time")
+    private Date expiryTime;
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/DeviceInfoRepository.java

@@ -0,0 +1,29 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.ClientInfo;
+import jakarta.transaction.Transactional;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.time.Instant;
+import java.util.List;
+
+@Repository
+public interface DeviceInfoRepository extends JpaRepository<ClientInfo, Long> {
+
+	List<ClientInfo> findAllByDeviceFuid(String deviceId);
+
+    Page<ClientInfo> findAll(Specification<ClientInfo> listSpec, Pageable pageable);
+
+    @Modifying
+    @Transactional
+    @Query(value="update ClientInfo set currentLoginUser=null, updatedAt=?2 " +
+            "where currentLoginUser=?1 ")
+    void clearLogoutDevice(String employeeId, Instant updateTime);
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/RolePermissionRepository.java

@@ -0,0 +1,16 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.RolePermission;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface RolePermissionRepository extends JpaRepository<RolePermission, Long> {
+
+    @Query("SELECT rp FROM RolePermission rp WHERE rp.roleId = ?1")
+    List<RolePermission> getAllPermissionByRoleId(Long roleId);
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/RouterPermissionRepository.java

@@ -0,0 +1,21 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.RouterPermission;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface RouterPermissionRepository extends JpaRepository<RouterPermission, Long> {
+
+    @Query(value="select rp from RouterPermission rp where rp.id in " +
+            " (select rop.permissionId from RolePermission rop where rop.roleId in ?1) ")
+    List<RouterPermission> queryPermissionByRoleIds(List<Long> roleIds);
+
+    @Query(value="select rp from RouterPermission rp where rp.id in " +
+            " (select rop.permissionId from RolePermission rop where rop.roleId in ?1) and rp.routerId in ?2 ")
+    List<RouterPermission> queryPermissionByRoleAndRouterIds(List<Long> roleIds,List<String> routerIds);
+
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/SysRouterRepository.java

@@ -0,0 +1,24 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.SysRouter;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface SysRouterRepository extends JpaRepository<SysRouter, String> {
+
+    @Query(value="select rte from SysRouter rte where rte.status=1 order by rte.sortNo")
+    List<SysRouter> queryAllActiveRouter();
+
+    @Query(value="select rte from SysRouter rte order by rte.sortNo")
+    List<SysRouter> queryAllRoutersOrderBySort();
+
+    @Query(value="select rte from SysRouter rte where rte.heading is not null and rte.status=1 order by rte.sortNo")
+    List<SysRouter> getAllChildrenRoutes();
+
+    @Query(value="select rte.id from SysRouter rte where heading=?1")
+    List<String> queryIdsByHeading(String appRouterName);
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/UserRepository.java

@@ -0,0 +1,66 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.User;
+import jakarta.transaction.Transactional;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+	 Optional<User> findByEmployeeId(String employeeId);
+
+    Optional<User> findByDeviceId(String deviceId);
+
+    List<User> findByEmployeeIdIn(Collection<String> employeeIds);
+
+    Optional<User> findByDeviceToken(String deviceToken);
+
+    Page<User> findAll(Specification<User> listSpec, Pageable pageable);
+
+    List<User> findAll(Specification<User> spec, Sort sort);
+
+    @Query(value="select usr from User usr where casinoCode=?1 and pitCodes like %?2% and lastHeartbeat >= ?3")
+    List<User> queryOnlineUserForPit(String casinoCode, String pitCode, Instant heartbeatAfter);
+
+    int countByEmployeeIdAndPassword(String upperCase, String encryptPassword);
+
+    @Modifying
+    @Transactional
+    @Query(value="update User set casinoCode='', pitCodes='', deviceId=null, deviceToken=null, onlineStatus=false, lastHeartbeat=null " +
+            " where employeeId=?1 ")
+    void clearAppLoginInfoByUser(String employeeId);
+
+    @Modifying
+    @Transactional
+    @Query(value="update User set lastHeartbeat=?2 where employeeId=?1 ")
+    int registerHeartBeat(String employeeId, Instant now);
+
+    @Query(value = "select u.employeeId from User u where u.lastHeartbeat < ?1 order by u.lastHeartbeat asc")
+    List<String> findExpiredSessionEmployeeIds(Instant checkExpiryTime, Pageable pageable);
+
+    @Modifying
+    @Transactional
+    @Query(value="update User set deviceId=null, deviceToken=null where employeeId<>?1 and deviceId=?2")
+    void clearOtherUserDeviceInfo(String employeeId, String deviceId);
+
+    @Modifying
+    @Transactional
+    @Query("update User u set u.deviceToken = null where u.deviceToken = ?1")
+    int clearDeviceTokenByToken(String deviceToken);
+
+    @Modifying
+    @Transactional
+    @Query("update User u set u.deviceToken = null where u.employeeId = ?1")
+    int clearDeviceTokenByEmployeeId(String employeeId);
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/UserRoleRepository.java

@@ -0,0 +1,15 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.UserRole;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface UserRoleRepository extends JpaRepository<UserRole, Long> {
+
+    @Query(value="select usrRole.id from UserRole usrRole where userId=?1 ")
+    List<Long> findRoleIdListByUserId(Long userId);
+}

src/main/java/com/sjmresorts/opsapp/authentication/repositories/UserTokenRepository.java

@@ -0,0 +1,30 @@
+package com.sjmresorts.opsapp.authentication.repositories;
+
+import com.sjmresorts.opsapp.authentication.models.UserToken;
+import jakarta.transaction.Transactional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.Date;
+
+@Repository
+public interface UserTokenRepository extends JpaRepository<UserToken, Long> {
+
+    int countByTokenUniqueId(String tokenUuid);
+    int countByTokenTypeAndTokenValue(String tokenType, String tokenValue);
+
+    @Modifying
+    @Transactional
+    void deleteAllByTokenTypeAndUserCode(String tokenType, String userCode);
+
+    @Modifying
+    @Transactional
+    void deleteAllByTokenUniqueId(String tokenUuid);
+
+    @Modifying
+    @Transactional
+    @Query(value="delete from UserToken where expiryTime<?1")
+    void deleteAllExpiredBeforeTime(Date expiryTime);
+}

src/main/java/com/sjmresorts/opsapp/authentication/services/AdAuthorizeService.java

@@ -0,0 +1,76 @@
+package com.sjmresorts.opsapp.authentication.services;
+
+import com.sjmresorts.opsapp.authentication.dtos.AdAuthorizeResponse;
+import com.sjmresorts.opsapp.authentication.dtos.AdUserInfo;
+import com.sjmresorts.opsapp.common.dtos.LDAP.ADAccountInfo;
+import com.sjmresorts.opsapp.common.utils.LDAPUtil;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class AdAuthorizeService {
+	@Resource
+	private LDAPUtil ldapUtil;
+
+	public AdAuthorizeResponse mockupAdUserLogin(String userCode, String password) {
+		AdAuthorizeResponse result = new AdAuthorizeResponse();
+
+		result.setSuccess(true);
+		result.setCode("200");
+		AdUserInfo adUser = new AdUserInfo();
+		adUser.setEmployeeId(userCode);
+		adUser.setAdGroup(List.of("APP Admin"));
+		adUser.setUserName("chanTaiman");
+		adUser.setRole("ADRole");
+		adUser.setEmail("TestEmail@sjm.com");
+		result.setUserInfo(adUser);
+		return result;
+	}
+
+	public AdAuthorizeResponse verfiyAdUser(String employeeID, String password) {
+		AdAuthorizeResponse result = new AdAuthorizeResponse();
+
+		/*************Check And Get AD Account************/
+		boolean checkPassed = false;
+		checkPassed = ldapUtil.authenticate(employeeID, password);
+		ADAccountInfo account = ldapUtil.getAccountInfo(employeeID);
+		/*************Check And Get AD Account************/
+
+		if (account == null) {
+			// Handle user not found, e.g. throw custom exception or return error
+			throw new RuntimeException("User not found in LDAP: " + employeeID);
+		}
+
+		result.setSuccess(true);
+		result.setCode("200");
+		AdUserInfo adUser = new AdUserInfo();
+		adUser.setEmployeeId(employeeID);
+		adUser.setAdGroup(account.getDirectGroups());
+		adUser.setUserName(account.getDisplayName());
+		adUser.setRole("ADRole");
+		adUser.setEmail(account.getMail());
+		result.setUserInfo(adUser);
+		return result;
+	}
+
+	public AdAuthorizeResponse getAdUser(String userCode) {
+		AdAuthorizeResponse result = new AdAuthorizeResponse();
+
+		ADAccountInfo account = ldapUtil.getAccountInfo(userCode);
+
+		result.setSuccess(true);
+		result.setCode("200");
+		AdUserInfo adUser = new AdUserInfo();
+		adUser.setEmployeeId(userCode);
+		adUser.setAdGroup(account.getDirectGroups());
+//		adUser.setAdGroup(List.of("APP Admin"));
+		adUser.setUserName(account.getDisplayName());
+		adUser.setRole("ADRole");
+
+		adUser.setEmail(account.getMail());
+		result.setUserInfo(adUser);
+		return result;
+	}
+}