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 org.springframework.http.ResponseEntity;
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 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.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
@RestController
@ -24,89 +14,40 @@ import java.util.HashSet;
@RequiredArgsConstructor
public class AccountsController {
private final AccountService accountService;
private final PasswordEncoder passwordEncoder;
@GetMapping("/current")
ResponseAccount currentAccount() {
var account = (Account) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
return account.toResponseObject();
throw new UnsupportedOperationException("Not implemented");
}
@PreAuthorize("hasRole('ADMIN')")
@GetMapping("/{accountId}")
ResponseEntity<ResponseAccount> findAccount(@PathVariable String accountId) {
try {
return ResponseEntity.ok(accountService.loadUserByUsername(accountId).toResponseObject());
} catch (UsernameNotFoundException ex) {
return ResponseEntity.notFound().build();
}
throw new UnsupportedOperationException("Not implemented");
}
@GetMapping
AllAccountsResponse allAccounts() {
return new AllAccountsResponse(accountService.allAccounts().stream()
.map(Account::toResponseObject)
.toList());
throw new UnsupportedOperationException("Not implemented");
}
@PostMapping
ResponseAccount registerAccount(@RequestParam String username, @RequestParam String password, @RequestParam(defaultValue = "") String permissions) {
var account = accountService.createNewAccount(username, password);
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();
throw new UnsupportedOperationException("Not implemented");
}
@PutMapping("/{accountId}")
ResponseEntity<?> updatePermissions(@PathVariable String accountId, @RequestParam(defaultValue = "") String permissions) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId));
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();
throw new UnsupportedOperationException("Not implemented");
}
@DeleteMapping("/{accountId}")
ResponseEntity<?> removeAccount(@PathVariable String accountId) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId));
accountService.removeAccount(account);
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
@PreAuthorize("hasRole('ADMIN') || principal.username.equals(accountId)")
@PutMapping("/{accountId}/password")
ResponseEntity<?> changePassword(@PathVariable String accountId, @RequestParam String newPassword) {
var account = accountService.findAccount(accountId).orElseThrow(() -> new AccountDoesNotExistsException(accountId));
account.setPassword(passwordEncoder.encode(newPassword));
accountService.updateState(account);
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
}

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 org.springframework.http.ResponseEntity;
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.user.UserDefinition;
import ru.dragonestia.picker.api.repository.response.NodeDetailsResponse;
import ru.dragonestia.picker.api.repository.response.NodeListResponse;
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")
@RestController
@ -30,17 +17,10 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
public class NodeController {
private final NodeService nodeService;
private final RoomService roomService;
private final DetailsParser detailsParser;
private final NamingValidator namingValidator;
@Operation(summary = "Get all nodes")
@GetMapping
NodeListResponse allNodes(
@RequestParam(name = "requiredDetails", required = false, defaultValue = "") String detailsSeq
) {
return new NodeListResponse(nodeService.getAllNodesWithDetailsResponse(detailsParser.parseNodeDetails(detailsSeq)));
NodeListResponse allNodes() {
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Register new node")
@ -50,8 +30,7 @@ public class NodeController {
@Parameter(description = "Picking method method") @RequestParam(name = "method") PickingMethod method,
@Parameter(description = "Save node") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist
) {
nodeService.create(new Node(NodeIdentifier.of(nodeId), method, persist));
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Get node details")
@ -59,11 +38,7 @@ public class NodeController {
ResponseEntity<NodeDetailsResponse> nodeDetails(
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId
) {
namingValidator.validateNodeId(nodeId);
return nodeService.find(nodeId)
.map(node -> ResponseEntity.ok(new NodeDetailsResponse(node.toResponseObject())))
.orElseThrow(() -> new NodeNotFoundException(nodeId));
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Unregister node")
@ -71,10 +46,7 @@ public class NodeController {
ResponseEntity<?> removeNode(
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId
) {
namingValidator.validateNodeId(nodeId);
nodeService.find(nodeId).ifPresent(nodeService::remove);
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Pick node for users")
@ -83,14 +55,6 @@ public class NodeController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@RequestBody String userIds
) {
namingValidator.validateNodeId(nodeId);
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);
throw new UnsupportedOperationException("Not implemented");
}
}

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 org.springframework.http.ResponseEntity;
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.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")
@RestController
@ -25,24 +16,12 @@ import ru.dragonestia.picker.util.NamingValidator;
@RequiredArgsConstructor
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")
@GetMapping
ResponseEntity<RoomListResponse> all(
@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
@Parameter(description = "Node identifier") @PathVariable(name = "nodeId") String nodeId
) {
return nodeService.find(nodeId)
.map(node -> {
var details = detailsParser.parseRoomDetails(detailsSeq);
var response = new RoomListResponse(nodeId, roomService.getAllRoomsWithDetailsResponse(node, details));
return ResponseEntity.ok(response);
}).orElseThrow(() -> new NodeNotFoundException(nodeId));
throw new UnsupportedOperationException("Not implemented");
}
@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 = "Save room") @RequestParam(name = "persist", required = false, defaultValue = "false") boolean persist
) {
var node = nodeService.find(nodeId).orElseThrow(() -> new NodeNotFoundException(nodeId));
var room = roomFactory.create(RoomIdentifier.of(roomId), node, slots, payload, persist);
roomService.create(room);
room.setLocked(locked);
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Unregister room")
@ -69,14 +43,7 @@ public class RoomController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId
) {
namingValidator.validateNodeId(nodeId);
namingValidator.validateRoomId(nodeId, roomId);
var nodeOpt = nodeService.find(nodeId);
nodeOpt.flatMap(node -> roomService.find(node, roomId))
.ifPresent(roomService::remove);
return ResponseEntity.ok().build();
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Get room details")
@ -85,13 +52,7 @@ public class RoomController {
@Parameter(description = "Node identifier") @PathVariable("nodeId") String nodeId,
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId
) {
namingValidator.validateNodeId(nodeId);
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));
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Lock/unlock room")
@ -102,13 +63,6 @@ public class RoomController {
@Parameter(description = "Room identifier") @PathVariable("roomId") String roomId,
@Parameter(description = "New state for Lock property") @RequestParam(name = "newState") boolean value
) {
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));
room.setLocked(value);
roomService.updateState(room);
return ResponseEntity.ok(true);
throw new UnsupportedOperationException("Not implemented");
}
}

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 lombok.RequiredArgsConstructor;
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.SearchUserResponse;
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")
@RequiredArgsConstructor
@ -23,46 +15,27 @@ import java.util.List;
@RequestMapping("/users")
public class UserController {
private final UserService userService;
private final DetailsParser detailsParser;
private final NamingValidator namingValidator;
@Operation(summary = "Search user by identifier")
@GetMapping("/search")
SearchUserResponse search(
@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
@Parameter(description = "User identifier input") @RequestParam(name = "input") String input
) {
if (!namingValidator.validateUserId(input) || input.isEmpty()) {
return new SearchUserResponse(List.of());
}
return new SearchUserResponse(userService.searchUsers(input, detailsParser.parseUserDetails(detailsSeq)));
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Get user info")
@GetMapping("/{userId}")
UserDetailsResponse find(
@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
@Parameter(description = "User identifier") @PathVariable(value = "userId") String userId
) {
if (!namingValidator.validateUserId(userId)) {
return new UserDetailsResponse(new ResponseUser(userId));
}
return new UserDetailsResponse(userService.getUserDetails(userId, detailsParser.parseUserDetails(detailsSeq)));
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Get rooms linked with user")
@GetMapping("/{userId}/rooms")
LinkedRoomsWithUserResponse roomsOf(
@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
@Parameter(description = "User identifier") @PathVariable(value = "userId") String userId
) {
if (!namingValidator.validateUserId(userId)) {
return new LinkedRoomsWithUserResponse(List.of());
}
return new LinkedRoomsWithUserResponse(userService.getUserRoomsWithDetails(new User(UserIdentifier.of(userId)), detailsParser.parseRoomDetails(detailsSeq)));
throw new UnsupportedOperationException("Not implemented");
}
}

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 org.springframework.http.ResponseEntity;
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.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")
@RequiredArgsConstructor
@ -29,12 +15,6 @@ import java.util.stream.Collectors;
@RequestMapping("/nodes/{nodeId}/rooms/{roomId}/users")
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")
@GetMapping
ResponseEntity<RoomUserListResponse> usersInsideRoom(
@ -42,10 +22,7 @@ public class UserRoomController {
@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
) {
var room = getNodeAndRoom(nodeId, roomId).room();
var users = userService.getRoomUsersWithDetailsResponse(room, detailsParser.parseUserDetails(detailsSeq));
return ResponseEntity.ok(new RoomUserListResponse(room.getMaxSlots(), users.size(), users));
throw new UnsupportedOperationException("Not implemented");
}
@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 = "Ignore slot limitation") @RequestParam(name = "force") boolean force
) {
var room = getNodeAndRoom(nodeId, roomId).room();
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()));
throw new UnsupportedOperationException("Not implemented");
}
@Operation(summary = "Unlink users from room")
@ -72,24 +43,6 @@ public class UserRoomController {
@Parameter(description = "Room identifier") @PathVariable(name = "roomId") String roomId,
@Parameter(description = "User identifiers", example = "user1,user2,user3") @RequestParam(name = "userIds") String userIds
) {
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);
throw new UnsupportedOperationException("Not implemented");
}
}

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 java.util.List;
import java.util.Set;
@Controller
public class GraphqlController {
@ -73,7 +72,7 @@ public class GraphqlController {
@QueryMapping
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))
.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<ResponseNode> getAllNodesWithDetailsResponse(Set<NodeDetails> details);
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);
List<ShortResponseRoom> getAllRoomsWithDetailsResponse(Node node, Set<RoomDetails> details);
PickedRoomResponse pickAvailable(Node node, Set<User> users);
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;
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.UserDetails;
import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User;
import java.util.Collection;
import java.util.List;
import java.util.Set;
public interface UserService {
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 unlinkUsersFromRoom(Room room, Collection<User> users);
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, Set<UserDetails> details);
ResponseUser getUserDetails(String userId);
}

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 ru.dragonestia.picker.api.exception.InvalidNodeIdentifierException;
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.repository.NodeRepository;
import ru.dragonestia.picker.repository.RoomRepository;
import ru.dragonestia.picker.service.NodeService;
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.Optional;
import java.util.Set;
@Service
@RequiredArgsConstructor
@ -25,8 +19,6 @@ public class NodeServiceImpl implements NodeService {
private final NodeRepository nodeRepository;
private final RoomRepository roomRepository;
private final DetailsExtractor detailsExtractor;
private final NamingValidator namingValidator;
private final NodeAndRoomStorage storage;
@Override
@ -50,15 +42,6 @@ public class NodeServiceImpl implements NodeService {
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
public Optional<Node> find(String 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.NotPersistedNodeException;
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.model.Room;
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.service.RoomService;
import ru.dragonestia.picker.storage.NodeAndRoomStorage;
import ru.dragonestia.picker.util.DetailsExtractor;
import ru.dragonestia.picker.util.NamingValidator;
import java.util.*;
@ -32,7 +29,6 @@ public class RoomServiceImpl implements RoomService {
private final RoomRepository roomRepository;
private final NodeRepository nodeRepository;
private final UserRepository userRepository;
private final DetailsExtractor detailsExtractor;
private final NamingValidator namingValidator;
private final NodeAndRoomStorage storage;
@ -65,15 +61,6 @@ public class RoomServiceImpl implements RoomService {
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
public PickedRoomResponse pickAvailable(Node node, Set<User> 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 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.UserDetails;
import ru.dragonestia.picker.api.repository.type.UserIdentifier;
import ru.dragonestia.picker.model.Room;
import ru.dragonestia.picker.model.User;
import ru.dragonestia.picker.repository.UserRepository;
import ru.dragonestia.picker.service.UserService;
import ru.dragonestia.picker.util.DetailsExtractor;
import java.util.*;
@ -20,22 +15,12 @@ import java.util.*;
public class UserServiceImpl implements UserService {
private final UserRepository userRepository;
private final DetailsExtractor detailsExtractor;
@Override
public Collection<Room> getUserRooms(User 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
public void linkUsersWithRoom(Room room, Collection<User> users, boolean force) {
userRepository.linkWithRoom(room, users, force);
@ -52,21 +37,12 @@ public class UserServiceImpl implements UserService {
}
@Override
public List<ResponseUser> getRoomUsersWithDetailsResponse(Room room, Set<UserDetails> details) {
var users = new LinkedList<ResponseUser>();
for (var user: getRoomUsers(room)) {
users.add(detailsExtractor.extract(user, details));
}
return users;
public List<ResponseUser> searchUsers(String input) {
return userRepository.search(input).stream().map(User::toResponseObject).toList();
}
@Override
public List<ResponseUser> searchUsers(String input, Set<UserDetails> details) {
return userRepository.search(input).stream().map(user -> detailsExtractor.extract(user, details)).toList();
}
@Override
public ResponseUser getUserDetails(String userId, Set<UserDetails> details) {
return detailsExtractor.extract(new User(UserIdentifier.of(userId)), details);
public ResponseUser getUserDetails(String userId) {
throw new UnsupportedOperationException("Not implemented");
}
}

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;
}
}