diff --git a/src/main/java/com/flow/admin/main/common/config/WebConfig.java b/src/main/java/com/flow/admin/main/common/config/WebConfig.java new file mode 100644 index 0000000..059e409 --- /dev/null +++ b/src/main/java/com/flow/admin/main/common/config/WebConfig.java @@ -0,0 +1,18 @@ +package com.flow.admin.main.common.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.web.servlet.config.annotation.CorsRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +@Configuration +public class WebConfig implements WebMvcConfigurer { + + @Override + public void addCorsMappings(CorsRegistry registry) { + registry.addMapping("/**") + .allowedOrigins("http://localhost:3000") + .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") + .allowedHeaders("*") + .allowCredentials(true); + } +} \ No newline at end of file diff --git a/src/main/java/com/flow/admin/main/controller/DashBoardController.java b/src/main/java/com/flow/admin/main/controller/DashBoardController.java index 919b4f7..ecf7bee 100644 --- a/src/main/java/com/flow/admin/main/controller/DashBoardController.java +++ b/src/main/java/com/flow/admin/main/controller/DashBoardController.java @@ -1,10 +1,13 @@ package com.flow.admin.main.controller; import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; +import com.flow.admin.main.dto.controller.dashboard.DashboardResponseDto; +import com.flow.admin.main.service.domain.dashboard.DashboardService; + import lombok.RequiredArgsConstructor; @RestController @@ -12,9 +15,11 @@ @RequiredArgsConstructor public class DashBoardController { - @PostMapping - public ResponseEntity inquiry() { - return null; + private final DashboardService dashboardService; + + @GetMapping + public ResponseEntity views() { + return ResponseEntity.ok().body(dashboardService.getDashboard()); } } diff --git a/src/main/java/com/flow/admin/main/controller/UserController.java b/src/main/java/com/flow/admin/main/controller/UserController.java new file mode 100644 index 0000000..c7103fc --- /dev/null +++ b/src/main/java/com/flow/admin/main/controller/UserController.java @@ -0,0 +1,26 @@ +package com.flow.admin.main.controller; + +import org.springframework.data.domain.Pageable; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import com.flow.admin.main.dto.controller.user.UserResponseDto; +import com.flow.admin.main.service.domain.user.UserService; + +import lombok.RequiredArgsConstructor; + +@RestController +@RequestMapping("/api/admin/user") +@RequiredArgsConstructor +public class UserController { + + private final UserService userService; + + @GetMapping + public ResponseEntity views(Pageable pageable) { + return ResponseEntity.ok().body(userService.getUser(pageable)); + } + +} diff --git a/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardRequestDto.java b/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardRequestDto.java new file mode 100644 index 0000000..be9016b --- /dev/null +++ b/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardRequestDto.java @@ -0,0 +1,18 @@ +package com.flow.admin.main.dto.controller.dashboard; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; + +import lombok.Builder; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.ToString; + +@Getter +@ToString +@Builder +@EqualsAndHashCode +@NoArgsConstructor +@JsonIgnoreProperties(ignoreUnknown = true) +public class DashboardRequestDto { +} diff --git a/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardResponseDto.java b/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardResponseDto.java new file mode 100644 index 0000000..37eb6be --- /dev/null +++ b/src/main/java/com/flow/admin/main/dto/controller/dashboard/DashboardResponseDto.java @@ -0,0 +1,25 @@ +package com.flow.admin.main.dto.controller.dashboard; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class DashboardResponseDto { + private ValueDto member; + private ValueDto order; + private ValueDto income; + + @Data + @Builder + @AllArgsConstructor + @NoArgsConstructor + public static class ValueDto { + private Long value; + } + +} diff --git a/src/main/java/com/flow/admin/main/dto/controller/user/UserRequestDto.java b/src/main/java/com/flow/admin/main/dto/controller/user/UserRequestDto.java new file mode 100644 index 0000000..d05066e --- /dev/null +++ b/src/main/java/com/flow/admin/main/dto/controller/user/UserRequestDto.java @@ -0,0 +1,15 @@ +package com.flow.admin.main.dto.controller.user; + +import lombok.Builder; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.ToString; + +@Getter +@ToString +@Builder +@EqualsAndHashCode +@NoArgsConstructor +public class UserRequestDto { +} diff --git a/src/main/java/com/flow/admin/main/dto/controller/user/UserResponseDto.java b/src/main/java/com/flow/admin/main/dto/controller/user/UserResponseDto.java new file mode 100644 index 0000000..d277e0d --- /dev/null +++ b/src/main/java/com/flow/admin/main/dto/controller/user/UserResponseDto.java @@ -0,0 +1,42 @@ +package com.flow.admin.main.dto.controller.user; + +import java.time.LocalDateTime; +import java.util.List; + +import org.springframework.data.domain.Pageable; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NoArgsConstructor; + +@Getter +@Builder +@EqualsAndHashCode +@AllArgsConstructor +@NoArgsConstructor +public class UserResponseDto { + + private List data; + private Pageable page; + + @Getter + @Builder + @EqualsAndHashCode + @AllArgsConstructor + @NoArgsConstructor + public static class DataDto { + private Long userId; + private String email; + private String userName; + private String schoolName; + private String schoolNumber; + private String majorName; + private Boolean status; + private String role; + private LocalDateTime createDate; + private LocalDateTime modifyDate; + } + +} diff --git a/src/main/java/com/flow/admin/main/dto/jpa/payments/PaymentsDto.java b/src/main/java/com/flow/admin/main/dto/jpa/payments/PaymentsDto.java new file mode 100644 index 0000000..2ec74e6 --- /dev/null +++ b/src/main/java/com/flow/admin/main/dto/jpa/payments/PaymentsDto.java @@ -0,0 +1,22 @@ +package com.flow.admin.main.dto.jpa.payments; + +import java.math.BigDecimal; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class PaymentsDto { + + private Long paymentId; + private Long orderId; + private BigDecimal amount; + private String paymentKey; + private String status; + +} diff --git a/src/main/java/com/flow/admin/main/dto/jpa/users/UsersDto.java b/src/main/java/com/flow/admin/main/dto/jpa/users/UsersDto.java index 87bbdb6..b753c9f 100644 --- a/src/main/java/com/flow/admin/main/dto/jpa/users/UsersDto.java +++ b/src/main/java/com/flow/admin/main/dto/jpa/users/UsersDto.java @@ -1,5 +1,7 @@ package com.flow.admin.main.dto.jpa.users; +import java.time.LocalDateTime; + import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; @@ -12,8 +14,11 @@ @NoArgsConstructor @Builder public class UsersDto { - private Long userId; - private String email; - private String password; - private int version; + private Long userId; + private String email; + private String password; + private LocalDateTime createDate; + private LocalDateTime modifyDate; + private Boolean useYn; + private int version; } diff --git a/src/main/java/com/flow/admin/main/entity/CategoriesEntity.java b/src/main/java/com/flow/admin/main/entity/CategoriesEntity.java index 3dafda5..651fcc2 100644 --- a/src/main/java/com/flow/admin/main/entity/CategoriesEntity.java +++ b/src/main/java/com/flow/admin/main/entity/CategoriesEntity.java @@ -1,30 +1,23 @@ package com.flow.admin.main.entity; -import java.util.ArrayList; -import java.util.List; - import org.hibernate.annotations.Where; import com.flow.admin.main.common.entity.BaseEntity; -import jakarta.persistence.CascadeType; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; -import jakarta.persistence.OneToMany; import jakarta.persistence.Table; import jakarta.persistence.Version; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; import lombok.NoArgsConstructor; -import lombok.Setter; @Entity @Getter -@Setter @AllArgsConstructor @NoArgsConstructor @Builder @@ -32,17 +25,14 @@ @Where(clause = "use_yn = true") public class CategoriesEntity extends BaseEntity { - @Id - @GeneratedValue(strategy = GenerationType.IDENTITY) - @Column(name = "category_id") - private Long categoryId; - - @Column(name = "category_name") - private String categoryName; + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "category_id") + private Long categoryId; - @OneToMany(mappedBy = "category", cascade = CascadeType.ALL, orphanRemoval = true) - private List postsEntities = new ArrayList<>(); + @Column(name = "category_name") + private String categoryName; - @Version - private int version; + @Version + private int version; } diff --git a/src/main/java/com/flow/admin/main/entity/OrdersEntity.java b/src/main/java/com/flow/admin/main/entity/OrdersEntity.java new file mode 100644 index 0000000..71b1129 --- /dev/null +++ b/src/main/java/com/flow/admin/main/entity/OrdersEntity.java @@ -0,0 +1,60 @@ +package com.flow.admin.main.entity; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.UUID; + +import org.hibernate.annotations.Where; + +import com.flow.admin.main.common.entity.BaseEntity; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Entity +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +@Table(name = "orders") +@Where(clause = "use_yn = true") +public class OrdersEntity extends BaseEntity { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "order_id") + private Long orderId; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "coffee_id") + private CoffeeChatsEntity coffee; + + @Column(name = "toss_order_id", nullable = false) + private UUID tossOrderId; + + @Column(name = "customer_key", nullable = false) + private UUID customerKey; + + @Column(name = "order_date", nullable = false) + private LocalDateTime orderDate; + + @Column(name = "total_amount", nullable = false, precision = 10, scale = 2) + private BigDecimal totalAmount; + + @Column(name = "status", nullable = false, length = 20) + private String status; + +} diff --git a/src/main/java/com/flow/admin/main/entity/PaymentsEntity.java b/src/main/java/com/flow/admin/main/entity/PaymentsEntity.java new file mode 100644 index 0000000..888389a --- /dev/null +++ b/src/main/java/com/flow/admin/main/entity/PaymentsEntity.java @@ -0,0 +1,47 @@ +package com.flow.admin.main.entity; + +import org.hibernate.annotations.Where; + +import com.flow.admin.main.common.entity.BaseEntity; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Entity +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@Builder +@Table(name = "payments") +@Where(clause = "use_yn = true") +public class PaymentsEntity extends BaseEntity { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "payment_id") + private Long paymentId; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "order_id", nullable = false) + private OrdersEntity order; + + @Column(name = "payment_key", nullable = false, length = 255) + private String paymentKey; + + @Column(name = "status", nullable = false, length = 20) + private String status; + +} diff --git a/src/main/java/com/flow/admin/main/mapper/PaymentsMapper.java b/src/main/java/com/flow/admin/main/mapper/PaymentsMapper.java new file mode 100644 index 0000000..d5b6310 --- /dev/null +++ b/src/main/java/com/flow/admin/main/mapper/PaymentsMapper.java @@ -0,0 +1,19 @@ +package com.flow.admin.main.mapper; + +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; + +import com.flow.admin.main.common.mapper.GenericMapper; +import com.flow.admin.main.dto.jpa.payments.PaymentsDto; +import com.flow.admin.main.entity.PaymentsEntity; + +@Mapper(componentModel = "spring") +public interface PaymentsMapper extends GenericMapper { + + @Mapping(target = "orderId", source = "order.orderId") + PaymentsDto toDto(PaymentsEntity paymentsEntity); + + @Mapping(target = "order.orderId", source = "orderId") + PaymentsEntity toEntity(PaymentsDto paymentsDto); + +} diff --git a/src/main/java/com/flow/admin/main/mapper/UserInfoMapper.java b/src/main/java/com/flow/admin/main/mapper/UserInfoMapper.java index 5114bc0..9b145f6 100644 --- a/src/main/java/com/flow/admin/main/mapper/UserInfoMapper.java +++ b/src/main/java/com/flow/admin/main/mapper/UserInfoMapper.java @@ -1,5 +1,7 @@ package com.flow.admin.main.mapper; +import java.util.List; + import org.mapstruct.Mapper; import org.mapstruct.Mapping; @@ -15,4 +17,11 @@ public interface UserInfoMapper extends GenericMapper toListDto(List userInfoEntities); + } diff --git a/src/main/java/com/flow/admin/main/mapper/UsersMapper.java b/src/main/java/com/flow/admin/main/mapper/UsersMapper.java index fac425b..b20d6af 100644 --- a/src/main/java/com/flow/admin/main/mapper/UsersMapper.java +++ b/src/main/java/com/flow/admin/main/mapper/UsersMapper.java @@ -1,5 +1,7 @@ package com.flow.admin.main.mapper; +import java.util.List; + import org.mapstruct.Mapper; import com.flow.admin.main.common.mapper.GenericMapper; @@ -8,5 +10,5 @@ @Mapper(componentModel = "spring") public interface UsersMapper extends GenericMapper { - + List toListDto(List users); } diff --git a/src/main/java/com/flow/admin/main/repository/MajorRepository.java b/src/main/java/com/flow/admin/main/repository/MajorRepository.java index 5527075..cbce024 100644 --- a/src/main/java/com/flow/admin/main/repository/MajorRepository.java +++ b/src/main/java/com/flow/admin/main/repository/MajorRepository.java @@ -12,4 +12,7 @@ public interface MajorRepository extends JpaRepository { @Query("SELECT m FROM MajorEntity m WHERE m.majorName = :majorName AND m.useYn = true") Optional findByMajorName(@Param("majorName") String majorName); + @Query("SELECT m FROM MajorEntity m WHERE m.majorId = :majorId") + Optional findByMajorId(@Param("majorId") Long majorId); + } diff --git a/src/main/java/com/flow/admin/main/repository/PaymentsRepository.java b/src/main/java/com/flow/admin/main/repository/PaymentsRepository.java new file mode 100644 index 0000000..5f447c9 --- /dev/null +++ b/src/main/java/com/flow/admin/main/repository/PaymentsRepository.java @@ -0,0 +1,9 @@ +package com.flow.admin.main.repository; + +import org.springframework.data.jpa.repository.JpaRepository; + +import com.flow.admin.main.entity.PaymentsEntity; + +public interface PaymentsRepository extends JpaRepository { + long count(); +} diff --git a/src/main/java/com/flow/admin/main/repository/SchoolRepository.java b/src/main/java/com/flow/admin/main/repository/SchoolRepository.java index 3a51090..c5166dd 100644 --- a/src/main/java/com/flow/admin/main/repository/SchoolRepository.java +++ b/src/main/java/com/flow/admin/main/repository/SchoolRepository.java @@ -13,4 +13,7 @@ public interface SchoolRepository extends JpaRepository { @Query("SELECT s FROM SchoolEntity s WHERE s.schoolName = :schoolName AND s.useYn = true") Optional findBySchoolName(@Param("schoolName") String schoolName); + @Query("SELECT s FROM SchoolEntity s WHERE s.schoolId = :schoolId") + Optional findBySchoolId(@Param("schoolId") Long schoolId); + } diff --git a/src/main/java/com/flow/admin/main/repository/UserInfoRepository.java b/src/main/java/com/flow/admin/main/repository/UserInfoRepository.java index bc77005..5bac70a 100644 --- a/src/main/java/com/flow/admin/main/repository/UserInfoRepository.java +++ b/src/main/java/com/flow/admin/main/repository/UserInfoRepository.java @@ -1,5 +1,6 @@ package com.flow.admin.main.repository; +import java.util.List; import java.util.Optional; import org.springframework.data.jpa.repository.JpaRepository; @@ -13,4 +14,6 @@ public interface UserInfoRepository extends JpaRepository @Query("SELECT ui FROM UserInfoEntity ui WHERE ui.user.userId = :userId") Optional findByUserId(@Param("userId") Long userId); + List findAll(); + } diff --git a/src/main/java/com/flow/admin/main/repository/UsersRepository.java b/src/main/java/com/flow/admin/main/repository/UsersRepository.java index 8bf5255..0d18d42 100644 --- a/src/main/java/com/flow/admin/main/repository/UsersRepository.java +++ b/src/main/java/com/flow/admin/main/repository/UsersRepository.java @@ -1,7 +1,9 @@ package com.flow.admin.main.repository; +import java.util.List; import java.util.Optional; +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; @@ -15,4 +17,9 @@ public interface UsersRepository extends JpaRepository { @Query("SELECT u FROM UsersEntity u WHERE u.email = :email") Optional findByEmail(@Param("email") String email); + @Query("SELECT u FROM UsersEntity u") + List findAllByPageable(Pageable pageable); + + long count(); + } diff --git a/src/main/java/com/flow/admin/main/service/dashboard/DashboardService.java b/src/main/java/com/flow/admin/main/service/dashboard/DashboardService.java deleted file mode 100644 index 1bc8150..0000000 --- a/src/main/java/com/flow/admin/main/service/dashboard/DashboardService.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.flow.admin.main.service.dashboard; - -import org.springframework.stereotype.Service; - -import lombok.RequiredArgsConstructor; - -@Service -@RequiredArgsConstructor -public class DashboardService { -} diff --git a/src/main/java/com/flow/admin/main/service/domain/dashboard/DashboardService.java b/src/main/java/com/flow/admin/main/service/domain/dashboard/DashboardService.java new file mode 100644 index 0000000..349ffc1 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/domain/dashboard/DashboardService.java @@ -0,0 +1,37 @@ +package com.flow.admin.main.service.domain.dashboard; + +import org.springframework.stereotype.Service; + +import com.flow.admin.main.dto.controller.dashboard.DashboardResponseDto; +import com.flow.admin.main.service.management.payments.persistence.PaymentsService; +import com.flow.admin.main.service.management.users.persistence.UsersService; + +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class DashboardService { + + private final UsersService usersService; + private final PaymentsService paymentsService; + + public DashboardResponseDto getDashboard() { + Long countAllByUser = usersService.countAll(); + Long countAllByPayment = paymentsService.count(); + + DashboardResponseDto.ValueDto memberValue = DashboardResponseDto.ValueDto.builder() + .value(countAllByUser) + .build(); + + DashboardResponseDto.ValueDto paymentValue = DashboardResponseDto.ValueDto.builder() + .value(countAllByPayment) + .build(); + + DashboardResponseDto.ValueDto incomeValue = DashboardResponseDto.ValueDto.builder() + .value(countAllByPayment * 2000) + .build(); + + return DashboardResponseDto.builder().member(memberValue).order(paymentValue).income(incomeValue).build(); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/domain/user/UserService.java b/src/main/java/com/flow/admin/main/service/domain/user/UserService.java new file mode 100644 index 0000000..0c7179c --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/domain/user/UserService.java @@ -0,0 +1,81 @@ +package com.flow.admin.main.service.domain.user; + +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.stream.Collectors; + +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; + +import com.flow.admin.main.dto.controller.user.UserResponseDto; +import com.flow.admin.main.dto.jpa.major.MajorDto; +import com.flow.admin.main.dto.jpa.school.SchoolDto; +import com.flow.admin.main.dto.jpa.userinfo.UserInfoDto; +import com.flow.admin.main.dto.jpa.users.UsersDto; +import com.flow.admin.main.service.management.major.persistence.MajorService; +import com.flow.admin.main.service.management.school.persistence.SchoolService; +import com.flow.admin.main.service.management.userinfo.persistence.UserInfoService; +import com.flow.admin.main.service.management.users.persistence.UsersService; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +@Slf4j +@Service +@RequiredArgsConstructor +public class UserService { + + private final UsersService usersService; + private final UserInfoService userInfoService; + private final MajorService majorService; + private final SchoolService schoolService; + + public UserResponseDto getUser(Pageable pageable) { + List usersDtoList = usersService.findAllByPageable(pageable); + + Map userInfoMap = userInfoService.findAll() + .stream() + .collect(Collectors.toMap( + UserInfoDto::getUserId, + userInfoDto -> userInfoDto, + (existing, replacement) -> replacement + )); + + List responseDataDtoList = usersDtoList.stream() + .map(usersDto -> { + UserInfoDto matchedUserInfo = userInfoMap.get(usersDto.getUserId()); + + return Optional.ofNullable(matchedUserInfo) + .map(userInfoDto -> UserResponseDto.DataDto.builder() + .userId(usersDto.getUserId()) + .userName(userInfoDto.getUserName()) + .email(usersDto.getEmail()) + .schoolName(fetchSchoolName(userInfoDto.getSchoolId())) + .schoolNumber(userInfoDto.getStudentNumber()) + .majorName(fetchMajorName(userInfoDto.getMajorId())) + .status(usersDto.getUseYn()) + .role(userInfoDto.getRole()) + .createDate(usersDto.getCreateDate()) + .modifyDate(usersDto.getModifyDate()) + .build()) + .orElse(null); + }) + .filter(Objects::nonNull) + .toList(); + + return UserResponseDto.builder().data(responseDataDtoList).page(pageable).build(); + } + + private String fetchSchoolName(Long schoolId) { + SchoolDto schoolDto = schoolService.findBySchoolId(schoolId); + return schoolDto.getSchoolName(); + } + + private String fetchMajorName(Long majorId) { + MajorDto majorDto = majorService.findByMajorId(majorId); + return majorDto.getMajorName(); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/categories/persistence/CategoriesService.java b/src/main/java/com/flow/admin/main/service/management/categories/persistence/CategoriesService.java new file mode 100644 index 0000000..497e52e --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/categories/persistence/CategoriesService.java @@ -0,0 +1,24 @@ +package com.flow.admin.main.service.management.categories.persistence; + +import org.springframework.stereotype.Service; + +import com.flow.admin.main.dto.jpa.categories.CategoriesDto; +import com.flow.admin.main.mapper.CategoriesMapper; +import com.flow.admin.main.repository.CategoriesRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class CategoriesService { + + private final CategoriesRepository categoriesRepository; + private final CategoriesMapper categoriesMapper; + + public CategoriesDto findByCategoryName(String categoryName) { + return categoriesMapper.toDto(categoriesRepository.findByCategoryName(categoryName) + .orElseThrow(() -> new EntityNotFoundException("Category not found with categoryName : " + categoryName))); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/coffeeChats/persistence/CoffeeChatsService.java b/src/main/java/com/flow/admin/main/service/management/coffeeChats/persistence/CoffeeChatsService.java new file mode 100644 index 0000000..afe07a8 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/coffeeChats/persistence/CoffeeChatsService.java @@ -0,0 +1,36 @@ +package com.flow.admin.main.service.management.coffeeChats.persistence; + +import java.util.List; + +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.coffeeChats.CoffeeChatsDto; +import com.flow.admin.main.entity.CoffeeChatsEntity; +import com.flow.admin.main.mapper.CoffeeChatsMapper; +import com.flow.admin.main.repository.CoffeeChatsRepository; + +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class CoffeeChatsService { + + private final CoffeeChatsRepository coffeeChatsRepository; + private final CoffeeChatsMapper coffeeChatsMapper; + + @Transactional(readOnly = true) + public List getAllByInitiatorUserIdWithPageable(Long initiatorUserId, Pageable pageable) { + return coffeeChatsMapper.toListDto( + coffeeChatsRepository.findAllCoffeeChatsByInitiatorUserIdWithPageable(initiatorUserId, pageable)); + } + + @Transactional + public CoffeeChatsDto save(CoffeeChatsDto coffeeChatsDto) { + CoffeeChatsEntity coffeeChatsEntity = coffeeChatsMapper.toEntity(coffeeChatsDto); + coffeeChatsRepository.save(coffeeChatsEntity); + return coffeeChatsMapper.toDto(coffeeChatsEntity); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/comments/persistence/CommentsService.java b/src/main/java/com/flow/admin/main/service/management/comments/persistence/CommentsService.java new file mode 100644 index 0000000..4cb0869 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/comments/persistence/CommentsService.java @@ -0,0 +1,46 @@ +package com.flow.admin.main.service.management.comments.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.comments.CommentsDto; +import com.flow.admin.main.entity.CommentsEntity; +import com.flow.admin.main.mapper.CommentsMapper; +import com.flow.admin.main.repository.CommentsRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class CommentsService { + + private final CommentsRepository commentsRepository; + private final CommentsMapper commentsMapper; + + @Transactional + public CommentsDto save(CommentsDto commentsDto) { + CommentsEntity commentsEntity = commentsMapper.toEntity(commentsDto); + return commentsMapper.toDto(commentsRepository.save(commentsEntity)); + } + + @Transactional(readOnly = true) + public CommentsDto findByCommentId(Long commentId) { + return commentsMapper.toDto(commentsRepository.findByCommentId(commentId) + .orElseThrow(() -> new EntityNotFoundException("Comments not found with commentId : " + commentId))); + } + + @Transactional(readOnly = true) + public CommentsDto findByCommentId(Long commentId, Long userId) { + return commentsMapper.toDto(commentsRepository.findByCommentId(commentId, userId) + .orElseThrow(() -> new EntityNotFoundException( + "Comments not found with commentId : " + commentId + " , userId : " + userId))); + } + + @Transactional + public CommentsDto delete(CommentsDto commentsDto) { + CommentsEntity commentsEntity = commentsMapper.toEntity(commentsDto); + commentsEntity.markDeleted(); + return commentsMapper.toDto(commentsRepository.save(commentsEntity)); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/likes/persistence/LikesService.java b/src/main/java/com/flow/admin/main/service/management/likes/persistence/LikesService.java new file mode 100644 index 0000000..182ce98 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/likes/persistence/LikesService.java @@ -0,0 +1,38 @@ +package com.flow.admin.main.service.management.likes.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.likes.LikesDto; +import com.flow.admin.main.entity.LikesEntity; +import com.flow.admin.main.mapper.LikesMapper; +import com.flow.admin.main.repository.LikesRepository; + +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class LikesService { + + private final LikesRepository likesRepository; + private final LikesMapper likesMapper; + + @Transactional + public LikesDto save(LikesDto likesDto) { + LikesEntity likesEntity = likesMapper.toEntity(likesDto); + return likesMapper.toDto(likesRepository.save(likesEntity)); + } + + @Transactional(readOnly = true) + public LikesDto findOrCreateByUserIdAndPostId(Long userId, Long postId) { + return likesMapper.toDto(likesRepository.findByUserIdAndPostId(userId, postId) + .orElse(LikesEntity.builder().build())); + } + + @Transactional + public LikesDto reuse(LikesDto likesDto) { + LikesEntity likesEntity = likesMapper.toEntity(likesDto); + likesEntity.markReuse(); + return likesMapper.toDto(likesRepository.save(likesEntity)); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/major/persistence/MajorService.java b/src/main/java/com/flow/admin/main/service/management/major/persistence/MajorService.java new file mode 100644 index 0000000..b99c5ce --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/major/persistence/MajorService.java @@ -0,0 +1,31 @@ +package com.flow.admin.main.service.management.major.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.major.MajorDto; +import com.flow.admin.main.mapper.MajorMapper; +import com.flow.admin.main.repository.MajorRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class MajorService { + + private final MajorRepository majorRepository; + private final MajorMapper majorMapper; + + @Transactional(readOnly = true) + public MajorDto findByMajorName(String majorName) { + return majorMapper.toDto(majorRepository.findByMajorName(majorName) + .orElseThrow(() -> new EntityNotFoundException("Major not found with majorName : " + majorName))); + } + + @Transactional(readOnly = true) + public MajorDto findByMajorId(Long majorId) { + return majorMapper.toDto(majorRepository.findByMajorId(majorId) + .orElseThrow(() -> new EntityNotFoundException("Major not found with majorName : " + majorId))); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/payments/persistence/PaymentsService.java b/src/main/java/com/flow/admin/main/service/management/payments/persistence/PaymentsService.java new file mode 100644 index 0000000..9b25f31 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/payments/persistence/PaymentsService.java @@ -0,0 +1,31 @@ +package com.flow.admin.main.service.management.payments.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.payments.PaymentsDto; +import com.flow.admin.main.entity.PaymentsEntity; +import com.flow.admin.main.mapper.PaymentsMapper; +import com.flow.admin.main.repository.PaymentsRepository; + +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class PaymentsService { + + private final PaymentsRepository paymentsRepository; + private final PaymentsMapper paymentsMapper; + + @Transactional + public PaymentsDto save(PaymentsDto paymentsDto) { + PaymentsEntity payments = paymentsMapper.toEntity(paymentsDto); + paymentsRepository.save(payments); + return paymentsMapper.toDto(payments); + } + + public Long count() { + return paymentsRepository.count(); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/posts/persistence/PostsService.java b/src/main/java/com/flow/admin/main/service/management/posts/persistence/PostsService.java new file mode 100644 index 0000000..53a965c --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/posts/persistence/PostsService.java @@ -0,0 +1,50 @@ +package com.flow.admin.main.service.management.posts.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.posts.PostsDto; +import com.flow.admin.main.entity.PostsEntity; +import com.flow.admin.main.mapper.PostsMapper; +import com.flow.admin.main.repository.PostsRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class PostsService { + + private final PostsRepository postsRepository; + private final PostsMapper postsMapper; + + @Transactional + public PostsDto save(PostsDto postsDto) { + PostsEntity postsEntity = postsMapper.toEntity(postsDto); + return postsMapper.toDto(postsRepository.save(postsEntity)); + } + + @Transactional(readOnly = true) + public PostsDto findByPostId(Long postId) { + PostsEntity postsEntity = postsRepository.findByPostId(postId) + .orElseThrow(() -> new EntityNotFoundException("Posts not found with postId : " + postId)); + return postsMapper.toDto(postsEntity); + } + + @Transactional(readOnly = true) + public PostsDto findByPostId(Long postId, Long userId) { + PostsEntity postsEntity = postsRepository.findByPostId(postId, userId) + .orElseThrow( + () -> new EntityNotFoundException("Posts not found with postId : " + postId + " , userId : " + userId)); + return postsMapper.toDto(postsEntity); + } + + @Transactional + public PostsDto delete(Long postId, Long userId) { + PostsEntity postsEntity = postsRepository.findByPostId(postId, userId) + .orElseThrow( + () -> new EntityNotFoundException("Posts not found with postId : " + postId + " , userId : " + userId)); + postsEntity.markDeleted(); + return postsMapper.toDto(postsRepository.save(postsEntity)); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/posttags/persistence/PostTagsService.java b/src/main/java/com/flow/admin/main/service/management/posttags/persistence/PostTagsService.java new file mode 100644 index 0000000..060b414 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/posttags/persistence/PostTagsService.java @@ -0,0 +1,62 @@ +package com.flow.admin.main.service.management.posttags.persistence; + +import java.util.Collections; +import java.util.List; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.posttags.PostTagsDto; +import com.flow.admin.main.entity.PostTagsEntity; +import com.flow.admin.main.mapper.PostTagsMapper; +import com.flow.admin.main.repository.PostTagsRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class PostTagsService { + + private final PostTagsRepository postTagsRepository; + private final PostTagsMapper postTagsMapper; + + @Transactional + public PostTagsDto save(PostTagsDto postTagsDto) { + PostTagsEntity postTagsEntity = postTagsMapper.toEntity(postTagsDto); + return postTagsMapper.toDto(postTagsRepository.save(postTagsEntity)); + } + + @Transactional(readOnly = true) + public List findAllByPostId(Long postId) { + List postTagsEntities = postTagsRepository.findAllByPostId(postId).orElse( + Collections.emptyList()); + return postTagsMapper.toListDto(postTagsEntities); + } + + @Transactional(readOnly = true) + public PostTagsDto findByPostIdAndTagId(Long postId, Long tagId) { + return postTagsMapper.toDto(postTagsRepository.findByPostIdAndTagId(postId, tagId) + .orElseThrow(() -> new EntityNotFoundException( + "PostTags not found with postId : " + postId + " and tagId : " + tagId))); + } + + @Transactional + public PostTagsDto reuseOrSavePostTags(PostTagsDto postTagsDto) { + PostTagsEntity postTagsEntity = postTagsRepository.findByPostIdAndTagIdUseYnFalse( + postTagsDto.getPostId(), postTagsDto.getTagId()).orElse(null); + if (postTagsEntity == null) { + return postTagsMapper.toDto(postTagsRepository.save(postTagsMapper.toEntity(postTagsDto))); + } + postTagsEntity.markReuse(); + return postTagsMapper.toDto(postTagsRepository.save(postTagsEntity)); + + } + + @Transactional + public PostTagsDto delete(PostTagsDto postTagsDto) { + PostTagsEntity postTagsEntity = postTagsMapper.toEntity(postTagsDto); + postTagsEntity.markDeleted(); + return postTagsMapper.toDto(postTagsRepository.save(postTagsEntity)); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/replies/persistence/RepliesService.java b/src/main/java/com/flow/admin/main/service/management/replies/persistence/RepliesService.java new file mode 100644 index 0000000..235e680 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/replies/persistence/RepliesService.java @@ -0,0 +1,41 @@ +package com.flow.admin.main.service.management.replies.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.replies.RepliesDto; +import com.flow.admin.main.entity.RepliesEntity; +import com.flow.admin.main.mapper.RepliesMapper; +import com.flow.admin.main.repository.RepliesRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class RepliesService { + + private final RepliesRepository repliesRepository; + private final RepliesMapper repliesMapper; + + @Transactional + public RepliesDto save(RepliesDto repliesDto) { + RepliesEntity repliesEntity = repliesMapper.toEntity(repliesDto); + return repliesMapper.toDto(repliesRepository.save(repliesEntity)); + } + + @Transactional(readOnly = true) + public RepliesDto findByReplyId(Long replyId, Long userId) { + RepliesEntity repliesEntity = repliesRepository.findByReplyId(replyId, userId) + .orElseThrow(() -> new EntityNotFoundException( + "Replies not found with replyId : " + replyId + " , userId : " + userId)); + return repliesMapper.toDto(repliesEntity); + } + + @Transactional + public RepliesDto delete(RepliesDto repliesDto) { + RepliesEntity repliesEntity = repliesMapper.toEntity(repliesDto); + repliesEntity.markDeleted(); + return repliesMapper.toDto(repliesRepository.save(repliesEntity)); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/school/persistence/SchoolService.java b/src/main/java/com/flow/admin/main/service/management/school/persistence/SchoolService.java new file mode 100644 index 0000000..9e7a6d6 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/school/persistence/SchoolService.java @@ -0,0 +1,31 @@ +package com.flow.admin.main.service.management.school.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.school.SchoolDto; +import com.flow.admin.main.mapper.SchoolMapper; +import com.flow.admin.main.repository.SchoolRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class SchoolService { + + private final SchoolRepository schoolRepository; + private final SchoolMapper schoolMapper; + + @Transactional(readOnly = true) + public SchoolDto findBySchoolName(String schoolName) { + return schoolMapper.toDto(schoolRepository.findBySchoolName(schoolName) + .orElseThrow(() -> new EntityNotFoundException("School not found with schoolName : " + schoolName))); + } + + @Transactional(readOnly = true) + public SchoolDto findBySchoolId(Long schoolId) { + return schoolMapper.toDto(schoolRepository.findBySchoolId(schoolId) + .orElseThrow(() -> new EntityNotFoundException("School not found with schoolId : " + schoolId))); + } +} diff --git a/src/main/java/com/flow/admin/main/service/management/tags/persistence/TagsService.java b/src/main/java/com/flow/admin/main/service/management/tags/persistence/TagsService.java new file mode 100644 index 0000000..f4f38f0 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/tags/persistence/TagsService.java @@ -0,0 +1,36 @@ +package com.flow.admin.main.service.management.tags.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.tags.TagsDto; +import com.flow.admin.main.entity.TagsEntity; +import com.flow.admin.main.mapper.TagsMapper; +import com.flow.admin.main.repository.TagsRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class TagsService { + + private final TagsRepository tagsRepository; + private final TagsMapper tagsMapper; + + @Transactional + public TagsDto saveOrFindByTagName(String tagName) { + boolean check = tagsRepository.existsByTagName(tagName); + if (!check) + return tagsMapper.toDto(tagsRepository.save(TagsEntity.builder().tagName(tagName).build())); + else + return findByTagName(tagName); + } + + @Transactional(readOnly = true) + public TagsDto findByTagName(String tagName) { + return tagsMapper.toDto(tagsRepository.findByTagName(tagName) + .orElseThrow(() -> new EntityNotFoundException("Tag not found with tagName : " + tagName))); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/userinfo/persistence/UserInfoService.java b/src/main/java/com/flow/admin/main/service/management/userinfo/persistence/UserInfoService.java new file mode 100644 index 0000000..1e98e61 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/userinfo/persistence/UserInfoService.java @@ -0,0 +1,43 @@ +package com.flow.admin.main.service.management.userinfo.persistence; + +import java.util.List; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.userinfo.UserInfoDto; +import com.flow.admin.main.entity.UserInfoEntity; +import com.flow.admin.main.mapper.UserInfoMapper; +import com.flow.admin.main.repository.UserInfoRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +@Slf4j +@Service +@RequiredArgsConstructor +public class UserInfoService { + + private final UserInfoRepository userInfoRepository; + private final UserInfoMapper userInfoMapper; + + @Transactional + public UserInfoDto save(UserInfoDto userInfoDto) { + UserInfoEntity userInfoEntity = userInfoMapper.toEntity(userInfoDto); + return userInfoMapper.toDto(userInfoRepository.save(userInfoEntity)); + } + + @Transactional(readOnly = true) + public UserInfoDto findByUserId(Long userId) { + return userInfoMapper.toDto(userInfoRepository.findByUserId(userId).orElseThrow( + () -> new EntityNotFoundException("UserInfo not found with userI : " + userId) + )); + } + + @Transactional(readOnly = true) + public List findAll() { + return userInfoMapper.toListDto(userInfoRepository.findAll()); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/users/persistence/UsersService.java b/src/main/java/com/flow/admin/main/service/management/users/persistence/UsersService.java new file mode 100644 index 0000000..f74b2f6 --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/users/persistence/UsersService.java @@ -0,0 +1,48 @@ +package com.flow.admin.main.service.management.users.persistence; + +import java.util.List; + +import org.springframework.data.domain.Pageable; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.users.UsersDto; +import com.flow.admin.main.mapper.UsersMapper; +import com.flow.admin.main.repository.UsersRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class UsersService { + + private final UsersRepository usersRepository; + private final UsersMapper usersMapper; + + @Transactional + public UsersDto save(UsersDto usersDto) { + return usersMapper.toDto(usersRepository.save(usersMapper.toEntity(usersDto))); + } + + public boolean existsByEmail(String email) { + return usersRepository.existsByEmail(email); + } + + @Transactional(readOnly = true) + public UsersDto findByEmail(String email) { + return usersMapper.toDto(usersRepository.findByEmail(email).orElseThrow( + () -> new EntityNotFoundException("User not found with email : " + email))); + } + + @Transactional(readOnly = true) + public List findAllByPageable(Pageable pageable) { + return usersMapper.toListDto(usersRepository.findAllByPageable(pageable)); + } + + @Transactional(readOnly = true) + public Long countAll() { + return usersRepository.count(); + } + +} diff --git a/src/main/java/com/flow/admin/main/service/management/usersessions/persistence/UserSessionsService.java b/src/main/java/com/flow/admin/main/service/management/usersessions/persistence/UserSessionsService.java new file mode 100644 index 0000000..09282bc --- /dev/null +++ b/src/main/java/com/flow/admin/main/service/management/usersessions/persistence/UserSessionsService.java @@ -0,0 +1,49 @@ +package com.flow.admin.main.service.management.usersessions.persistence; + +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import com.flow.admin.main.dto.jpa.usersessions.UserSessionsDto; +import com.flow.admin.main.entity.UserSessionsEntity; +import com.flow.admin.main.mapper.UserSessionsMapper; +import com.flow.admin.main.mapper.UsersMapper; +import com.flow.admin.main.repository.UserSessionsRepository; + +import jakarta.persistence.EntityNotFoundException; +import lombok.RequiredArgsConstructor; + +@Service +@RequiredArgsConstructor +public class UserSessionsService { + + private final UserSessionsRepository userSessionsRepository; + private final UserSessionsMapper userSessionsMapper; + private final UsersMapper usersMapper; + + @Transactional + public UserSessionsDto save(UserSessionsDto userSessionsDto) { + UserSessionsEntity userSessionsEntity = userSessionsMapper.toEntity(userSessionsDto); + return userSessionsMapper.toDto(userSessionsRepository.save(userSessionsEntity)); + } + + public UserSessionsDto existsByUserId(Long userId) { + boolean check = userSessionsRepository.existsByUserId(userId); + if (!check) + return UserSessionsDto.builder().build(); + else + return findByUserId(userId); + } + + @Transactional(readOnly = true) + public UserSessionsDto findByUserId(Long userId) { + return userSessionsMapper.toDto(userSessionsRepository.findByUserId(userId) + .orElseThrow(() -> new EntityNotFoundException("UserSessions not found with userId : " + userId))); + } + + @Transactional(readOnly = true) + public UserSessionsDto findByRefreshToken(String refreshToken) { + return userSessionsMapper.toDto(userSessionsRepository.findByRefreshToken(refreshToken) + .orElseThrow( + () -> new EntityNotFoundException("UserSessions not found with refreshToken : " + refreshToken))); + } +}