change package,change message_code

src/main/java/ru/soune/nocopy/service/AuthService.java

@@ -0,0 +1,95 @@
+package ru.soune.nocopy.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.MessageSource;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.*;
+import ru.soune.nocopy.entity.AuthToken;
+import ru.soune.nocopy.entity.User;
+import ru.soune.nocopy.exception.NotValidFieldException;
+import ru.soune.nocopy.repository.AuthTokenRepository;
+import ru.soune.nocopy.repository.UserRepository;
+
+import java.security.SecureRandom;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Map;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class AuthService {
+
+    private final UserRepository userRepository;
+
+    private final AuthTokenRepository authTokenRepository;
+
+    private final PasswordEncoder passwordEncoder;
+
+    private final MessageSource messageSource;
+
+    private final SecureRandom secureRandom = new SecureRandom();
+
+    @Transactional
+    public AuthToken register(RegRequest registerRequest) {
+        User user = new User();
+        user.setFullName(registerRequest.getFullName());
+        user.setEmail(registerRequest.getEmail());
+        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
+
+        if (registerRequest.getCompanyName() != null) {
+            user.setCompany(registerRequest.getCompanyName());
+        }
+
+        if (registerRequest.getPhone() != null) {
+            user.setPhone(registerRequest.getPhone());
+        }
+
+        User savedUser = userRepository.save(user);
+
+        AuthToken authToken = new AuthToken();
+        authToken.setToken(generateAuthToken());
+        authToken.setUser(savedUser);
+
+        return authTokenRepository.save(authToken);
+    }
+
+    @Transactional
+    public AuthToken login(LoginRequest request) {
+        Optional<User> userOpt = userRepository.findByEmail(request.getEmail());
+        User user = userOpt.get();
+
+        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
+            LoginAnswer loginAnswer = new LoginAnswer();
+            loginAnswer.setFieldErrors(Arrays.asList(Map.of("password", request.getPassword())));
+
+            throw new NotValidFieldException("Invalid password", new BaseResponse(20003,
+                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getCode(),
+                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getDescription(), loginAnswer));
+        }
+
+        user.setLastLoginAt(LocalDateTime.now());
+        User savedUser = userRepository.save(user);
+
+        AuthToken authToken = new AuthToken();
+        authToken.setToken(generateAuthToken());
+        authToken.setUser(savedUser);
+
+        return authTokenRepository.save(authToken);
+    }
+
+    @Transactional
+    public void logout(String token) {
+        authTokenRepository.findByToken(token)
+                .ifPresent(authTokenRepository::delete);
+    }
+
+    private String generateAuthToken() {
+        byte[] bytes = new byte[32];
+        secureRandom.nextBytes(bytes);
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
+    }
+}

src/main/java/ru/soune/nocopy/service/UserContentService.java

@@ -0,0 +1,72 @@
+package ru.soune.nocopy.service;
+
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.UserContentRequest;
+import ru.soune.nocopy.dto.UserContentUpdateRequest;
+import ru.soune.nocopy.entity.FileType;
+import ru.soune.nocopy.entity.User;
+import ru.soune.nocopy.entity.UserContent;
+import ru.soune.nocopy.exception.ContentNotFoundException;
+import ru.soune.nocopy.exception.UserNotFoundException;
+import ru.soune.nocopy.mapper.UserContentMapper;
+import ru.soune.nocopy.repository.UserContentRepository;
+import ru.soune.nocopy.repository.UserRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@AllArgsConstructor
+public class UserContentService {
+
+    private final UserContentRepository userContentRepository;
+
+    private final UserRepository userRepository;
+
+    private final UserContentMapper userContentMapper;
+
+    public List<UserContent> findByUser(long userId) {
+        return userContentRepository.findByUserId(userId);
+    }
+
+    @Transactional
+    public UserContent addUserContent(UserContentRequest userContentRequest) {
+        UserContent userContent = new UserContent();
+
+        Optional<User> byEmail = userRepository.findByEmail(userContentRequest.userEmail());
+        User user = byEmail.orElseThrow(() -> new UserNotFoundException(userContentRequest.userEmail()));
+
+        userContent.setUser(user);
+        userContent.setFilename(userContentRequest.fileName());
+        userContent.setFileExtension(userContentRequest.fileExtension());
+        userContent.setFilePath(userContentRequest.filePath());
+        userContent.setFileType(FileType.valueOf(userContentRequest.fileType()));
+        userContent.setOriginalFilename(userContentRequest.originalFilename());
+        userContent.setProtectionLevel(userContentRequest.protectionLevel());
+        userContent.setFileSize(userContentRequest.fileSize());
+
+        //TODO add
+        //    @Column(name = "protection_hash", length = 64)
+        //    private String protectionHash;
+        //    @Column(name = "watermark_id", length = 50)
+        //    private String watermarkId;
+
+        return userContentRepository.save(userContent);
+    }
+
+    @Transactional
+    public UserContent updateUserContent(UserContentUpdateRequest userContentRequest) {
+        UserContent entity = userContentRepository.findById(userContentRequest.id())
+                .orElseThrow(() -> new ContentNotFoundException("Content not found with: " + userContentRequest.id()));
+
+        userContentMapper.updateEntityFromDto(userContentRequest, entity);
+
+        return userContentRepository.save(entity);
+    }
+
+    public void deleteUserContent(long userContentId) {
+        userContentRepository.deleteById(userContentId);
+    }
+}

src/main/java/ru/soune/nocopy/service/UserService.java

@@ -0,0 +1,86 @@
+package ru.soune.nocopy.service;
+
+import lombok.AllArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.ChangePasswordRequest;
+import ru.soune.nocopy.dto.UserDTO;
+import ru.soune.nocopy.dto.UserRequest;
+import ru.soune.nocopy.entity.User;
+import ru.soune.nocopy.exception.InvalidUserEmail;
+import ru.soune.nocopy.exception.NotValidationPasswordException;
+import ru.soune.nocopy.exception.UserNotFoundException;
+import ru.soune.nocopy.repository.UserRepository;
+
+@Service
+@AllArgsConstructor
+public class UserService {
+
+    private final UserRepository userRepository;
+
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public User changePassword(User user, ChangePasswordRequest request) {
+        if (!passwordEncoder.matches(request.getCurrentPassword(), user.getPassword())) {
+            throw new NotValidationPasswordException("Current password is incorrect");
+        }
+
+        user.setPassword(passwordEncoder.encode(request.getNewPassword()));
+
+        return userRepository.save(user);
+    }
+
+    @Transactional
+    public UserDTO updateUser(UserRequest userRequest, User currentUser) {
+        User user = userRepository.findById(currentUser.getId())
+                .orElseThrow(() -> new UserNotFoundException("User not found with id: " + currentUser.getId()));
+
+        updateUserFromRequest(user, userRequest);
+
+        User updatedUser = userRepository.save(user);
+
+        return mapToDTO(updatedUser);
+    }
+
+    private void updateUserFromRequest(User user, UserRequest request) {
+        if (request.getFullName() != null) {
+            user.setFullName(request.getFullName());
+        }
+
+        if (request.getCompany() != null) {
+            user.setCompany(request.getCompany());
+        }
+
+        if (request.getEmail() != null && !request.getEmail().equals(user.getEmail())) {
+            if (userRepository.existsByEmail(request.getEmail())) {
+                throw new InvalidUserEmail("Email already exists: " + request.getEmail());
+            }
+            user.setEmail(request.getEmail());
+        }
+
+        if (request.getPhone() != null) {
+            user.setPhone(request.getPhone());
+        }
+        if (request.getGenderType() != null) {
+            user.setGenderType(request.getGenderType());
+        }
+        if (request.getBirthday() != null) {
+            user.setBirthday(request.getBirthday());
+        }
+    }
+
+    private UserDTO mapToDTO(User user) {
+        return UserDTO.builder()
+                .fullName(user.getFullName())
+                .email(user.getEmail())
+                .company(user.getCompany())
+                .phone(user.getPhone())
+                .genderType(user.getGenderType())
+                .birthday(user.getBirthday())
+                .subscriptionType(user.getSubscriptionType())
+                .createdAt(user.getCreatedAt())
+                .build();
+    }
+}