Dragonestia/RoomPicker
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!removed all controller implementation and removed details

Browse Source
This commit is contained in:
Andrey Terentev 2024-05-10 10:50:33 +07:00 committed by Andrey Terentev
parent df44b55ce3
commit db7cdd2837
14 changed files with 35 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
server/src/main/java/ru/dragonestia/picker/controller/AccountsController.java
View File

@ -4,19 +4,9 @@ import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2; import lombok.extern.log4j.Log4j2;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import ru.dragonestia.picker.api.exception.AccountDoesNotExistsException;
import ru.dragonestia.picker.api.exception.PermissionNotFoundException;
import ru.dragonestia.picker.api.model.account.ResponseAccount; import ru.dragonestia.picker.api.model.account.ResponseAccount;
import ru.dragonestia.picker.api.repository.response.AllAccountsResponse; import ru.dragonestia.picker.api.repository.response.AllAccountsResponse;
import ru.dragonestia.picker.model.Account;
import ru.dragonestia.picker.model.Permission;
import ru.dragonestia.picker.service.AccountService;
import java.util.HashSet;
@Log4j2 @Log4j2
@RestController @RestController
@ -24,89 +14,40 @@ import java.util.HashSet;
@RequiredArgsConstructor @RequiredArgsConstructor
public class AccountsController { public class AccountsController {
private final AccountService accountService;
private final PasswordEncoder passwordEncoder;
@GetMapping("/current") @GetMapping("/current")
ResponseAccount currentAccount() { ResponseAccount currentAccount() {
var account = (Account) SecurityContextHolder.getContext().getAuthentication().getPrincipal(); throw new UnsupportedOperationException("Not implemented");
return account.toResponseObject();
} }
@PreAuthorize("hasRole('ADMIN')") @PreAuthorize("hasRole('ADMIN')")
@GetMapping("/{accountId}") @GetMapping("/{accountId}")
ResponseEntity<ResponseAccount> findAccount(@PathVariable String accountId) { ResponseEntity<ResponseAccount> findAccount(@PathVariable String accountId) {
try { throw new UnsupportedOperationException("Not implemented");
return ResponseEntity.ok(accountService.loadUserByUsername(accountId).toResponseObject());
} catch (UsernameNotFoundException ex) {
return ResponseEntity.notFound().build();
}
} }
@GetMapping @GetMapping
AllAccountsResponse allAccounts() { AllAccountsResponse allAccounts() {
return new AllAccountsResponse(accountService.allAccounts().stream() throw new UnsupportedOperationException("Not implemented");
.map(Account::toResponseObject)
.toList());
} }
@PostMapping @PostMapping
ResponseAccount registerAccount(@RequestParam String username, @RequestParam String password, @RequestParam(defaultValue = "") String permissions) { ResponseAccount registerAccount(@RequestParam String username, @RequestParam String password, @RequestParam(defaultValue = "") String permissions) {
var account = accountService.createNewAccount(username, password); throw new UnsupportedOperationException("Not implemented");
var authorities = new HashSet<Permission>();
for (var permStr : permissions.split(",")) {
if (permStr.isBlank()) continue;
try {
var perm = Permission.valueOf(permStr);
authorities.add(perm);
} catch (IllegalArgumentException ex) {
throw new PermissionNotFoundException(permStr);
}
}
account.setAuthorities(authorities);
accountService.updateState(account);
return account.toResponseObject();
} }
@PutMapping("/{accountId}") @PutMapping("/{accountId}")
ResponseEntity<?> updatePermissions(@PathVariable String accountId, @RequestParam(defaultValue = "") String permissions) { ResponseEntity<?> updatePermissions(@PathVariable String accountId, @RequestParam(defaultValue = "") String permissions) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId)); throw new UnsupportedOperationException("Not implemented");
var authorities = new HashSet<Permission>();
for (var permStr : permissions.split(",")) {
if (permStr.isBlank()) continue;
try {
var perm = Permission.valueOf(permStr);
authorities.add(perm);
} catch (IllegalArgumentException ex) {
throw new PermissionNotFoundException(permStr);
}
}
account.setAuthorities(authorities);
accountService.updateState(account);
return ResponseEntity.ok().build();
} }
@DeleteMapping("/{accountId}") @DeleteMapping("/{accountId}")
ResponseEntity<?> removeAccount(@PathVariable String accountId) { ResponseEntity<?> removeAccount(@PathVariable String accountId) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId)); throw new UnsupportedOperationException("Not implemented");
accountService.removeAccount(account);
return ResponseEntity.ok().build();
} }
@PreAuthorize("hasRole('ADMIN') || principal.username.equals(accountId)") @PreAuthorize("hasRole('ADMIN') || principal.username.equals(accountId)")
@PutMapping("/{accountId}/password") @PutMapping("/{accountId}/password")
ResponseEntity<?> changePassword(@PathVariable String accountId, @RequestParam String newPassword) { ResponseEntity<?> changePassword(@PathVariable String accountId, @RequestParam String newPassword) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId)); throw new UnsupportedOperationException("Not implemented");
account.setPassword(passwordEncoder.encode(newPassword));
accountService.updateState(account);
return ResponseEntity.ok().build();
} }
} }

48
server/src/main/java/ru/dragonestia/picker/controller/NodeController.java
View File

@ -6,23 +6,10 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import ru.dragonestia.picker.api.exception.NodeNotFoundException;
import ru.dragonestia.picker.api.model.node.PickingMethod; import ru.dragonestia.picker.api.model.node.PickingMethod;
import ru.dragonestia.picker.api.model.user.UserDefinition;
import ru.dragonestia.picker.api.repository.response.NodeDetailsResponse; import ru.dragonestia.picker.api.repository.response.NodeDetailsResponse;
import ru.dragonestia.picker.api.repository.response.NodeListResponse; import ru.dragonestia.picker.api.repository.response.NodeListResponse;
import ru.dragonestia.picker.api.repository.response.PickedRoomResponse; import ru.dragonestia.picker.api.repository.response.PickedRoomResponse;
import ru.dragonestia.picker.api.repository.type.NodeIdentifier;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.service.NodeService;
import ru.dragonestia.picker.service.RoomService;
import ru.dragonestia.picker.util.DetailsParser;
import ru.dragonestia.picker.util.NamingValidator;
import java.util.Arrays;
import java.util.stream.Collectors;
@Tag(name = "Nodes", description = "Node management") @Tag(name = "Nodes", description = "Node management")
@RestController @RestController
@ -30,17 +17,10 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor @RequiredArgsConstructor
public class NodeController { public class NodeController {
private final NodeService nodeService;
private final RoomService roomService;
private final DetailsParser detailsParser;
private final NamingValidator namingValidator;
@Operation(summary = "Get all nodes") @Operation(summary = "Get all nodes")
@GetMapping @GetMapping
NodeListResponse allNodes( NodeListResponse allNodes() {
@RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq throw new UnsupportedOperationException("Not implemented");
) {
return new NodeListResponse(nodeService.getAllNodesWithDetailsResponse(detailsParser.parseNodeDetails(detailsSeq)));
} }
@Operation(summary = "Register new node") @Operation(summary = "Register new node")
@ -50,8 +30,7 @@ public class NodeController {
@Parameter(description = "Picking method method") @RequestParam(name = "method") PickingMethod method, @Parameter(description = "Picking method method") @RequestParam(name = "method") PickingMethod method,
@Parameter(description = "Save node") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist @Parameter(description = "Save node") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist
) { ) {
nodeService.create(new Node(NodeIdentifier.of(nodeId), method, persist)); throw new UnsupportedOperationException("Not implemented");
return ResponseEntity.ok().build();
} }
@Operation(summary = "Get node details") @Operation(summary = "Get node details")
@ -59,11 +38,7 @@ public class NodeController {
ResponseEntity<NodeDetailsResponse> nodeDetails( ResponseEntity<NodeDetailsResponse> nodeDetails(
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId @Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
return nodeService.find(nodeId)
.map(node -> ResponseEntity.ok(new NodeDetailsResponse(node.toResponseObject())))
.orElseThrow(() -> new NodeNotFoundException(nodeId));
} }
@Operation(summary = "Unregister node") @Operation(summary = "Unregister node")
@ -71,10 +46,7 @@ public class NodeController {
ResponseEntity<?> removeNode( ResponseEntity<?> removeNode(
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId @Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
nodeService.find(nodeId).ifPresent(nodeService::remove);
return ResponseEntity.ok().build();
} }
@Operation(summary = "Pick node for users") @Operation(summary = "Pick node for users")
@ -83,14 +55,6 @@ public class NodeController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId, @Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@RequestBody String userIds @RequestBody String userIds
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId));
var users = Arrays.stream(userIds.split(","))
.map(userId -> new User(UserIdentifier.of(userId)))
.collect(Collectors.toSet());
var response = roomService.pickAvailable(node, users);
return ResponseEntity.ok(response);
} }
} }

58
server/src/main/java/ru/dragonestia/picker/controller/RoomController.java
View File

@ -7,17 +7,8 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import ru.dragonestia.picker.api.exception.NodeNotFoundException;
import ru.dragonestia.picker.api.exception.RoomNotFoundException;
import ru.dragonestia.picker.api.repository.response.RoomInfoResponse; import ru.dragonestia.picker.api.repository.response.RoomInfoResponse;
import ru.dragonestia.picker.api.repository.response.RoomListResponse; import ru.dragonestia.picker.api.repository.response.RoomListResponse;
import ru.dragonestia.picker.api.repository.type.RoomIdentifier;
import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.factory.RoomFactory;
import ru.dragonestia.picker.service.RoomService;
import ru.dragonestia.picker.service.NodeService;
import ru.dragonestia.picker.util.DetailsParser;
import ru.dragonestia.picker.util.NamingValidator;
@Tag(name = "Rooms", description = "Room management") @Tag(name = "Rooms", description = "Room management")
@RestController @RestController
@ -25,24 +16,12 @@ import ru.dragonestia.picker.util.NamingValidator;
@RequiredArgsConstructor @RequiredArgsConstructor
public class RoomController { public class RoomController {
private final NodeService nodeService;
private final RoomService roomService;
private final NamingValidator namingValidator;
private final DetailsParser detailsParser;
private final RoomFactory roomFactory;
@Operation(summary = "Get all rooms from node") @Operation(summary = "Get all rooms from node")
@GetMapping @GetMapping
ResponseEntity<RoomListResponse> all( ResponseEntity<RoomListResponse> all(
@Parameter(description = "Node identifier") @PathVariable(name = "nodeId") String nodeId, @Parameter(description = "Node identifier") @PathVariable(name = "nodeId") String nodeId
@Parameter(description = "Required addition data", example = "COUNT_USERS") @RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq
) { ) {
return nodeService.find(nodeId) throw new UnsupportedOperationException("Not implemented");
.map(node -> {
var details = detailsParser.parseRoomDetails(detailsSeq);
var response = new RoomListResponse(nodeId, roomService.getAllRoomsWithDetailsResponse(node, details));
return ResponseEntity.ok(response);
}).orElseThrow(() -> new NodeNotFoundException(nodeId));
} }
@Operation(summary = "Register new room") @Operation(summary = "Register new room")
@ -55,12 +34,7 @@ public class RoomController {
@Parameter(description = "Lock for picking") @RequestParam(name = "locked", required = false, defaultValue = "false") boolean locked, @Parameter(description = "Lock for picking") @RequestParam(name = "locked", required = false, defaultValue = "false") boolean locked,
@Parameter(description = "Save room") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist @Parameter(description = "Save room") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist
) { ) {
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId)); throw new UnsupportedOperationException("Not implemented");
var room = roomFactory.create(RoomIdentifier.of(roomId), node, slots, payload, persist);
roomService.create(room);
room.setLocked(locked);
return ResponseEntity.ok().build();
} }
@Operation(summary = "Unregister room") @Operation(summary = "Unregister room")
@ -69,14 +43,7 @@ public class RoomController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId, @Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId @Parameter(description = "Room identifier") @PathVariable("roomId") String roomId
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
namingValidator.validateRoomId(nodeId, roomId);
var nodeOpt = nodeService.find(nodeId);
nodeOpt.flatMap(node -> roomService.find(node, roomId))
.ifPresent(roomService::remove);
return ResponseEntity.ok().build();
} }
@Operation(summary = "Get room details") @Operation(summary = "Get room details")
@ -85,13 +52,7 @@ public class RoomController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId, @Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId @Parameter(description = "Room identifier") @PathVariable("roomId") String roomId
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
namingValidator.validateRoomId(nodeId, roomId);
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId));
return roomService.find(node, roomId)
.map(room -> ResponseEntity.ok(new RoomInfoResponse(room.toResponseObject())))
.orElseThrow(() -> new RoomNotFoundException(nodeId, roomId));
} }
@Operation(summary = "Lock/unlock room") @Operation(summary = "Lock/unlock room")
@ -102,13 +63,6 @@ public class RoomController {
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId, @Parameter(description = "Room identifier") @PathVariable("roomId") String roomId,
@Parameter(description = "New state for Lock property") @RequestParam(name = "newState") boolean value @Parameter(description = "New state for Lock property") @RequestParam(name = "newState") boolean value
) { ) {
namingValidator.validateNodeId(nodeId); throw new UnsupportedOperationException("Not implemented");
namingValidator.validateRoomId(nodeId, roomId);
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId));
var room = roomService.find(node, roomId).orElseThrow(() -> new RoomNotFoundException(nodeId, roomId));
room.setLocked(value);
roomService.updateState(room);
return ResponseEntity.ok(true);
} }
} }

39
server/src/main/java/ru/dragonestia/picker/controller/UserController.java
View File

@ -5,17 +5,9 @@ import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag; import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import ru.dragonestia.picker.api.model.user.ResponseUser;
import ru.dragonestia.picker.api.repository.response.LinkedRoomsWithUserResponse; import ru.dragonestia.picker.api.repository.response.LinkedRoomsWithUserResponse;
import ru.dragonestia.picker.api.repository.response.SearchUserResponse; import ru.dragonestia.picker.api.repository.response.SearchUserResponse;
import ru.dragonestia.picker.api.repository.response.UserDetailsResponse; import ru.dragonestia.picker.api.repository.response.UserDetailsResponse;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.service.UserService;
import ru.dragonestia.picker.util.DetailsParser;
import ru.dragonestia.picker.util.NamingValidator;
import java.util.List;
@Tag(name = "Users", description = "User management") @Tag(name = "Users", description = "User management")
@RequiredArgsConstructor @RequiredArgsConstructor
@ -23,46 +15,27 @@ import java.util.List;
@RequestMapping("/users") @RequestMapping("/users")
public class UserController { public class UserController {
private final UserService userService;
private final DetailsParser detailsParser;
private final NamingValidator namingValidator;
@Operation(summary = "Search user by identifier") @Operation(summary = "Search user by identifier")
@GetMapping("/search") @GetMapping("/search")
SearchUserResponse search( SearchUserResponse search(
@Parameter(description = "User identifier input") @RequestParam(name = "input") String input, @Parameter(description = "User identifier input") @RequestParam(name = "input") String input
@Parameter(description = "Required addition user data", example = "COUNT_ROOMS") @RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq
) { ) {
if (!namingValidator.validateUserId(input) || input.isEmpty()) { throw new UnsupportedOperationException("Not implemented");
return new SearchUserResponse(List.of());
}
return new SearchUserResponse(userService.searchUsers(input, detailsParser.parseUserDetails(detailsSeq)));
} }
@Operation(summary = "Get user info") @Operation(summary = "Get user info")
@GetMapping("/{userId}") @GetMapping("/{userId}")
UserDetailsResponse find( UserDetailsResponse find(
@Parameter(description = "User identifier") @PathVariable(value = "userId") String userId, @Parameter(description = "User identifier") @PathVariable(value = "userId") String userId
@Parameter(description = "Required addition user data", example = "COUNT_ROOMS") @RequestParam(value = "requiredDetails", required = false) String detailsSeq
) { ) {
if (!namingValidator.validateUserId(userId)) { throw new UnsupportedOperationException("Not implemented");
return new UserDetailsResponse(new ResponseUser(userId));
}
return new UserDetailsResponse(userService.getUserDetails(userId, detailsParser.parseUserDetails(detailsSeq)));
} }
@Operation(summary = "Get rooms linked with user") @Operation(summary = "Get rooms linked with user")
@GetMapping("/{userId}/rooms") @GetMapping("/{userId}/rooms")
LinkedRoomsWithUserResponse roomsOf( LinkedRoomsWithUserResponse roomsOf(
@Parameter(description = "User identifier") @PathVariable(value = "userId") String userId, @Parameter(description = "User identifier") @PathVariable(value = "userId") String userId
@Parameter(description = "Required addition room data", example = "COUNT_USERS") @RequestParam(value = "requiredDetails", defaultValue = "", required = false) String detailsSeq
) { ) {
if (!namingValidator.validateUserId(userId)) { throw new UnsupportedOperationException("Not implemented");
return new LinkedRoomsWithUserResponse(List.of());
}
return new LinkedRoomsWithUserResponse(userService.getUserRoomsWithDetails(new User(UserIdentifier.of(userId)), detailsParser.parseRoomDetails(detailsSeq)));
} }
} }

53
server/src/main/java/ru/dragonestia/picker/controller/UserRoomController.java
View File

@ -6,22 +6,8 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import ru.dragonestia.picker.api.exception.NodeNotFoundException;
import ru.dragonestia.picker.api.exception.RoomNotFoundException;
import ru.dragonestia.picker.api.repository.response.LinkUsersWithRoomResponse; import ru.dragonestia.picker.api.repository.response.LinkUsersWithRoomResponse;
import ru.dragonestia.picker.api.repository.response.RoomUserListResponse; import ru.dragonestia.picker.api.repository.response.RoomUserListResponse;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.service.RoomService;
import ru.dragonestia.picker.service.NodeService;
import ru.dragonestia.picker.service.UserService;
import ru.dragonestia.picker.util.DetailsParser;
import ru.dragonestia.picker.util.NamingValidator;
import java.util.Arrays;
import java.util.stream.Collectors;
@Tag(name = "Users", description = "User management") @Tag(name = "Users", description = "User management")
@RequiredArgsConstructor @RequiredArgsConstructor
@ -29,12 +15,6 @@ import java.util.stream.Collectors;
@RequestMapping("/nodes/{nodeId}/rooms/{roomId}/users") @RequestMapping("/nodes/{nodeId}/rooms/{roomId}/users")
public class UserRoomController { public class UserRoomController {
private final NodeService nodeService;
private final RoomService roomService;
private final UserService userService;
private final NamingValidator namingValidator;
private final DetailsParser detailsParser;
@Operation(summary = "Get users inside room") @Operation(summary = "Get users inside room")
@GetMapping @GetMapping
ResponseEntity<RoomUserListResponse> usersInsideRoom( ResponseEntity<RoomUserListResponse> usersInsideRoom(
@ -42,10 +22,7 @@ public class UserRoomController {
@Parameter(description = "Room identifier") @PathVariable(name = "roomId") String roomId, @Parameter(description = "Room identifier") @PathVariable(name = "roomId") String roomId,
@Parameter(description = "Required addition user data", example = "COUNT_ROOMS") @RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq @Parameter(description = "Required addition user data", example = "COUNT_ROOMS") @RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq
) { ) {
var room = getNodeAndRoom(nodeId, roomId).room(); throw new UnsupportedOperationException("Not implemented");
var users = userService.getRoomUsersWithDetailsResponse(room, detailsParser.parseUserDetails(detailsSeq));
return ResponseEntity.ok(new RoomUserListResponse(room.getMaxSlots(), users.size(), users));
} }
@Operation(summary = "Link users with room") @Operation(summary = "Link users with room")
@ -56,13 +33,7 @@ public class UserRoomController {
@Parameter(description = "User identifiers", example = "user1,user2,user3") @RequestParam(name = "userIds") String userIds, @Parameter(description = "User identifiers", example = "user1,user2,user3") @RequestParam(name = "userIds") String userIds,
@Parameter(description = "Ignore slot limitation") @RequestParam(name = "force") boolean force @Parameter(description = "Ignore slot limitation") @RequestParam(name = "force") boolean force
) { ) {
var room = getNodeAndRoom(nodeId, roomId).room(); throw new UnsupportedOperationException("Not implemented");
var users = Arrays.stream(userIds.split(","))
.map(userId -> new User(UserIdentifier.of(userId)))
.collect(Collectors.toSet());
userService.linkUsersWithRoom(room, users, force);
var usedSlots = userService.getRoomUsers(room).size();
return ResponseEntity.ok(new LinkUsersWithRoomResponse(usedSlots, room.getMaxSlots()));
} }
@Operation(summary = "Unlink users from room") @Operation(summary = "Unlink users from room")
@ -72,24 +43,6 @@ public class UserRoomController {
@Parameter(description = "Room identifier") @PathVariable(name = "roomId") String roomId, @Parameter(description = "Room identifier") @PathVariable(name = "roomId") String roomId,
@Parameter(description = "User identifiers", example = "user1,user2,user3") @RequestParam(name = "userIds") String userIds @Parameter(description = "User identifiers", example = "user1,user2,user3") @RequestParam(name = "userIds") String userIds
) { ) {
throw new UnsupportedOperationException("Not implemented");
var room = getNodeAndRoom(nodeId, roomId).room();
var users = Arrays.stream(userIds.split(","))
.map(userId -> new User(UserIdentifier.of(userId)))
.collect(Collectors.toSet());
userService.unlinkUsersFromRoom(room, users);
return ResponseEntity.ok().build();
}
private record NodeAndRoom(Node node, Room room) {}
private NodeAndRoom getNodeAndRoom(String nodeId, String roomId) {
namingValidator.validateNodeId(nodeId);
namingValidator.validateRoomId(nodeId, roomId);
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId));
var room = roomService.find(node, roomId).orElseThrow(() -> new RoomNotFoundException(nodeId, roomId));
return new NodeAndRoom(node, room);
} }
} }

3
server/src/main/java/ru/dragonestia/picker/controller/graphql/GraphqlController.java
View File

@ -15,7 +15,6 @@ import ru.dragonestia.picker.service.RoomService;
import ru.dragonestia.picker.service.UserService; import ru.dragonestia.picker.service.UserService;
import java.util.List; import java.util.List;
import java.util.Set;
@Controller @Controller
public class GraphqlController { public class GraphqlController {
@ -73,7 +72,7 @@ public class GraphqlController {
@QueryMapping @QueryMapping
List<EntityUser> searchUser(@Argument String input) { List<EntityUser> searchUser(@Argument String input) {
return userService.searchUsers(input, Set.of()).stream() return userService.searchUsers(input).stream()
.map(user -> new EntityUser(new User(user.getIdentifierObject()), dataProvider)) .map(user -> new EntityUser(new User(user.getIdentifierObject()), dataProvider))
.toList(); .toList();
} }

2
server/src/main/java/ru/dragonestia/picker/service/NodeService.java
View File

@ -21,7 +21,5 @@ public interface NodeService {
List<Node> all(); List<Node> all();
List<ResponseNode> getAllNodesWithDetailsResponse(Set<NodeDetails> details);
Optional<Node> find(String nodeId); Optional<Node> find(String nodeId);
} }

2
server/src/main/java/ru/dragonestia/picker/service/RoomService.java
View File

@ -24,8 +24,6 @@ public interface RoomService {
Collection<Room> all(Node node); Collection<Room> all(Node node);
List<ShortResponseRoom> getAllRoomsWithDetailsResponse(Node node, Set<RoomDetails> details);
PickedRoomResponse pickAvailable(Node node, Set<User> users); PickedRoomResponse pickAvailable(Node node, Set<User> users);
void updateState(Room room); void updateState(Room room);

12
server/src/main/java/ru/dragonestia/picker/service/UserService.java
View File

@ -1,32 +1,24 @@
package ru.dragonestia.picker.service; package ru.dragonestia.picker.service;
import ru.dragonestia.picker.api.exception.RoomAreFullException; import ru.dragonestia.picker.api.exception.RoomAreFullException;
import ru.dragonestia.picker.api.model.room.RoomDetails;
import ru.dragonestia.picker.api.model.room.ShortResponseRoom;
import ru.dragonestia.picker.api.model.user.ResponseUser; import ru.dragonestia.picker.api.model.user.ResponseUser;
import ru.dragonestia.picker.api.model.user.UserDetails;
import ru.dragonestia.picker.model.Room; import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User; import ru.dragonestia.picker.model.User;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Set;
public interface UserService { public interface UserService {
Collection<Room> getUserRooms(User user); Collection<Room> getUserRooms(User user);
List<ShortResponseRoom> getUserRoomsWithDetails(User user, Set<RoomDetails> details);
void linkUsersWithRoom(Room room, Collection<User> users, boolean force) throws RoomAreFullException; void linkUsersWithRoom(Room room, Collection<User> users, boolean force) throws RoomAreFullException;
void unlinkUsersFromRoom(Room room, Collection<User> users); void unlinkUsersFromRoom(Room room, Collection<User> users);
Collection<User> getRoomUsers(Room room); Collection<User> getRoomUsers(Room room);
List<ResponseUser> getRoomUsersWithDetailsResponse(Room room, Set<UserDetails> details); List<ResponseUser> searchUsers(String input);
List<ResponseUser> searchUsers(String input, Set<UserDetails> details); ResponseUser getUserDetails(String userId);
ResponseUser getUserDetails(String userId, Set<UserDetails> details);
} }

17
server/src/main/java/ru/dragonestia/picker/service/impl/NodeServiceImpl.java
View File

@ -4,20 +4,14 @@ import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import ru.dragonestia.picker.api.exception.InvalidNodeIdentifierException; import ru.dragonestia.picker.api.exception.InvalidNodeIdentifierException;
import ru.dragonestia.picker.api.exception.NodeAlreadyExistException; import ru.dragonestia.picker.api.exception.NodeAlreadyExistException;
import ru.dragonestia.picker.api.model.node.NodeDetails;
import ru.dragonestia.picker.api.model.node.ResponseNode;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.repository.NodeRepository; import ru.dragonestia.picker.repository.NodeRepository;
import ru.dragonestia.picker.repository.RoomRepository; import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.service.NodeService; import ru.dragonestia.picker.service.NodeService;
import ru.dragonestia.picker.storage.NodeAndRoomStorage; import ru.dragonestia.picker.storage.NodeAndRoomStorage;
import ru.dragonestia.picker.util.DetailsExtractor;
import ru.dragonestia.picker.util.NamingValidator;
import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.Set;
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
@ -25,8 +19,6 @@ public class NodeServiceImpl implements NodeService {
private final NodeRepository nodeRepository; private final NodeRepository nodeRepository;
private final RoomRepository roomRepository; private final RoomRepository roomRepository;
private final DetailsExtractor detailsExtractor;
private final NamingValidator namingValidator;
private final NodeAndRoomStorage storage; private final NodeAndRoomStorage storage;
@Override @Override
@ -50,15 +42,6 @@ public class NodeServiceImpl implements NodeService {
return nodeRepository.all(); return nodeRepository.all();
} }
@Override
public List<ResponseNode> getAllNodesWithDetailsResponse(Set<NodeDetails> details) {
var response = new LinkedList<ResponseNode>();
for (var node: all()) {
response.add(detailsExtractor.extract(node, details));
}
return response;
}
@Override @Override
public Optional<Node> find(String nodeId) { public Optional<Node> find(String nodeId) {
return nodeRepository.findById(nodeId); return nodeRepository.findById(nodeId);

13
server/src/main/java/ru/dragonestia/picker/service/impl/RoomServiceImpl.java
View File

@ -7,8 +7,6 @@ import ru.dragonestia.picker.api.exception.InvalidRoomIdentifierException;
import ru.dragonestia.picker.api.exception.NodeNotFoundException; import ru.dragonestia.picker.api.exception.NodeNotFoundException;
import ru.dragonestia.picker.api.exception.NotPersistedNodeException; import ru.dragonestia.picker.api.exception.NotPersistedNodeException;
import ru.dragonestia.picker.api.exception.RoomAlreadyExistException; import ru.dragonestia.picker.api.exception.RoomAlreadyExistException;
import ru.dragonestia.picker.api.model.room.RoomDetails;
import ru.dragonestia.picker.api.model.room.ShortResponseRoom;
import ru.dragonestia.picker.api.repository.response.PickedRoomResponse; import ru.dragonestia.picker.api.repository.response.PickedRoomResponse;
import ru.dragonestia.picker.model.Room; import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.Node; import ru.dragonestia.picker.model.Node;
@ -18,7 +16,6 @@ import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.UserRepository; import ru.dragonestia.picker.repository.UserRepository;
import ru.dragonestia.picker.service.RoomService; import ru.dragonestia.picker.service.RoomService;
import ru.dragonestia.picker.storage.NodeAndRoomStorage; import ru.dragonestia.picker.storage.NodeAndRoomStorage;
import ru.dragonestia.picker.util.DetailsExtractor;
import ru.dragonestia.picker.util.NamingValidator; import ru.dragonestia.picker.util.NamingValidator;
import java.util.*; import java.util.*;
@ -32,7 +29,6 @@ public class RoomServiceImpl implements RoomService {
private final RoomRepository roomRepository; private final RoomRepository roomRepository;
private final NodeRepository nodeRepository; private final NodeRepository nodeRepository;
private final UserRepository userRepository; private final UserRepository userRepository;
private final DetailsExtractor detailsExtractor;
private final NamingValidator namingValidator; private final NamingValidator namingValidator;
private final NodeAndRoomStorage storage; private final NodeAndRoomStorage storage;
@ -65,15 +61,6 @@ public class RoomServiceImpl implements RoomService {
return roomRepository.all(node); return roomRepository.all(node);
} }
@Override
public List<ShortResponseRoom> getAllRoomsWithDetailsResponse(Node node, Set<RoomDetails> details) {
var response = new LinkedList<ShortResponseRoom>();
for (var room: all(node)) {
response.add(detailsExtractor.extract(room, details));
}
return response;
}
@Override @Override
public PickedRoomResponse pickAvailable(Node node, Set<User> users) { public PickedRoomResponse pickAvailable(Node node, Set<User> users) {
var room = roomRepository.pick(node, users); var room = roomRepository.pick(node, users);

32
server/src/main/java/ru/dragonestia/picker/service/impl/UserServiceImpl.java
View File

@ -2,16 +2,11 @@ package ru.dragonestia.picker.service.impl;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import ru.dragonestia.picker.api.model.room.RoomDetails;
import ru.dragonestia.picker.api.model.room.ShortResponseRoom;
import ru.dragonestia.picker.api.model.user.ResponseUser; import ru.dragonestia.picker.api.model.user.ResponseUser;
import ru.dragonestia.picker.api.model.user.UserDetails;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Room; import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User; import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.repository.UserRepository; import ru.dragonestia.picker.repository.UserRepository;
import ru.dragonestia.picker.service.UserService; import ru.dragonestia.picker.service.UserService;
import ru.dragonestia.picker.util.DetailsExtractor;
import java.util.*; import java.util.*;
@ -20,22 +15,12 @@ import java.util.*;
public class UserServiceImpl implements UserService { public class UserServiceImpl implements UserService {
private final UserRepository userRepository; private final UserRepository userRepository;
private final DetailsExtractor detailsExtractor;
@Override @Override
public Collection<Room> getUserRooms(User user) { public Collection<Room> getUserRooms(User user) {
return userRepository.findAllLinkedUserRooms(user); return userRepository.findAllLinkedUserRooms(user);
} }
@Override
public List<ShortResponseRoom> getUserRoomsWithDetails(User user, Set<RoomDetails> details) {
var result = new LinkedList<ShortResponseRoom>();
for (var room: getUserRooms(user)) {
result.add(detailsExtractor.extract(room, details));
}
return result;
}
@Override @Override
public void linkUsersWithRoom(Room room, Collection<User> users, boolean force) { public void linkUsersWithRoom(Room room, Collection<User> users, boolean force) {
userRepository.linkWithRoom(room, users, force); userRepository.linkWithRoom(room, users, force);
@ -52,21 +37,12 @@ public class UserServiceImpl implements UserService {
} }
@Override @Override
public List<ResponseUser> getRoomUsersWithDetailsResponse(Room room, Set<UserDetails> details) { public List<ResponseUser> searchUsers(String input) {
var users = new LinkedList<ResponseUser>(); return userRepository.search(input).stream().map(User::toResponseObject).toList();
for (var user: getRoomUsers(room)) {
users.add(detailsExtractor.extract(user, details));
}
return users;
} }
@Override @Override
public List<ResponseUser> searchUsers(String input, Set<UserDetails> details) { public ResponseUser getUserDetails(String userId) {
return userRepository.search(input).stream().map(user -> detailsExtractor.extract(user, details)).toList(); throw new UnsupportedOperationException("Not implemented");
}
@Override
public ResponseUser getUserDetails(String userId, Set<UserDetails> details) {
return detailsExtractor.extract(new User(UserIdentifier.of(userId)), details);
} }
} }

71
server/src/main/java/ru/dragonestia/picker/util/DetailsExtractor.java
View File

@ -1,71 +0,0 @@
package ru.dragonestia.picker.util;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import ru.dragonestia.picker.api.model.node.NodeDetails;
import ru.dragonestia.picker.api.model.node.ResponseNode;
import ru.dragonestia.picker.api.model.room.RoomDetails;
import ru.dragonestia.picker.api.model.room.ShortResponseRoom;
import ru.dragonestia.picker.api.model.user.ResponseUser;
import ru.dragonestia.picker.api.model.user.UserDetails;
import ru.dragonestia.picker.model.Node;
import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.repository.NodeRepository;
import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.repository.UserRepository;
import java.util.Set;
@RequiredArgsConstructor
@Component
public class DetailsExtractor {
private final NodeRepository nodeRepository;
private final RoomRepository roomRepository;
private final UserRepository userRepository;
public ResponseNode extract(Node node, Set<NodeDetails> details) {
var response = node.toResponseObject();
for (var detail: details) {
if (detail == NodeDetails.PERSIST) {
response.putDetail(NodeDetails.PERSIST, Boolean.toString(node.isPersist()));
continue;
}
}
return response;
}
public ShortResponseRoom extract(Room room, Set<RoomDetails> details) {
var response = room.toShortResponseObject();
for (var detail: details) {
if (detail == RoomDetails.COUNT_USERS) {
var users = Integer.toString(userRepository.usersOf(room).size());
response.putDetail(RoomDetails.COUNT_USERS, users);
continue;
}
if (detail == RoomDetails.PERSIST) {
response.putDetail(RoomDetails.PERSIST, Boolean.toString(room.isPersist()));
continue;
}
}
return response;
}
public ResponseUser extract(User user, Set<UserDetails> details) {
var response = user.toResponseObject();
for (var detail: details) {
if (detail == UserDetails.COUNT_ROOMS) {
response.putDetail(UserDetails.COUNT_ROOMS, Integer.toString(userRepository.findAllLinkedUserRooms(user).size()));
}
}
return response;
}
}

43
server/src/main/java/ru/dragonestia/picker/util/DetailsParser.java
View File

@ -1,43 +0,0 @@
package ru.dragonestia.picker.util;
import org.springframework.stereotype.Component;
import ru.dragonestia.picker.api.model.node.NodeDetails;
import ru.dragonestia.picker.api.model.room.RoomDetails;
import ru.dragonestia.picker.api.model.user.UserDetails;
import java.util.HashSet;
import java.util.Set;
@Component
public class DetailsParser {
public Set<NodeDetails> parseNodeDetails(String detailsSeq) {
var details = new HashSet<NodeDetails>();
for (var detailStr: detailsSeq.split(",")) {
try {
details.add(NodeDetails.valueOf(detailStr.toUpperCase()));
} catch (IllegalArgumentException ignore) {}
}
return details;
}
public Set<RoomDetails> parseRoomDetails(String detailsSeq) {
var details = new HashSet<RoomDetails>();
for (var detailStr: detailsSeq.split(",")) {
try {
details.add(RoomDetails.valueOf(detailStr.toUpperCase()));
} catch (IllegalArgumentException ignore) {}
}
return details;
}
public Set<UserDetails> parseUserDetails(String detailsSeq) {
var details = new HashSet<UserDetails>();
for (var detailStr: detailsSeq.split(",")) {
try {
details.add(UserDetails.valueOf(detailStr.toUpperCase()));
} catch (IllegalArgumentException ignore) {}
}
return details;
}
}