feat: 사장님 정보 조회

src/main/java/in/koreatech/koin/domain/community/model/Article.java

@@ -26,10 +26,8 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.Setter;
 
 @Getter
-@Setter
 @Entity
 @Table(name = "articles")
 @Where(clause = "is_deleted=0")

src/main/java/in/koreatech/koin/domain/community/model/Board.java

@@ -18,10 +18,8 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.Setter;
 
 @Getter
-@Setter
 @Entity
 @Table(name = "boards")
 @Where(clause = "is_deleted=0")

src/main/java/in/koreatech/koin/domain/owner/controller/OwnerApi.java

@@ -0,0 +1,35 @@
+package in.koreatech.koin.domain.owner.controller;
+
+import static in.koreatech.koin.domain.user.model.UserType.OWNER;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+
+import in.koreatech.koin.domain.owner.dto.OwnerResponse;
+import in.koreatech.koin.global.auth.Auth;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "(Normal) Owner: 사장님", description = "사장님 정보를 관리한다.")
+public interface OwnerApi {
+
+    @ApiResponses(
+        value = {
+            @ApiResponse(responseCode = "200"),
+            @ApiResponse(responseCode = "401", content = @Content(schema = @Schema(hidden = true))),
+            @ApiResponse(responseCode = "403", content = @Content(schema = @Schema(hidden = true))),
+            @ApiResponse(responseCode = "404", content = @Content(schema = @Schema(hidden = true))),
+        }
+    )
+    @Operation(summary = "사장님 정보 조회")
+    @SecurityRequirement(name = "Jwt Authentication")
+    @GetMapping("/owner")
+    ResponseEntity<OwnerResponse> getOwner(
+        @Auth(permit = {OWNER}) Long userId
+    );
+}

src/main/java/in/koreatech/koin/domain/owner/controller/OwnerController.java

@@ -0,0 +1,26 @@
+package in.koreatech.koin.domain.owner.controller;
+
+import static in.koreatech.koin.domain.user.model.UserType.OWNER;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+
+import in.koreatech.koin.domain.owner.dto.OwnerResponse;
+import in.koreatech.koin.domain.owner.service.OwnerService;
+import in.koreatech.koin.global.auth.Auth;
+import lombok.RequiredArgsConstructor;
+
+@Controller
+@RequiredArgsConstructor
+public class OwnerController implements OwnerApi {
+
+    private final OwnerService ownerService;
+
+    @Override
+    public ResponseEntity<OwnerResponse> getOwner(
+        @Auth(permit = {OWNER}) Long ownerId
+    ) {
+        OwnerResponse ownerInfo = ownerService.getOwner(ownerId);
+        return ResponseEntity.ok().body(ownerInfo);
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/domain/Owner.java

@@ -0,0 +1,58 @@
+package in.koreatech.koin.domain.owner.domain;
+
+import in.koreatech.koin.domain.user.model.User;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.MapsId;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+@Table(name = "owners")
+public class Owner {
+
+    @Id
+    @Column(name = "user_id", nullable = false)
+    private Long id;
+
+    @MapsId
+    @OneToOne(cascade = CascadeType.ALL)
+    @JoinColumn(name = "user_id", referencedColumnName = "id")
+    private User user;
+
+    @Size(max = 12)
+    @NotNull
+    @Column(name = "company_registration_number", nullable = false, length = 12)
+    private String companyRegistrationNumber;
+
+    @Size(max = 255)
+    @Column(name = "company_registration_certificate_image_url")
+    private String companyRegistrationCertificateImageUrl;
+
+    @Column(name = "grant_shop")
+    private Boolean grantShop;
+
+    @Column(name = "grant_event")
+    private Boolean grantEvent;
+
+    @Builder
+    public Owner(User user, String companyRegistrationNumber,
+        String companyRegistrationCertificateImageUrl, Boolean grantShop, Boolean grantEvent) {
+        this.user = user;
+        this.companyRegistrationNumber = companyRegistrationNumber;
+        this.companyRegistrationCertificateImageUrl = companyRegistrationCertificateImageUrl;
+        this.grantShop = grantShop;
+        this.grantEvent = grantEvent;
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/domain/OwnerAttachment.java

@@ -0,0 +1,76 @@
+package in.koreatech.koin.domain.owner.domain;
+
+import org.hibernate.annotations.Where;
+
+import in.koreatech.koin.domain.owner.exception.AttachmentNotFoundException;
+import in.koreatech.koin.global.common.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.Lob;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.PostLoad;
+import jakarta.persistence.PostPersist;
+import jakarta.persistence.Table;
+import jakarta.persistence.Transient;
+import jakarta.validation.constraints.NotNull;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Where(clause = "is_deleted=0")
+@Table(name = "owner_attachments")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class OwnerAttachment extends BaseEntity {
+
+    private static final String NAME_SEPARATOR = "/";
+    private static final int NOT_FOUND_IDX = -1;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id", nullable = false)
+    private Long id;
+
+    @NotNull
+    @ManyToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "owner_id", nullable = false, referencedColumnName = "user_id")
+    private Owner owner;
+
+    @NotNull
+    @Lob
+    @Column(name = "url", nullable = false)
+    private String url;
+
+    @NotNull
+    @Column(name = "is_deleted", nullable = false)
+    private Boolean isDeleted = false;
+
+    @Transient
+    private String name;
+
+    @PostPersist
+    @PostLoad
+    public void updateName() {
+        int separateIndex = url.lastIndexOf(NAME_SEPARATOR);
+        if (separateIndex == NOT_FOUND_IDX) {
+            throw AttachmentNotFoundException.withDetail("코인 파일 저장 형식(static.koreatech.in)이 아닙니다. url: " + url);
+        }
+
+        name = url.substring(separateIndex + NAME_SEPARATOR.length());
+    }
+
+    @Builder
+    public OwnerAttachment(Owner owner, String url, Boolean isDeleted, String name) {
+        this.owner = owner;
+        this.url = url;
+        this.isDeleted = isDeleted;
+        this.name = name;
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/dto/OwnerResponse.java

@@ -0,0 +1,81 @@
+package in.koreatech.koin.domain.owner.dto;
+
+import java.util.List;
+
+import com.fasterxml.jackson.databind.PropertyNamingStrategies.SnakeCaseStrategy;
+import com.fasterxml.jackson.databind.annotation.JsonNaming;
+
+import in.koreatech.koin.domain.owner.domain.Owner;
+import in.koreatech.koin.domain.owner.domain.OwnerAttachment;
+import in.koreatech.koin.domain.shop.model.Shop;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record OwnerResponse(
+    @Schema(description = "이메일", example = "example@gmail.com")
+    String email,
+
+    @Schema(description = "이름", example = "홍길동")
+    String name,
+
+    @Schema(description = "사업자 등록 번호", example = "123-45-67890")
+    String company_number,
+
+    @Schema(description = "첨부 파일 목록")
+    List<InnerAttachmentResponse> attachments,
+
+    @Schema(description = "가게 목록")
+    List<InnerShopResponse> shops
+) {
+
+    public static OwnerResponse of(Owner owner, List<OwnerAttachment> attachments, List<Shop> shops) {
+        return new OwnerResponse(
+            owner.getUser().getEmail(),
+            owner.getUser().getName(),
+            owner.getCompanyRegistrationNumber(),
+            attachments.stream()
+                .map(InnerAttachmentResponse::from)
+                .toList(),
+            shops.stream()
+                .map(InnerShopResponse::from)
+                .toList()
+            );
+    }
+
+    @JsonNaming(SnakeCaseStrategy.class)
+    private record InnerAttachmentResponse(
+        @Schema(description = "첨부 파일 ID", example = "1")
+        Long id,
+
+        @Schema(description = "첨부 파일 URL", example = "https://static.koreatech.in/1.png")
+        String fileUrl,
+
+        @Schema(description = "첨부 파일 이름", example = "1.jpg")
+        String fileName
+    ) {
+
+        public static InnerAttachmentResponse from(OwnerAttachment ownerAttachment) {
+            return new InnerAttachmentResponse(
+                ownerAttachment.getId(),
+                ownerAttachment.getUrl(),
+                ownerAttachment.getName()
+            );
+        }
+    }
+
+    @JsonNaming(SnakeCaseStrategy.class)
+    private record InnerShopResponse(
+        @Schema(description = "가게 ID", example = "1")
+        Long id,
+
+        @Schema(description = "가게 이름", example = "가게1")
+        String name
+    ) {
+
+        public static InnerShopResponse from(Shop shop) {
+            return new InnerShopResponse(
+                shop.getId(),
+                shop.getName()
+            );
+        }
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/exception/AttachmentNotFoundException.java

@@ -0,0 +1,18 @@
+package in.koreatech.koin.domain.owner.exception;
+
+import in.koreatech.koin.domain.shop.exception.MenuNotFoundException;
+import in.koreatech.koin.global.exception.DataNotFoundException;
+
+public class AttachmentNotFoundException extends DataNotFoundException {
+
+    private static final String DEFAULT_MESSAGE = "존재하지 않는 첨부파일입니다.";
+
+    public AttachmentNotFoundException(String message) {
+        super(message);
+    }
+
+    public static MenuNotFoundException withDetail(String detail) {
+        String message = String.format("%s %s", DEFAULT_MESSAGE, detail);
+        return new MenuNotFoundException(message);
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/exception/OwnerNotFoundException.java

@@ -0,0 +1,17 @@
+package in.koreatech.koin.domain.owner.exception;
+
+import in.koreatech.koin.global.exception.DataNotFoundException;
+
+public class OwnerNotFoundException extends DataNotFoundException {
+
+    private static final String DEFAULT_MESSAGE = "존재하지 않는 사장님입니다.";
+
+    public OwnerNotFoundException(String message) {
+        super(message);
+    }
+
+    public static OwnerNotFoundException withDetail(String detail) {
+        String message = String.format("%s %s", DEFAULT_MESSAGE, detail);
+        return new OwnerNotFoundException(message);
+    }
+}

src/main/java/in/koreatech/koin/domain/owner/repository/OwnerAttachmentRepository.java

@@ -0,0 +1,16 @@
+package in.koreatech.koin.domain.owner.repository;
+
+import java.util.List;
+
+import org.springframework.data.repository.Repository;
+
+import in.koreatech.koin.domain.owner.domain.OwnerAttachment;
+
+public interface OwnerAttachmentRepository extends Repository<OwnerAttachment, Long> {
+
+    OwnerAttachment save(OwnerAttachment ownerAttachment);
+
+    OwnerAttachment findById(Long id);
+
+    List<OwnerAttachment> findAllByOwnerId(Long ownerId);
+}

src/main/java/in/koreatech/koin/domain/owner/repository/OwnerRepository.java

@@ -0,0 +1,19 @@
+package in.koreatech.koin.domain.owner.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.repository.Repository;
+
+import in.koreatech.koin.domain.owner.domain.Owner;
+import in.koreatech.koin.domain.owner.exception.OwnerNotFoundException;
+
+public interface OwnerRepository extends Repository<Owner, Long> {
+
+    Optional<Owner> findById(Long ownerId);
+
+    default Owner getById(Long ownerId) {
+        return findById(ownerId).orElseThrow(() -> OwnerNotFoundException.withDetail("ownerId: " + ownerId));
+    }
+
+    Owner save(Owner owner);
+}