7. 사용자가 채용공고에 지원 API (가산점 요소)

사용자가 채용공고에 지원하면 채용공고와 사용자 정보를 RequestBody로 넘기는 API이다 

사용자는 사용자대로, 채용공고는 채용공고대로 있기에 따로 Apply라는 객체로 만들어서 

사용자와 채용공고가 매치되게 했다. N : M 관계 구현을 의도한 것 같은데, 사실 사용자는 해당 채용공고에 한번만 지원가능하므로 사실상 1 : 1 을 구현한 건가싶다 

 

- User

위치 : /domain/user

@Table
@Getter
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String userName;

    @Builder
    public User(String userName) {
        this.userName = userName;
    }

    public static User of(String userName) {
        User user = User.builder()
                .userName(userName)
                .build();

        return user;
    }
}

 

- UserRepository

위치 : /domain/user

public interface UserRepository extends JpaRepository<User, Long> {
}

 

- UserService

위치 : /service/user

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    public void createUser(CreateUserRequest request) {
        User created = User.of(request.getUserName());

        userRepository.save(created);
    }
}

 

- UserController

위치 : /web/user

@RestController
@RequiredArgsConstructor
@RequestMapping("/user")
public class UserController {

    private final UserService userService;

    @PostMapping("/create")
    public ApiResponse<String> createUser(@RequestBody CreateUserRequest request) {
        userService.createUser(request);
        return ApiResponse.SUCCESS;
    }
}

 

- Apply

위치 : /domain/apply

@Table
@Getter
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Apply {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    @JoinColumn(name = "USER_ID")
    private User user;

    @OneToOne
    @JoinColumn(name = "RECRUITMENT_ID")
    private Recruitment recruitment;

    @Builder
    public Apply(User user, Recruitment recruitment) {
        this.user = user;
        this.recruitment = recruitment;
    }

    public static Apply of(User user, Recruitment recruitment) {
        Apply apply = Apply.builder()
                .user(user)
                .recruitment(recruitment)
                .build();

        return apply;
    }
}

 

- ApplyRepository

public interface ApplyRepository extends JpaRepository<Apply, Long> {

    Optional<Apply> findByUser(User user);
}

 

- ApplyService

위치 : /domain/apply

@Service
@RequiredArgsConstructor
public class ApplyService {

    private final RecruitmentRepository recruitmentRepository;
    private final UserRepository userRepository;
    private final ApplyRepository applyRepository;

    public void createApply(CreateApplyRequest request) throws Exception {
        Optional<Recruitment> recruitment = recruitmentRepository.findById(request.getRecruitId());
        Optional<User> user = userRepository.findById(request.getUserId());

        Optional<Apply> apply = applyRepository.findByUser(user.get());
        if (apply.isPresent()) {
            // 사용자는 한 채용공고에 한번만 지원할 수 있다
            throw new Exception();
        }

        Apply created = Apply.of(user.get(), recruitment.get());
        applyRepository.save(created);
    }
}

 

- ApplyController

위치 : /web/apply

@RestController
@RequiredArgsConstructor
@RequestMapping("/apply")
public class ApplyController {

    private final ApplyService applyService;

    @PostMapping("/create")
    public ApiResponse<String> createApply(@RequestBody CreateApplyRequest request) throws Exception {
        applyService.createApply(request);
        return ApiResponse.SUCCESS;
    }
}

 

Postman

 

RequestBody

{
    "recruitId" : 1,
    "userId" : 1
}

 

ResponseBody

{
    "data": null
}