[FEAT] 유저 엔티티 구현

src/main/java/com/mr/domain/user/entity/Instrument.java

@@ -0,0 +1,65 @@
+package com.mr.domain.user.entity;
+
+import com.mr.domain.user.exception.InstrumentErrorStatus;
+import com.mr.global.apipayload.exception.GeneralException;
+import com.mr.global.entity.BaseTimeEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "instrument")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Instrument extends BaseTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "instrument_id")
+    private Long instrumentId;
+
+    @Column(name = "code", nullable = false, unique = true, length = 20)
+    private String code;
+
+    @Column(name = "name", nullable = false, length = 50)
+    private String name;
+
+    @Column(name = "is_active", nullable = false)
+    private boolean active;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Instrument(String code, String name, boolean active) {
+        validateCode(code);
+        validateName(name);
+        this.code = code;
+        this.name = name;
+        this.active = active;
+    }
+
+    public static Instrument create(String code, String name) {
+        return Instrument.builder()
+                .code(code)
+                .name(name)
+                .active(true)
+                .build();
+    }
+
+    private static void validateCode(String code) {
+        if (code == null) {
+            throw new GeneralException(InstrumentErrorStatus.CODE_REQUIRED);
+        }
+    }
+
+    private static void validateName(String name) {
+        if (name == null) {
+            throw new GeneralException(InstrumentErrorStatus.NAME_REQUIRED);
+        }
+    }
+}

src/main/java/com/mr/domain/user/entity/Student.java

@@ -0,0 +1,73 @@
+package com.mr.domain.user.entity;
+
+import com.mr.domain.user.entity.enums.TheoryLevel;
+import com.mr.domain.user.exception.StudentErrorStatus;
+import com.mr.global.apipayload.exception.GeneralException;
+import com.mr.global.entity.BaseTimeEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "student")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Student extends BaseTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "student_id")
+    private Long studentId;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false, unique = true)
+    private User user;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "theory_level", nullable = false, length = 20)
+    private TheoryLevel theoryLevel;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Student(User user, TheoryLevel theoryLevel) {
+        validateUser(user);
+        validateTheoryLevel(theoryLevel);
+        this.user = user;
+        this.theoryLevel = theoryLevel;
+    }
+
+    public static Student create(User user, TheoryLevel theoryLevel) {
+        return Student.builder()
+                .user(user)
+                .theoryLevel(theoryLevel)
+                .build();
+    }
+
+    public void updateTheoryLevel(TheoryLevel theoryLevel) {
+        validateTheoryLevel(theoryLevel);
+        this.theoryLevel = theoryLevel;
+    }
+
+    private static void validateUser(User user) {
+        if (user == null) {
+            throw new GeneralException(StudentErrorStatus.USER_REQUIRED);
+        }
+    }
+
+    private static void validateTheoryLevel(TheoryLevel theoryLevel) {
+        if (theoryLevel == null) {
+            throw new GeneralException(StudentErrorStatus.THEORY_LEVEL_REQUIRED);
+        }
+    }
+}

src/main/java/com/mr/domain/user/entity/StudentInstrument.java

@@ -0,0 +1,93 @@
+package com.mr.domain.user.entity;
+
+import com.mr.domain.user.exception.StudentInstrumentErrorStatus;
+import com.mr.global.apipayload.exception.GeneralException;
+import com.mr.global.entity.BaseTimeEntity;
+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 jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(
+        name = "student_instrument",
+        uniqueConstraints = {
+                @UniqueConstraint(name = "uk_student_instrument_student_id_instrument_id",
+                        columnNames = {"student_id", "instrument_id"})
+        }
+)
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class StudentInstrument extends BaseTimeEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "student_instrument_id")
+    private Long studentInstrumentId;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "student_id", nullable = false)
+    private Student student;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "instrument_id", nullable = false)
+    private Instrument instrument;
+
+    @Column(name = "is_primary", nullable = false)
+    private boolean primary;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private StudentInstrument(Student student, Instrument instrument, boolean primary) {
+        validateStudent(student);
+        validateInstrument(instrument);
+        this.student = student;
+        this.instrument = instrument;
+        this.primary = primary;
+    }
+
+    public static StudentInstrument createPrimary(Student student, Instrument instrument) {
+        return StudentInstrument.builder()
+                .student(student)
+                .instrument(instrument)
+                .primary(true)
+                .build();
+    }
+
+    public static StudentInstrument createSecondary(Student student, Instrument instrument) {
+        return StudentInstrument.builder()
+                .student(student)
+                .instrument(instrument)
+                .primary(false)
+                .build();
+    }
+
+    public void markAsPrimary() {
+        this.primary = true;
+    }
+
+    public void unmarkAsPrimary() {
+        this.primary = false;
+    }
+
+    private static void validateStudent(Student student) {
+        if (student == null) {
+            throw new GeneralException(StudentInstrumentErrorStatus.STUDENT_REQUIRED);
+        }
+    }
+
+    private static void validateInstrument(Instrument instrument) {
+        if (instrument == null) {
+            throw new GeneralException(StudentInstrumentErrorStatus.INSTRUMENT_REQUIRED);
+        }
+    }
+}

src/main/java/com/mr/domain/user/entity/User.java

@@ -0,0 +1,75 @@
+package com.mr.domain.user.entity;
+
+import com.mr.domain.user.exception.UserErrorStatus;
+import com.mr.global.apipayload.exception.GeneralException;
+import com.mr.global.entity.BaseTimeEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.Size;
+import java.util.regex.Pattern;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "users")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class User extends BaseTimeEntity {
+
+    private static final int NICKNAME_MIN_LENGTH = 2;
+    private static final int NICKNAME_MAX_LENGTH = 10;
+    private static final Pattern NICKNAME_PATTERN =
+            Pattern.compile("^[가-힣a-zA-Z0-9]{" + NICKNAME_MIN_LENGTH + "," + NICKNAME_MAX_LENGTH + "}$");
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "user_id")
+    private Long userId;
+
+    @Size(
+            min = NICKNAME_MIN_LENGTH,
+            max = NICKNAME_MAX_LENGTH,
+            message = "닉네임은 2자 이상 10자 이하로 입력해야 합니다."
+    )
+    @Column(name = "nickname", unique = true, length = NICKNAME_MAX_LENGTH)
+    private String nickname;
+
+    @Column(name = "profile_img_url", nullable = false, length = 255)
+    private String profileImgUrl;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private User(String profileImgUrl) {
+        this.profileImgUrl = profileImgUrl;
+    }
+
+    public static User createFromOAuth(String profileImgUrl) {
+        return User.builder()
+                .profileImgUrl(profileImgUrl)
+                .build();
+    }
+
+    public boolean isOnboardingCompleted() {
+        return nickname != null;
+    }
+
+    public void updateNickname(String nickname) {
+        String trimmedNickname = nickname == null ? null : nickname.trim();
+        validateNickname(trimmedNickname);
+        this.nickname = trimmedNickname;
+    }
+
+    private static void validateNickname(String nickname) {
+        if (nickname == null || nickname.isBlank()) {
+            throw new GeneralException(UserErrorStatus.NICKNAME_REQUIRED);
+        }
+        if (!NICKNAME_PATTERN.matcher(nickname).matches()) {
+            throw new GeneralException(UserErrorStatus.NICKNAME_INVALID_FORMAT);
+        }
+    }
+}

src/main/java/com/mr/domain/user/entity/enums/TheoryLevel.java

@@ -0,0 +1,7 @@
+package com.mr.domain.user.entity.enums;
+
+public enum TheoryLevel {
+    BEGINNER,
+    INTERMEDIATE,
+    ADVANCED
+}

src/main/java/com/mr/domain/user/exception/InstrumentErrorStatus.java

@@ -0,0 +1,18 @@
+package com.mr.domain.user.exception;
+
+import com.mr.global.apipayload.code.BaseCode;
+import org.springframework.http.HttpStatus;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum InstrumentErrorStatus implements BaseCode {
+
+    CODE_REQUIRED(HttpStatus.BAD_REQUEST, "INSTRUMENT_400_01", "code는 필수입니다."),
+    NAME_REQUIRED(HttpStatus.BAD_REQUEST, "INSTRUMENT_400_02", "name은 필수입니다.");
+
+    private final HttpStatus status;
+    private final String code;
+    private final String message;
+}

src/main/java/com/mr/domain/user/exception/StudentErrorStatus.java

@@ -0,0 +1,18 @@
+package com.mr.domain.user.exception;
+
+import com.mr.global.apipayload.code.BaseCode;
+import org.springframework.http.HttpStatus;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum StudentErrorStatus implements BaseCode {
+
+    USER_REQUIRED(HttpStatus.BAD_REQUEST, "STUDENT_400_01", "user는 필수입니다."),
+    THEORY_LEVEL_REQUIRED(HttpStatus.BAD_REQUEST, "STUDENT_400_02", "theoryLevel은 필수입니다.");
+
+    private final HttpStatus status;
+    private final String code;
+    private final String message;
+}

src/main/java/com/mr/domain/user/exception/StudentInstrumentErrorStatus.java

@@ -0,0 +1,18 @@
+package com.mr.domain.user.exception;
+
+import com.mr.global.apipayload.code.BaseCode;
+import org.springframework.http.HttpStatus;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum StudentInstrumentErrorStatus implements BaseCode {
+
+    STUDENT_REQUIRED(HttpStatus.BAD_REQUEST, "STUDENT_INSTRUMENT_400_01", "student는 필수입니다."),
+    INSTRUMENT_REQUIRED(HttpStatus.BAD_REQUEST, "STUDENT_INSTRUMENT_400_02", "instrument는 필수입니다.");
+
+    private final HttpStatus status;
+    private final String code;
+    private final String message;
+}

src/main/java/com/mr/domain/user/exception/UserErrorStatus.java

@@ -0,0 +1,18 @@
+package com.mr.domain.user.exception;
+
+import com.mr.global.apipayload.code.BaseCode;
+import org.springframework.http.HttpStatus;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum UserErrorStatus implements BaseCode {
+
+    NICKNAME_REQUIRED(HttpStatus.BAD_REQUEST, "USER_400_01", "닉네임은 필수입니다."),
+    NICKNAME_INVALID_FORMAT(HttpStatus.BAD_REQUEST, "USER_400_02", "닉네임은 한글, 영어, 숫자 2~10자로 입력해야 합니다.");
+
+    private final HttpStatus status;
+    private final String code;
+    private final String message;
+}