Main svc user

ewm-main-service/src/main/java/ru/practicum/controller/UserController.java

@@ -0,0 +1,59 @@
+package ru.practicum.controller;
+
+import jakarta.validation.constraints.Positive;
+import jakarta.validation.constraints.PositiveOrZero;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import ru.practicum.dto.AdminUserDto;
+import ru.practicum.dto.UserDtoReceived;
+import ru.practicum.dto.Validator;
+import ru.practicum.model.User;
+import ru.practicum.service.UserService;
+import ru.practicum.mapper.UserMapper;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@Validated
+@RequestMapping("/admin/users")
+@Slf4j
+public class UserController {
+
+    private final UserService userService;
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public ResponseEntity<AdminUserDto> createUser(@RequestBody @Validated({Validator.Create.class}) UserDtoReceived userDto) {
+        log.info("Calling the POST request to /admin/users endpoint {}", userDto);
+        User user = UserMapper.toUser(userDto);
+        return ResponseEntity.status(HttpStatus.CREATED)
+                .body(userService.createUser(user));
+
+    }
+
+
+    @DeleteMapping("/{userId}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    public ResponseEntity<String> deleteUser(@PathVariable Long userId) {
+        log.info("Calling the DELETE request to /admin/users/{userId} endpoint");
+        userService.deleteUser(userId);
+        return ResponseEntity
+                .status(HttpStatus.NO_CONTENT)
+                .body("User deleted: " + userId);
+    }
+
+    @GetMapping
+    public ResponseEntity<List<AdminUserDto>> getUsers(@RequestParam(defaultValue = "") List<Long> ids,
+                                                       @RequestParam(defaultValue = "0") @PositiveOrZero int from,
+                                                       @RequestParam(defaultValue = "10") @Positive int size) {
+        log.info("Calling the GET request to /admin/users endpoint");
+        List<AdminUserDto> response = UserMapper.toListAdminUserDto(userService.readUsers(ids, from, size));
+        return ResponseEntity.ok(response);
+    }
+
+}

ewm-main-service/src/main/java/ru/practicum/dto/AdminUserDto.java

@@ -0,0 +1,15 @@
+package ru.practicum.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+public class AdminUserDto {
+
+    private Long id;
+    private String name;
+    private String email;
+}

ewm-main-service/src/main/java/ru/practicum/dto/UserDto.java

@@ -0,0 +1,14 @@
+package ru.practicum.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+public class UserDto {
+
+    private Long id;
+    private String name;
+}

ewm-main-service/src/main/java/ru/practicum/dto/UserDtoReceived.java

@@ -0,0 +1,29 @@
+package ru.practicum.dto;
+
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+public class UserDtoReceived {
+
+    private Long id;
+
+    @Email(groups = {Validator.Create.class})
+    @Size(min = 6, max = 254, groups = {Validator.Create.class})
+    @NotBlank(groups = {Validator.Create.class})
+    private String email;
+
+    @NotBlank(groups = {Validator.Create.class})
+    @Size(min = 2, max = 250, groups = {Validator.Create.class})
+    private String name;
+
+
+    private Boolean isAdmin;
+}

ewm-main-service/src/main/java/ru/practicum/dto/UserShortDto.java

@@ -0,0 +1,14 @@
+package ru.practicum.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
+
+@Builder
+@Data
+public class UserShortDto {
+    @NotNull
+    private Long id;
+    @NotEmpty
+    private String name;
+}

ewm-main-service/src/main/java/ru/practicum/exception/ConflictException.java

@@ -0,0 +1,7 @@
+package ru.practicum.exception;
+
+public class ConflictException extends RuntimeException {
+    public ConflictException(final String massage) {
+        super(massage);
+    }
+}

ewm-main-service/src/main/java/ru/practicum/exception/NotFoundException.java

@@ -0,0 +1,7 @@
+package ru.practicum.exception;
+
+public class NotFoundException extends RuntimeException {
+    public NotFoundException(final String massage) {
+        super(massage);
+    }
+}

ewm-main-service/src/main/java/ru/practicum/exception/NotUniqueException.java

@@ -0,0 +1,7 @@
+package ru.practicum.exception;
+
+public class NotUniqueException extends RuntimeException {
+    public NotUniqueException(String message) {
+        super(message);
+    }
+}

ewm-main-service/src/main/java/ru/practicum/exception/handler/ErrorHandler.java

@@ -0,0 +1,67 @@
+package ru.practicum.exception.handler;
+
+
+import jakarta.validation.ConstraintViolationException;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.coyote.BadRequestException;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingRequestHeaderException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import ru.practicum.exception.ConflictException;
+import ru.practicum.exception.NotFoundException;
+import ru.practicum.exception.NotUniqueException;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+@Slf4j
+@RestControllerAdvice
+public class ErrorHandler {
+
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+
+    @ExceptionHandler({MissingRequestHeaderException.class, MethodArgumentNotValidException.class,
+            BadRequestException.class, ConstraintViolationException.class, MissingServletRequestParameterException.class})
+    public ResponseEntity<ErrorResponse> handleBadRequest(final Exception e) {
+        log.error("{} - Status: {}, Description: {}, Timestamp: {}",
+                "Bad Request", HttpStatus.BAD_REQUEST, e.getMessage(), LocalDateTime.now());
+
+        return new ResponseEntity<>(new ErrorResponse(HttpStatus.BAD_REQUEST.name(), e.getMessage(),
+                "Bad Request", LocalDateTime.now().format(FORMATTER)), HttpStatus.BAD_REQUEST);
+    }
+
+    @ExceptionHandler
+    public ResponseEntity<ErrorResponse> handleInternalServerError(final Exception e) {
+        log.error("{} - Status: {}, Description: {}, Timestamp: {}",
+                "SERVER ERROR", HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage(), LocalDateTime.now());
+
+        return new ResponseEntity<>(new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.name(), e.getMessage(),
+                "Internal Server Error", LocalDateTime.now().format(FORMATTER)), HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+
+    @ExceptionHandler({ConflictException.class, DataIntegrityViolationException.class, NotUniqueException.class})
+    public ResponseEntity<ErrorResponse> handleConflict(final Exception e) {
+        log.error("{} - Status: {}, Description: {}, Timestamp: {}",
+                "CONFLICT", HttpStatus.CONFLICT, e.getMessage(), LocalDateTime.now());
+
+        return new ResponseEntity<>(new ErrorResponse(HttpStatus.CONFLICT.name(), e.getMessage(),
+                "Data Integrity constraint violation occurred", LocalDateTime.now().format(FORMATTER)),
+                HttpStatus.CONFLICT);
+    }
+
+    @ExceptionHandler({NotFoundException.class})
+    public ResponseEntity<ErrorResponse> handleNotFound(final RuntimeException e) {
+        log.error("{} - Status: {}, Description: {}, Timestamp: {}",
+                "NOT FOUND", HttpStatus.NOT_FOUND, e.getMessage(), LocalDateTime.now());
+
+        return new ResponseEntity<>(new ErrorResponse(HttpStatus.NOT_FOUND.name(), e.getMessage(),
+                "Not Found", LocalDateTime.now().format(FORMATTER)), HttpStatus.NOT_FOUND);
+    }
+
+}

ewm-main-service/src/main/java/ru/practicum/exception/handler/ErrorResponse.java

@@ -0,0 +1,15 @@
+package ru.practicum.exception.handler;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class ErrorResponse {
+
+    private String status;
+    private String reason;
+    private String message;
+    private String timestamp;
+
+}

ewm-main-service/src/main/java/ru/practicum/mapper/UserMapper.java

@@ -0,0 +1,51 @@
+package ru.practicum.mapper;
+
+
+import lombok.experimental.UtilityClass;
+import ru.practicum.dto.AdminUserDto;
+import ru.practicum.dto.UserDto;
+import ru.practicum.dto.UserDtoReceived;
+import ru.practicum.dto.UserShortDto;
+import ru.practicum.model.User;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+public class UserMapper {
+
+    public UserDto toUserDto(User user) {
+        return UserDto.builder()
+                .name(user.getName())
+                .id(user.getId())
+                .build();
+    }
+
+    public static User toUser(UserDtoReceived userDto) {
+        return User.builder()
+                .email(userDto.getEmail())
+                .name(userDto.getName())
+                .isAdmin(userDto.getIsAdmin())
+                .build();
+    }
+
+    public static UserShortDto toUserShortDto(User user) {
+        return UserShortDto.builder()
+                .id(user.getId())
+                .name(user.getName())
+                .build();
+    }
+
+    public static AdminUserDto toAdminUserDto(User newUser) {
+        return AdminUserDto.builder()
+                .email(newUser.getEmail())
+                .id(newUser.getId())
+                .name(newUser.getName())
+                .build();
+    }
+
+    public static List<AdminUserDto> toListAdminUserDto(List<User> users) {
+        return users.stream().map(UserMapper::toAdminUserDto).collect(Collectors.toList());
+    }
+
+}

ewm-main-service/src/main/java/ru/practicum/model/User.java

@@ -0,0 +1,28 @@
+package ru.practicum.model;
+
+
+import jakarta.persistence.*;
+import lombok.*;
+
+@Data
+@Builder
+@Entity
+@AllArgsConstructor
+@NoArgsConstructor
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "user_name")
+    private String name;
+
+    @Column(name = "email")
+    private String email;
+
+    @Column(name = "is_admin")
+    private Boolean isAdmin;
+}

ewm-main-service/src/main/java/ru/practicum/repository/UserMainServiceRepository.java

@@ -0,0 +1,24 @@
+package ru.practicum.repository;
+
+
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import ru.practicum.model.User;
+
+import java.util.List;
+
+public interface UserMainServiceRepository extends JpaRepository<User, Long> {
+
+    @Query("SELECT u " +
+            "FROM User u " +
+            "WHERE u.id IN ?ids ")
+    List<User> findAllById(@Param("ids") List<Long> id, Pageable pageable);
+
+    @Query("SELECT u " +
+            "FROM User u")
+    List<User> findAllUser(Pageable pageable);
+
+    Boolean existsByEmail(String email);
+}

ewm-main-service/src/main/java/ru/practicum/service/UserService.java

@@ -0,0 +1,14 @@
+package ru.practicum.service;
+
+import ru.practicum.dto.AdminUserDto;
+import ru.practicum.model.User;
+
+import java.util.List;
+
+public interface UserService {
+    AdminUserDto createUser(User user);
+
+    void deleteUser(Long userId);
+
+    List<User> readUsers(List<Long> idList, int from, int size);
+}