diff --git a/.gitignore b/.gitignore index b8a0a9f..863e5f3 100644 --- a/.gitignore +++ b/.gitignore @@ -151,15 +151,13 @@ Temporary Items *.rdb ### Spring ### - -application.yml application-local.yml -application-deploy.yml ### Docker ### Dockerfile -docker-compose.yml +docker-compose-local.yml +.env diff --git a/build.gradle b/build.gradle index 767b711..c7982ea 100644 --- a/build.gradle +++ b/build.gradle @@ -31,7 +31,7 @@ dependencies { implementation 'org.springframework.boot:spring-boot-starter-webflux' implementation 'org.springframework.boot:spring-boot-starter-security' implementation 'io.jsonwebtoken:jjwt:0.9.1' - implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0' + implementation 'org.springdoc:springdoc-openapi-starter-webflux-ui:2.2.0' implementation 'org.springframework.boot:spring-boot-starter-mail' implementation 'org.projectlombok:lombok' implementation group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.1' diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..c4d37cc --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,53 @@ +version: '3' + +services: + + application: + container_name: application + hostname: application + build: + context: . + dockerfile: Dockerfile + ports: + - "8080:8080" + restart: always + environment: + TZ: "Asia/Seoul" + MongoDB_Host: ${MONGO_HOST} + MongoDB_Port: ${MONGO_PORT} + MongoDB_Database: ${MONGO_DATABASE} + Mongo_Username: ${MONGO_USERNAME} + Mongo_Password: ${MONGO_PASSWORD} + Redis_Host: ${REDIS_HOST} + Redis_Port: ${REDIS_PORT} + Mail_Email: ${MAIL_EMAIL} + Mail_Password: ${MAIL_PASSWORD} + JWT_Secret: ${JWT_SECRET} + + depends_on: + - redis + - mongo + + redis: + container_name: redis + hostname: redis + image: redis:latest + ports: + - "6379:6379" + restart: always + environment: + TZ: "Asia/Seoul" + + + mongo: + container_name: mongo + hostname: mongo + image: mongo:latest + ports: + - "27017:27017" + restart: always + environment: + MONGO_INITDB_ROOT_USERNAME: ${MONGO_USERNAME} + MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD} + MONGO_INITDB_DATABASE: ${MONGO_DATABASE} + TZ: "Asia/Seoul" \ No newline at end of file diff --git a/src/main/java/com/flowerd/backend/FlowErdBackendApplication.java b/src/main/java/com/flowerd/backend/FlowErdBackendApplication.java index 2b3d249..f6b7969 100644 --- a/src/main/java/com/flowerd/backend/FlowErdBackendApplication.java +++ b/src/main/java/com/flowerd/backend/FlowErdBackendApplication.java @@ -1,7 +1,11 @@ package com.flowerd.backend; +import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.annotation.Bean; +import org.springframework.data.mongodb.core.ReactiveMongoTemplate; +import reactor.core.publisher.Mono; @SpringBootApplication public class FlowErdBackendApplication { @@ -10,4 +14,25 @@ public static void main(String[] args) { SpringApplication.run(FlowErdBackendApplication.class, args); } + // 데이터베이스 초기화 + @Bean + public CommandLineRunner initDataBase(ReactiveMongoTemplate reactiveMongoTemplate) { + return args -> { + // 각 컬렉션 삭제 작업을 연결 + Mono initProcess = reactiveMongoTemplate.dropCollection("table") + .then(reactiveMongoTemplate.dropCollection("column")) + .then(reactiveMongoTemplate.dropCollection("constraints")) + .then(reactiveMongoTemplate.dropCollection("diagram_table")) + .then(reactiveMongoTemplate.dropCollection("schema")) + .then(reactiveMongoTemplate.dropCollection("diagram")) + .then(reactiveMongoTemplate.dropCollection("project")); + + // 모든 작업 완료 후 구독 + initProcess + .doOnSuccess(unused -> System.out.println("모든 컬렉션이 성공적으로 삭제되었습니다.")) + .doOnError(error -> System.err.println("컬렉션 삭제 중 오류 발생: " + error.getMessage())) + .subscribe(); + }; + } + } diff --git a/src/main/java/com/flowerd/backend/config/RedisConfig.java b/src/main/java/com/flowerd/backend/config/RedisConfig.java index e272763..68f8c8d 100644 --- a/src/main/java/com/flowerd/backend/config/RedisConfig.java +++ b/src/main/java/com/flowerd/backend/config/RedisConfig.java @@ -6,6 +6,8 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory; +import org.springframework.data.redis.connection.RedisStandaloneConfiguration; +import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration; import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; import org.springframework.data.redis.core.ReactiveRedisTemplate; import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; @@ -15,24 +17,24 @@ @Configuration @RequiredArgsConstructor public class RedisConfig { - @Value("${redis1.host}") - public String REDIS_HOST1; - @Value("${redis2.host}") - public String REDIS_HOST2; - @Value("${redis1.port}") - public int REDIS_PORT1; - @Value("${redis2.port}") - public int REDIS_PORT2; + @Value("${spring.data.redis.host}") + public String REDIS_HOST; + @Value("${spring.data.redis.port}") + public int REDIS_PORT; // Reactive Redis 연결 설정 @Bean public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory1() { - return new LettuceConnectionFactory(REDIS_HOST1, REDIS_PORT1); + RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(); + redisConfig.setDatabase(0); + return new LettuceConnectionFactory(redisConfig, LettuceClientConfiguration.defaultConfiguration()); } @Bean public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory2() { - return new LettuceConnectionFactory(REDIS_HOST2, REDIS_PORT2); + RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(); + redisConfig.setDatabase(1); + return new LettuceConnectionFactory(redisConfig, LettuceClientConfiguration.defaultConfiguration()); } // Reactive Redis 데이터 템플릿 설정, Refresh 토큰 저장용으로 String : Object(RefreshToken) 형식으로 설정 diff --git a/src/main/java/com/flowerd/backend/config/WebFluxConfig.java b/src/main/java/com/flowerd/backend/config/WebFluxConfig.java new file mode 100644 index 0000000..6786fad --- /dev/null +++ b/src/main/java/com/flowerd/backend/config/WebFluxConfig.java @@ -0,0 +1,20 @@ +package com.flowerd.backend.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.web.reactive.config.CorsRegistry; +import org.springframework.web.reactive.config.EnableWebFlux; +import org.springframework.web.reactive.config.WebFluxConfigurer; + +@Configuration +@EnableWebFlux +public class WebFluxConfig implements WebFluxConfigurer { + + @Override + public void addCorsMappings(CorsRegistry registry) { + registry.addMapping("/**") + .allowedOrigins("*") + .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") + .allowedHeaders("*"); + } +} + diff --git a/src/main/java/com/flowerd/backend/controller/ColumnController.java b/src/main/java/com/flowerd/backend/controller/ColumnController.java new file mode 100644 index 0000000..357421d --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/ColumnController.java @@ -0,0 +1,72 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.ColumnVO; +import com.flowerd.backend.entity.dto.outbound.ColumnReturns; +import com.flowerd.backend.service.ColumnService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + +@RestController +@RequiredArgsConstructor +@Slf4j +public class ColumnController { + + private final ColumnService columnService; + + // 새로운 컬럼 추가. + @PostMapping("/add/column") + @Operation(summary = "컬럼 추가", description = "새로운 컬럼을 추가합니다.") + public Mono>> saveColumn(@RequestBody ColumnVO columnVO) { + return columnService.saveColumn(columnVO) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("컬럼 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("컬럼 추가 실패: " + e.getMessage()))); + }); + } + + // 컬럼 수정. + @PutMapping("/update/column/{columnId}") + @Operation(summary = "컬럼 수정", description = "새로운 컬럼을 수정합니다.") + public Mono>> updateColumn(@RequestBody ColumnVO columnVO, @PathVariable ObjectId columnId) { + return columnService.updateColumn(columnVO, columnId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("컬럼 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("컬럼 수정 실패: " + e.getMessage()))); + }); + } + + + // 컬럼 삭제. + @DeleteMapping("/delete/column/{columnId}") + @Operation(summary = "컬럼 삭제", description = "컬럼을 삭제합니다.") + public Mono>> deleteColumn(@PathVariable ObjectId columnId) { + return columnService.deleteColumn(columnId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("컬럼 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("컬럼 삭제 실패: " + e.getMessage()))); + }); + } + + + // 컬럼 조회. + @GetMapping("/get/column/{columnId}") + @Operation(summary = "컬럼 조회", description = "컬럼을 조회합니다.") + public Mono>> getColumn(@PathVariable ObjectId columnId) { + return columnService.getListColumn(columnId) + .map(column -> ResponseEntity.ok(ApiResponse.success(column))) + .onErrorResume(e -> { + log.error("컬럼 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("컬럼 조회 실패: " + e.getMessage()))); + }); + } + +} diff --git a/src/main/java/com/flowerd/backend/controller/ConstraintsController.java b/src/main/java/com/flowerd/backend/controller/ConstraintsController.java new file mode 100644 index 0000000..c7c7a55 --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/ConstraintsController.java @@ -0,0 +1,72 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.ConstraintsVO; +import com.flowerd.backend.entity.dto.outbound.ConstraintsReturns; +import com.flowerd.backend.service.ConstraintsService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + +@RestController +@RequiredArgsConstructor +@Slf4j +public class ConstraintsController { + + private final ConstraintsService constraintsService; + + // 새로운 제약조건 추가 + @PostMapping("/add/constraints") + @Operation(summary = "제약조건 추가", description = "새로운 제약조건을 추가합니다.") + public Mono>> saveConstraints(@RequestBody ConstraintsVO constraintsVO) { + return constraintsService.saveConstraints(constraintsVO) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("제약조건 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("제약조건 추가 실패: " + e.getMessage()))); + }); + } + + + // 제약조건 수정 + @PutMapping("/update/constraints/{constraintsId}") + @Operation(summary = "제약조건 수정", description = "제약조건을 수정합니다.") + public Mono>> updateConstraints(@RequestBody ConstraintsVO constraintsVO, @PathVariable ObjectId constraintsId) { + return constraintsService.updateConstraints(constraintsVO, constraintsId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("제약조건 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("제약조건 수정 실패: " + e.getMessage()))); + }); + } + + + // 제약조건 삭제. + @DeleteMapping("/delete/constraints/{constraintsId}") + @Operation(summary = "제약조건 삭제", description = "제약조건을 삭제합니다.") + public Mono>> deleteConstraints(@PathVariable ObjectId constraintsId) { + return constraintsService.deleteConstraints(constraintsId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("제약조건 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("제약조건 삭제 실패: " + e.getMessage()))); + }); + } + + + // 제약조건 조회 + @GetMapping("/get/constraints/{constraintsId}") + @Operation(summary = "제약조건 조회", description = "제약조건을 조회합니다.") + public Mono>> getConstraints(@PathVariable ObjectId constraintsId) { + return constraintsService.getListConstraints(constraintsId) + .map(constraints -> ResponseEntity.ok(ApiResponse.success(constraints))) + .onErrorResume(e -> { + log.error("제약조건 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("제약조건 조회 실패: " + e.getMessage()))); + }); + } +} diff --git a/src/main/java/com/flowerd/backend/controller/DiagramController.java b/src/main/java/com/flowerd/backend/controller/DiagramController.java new file mode 100644 index 0000000..0e30b4a --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/DiagramController.java @@ -0,0 +1,69 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.DiagramVO; +import com.flowerd.backend.entity.dto.outbound.DiagramReturns; +import com.flowerd.backend.service.DiagramService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + +@RestController +@RequiredArgsConstructor +@Slf4j +public class DiagramController { + + private final DiagramService diagramService; + + // 다이어그램 추가 + @PostMapping("/add/diagram") + @Operation(summary = "다이어그램 추가", description = "새로운 다이어그램을 추가합니다.") + public Mono>> addDiagram(@RequestBody DiagramVO diagramVO) { + return diagramService.saveDiagram(diagramVO) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("다이어그램 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 추가 실패: " + e.getMessage()))); + }); + } + + // 다이어그램 조회 + @GetMapping("/get/diagram/{diagramId}") + @Operation(summary = "다이어그램 조회", description = "다이어그램을 조회합니다.") + public Mono>> getDiagram(@PathVariable ObjectId diagramId) { + return diagramService.getListDiagram(diagramId) + .map(diagram -> ResponseEntity.ok(ApiResponse.success(diagram))) + .onErrorResume(e -> { + log.error("다이어그램 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 조회 실패: " + e.getMessage()))); + }); + } + + // 다이어그램 수정 + @PutMapping("/update/diagram/{diagramId}") + @Operation(summary = "다이어그램 수정", description = "다이어그램을 수정합니다.") + public Mono>> updateDiagram(@RequestBody DiagramVO diagramVO, @PathVariable ObjectId diagramId) { + return diagramService.updateDiagram(diagramVO, diagramId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("다이어그램 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 수정 실패: " + e.getMessage()))); + }); + } + + // 다이어그램 삭제 + @DeleteMapping("/delete/diagram/{diagramId}") + @Operation(summary = "다이어그램 삭제", description = "다이어그램을 삭제합니다.") + public Mono>> deleteDiagram(@PathVariable ObjectId diagramId) { + return diagramService.deleteDiagram(diagramId) + .then(Mono.fromCallable(() -> ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("다이어그램 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 삭제 실패: " + e.getMessage()))); + }); + } +} diff --git a/src/main/java/com/flowerd/backend/controller/ProjectController.java b/src/main/java/com/flowerd/backend/controller/ProjectController.java new file mode 100644 index 0000000..c37bad6 --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/ProjectController.java @@ -0,0 +1,112 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.ProjectVO; +import com.flowerd.backend.entity.dto.outbound.AllReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectDrawReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectListReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectReturns; +import com.flowerd.backend.service.ProjectService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + +import java.util.List; + +@RestController +@RequiredArgsConstructor +@Slf4j +public class ProjectController { + + private final ProjectService projectService; + + // 새로운 프로젝트 추가. + @PostMapping("/add/project") + @Operation(summary = "프로젝트 추가", description = "새로운 프로젝트를 추가합니다.") + public Mono>> addProject(@RequestBody ProjectVO project, @RequestHeader("Authorization") String token) { + return projectService.saveProject(project, token) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("프로젝트 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 추가 실패: " + e.getMessage()))); + }); + } + + // All Project 리스트 조회 + @GetMapping("/get/project/all/{projectId}") + @Operation(summary = "프로젝트 All 조회", description = "모든 프로젝트 리스트를 조회합니다.") + public Mono>> getAllProject(@PathVariable ObjectId projectId) { + return projectService.getAllProject(projectId) + .map(allProject -> ResponseEntity.ok(ApiResponse.success(allProject))) + .onErrorResume(e -> { + log.error("프로젝트 리스트 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 리스트 조회 실패: " + e.getMessage()))); + }); + } + + + // Project 조회 + @GetMapping("/get/project/{projectId}") + @Operation(summary = "프로젝트 조회", description = "프로젝트를 조회합니다.") + public Mono>> getProject(@PathVariable ObjectId projectId) { + return projectService.getListProject(projectId) + .map(project -> ResponseEntity.ok(ApiResponse.success(project))) + .onErrorResume(e -> { + log.error("프로젝트 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 조회 실패: " + e.getMessage()))); + }); + } + + // ProjecrDraw 조회 + @GetMapping("/get/project/draw/{projectId}") + @Operation(summary = "프로젝트 Draw 조회", description = "프로젝트 Draw를 조회합니다.") + public Mono>> getProjectDraw(@PathVariable ObjectId projectId) { + return projectService.getListDrawProject(projectId) + .map(project -> ResponseEntity.ok(ApiResponse.success(project))) + .onErrorResume(e -> { + log.error("프로젝트 Draw 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 Draw 조회 실패: " + e.getMessage()))); + }); + } + + // 프로젝트 수정 + @PutMapping("/update/project/{projectId}") + @Operation(summary = "프로젝트 수정", description = "프로젝트를 수정합니다.") + public Mono>> updateProject(@RequestBody ProjectVO project, @PathVariable ObjectId projectId) { + return projectService.updateProject(project, projectId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("프로젝트 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 수정 실패: " + e.getMessage()))); + }); + } + + // 프로젝트 삭제 + @DeleteMapping("/delete/project/{projectId}") + @Operation(summary = "프로젝트 삭제", description = "프로젝트를 삭제합니다.") + public Mono>> deleteProject(@PathVariable ObjectId projectId) { + return projectService.deleteProject(projectId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("프로젝트 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 삭제 실패: " + e.getMessage()))); + }); + } + + // 프로젝트 리스트 + @GetMapping("/get/project/list") + @Operation(summary = "프로젝트 리스트", description = "프로젝트 리스트를 조회합니다.") + public Mono>>> getProjectList(@RequestHeader("Authorization") String token){ + return projectService.getProjectIdList(token) + .map(projectList -> ResponseEntity.ok(ApiResponse.success(projectList))) + .onErrorResume(e -> { + log.error("프로젝트 리스트 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("프로젝트 리스트 조회 실패: " + e.getMessage()))); + }); + } + +} diff --git a/src/main/java/com/flowerd/backend/controller/SchemaController.java b/src/main/java/com/flowerd/backend/controller/SchemaController.java new file mode 100644 index 0000000..82a34ce --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/SchemaController.java @@ -0,0 +1,68 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.SchemaVO; +import com.flowerd.backend.entity.dto.outbound.SchemaReturns; +import com.flowerd.backend.service.SchemaService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + + +@RestController +@RequiredArgsConstructor +@Slf4j +public class SchemaController { + + private final SchemaService schemaService; + + @PostMapping("/add/schema") + @Operation(summary = "스키마 추가", description = "새로운 스키마를 추가합니다.") + public Mono>> addSchema(@RequestBody SchemaVO schema) { + return schemaService.saveSchema(schema) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("스키마 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("스키마 추가 실패: " + e.getMessage()))); + }); + } + + @GetMapping("/get/schema/{projectId}") + @Operation(summary = "스키마 조회", description = "스키마를 조회합니다.") + public Mono>> getSchema(@PathVariable ObjectId projectId) { + return schemaService.getListSchema(projectId) + .map(schema -> ResponseEntity.ok(ApiResponse.success(schema))) + .onErrorResume(e -> { + log.error("스키마 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("스키마 조회 실패: " + e.getMessage()))); + }); + } + + + @DeleteMapping("/delete/schema/{schemaId}") + @Operation(summary = "스키마 삭제", description = "스키마를 삭제합니다.") + public Mono>> deleteSchema(@PathVariable ObjectId schemaId) { + return schemaService.deleteSchema(schemaId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("스키마 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("스키마 삭제 실패: " + e.getMessage()))); + }); + } + + + @PutMapping("/update/schema/{schemaId}") + @Operation(summary = "스키마 수정", description = "스키마를 수정합니다.") + public Mono>> updateSchema(@RequestBody SchemaVO schema, @PathVariable ObjectId schemaId) { + return schemaService.updateSchema(schema, schemaId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("스키마 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("스키마 수정 실패: " + e.getMessage()))); + }); + } +} diff --git a/src/main/java/com/flowerd/backend/controller/TableController.java b/src/main/java/com/flowerd/backend/controller/TableController.java new file mode 100644 index 0000000..26d5e2f --- /dev/null +++ b/src/main/java/com/flowerd/backend/controller/TableController.java @@ -0,0 +1,92 @@ +package com.flowerd.backend.controller; + +import com.flowerd.backend.entity.dto.ApiResponse; +import com.flowerd.backend.entity.dto.inbound.DiagramTableVO; +import com.flowerd.backend.entity.dto.inbound.TableVO; +import com.flowerd.backend.entity.dto.outbound.TableReturns; +import com.flowerd.backend.service.TableService; +import io.swagger.v3.oas.annotations.Operation; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.bson.types.ObjectId; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import reactor.core.publisher.Mono; + +@RestController +@RequiredArgsConstructor +@Slf4j +public class TableController { + + private final TableService tableService; + + // 새로운 테이블 추가 & 수정. + @PostMapping("/add/table") + @Operation(summary = "테이블 추가", description = "새로운 테이블을 추가합니다.") + public Mono>> saveTable(@RequestBody TableVO tableVO) { + return tableService.saveTable(tableVO) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("테이블 추가 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("테이블 추가 실패: " + e.getMessage()))); + }); + } + + // 테이블 삭제. + @DeleteMapping("/delete/table/{tableId}") + @Operation(summary = "테이블 삭제", description = "테이블을 삭제합니다.") + public Mono>> deleteTable(@PathVariable ObjectId tableId) { + return tableService.deleteTable(tableId) + .then(Mono.fromCallable(() -> ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("테이블 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("테이블 삭제 실패: " + e.getMessage()))); + }); + } + + // 테이블 수정 + @PutMapping("/update/table/{tableId}") + @Operation(summary = "테이블 수정", description = "테이블을 수정합니다.") + public Mono>> updateTable(@RequestBody TableVO tableVO, @PathVariable ObjectId tableId) { + return tableService.updateTable(tableVO, tableId) + .then(Mono.just(ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("테이블 수정 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("테이블 수정 실패: " + e.getMessage()))); + }); + } + + // 테이블 조회. + @GetMapping("/get/table/{tableId}") + @Operation(summary = "테이블 조회", description = "테이블을 조회합니다.") + public Mono>> getTable(@PathVariable ObjectId tableId) { + return tableService.getListTableByTableId(tableId) + .map(table -> ResponseEntity.ok(ApiResponse.success(table))) + .onErrorResume(e -> { + log.error("테이블 조회 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("테이블 조회 실패: " + e.getMessage()))); + }); + } + + @PostMapping("/diagramTable/{tableId}/{diagramId}") + @Operation(summary = "다이어그램 테이블 매핑", description = "다이어그램과 테이블을 매핑합니다.") + public Mono>> saveDiagramTable(@PathVariable ObjectId tableId, @PathVariable ObjectId diagramId, @RequestBody DiagramTableVO diagramTableVO) { + return tableService.mapTableToDiagram(tableId, diagramId, diagramTableVO) + .map(id -> ResponseEntity.ok(ApiResponse.success(id.toString()))) + .onErrorResume(e -> { + log.error("다이어그램 테이블 매핑 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 테이블 매핑 실패: " + e.getMessage()))); + }); + } + + @DeleteMapping("/diagramTable/{tableId}/{diagramId}") + @Operation(summary = "다이어그램 테이블 매핑 삭제", description = "다이어그램과 테이블의 매핑을 삭제합니다.") + public Mono>> deleteDiagramTable(@PathVariable ObjectId tableId, @PathVariable ObjectId diagramId) { + return tableService.unmapTableToDiagram(tableId, diagramId) + .then(Mono.fromCallable(() -> ResponseEntity.ok(ApiResponse.success()))) + .onErrorResume(e -> { + log.error("다이어그램 테이블 매핑 삭제 실패: {}", e.getMessage()); + return Mono.just(ResponseEntity.badRequest().body(ApiResponse.fail("다이어그램 테이블 매핑 삭제 실패: " + e.getMessage()))); + }); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Column.java b/src/main/java/com/flowerd/backend/entity/Column.java new file mode 100644 index 0000000..c140477 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Column.java @@ -0,0 +1,51 @@ +package com.flowerd.backend.entity; + +import com.flowerd.backend.entity.enum_name.DATATYPE; +import com.flowerd.backend.entity.enum_name.ISKEY; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + + +@Document(collection = "column") +@NoArgsConstructor +@Getter +@Setter +public class Column { + + @Id + private ObjectId id; + + private ObjectId tableId; + + private String columnName; + + private Boolean nullable; // Constraint + + private Boolean unique; // Constraint + + private ISKEY isKey; // Constraint + + private DATATYPE dataType; + + private Integer length; + + + public Column(ObjectId tableId, String columnName, Boolean nullable, Boolean unique, ISKEY isKey, DATATYPE dataType, Integer length) { + this.tableId = tableId; + this.columnName = columnName; + this.nullable = nullable; + this.unique = unique; + this.isKey = isKey; + this.dataType = dataType; + this.length = length; + } + + public Mono of(ObjectId tableId, String columnName, Boolean nullable, Boolean unique, ISKEY isKey, DATATYPE dataType, Integer length) { + return Mono.just(new Column(tableId, columnName, nullable, unique, isKey, dataType, length)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Constraints.java b/src/main/java/com/flowerd/backend/entity/Constraints.java new file mode 100644 index 0000000..0cf855f --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Constraints.java @@ -0,0 +1,54 @@ +package com.flowerd.backend.entity; + +import com.flowerd.backend.entity.enum_name.CARDINALITY; +import com.flowerd.backend.entity.enum_name.PARTICIPATION; +import com.flowerd.backend.entity.enum_name.RELTYPE; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +@Document(collection = "Constraint") +@NoArgsConstructor +@Getter +@Setter +public class Constraints { + + @Id + private ObjectId id; + + private ObjectId childTableId; + + private ObjectId childColumnId; + + private ObjectId parentTableId; + + private ObjectId parentColumnId; + + private PARTICIPATION parentParticipation; + + private PARTICIPATION childParticipation; + + private CARDINALITY parentCardinality; + + private CARDINALITY childCardinality; + + private RELTYPE relType; // 모두가 하나라도 식별이면 식별관계, 그렇지 않다면 비식별관계 + + public Constraints(ObjectId childColumnId, ObjectId parentColumnId, PARTICIPATION parentParticipation, PARTICIPATION childParticipation, CARDINALITY parentCardinality, CARDINALITY childCardinality, RELTYPE relType) { + this.childColumnId = childColumnId; + this.parentColumnId = parentColumnId; + this.parentParticipation = parentParticipation; + this.childParticipation = childParticipation; + this.parentCardinality = parentCardinality; + this.childCardinality = childCardinality; + this.relType = relType; + } + + public Mono of(ObjectId childColumnId, ObjectId parentColumnId, PARTICIPATION parentParticipation, PARTICIPATION childParticipation, CARDINALITY parentCardinality, CARDINALITY childCardinality, RELTYPE relType) { + return Mono.just(new Constraints(childColumnId, parentColumnId, parentParticipation, childParticipation, parentCardinality, childCardinality, relType)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Diagram.java b/src/main/java/com/flowerd/backend/entity/Diagram.java new file mode 100644 index 0000000..5bec282 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Diagram.java @@ -0,0 +1,49 @@ +package com.flowerd.backend.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.index.CompoundIndex; +import org.springframework.data.mongodb.core.index.CompoundIndexes; +import org.springframework.data.mongodb.core.mapping.DBRef; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +import java.util.ArrayList; +import java.util.List; + +@Document(collection = "diagram") +@NoArgsConstructor +@Getter +@Setter +public class Diagram { + + @Id + private ObjectId id; + + private ObjectId projectId; + + private String diagramId; + + private Long pixel_x; + + private Long pixel_y; + + private String diagramContent; + + + public Diagram(ObjectId projectId, String diagramId, Long pixel_x, Long pixel_y, String diagramContent) { + this.projectId = projectId; + this.diagramId = diagramId; + this.pixel_x = pixel_x; + this.pixel_y = pixel_y; + this.diagramContent = diagramContent; + } + + public static Mono of(ObjectId projectId, String diagramId, Long pixel_x, Long pixel_y, String diagramContent) { + return Mono.just(new Diagram(projectId, diagramId, pixel_x, pixel_y, diagramContent)); + } + +} diff --git a/src/main/java/com/flowerd/backend/entity/DiagramTable.java b/src/main/java/com/flowerd/backend/entity/DiagramTable.java new file mode 100644 index 0000000..e12ea5c --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/DiagramTable.java @@ -0,0 +1,39 @@ +package com.flowerd.backend.entity; + + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +@Document(collection = "diagram_table") +@NoArgsConstructor +@Getter +@Setter +public class DiagramTable { + @Id + private ObjectId id; + + private ObjectId diagramId; + + private ObjectId tableId; + + private Long size_x; + + private Long size_y; + + + public DiagramTable(ObjectId diagramId, ObjectId tableId, Long size_x, Long size_y) { + this.diagramId = diagramId; + this.tableId = tableId; + this.size_x = size_x; + this.size_y = size_y; + } + + public static Mono of(ObjectId diagramId, ObjectId tableId, Long size_x, Long size_y) { + return Mono.just(new DiagramTable(diagramId, tableId, size_x, size_y)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Member.java b/src/main/java/com/flowerd/backend/entity/Member.java index c07aef1..881d507 100644 --- a/src/main/java/com/flowerd/backend/entity/Member.java +++ b/src/main/java/com/flowerd/backend/entity/Member.java @@ -1,6 +1,8 @@ package com.flowerd.backend.entity; +import com.flowerd.backend.entity.enum_name.ROLE; import lombok.Getter; +import lombok.Setter; import org.bson.types.ObjectId; import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document; @@ -10,31 +12,35 @@ @Document(collection = "member") @Getter +@Setter public class Member { + @Id private ObjectId id; + // email은 unique해야 하므로 CompoundIndex를 사용하여 unique하게 설정 private final String email; private final String password; private final String name; - private final List roles = new ArrayList<>(); + private final List ROLES = new ArrayList<>(); + - private Member(String email, String name, String password, List roles) { + private Member(String email, String name, String password, List ROLES) { this.email = email; this.name = name; this.password = password; - this.roles.addAll(roles); + this.ROLES.addAll(ROLES); } public static Member of( String email, String name, String password, - List roles + List ROLES ) { - return new Member(email, name, password, roles); + return new Member(email, name, password, ROLES); } } diff --git a/src/main/java/com/flowerd/backend/entity/MemberProject.java b/src/main/java/com/flowerd/backend/entity/MemberProject.java new file mode 100644 index 0000000..c69ccd1 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/MemberProject.java @@ -0,0 +1,33 @@ +package com.flowerd.backend.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.DBRef; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +@Document(collection = "member_project") +@NoArgsConstructor +@Getter +public class MemberProject { + + @Id + private ObjectId id; + + @DBRef + private ObjectId memberId; + + @DBRef + private ObjectId projectId; + + MemberProject(ObjectId memberId, ObjectId projectId) { + this.memberId = memberId; + this.projectId = projectId; + } + + public static Mono of(ObjectId memberId, ObjectId projectId) { + return Mono.just(new MemberProject(memberId, projectId)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Project.java b/src/main/java/com/flowerd/backend/entity/Project.java new file mode 100644 index 0000000..64064f6 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Project.java @@ -0,0 +1,40 @@ +package com.flowerd.backend.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.index.CompoundIndex; +import org.springframework.data.mongodb.core.index.CompoundIndexes; +import org.springframework.data.mongodb.core.mapping.DBRef; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +import java.util.ArrayList; +import java.util.List; + +@Document(collection = "project") +@NoArgsConstructor +@Getter +@Setter +public class Project { + + @Id + private ObjectId id; + + private String projectName; + + private ObjectId ownerId; + + + // 프로젝트 생성시, MemberProject 생성. + public Project(String projectName, ObjectId ownerId) { + this.projectName = projectName; + this.ownerId = ownerId; + } + + public static Mono of(String projectName, ObjectId ownerId) { + return Mono.just(new Project(projectName, ownerId)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Schema.java b/src/main/java/com/flowerd/backend/entity/Schema.java new file mode 100644 index 0000000..3d66e8d --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Schema.java @@ -0,0 +1,32 @@ +package com.flowerd.backend.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + +@Document(collection = "schema") +@NoArgsConstructor +@Getter +@Setter +public class Schema { + + @Id + private ObjectId id; + + private ObjectId projectId; + + private String schemaName; + + public Schema(ObjectId projectId, String schemaName) { + this.projectId = projectId; + this.schemaName = schemaName; + } + + public static Mono of(ObjectId projectId, String schemaName) { + return Mono.just(new Schema(projectId, schemaName)); + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Table.java b/src/main/java/com/flowerd/backend/entity/Table.java new file mode 100644 index 0000000..b818c4a --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/Table.java @@ -0,0 +1,35 @@ +package com.flowerd.backend.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.bson.types.ObjectId; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import reactor.core.publisher.Mono; + + +@Document(collection = "table") +@NoArgsConstructor +@Getter +@Setter +public class Table { + + @Id + private ObjectId id; + + private ObjectId schemaId; + + private String tableName; + + + public Table(ObjectId schemaId, String tableName) { + this.schemaId = schemaId; + this.tableName = tableName; + } + + public static Mono of(ObjectId schemaId, String tableName) { + return Mono.just(new Table(schemaId, tableName)); + } + +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/ColumnVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/ColumnVO.java new file mode 100644 index 0000000..7751b48 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/ColumnVO.java @@ -0,0 +1,27 @@ +package com.flowerd.backend.entity.dto.inbound; + +import com.flowerd.backend.entity.enum_name.DATATYPE; +import com.flowerd.backend.entity.enum_name.ISKEY; +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ColumnVO { + + private ObjectId tableId; + + private String columnName; + + private Boolean nullable; // Constraint + + private Boolean unique; // Constraint + + private ISKEY isKey; // Constraint + + private DATATYPE dataType; + + private Integer length; + +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/ConstraintsVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/ConstraintsVO.java new file mode 100644 index 0000000..668e1a2 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/ConstraintsVO.java @@ -0,0 +1,31 @@ +package com.flowerd.backend.entity.dto.inbound; + +import com.flowerd.backend.entity.enum_name.CARDINALITY; +import com.flowerd.backend.entity.enum_name.PARTICIPATION; +import com.flowerd.backend.entity.enum_name.RELTYPE; +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ConstraintsVO { + + private ObjectId childTableId; + + private ObjectId childColumnId; + + private ObjectId parentTableId; + + private ObjectId parentColumnId; + + private PARTICIPATION parentParticipation; + + private PARTICIPATION childParticipation; + + private CARDINALITY parentCardinality; + + private CARDINALITY childCardinality; + + private RELTYPE relType; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramTableVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramTableVO.java new file mode 100644 index 0000000..35c4a43 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramTableVO.java @@ -0,0 +1,11 @@ +package com.flowerd.backend.entity.dto.inbound; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class DiagramTableVO { + private Long posX; + private Long posY; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramVO.java new file mode 100644 index 0000000..4b9e6d0 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/DiagramVO.java @@ -0,0 +1,15 @@ +package com.flowerd.backend.entity.dto.inbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class DiagramVO { + private ObjectId projectId; + private String diagramName; + private String diagramContent; + private Long SizeX; + private Long SizeY; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/ProjectVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/ProjectVO.java new file mode 100644 index 0000000..295a5b9 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/ProjectVO.java @@ -0,0 +1,11 @@ +package com.flowerd.backend.entity.dto.inbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ProjectVO { + private String projectName; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/SchemaVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/SchemaVO.java new file mode 100644 index 0000000..dc632c2 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/SchemaVO.java @@ -0,0 +1,12 @@ +package com.flowerd.backend.entity.dto.inbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class SchemaVO { + private ObjectId projectId; + private String schemaName; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/inbound/TableVO.java b/src/main/java/com/flowerd/backend/entity/dto/inbound/TableVO.java new file mode 100644 index 0000000..c7c7300 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/inbound/TableVO.java @@ -0,0 +1,12 @@ +package com.flowerd.backend.entity.dto.inbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class TableVO { + private ObjectId schemaId; + private String tableName; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/AllReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/AllReturns.java new file mode 100644 index 0000000..7a235df --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/AllReturns.java @@ -0,0 +1,13 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; + +import java.util.List; + +@Getter +@Setter +public class AllReturns { + List projectReturns; + List projectDrawReturns; +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/ColumnReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/ColumnReturns.java new file mode 100644 index 0000000..7f8601a --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/ColumnReturns.java @@ -0,0 +1,36 @@ +package com.flowerd.backend.entity.dto.outbound; + +import com.flowerd.backend.entity.enum_name.DATATYPE; +import com.flowerd.backend.entity.enum_name.ISKEY; +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ColumnReturns { + + private String id; + + private String columnName; + + private Boolean nullable; // Constraint + + private Boolean unique; // Constraint + + private ISKEY isKey; // Constraint + + private DATATYPE dataType; + + private Integer length; + + public ColumnReturns(ObjectId id, String columnName, Boolean nullable, Boolean unique, ISKEY isKey, DATATYPE dataType, Integer length) { + this.id = id.toString(); + this.columnName = columnName; + this.nullable = nullable; + this.unique = unique; + this.isKey = isKey; + this.dataType = dataType; + this.length = length; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/ConstraintsReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/ConstraintsReturns.java new file mode 100644 index 0000000..bd7368d --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/ConstraintsReturns.java @@ -0,0 +1,40 @@ +package com.flowerd.backend.entity.dto.outbound; + +import com.flowerd.backend.entity.enum_name.CARDINALITY; +import com.flowerd.backend.entity.enum_name.PARTICIPATION; +import com.flowerd.backend.entity.enum_name.RELTYPE; +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ConstraintsReturns { + + private String id; + + private String childColumnId; + + private String parentColumnId; + + private PARTICIPATION parentParticipation; + + private PARTICIPATION childParticipation; + + private CARDINALITY parentCardinality; + + private CARDINALITY childCardinality; + + private RELTYPE relType; + + public ConstraintsReturns(ObjectId id,ObjectId childColumnId, ObjectId parentColumnId, PARTICIPATION parentParticipation, PARTICIPATION childParticipation, CARDINALITY parentCardinality, CARDINALITY childCardinality, RELTYPE relType) { + this.id = id.toString(); + this.childColumnId = childColumnId.toString(); + this.parentColumnId = parentColumnId.toString(); + this.parentParticipation = parentParticipation; + this.childParticipation = childParticipation; + this.parentCardinality = parentCardinality; + this.childCardinality = childCardinality; + this.relType = relType; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/DiagramReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/DiagramReturns.java new file mode 100644 index 0000000..309a045 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/DiagramReturns.java @@ -0,0 +1,25 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Setter +@Getter +public class DiagramReturns { + String id; + Long pixel_x; + Long pixel_y; + String diagramContent; + List tables; + + public DiagramReturns(ObjectId id, Long pixel_x, Long pixel_y, String diagramContent, List tables) { + this.id = id.toString(); + this.pixel_x = pixel_x; + this.pixel_y = pixel_y; + this.diagramContent = diagramContent; + this.tables = tables; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectDrawReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectDrawReturns.java new file mode 100644 index 0000000..d70a021 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectDrawReturns.java @@ -0,0 +1,21 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Setter +@Getter +public class ProjectDrawReturns { + String id; + String projectName; + List diagramReturns; + + public ProjectDrawReturns(ObjectId id, String projectName, List diagramReturns) { + this.id = id.toString(); + this.projectName = projectName; + this.diagramReturns = diagramReturns; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectListReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectListReturns.java new file mode 100644 index 0000000..3c24c3b --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectListReturns.java @@ -0,0 +1,17 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +@Getter +@Setter +public class ProjectListReturns { + String id; + String projectName; + + public ProjectListReturns(ObjectId id, String projectName) { + this.id = id.toString(); + this.projectName = projectName; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectReturns.java new file mode 100644 index 0000000..40aa224 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/ProjectReturns.java @@ -0,0 +1,21 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Getter +@Setter +public class ProjectReturns { + String id; + String projectName; + List schemaReturns; + + public ProjectReturns(ObjectId id, String projectName, List schemaReturns) { + this.id = id.toString(); + this.projectName = projectName; + this.schemaReturns = schemaReturns; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/SchemaReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/SchemaReturns.java new file mode 100644 index 0000000..3438e1c --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/SchemaReturns.java @@ -0,0 +1,21 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Setter +@Getter +public class SchemaReturns { + String SchemaId; + String schemaName; + List tableReturns; + + public SchemaReturns(ObjectId schemaId, String schemaName, List tableReturns) { + this.SchemaId = schemaId.toString(); + this.schemaName = schemaName; + this.tableReturns = tableReturns; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/TableDiagramReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/TableDiagramReturns.java new file mode 100644 index 0000000..b33129c --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/TableDiagramReturns.java @@ -0,0 +1,27 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Setter +@Getter +public class TableDiagramReturns { + String id; + String tableName; + Long pos_x; + Long pos_y; + List columns; + List constraints; + + public TableDiagramReturns(ObjectId id, String tableName, Long pos_x, Long pos_y, List columns, List constraints) { + this.id = id.toString(); + this.tableName = tableName; + this.pos_x = pos_x; + this.pos_y = pos_y; + this.columns = columns; + this.constraints = constraints; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/dto/outbound/TableReturns.java b/src/main/java/com/flowerd/backend/entity/dto/outbound/TableReturns.java new file mode 100644 index 0000000..7cc4479 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/dto/outbound/TableReturns.java @@ -0,0 +1,23 @@ +package com.flowerd.backend.entity.dto.outbound; + +import lombok.Getter; +import lombok.Setter; +import org.bson.types.ObjectId; + +import java.util.List; + +@Getter +@Setter +public class TableReturns { + String id; + String tableName; + List columns; + List constraints; + + public TableReturns(ObjectId id, String tableName, List columns, List constraints) { + this.id = id.toString(); + this.tableName = tableName; + this.columns = columns; + this.constraints = constraints; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/enum_name/CARDINALITY.java b/src/main/java/com/flowerd/backend/entity/enum_name/CARDINALITY.java new file mode 100644 index 0000000..623f3f1 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/enum_name/CARDINALITY.java @@ -0,0 +1,15 @@ +package com.flowerd.backend.entity.enum_name; + +import lombok.Getter; + +@Getter +public enum CARDINALITY { + ONE("ONE"), + MANY("MANY"); + + private final String cardinality; + + CARDINALITY(String cardinality) { + this.cardinality = cardinality; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/enum_name/DATATYPE.java b/src/main/java/com/flowerd/backend/entity/enum_name/DATATYPE.java new file mode 100644 index 0000000..947f27b --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/enum_name/DATATYPE.java @@ -0,0 +1,62 @@ +package com.flowerd.backend.entity.enum_name; + +import lombok.Getter; + +@Getter +public enum DATATYPE { + // 정수 타입 (Integer Types) + TINYINT("TINYINT"), + SMALLINT("SMALLINT"), + MEDIUMINT("MEDIUMINT"), + INT("INT"), + INTEGER("INTEGER"), + BIGINT("BIGINT"), + BIT("BIT"), + BOOLEAN("BOOLEAN"), // BOOL과 동일 + BOOL("BOOL"), // BOOLEAN과 동일 + + // 고정 소수점 타입 (Fixed-Point Types) + DECIMAL("DECIMAL"), + DEC("DEC"), + NUMERIC("NUMERIC"), + + // 부동 소수점 타입 (Floating-Point Types) + FLOAT("FLOAT"), + DOUBLE("DOUBLE"), + DOUBLE_PRECISION("DOUBLE PRECISION"), + REAL("REAL"), + + // 날짜 및 시간 타입 (Date and Time Types) + DATE("DATE"), + DATETIME("DATETIME"), + TIMESTAMP("TIMESTAMP"), + TIME("TIME"), + YEAR("YEAR"), + + // 문자열 타입 (String Types) + CHAR("CHAR"), + VARCHAR("VARCHAR"), + BINARY("BINARY"), + VARBINARY("VARBINARY"), + TINYBLOB("TINYBLOB"), + BLOB("BLOB"), + MEDIUMBLOB("MEDIUMBLOB"), + LONGBLOB("LONGBLOB"), + TINYTEXT("TINYTEXT"), + TEXT("TEXT"), + MEDIUMTEXT("MEDIUMTEXT"), + LONGTEXT("LONGTEXT"), + ENUM("ENUM"), + SET("SET"), + + + // 기타 타입 (Other Types) + JSON("JSON"), + UUID("UUID"); + + private final String type; + + DATATYPE(String type) { + this.type = type; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/enum_name/ISKEY.java b/src/main/java/com/flowerd/backend/entity/enum_name/ISKEY.java new file mode 100644 index 0000000..5afcbea --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/enum_name/ISKEY.java @@ -0,0 +1,15 @@ +package com.flowerd.backend.entity.enum_name; + +import lombok.Getter; + +@Getter +public enum ISKEY { + PRIMARY_KEY("PRIMARY KEY"), + NORMAL("NORMAL"); + + private final String constraintType; + + ISKEY (String constraintType) { + this.constraintType = constraintType; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/enum_name/PARTICIPATION.java b/src/main/java/com/flowerd/backend/entity/enum_name/PARTICIPATION.java new file mode 100644 index 0000000..6ee9c16 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/enum_name/PARTICIPATION.java @@ -0,0 +1,14 @@ +package com.flowerd.backend.entity.enum_name; + +import lombok.Getter; + +@Getter +public enum PARTICIPATION { + FULL("FULL"), + PARTIAL("PARTIAL"); + + private final String participation; + PARTICIPATION(String participation) { + this.participation = participation; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/enum_name/RELTYPE.java b/src/main/java/com/flowerd/backend/entity/enum_name/RELTYPE.java new file mode 100644 index 0000000..9999445 --- /dev/null +++ b/src/main/java/com/flowerd/backend/entity/enum_name/RELTYPE.java @@ -0,0 +1,15 @@ +package com.flowerd.backend.entity.enum_name; + +import lombok.Getter; + +@Getter +public enum RELTYPE { + IDENTIFYING("IDENTIFYING"), + NON_IDENTIFYING("NON_IDENTIFYING"); + + private final String relType; + + RELTYPE(String relType) { + this.relType = relType; + } +} diff --git a/src/main/java/com/flowerd/backend/entity/Role.java b/src/main/java/com/flowerd/backend/entity/enum_name/ROLE.java similarity index 66% rename from src/main/java/com/flowerd/backend/entity/Role.java rename to src/main/java/com/flowerd/backend/entity/enum_name/ROLE.java index b6ba0f0..6be2f30 100644 --- a/src/main/java/com/flowerd/backend/entity/Role.java +++ b/src/main/java/com/flowerd/backend/entity/enum_name/ROLE.java @@ -1,9 +1,9 @@ -package com.flowerd.backend.entity; +package com.flowerd.backend.entity.enum_name; import lombok.Getter; @Getter -public enum Role { +public enum ROLE { ROLE_USER("ROLE_USER"), @@ -12,7 +12,7 @@ public enum Role { final String role; - Role(String role) { + ROLE(String role) { this.role = role; } } diff --git a/src/main/java/com/flowerd/backend/exception/FilterExceptionHandler.java b/src/main/java/com/flowerd/backend/exception/FilterExceptionHandler.java index c3c33f6..39cfad1 100644 --- a/src/main/java/com/flowerd/backend/exception/FilterExceptionHandler.java +++ b/src/main/java/com/flowerd/backend/exception/FilterExceptionHandler.java @@ -15,6 +15,8 @@ import org.springframework.web.server.WebFilterChain; import reactor.core.publisher.Mono; +import java.util.Arrays; + @Component @RequiredArgsConstructor @Slf4j @@ -30,7 +32,7 @@ public Mono filter(ServerWebExchange exchange, WebFilterChain chain) { return setErrorResponse(exchange.getResponse(), e.getResponse()); }) .onErrorResume(Exception.class, e -> { - log.error("FilterExceptionHandler: 필터 예외가 발생했습니다."); + log.error("FilterExceptionHandler: 필터 예외가 발생했습니다." + Arrays.toString(e.getStackTrace())); ApiResponse err = ApiResponse.fail("필터 내부의 예외가 발생했습니다."); return setErrorResponse(exchange.getResponse(), err); }); diff --git a/src/main/java/com/flowerd/backend/repository/ColumnRepository.java b/src/main/java/com/flowerd/backend/repository/ColumnRepository.java new file mode 100644 index 0000000..46a0a49 --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/ColumnRepository.java @@ -0,0 +1,14 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Column; +import com.flowerd.backend.entity.Table; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface ColumnRepository extends ReactiveMongoRepository{ + Flux findAllByTableId(ObjectId tableId); +} diff --git a/src/main/java/com/flowerd/backend/repository/ConstraintsRepository.java b/src/main/java/com/flowerd/backend/repository/ConstraintsRepository.java new file mode 100644 index 0000000..588a5f3 --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/ConstraintsRepository.java @@ -0,0 +1,18 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Constraints; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface ConstraintsRepository extends ReactiveMongoRepository{ + + Flux findAllByParentTableId(ObjectId TableId); + + Mono deleteAllByParentColumnId(ObjectId columnId); + + Mono deleteAllByChildColumnId(ObjectId columnId); +} diff --git a/src/main/java/com/flowerd/backend/repository/DiagramRepository.java b/src/main/java/com/flowerd/backend/repository/DiagramRepository.java new file mode 100644 index 0000000..07ce82f --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/DiagramRepository.java @@ -0,0 +1,14 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Diagram; +import com.flowerd.backend.entity.Project; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface DiagramRepository extends ReactiveMongoRepository { + Flux findAllByProjectId(ObjectId projectId); +} diff --git a/src/main/java/com/flowerd/backend/repository/DiagramTableRepository.java b/src/main/java/com/flowerd/backend/repository/DiagramTableRepository.java new file mode 100644 index 0000000..8271ac5 --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/DiagramTableRepository.java @@ -0,0 +1,18 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Diagram; +import com.flowerd.backend.entity.DiagramTable; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface DiagramTableRepository extends ReactiveMongoRepository{ + Flux findAllByDiagramId(ObjectId diagramId); + + Flux findAllByTableId(ObjectId tableId); + + Mono findByDiagramIdAndTableId(ObjectId diagramId, ObjectId tableId); +} diff --git a/src/main/java/com/flowerd/backend/repository/MemberRepository.java b/src/main/java/com/flowerd/backend/repository/MemberRepository.java index 1e001bc..09adffc 100644 --- a/src/main/java/com/flowerd/backend/repository/MemberRepository.java +++ b/src/main/java/com/flowerd/backend/repository/MemberRepository.java @@ -1,7 +1,7 @@ package com.flowerd.backend.repository; import com.flowerd.backend.entity.Member; -import org.springframework.data.mongodb.repository.MongoRepository; +import org.bson.types.ObjectId; import org.springframework.data.mongodb.repository.ReactiveMongoRepository; import org.springframework.stereotype.Repository; import reactor.core.publisher.Mono; @@ -9,7 +9,7 @@ import java.util.Optional; @Repository -public interface MemberRepository extends ReactiveMongoRepository { +public interface MemberRepository extends ReactiveMongoRepository { Mono existsByEmail(String email); Mono findByEmail(String email); diff --git a/src/main/java/com/flowerd/backend/repository/ProjectRepository.java b/src/main/java/com/flowerd/backend/repository/ProjectRepository.java new file mode 100644 index 0000000..f52f057 --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/ProjectRepository.java @@ -0,0 +1,14 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Project; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface ProjectRepository extends ReactiveMongoRepository{ + + Flux findAllByOwnerId(ObjectId ownerId); +} diff --git a/src/main/java/com/flowerd/backend/repository/RefreshTokenRedisRepository.java b/src/main/java/com/flowerd/backend/repository/RefreshTokenRedisRepository.java index 73377a4..51d39fd 100644 --- a/src/main/java/com/flowerd/backend/repository/RefreshTokenRedisRepository.java +++ b/src/main/java/com/flowerd/backend/repository/RefreshTokenRedisRepository.java @@ -56,5 +56,3 @@ public Mono delete(RefreshToken refreshToken) { .doOnError(error -> log.error("Error deleting refresh token for email: {}. Error: {}", refreshToken.getEmail(), error.getMessage())); } } - - diff --git a/src/main/java/com/flowerd/backend/repository/SchemaRepository.java b/src/main/java/com/flowerd/backend/repository/SchemaRepository.java new file mode 100644 index 0000000..2b4f290 --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/SchemaRepository.java @@ -0,0 +1,13 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Schema; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface SchemaRepository extends ReactiveMongoRepository { + Flux findAllByProjectId(ObjectId projectId); +} diff --git a/src/main/java/com/flowerd/backend/repository/TableRepository.java b/src/main/java/com/flowerd/backend/repository/TableRepository.java new file mode 100644 index 0000000..058d2ba --- /dev/null +++ b/src/main/java/com/flowerd/backend/repository/TableRepository.java @@ -0,0 +1,13 @@ +package com.flowerd.backend.repository; + +import com.flowerd.backend.entity.Table; +import org.bson.types.ObjectId; +import org.springframework.data.mongodb.repository.ReactiveMongoRepository; +import org.springframework.stereotype.Repository; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +@Repository +public interface TableRepository extends ReactiveMongoRepository { + Flux
findAllBySchemaId(ObjectId schemaId); +} diff --git a/src/main/java/com/flowerd/backend/service/ColumnService.java b/src/main/java/com/flowerd/backend/service/ColumnService.java new file mode 100644 index 0000000..2fde14e --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/ColumnService.java @@ -0,0 +1,83 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.Column; +import com.flowerd.backend.entity.dto.inbound.ColumnVO; +import com.flowerd.backend.entity.enum_name.DATATYPE; +import com.flowerd.backend.entity.enum_name.ISKEY; +import com.flowerd.backend.entity.dto.outbound.ColumnReturns; +import com.flowerd.backend.repository.ColumnRepository; +import com.flowerd.backend.repository.ConstraintsRepository; +import com.flowerd.backend.repository.TableRepository; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +@Service +@RequiredArgsConstructor +public class ColumnService { + + private final ColumnRepository columnRepository; + private final ConstraintsRepository constraintsRepository; + private final TableRepository tableRepository; + + public Mono deleteColumn(ObjectId columnId) { + return constraintsRepository.deleteAllByParentColumnId(columnId) + .then(constraintsRepository.deleteAllByChildColumnId(columnId)) + .then(columnRepository.deleteById(columnId)) + .switchIfEmpty(Mono.error(new RuntimeException("컬럼이 존재하지 않습니다."))); + } + + + public Mono updateColumn(ColumnVO columnVO, ObjectId columnId) { + return columnRepository.findById(columnId) + .switchIfEmpty(Mono.error(new RuntimeException("컬럼이 존재하지 않습니다."))) + .flatMap(column -> { + if (columnVO.getColumnName() != null) { + column.setColumnName(columnVO.getColumnName()); + } + if (columnVO.getNullable() != null) { + column.setNullable(columnVO.getNullable()); + } + if (columnVO.getUnique() != null) { + column.setUnique(columnVO.getUnique()); + } + if (columnVO.getIsKey() != null) { + column.setIsKey(columnVO.getIsKey()); + } + if (columnVO.getDataType() != null) { + column.setDataType(columnVO.getDataType()); + } + if (columnVO.getLength() != null) { + column.setLength(columnVO.getLength()); + } + return columnRepository.save(column); + }).then(); + } + + + public Mono getListColumn(ObjectId columnId) { + return columnRepository.findById(columnId) + .switchIfEmpty(Mono.error(new RuntimeException("컬럼이 존재하지 않습니다."))) + .map(column -> new ColumnReturns(column.getId(), column.getColumnName(), column.getNullable(), column.getUnique(), column.getIsKey(), column.getDataType(), column.getLength())); + } + + public Mono saveColumn(ColumnVO columnVO) { + return tableRepository.findById(columnVO.getTableId()) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(table -> + columnRepository.save( + new Column( + columnVO.getTableId(), + columnVO.getColumnName(), + columnVO.getNullable(), + columnVO.getUnique(), + columnVO.getIsKey(), + columnVO.getDataType(), + columnVO.getLength() + ) + ).map(Column::getId) + ); + } + +} diff --git a/src/main/java/com/flowerd/backend/service/ConstraintsService.java b/src/main/java/com/flowerd/backend/service/ConstraintsService.java new file mode 100644 index 0000000..0d33b5f --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/ConstraintsService.java @@ -0,0 +1,104 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.Constraints; +import com.flowerd.backend.entity.dto.inbound.ConstraintsVO; +import com.flowerd.backend.entity.enum_name.CARDINALITY; +import com.flowerd.backend.entity.enum_name.PARTICIPATION; +import com.flowerd.backend.entity.enum_name.RELTYPE; +import com.flowerd.backend.entity.dto.outbound.ConstraintsReturns; +import com.flowerd.backend.repository.ColumnRepository; +import com.flowerd.backend.repository.ConstraintsRepository; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +@Service +@RequiredArgsConstructor +public class ConstraintsService { + + private final ConstraintsRepository constraintsRepository; + private final ColumnRepository columnRepository; + + public Mono getListConstraints(ObjectId constraintsId) { + return constraintsRepository.findById(constraintsId) + .switchIfEmpty(Mono.error(new RuntimeException("칼럼이 존재하지 않습니다."))) + .map(constraints -> new ConstraintsReturns(constraints.getId(), constraints.getChildColumnId(), constraints.getParentColumnId(), constraints.getParentParticipation(), constraints.getChildParticipation(), constraints.getParentCardinality(), constraints.getChildCardinality(), constraints.getRelType())); + } + + public Mono saveConstraints(ConstraintsVO constraintsVO) { + return columnRepository.findById(constraintsVO.getChildColumnId()) + .switchIfEmpty(Mono.error(new RuntimeException("칼럼이 존재하지 않습니다."))) + .zipWith(columnRepository.findById(constraintsVO.getParentColumnId())) + .switchIfEmpty(Mono.error(new RuntimeException("칼럼이 존재하지 않습니다."))) + .flatMap(tuple -> + constraintsRepository.save( + new Constraints( + constraintsVO.getChildColumnId(), + constraintsVO.getParentColumnId(), + constraintsVO.getParentParticipation(), + constraintsVO.getChildParticipation(), + constraintsVO.getParentCardinality(), + constraintsVO.getChildCardinality(), + constraintsVO.getRelType())) + .map(Constraints::getId) + ); + } + + + public Mono deleteConstraints(ObjectId constraintsId) { + return constraintsRepository.deleteById(constraintsId) + .switchIfEmpty(Mono.error(new RuntimeException("제약조건이 존재하지 않습니다."))); + } + + public Mono updateConstraints(ConstraintsVO constraintsVO, ObjectId constraintsId) { + return constraintsRepository.findById(constraintsId) + .switchIfEmpty(Mono.error(new RuntimeException("제약조건이 존재하지 않습니다."))) + .flatMap(constraints -> { + Mono childColumnExists = constraintsVO.getChildColumnId() == null + ? Mono.just(true) + : columnRepository.findById(constraintsVO.getChildColumnId()).hasElement(); + + Mono parentColumnExists = constraintsVO.getParentColumnId() == null + ? Mono.just(true) + : columnRepository.findById(constraintsVO.getParentColumnId()).hasElement(); + + return Mono.zip(childColumnExists, parentColumnExists) + .flatMap(tuple -> { + boolean childExists = tuple.getT1(); + boolean parentExists = tuple.getT2(); + + if (!childExists || !parentExists) { + return Mono.error(new RuntimeException("칼럼이 존재하지 않습니다.")); + } + + // 업데이트할 필드가 존재하면 설정 + if (constraintsVO.getChildColumnId() != null) { + constraints.setChildColumnId(constraintsVO.getChildColumnId()); + } + if (constraintsVO.getParentColumnId() != null) { + constraints.setParentColumnId(constraintsVO.getParentColumnId()); + } + if (constraintsVO.getParentParticipation() != null) { + constraints.setParentParticipation(constraintsVO.getParentParticipation()); + } + if (constraintsVO.getChildParticipation() != null) { + constraints.setChildParticipation(constraintsVO.getChildParticipation()); + } + if (constraintsVO.getParentCardinality() != null) { + constraints.setParentCardinality(constraintsVO.getParentCardinality()); + } + if (constraintsVO.getChildCardinality() != null) { + constraints.setChildCardinality(constraintsVO.getChildCardinality()); + } + if (constraintsVO.getRelType() != null) { + constraints.setRelType(constraintsVO.getRelType()); + } + + return constraintsRepository.save(constraints); + }); + }) + .then(); + } + +} diff --git a/src/main/java/com/flowerd/backend/service/DiagramService.java b/src/main/java/com/flowerd/backend/service/DiagramService.java new file mode 100644 index 0000000..c0bb3e1 --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/DiagramService.java @@ -0,0 +1,79 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.Diagram; +import com.flowerd.backend.entity.dto.inbound.DiagramVO; +import com.flowerd.backend.entity.dto.outbound.DiagramReturns; +import com.flowerd.backend.repository.DiagramRepository; +import com.flowerd.backend.repository.DiagramTableRepository; +import com.flowerd.backend.repository.ProjectRepository; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +@Service +@RequiredArgsConstructor +public class DiagramService { + + private final DiagramRepository diagramRepository; + private final DiagramTableRepository diagramTableRepository; + private final TableService tableService; + private final ProjectRepository projectRepository; + + // 다이어그램 생성시에는 테이블과 매핑 안됨 + public Mono saveDiagram(DiagramVO diagramVO) { + return projectRepository.findById(diagramVO.getProjectId()) + .switchIfEmpty(Mono.error(new RuntimeException("프로젝트를 찾을 수 없습니다."))) + .flatMap(project -> + diagramRepository.save( + new Diagram( + diagramVO.getProjectId(), + diagramVO.getDiagramName(), + diagramVO.getSizeX(), + diagramVO.getSizeY(), + diagramVO.getDiagramContent() + ) + ).map(Diagram::getId) + ); + } + + // DiagramTable 삭제 -> 체이닝 돌면서 삭제해줌. + public Mono deleteDiagram(ObjectId diagramId) { + return diagramTableRepository.findAllByDiagramId(diagramId) + .flatMap(diagramTable -> diagramTableRepository.deleteById(diagramTable.getId())) + .then(diagramRepository.deleteById(diagramId)) + .switchIfEmpty(Mono.error(new RuntimeException("다이어그램이 존재하지 않습니다."))); + } + + public Mono updateDiagram(DiagramVO diagramVO, ObjectId diagramId) { + return diagramRepository.findById(diagramId). + switchIfEmpty(Mono.error(new RuntimeException("다이어그램이 존재하지 않습니다."))) + .flatMap(diagram -> { + if(diagramVO.getDiagramName() != null) + diagram.setDiagramId(diagramVO.getDiagramName()); + if(diagramVO.getSizeX() != null) + diagram.setPixel_x(diagramVO.getSizeX()); // maxPixel 조정 + if(diagramVO.getSizeY() != null) + diagram.setPixel_y(diagramVO.getSizeY()); // maxPixel 조정 + if(diagramVO.getDiagramContent() != null) + diagram.setDiagramContent(diagramVO.getDiagramContent()); + return diagramRepository.save(diagram); + }).then(); + } + + // 다이어그램 -> 다이어그램 테이블 검색 -> 테이블 모두 검색 + public Mono getListDiagram(ObjectId diagramId) { + return diagramRepository.findById(diagramId) + .flatMap(diagram -> { + DiagramReturns diagramReturns = new DiagramReturns(diagram.getId(), diagram.getPixel_x(), diagram.getPixel_y(), diagram.getDiagramContent(), null); + + return diagramTableRepository.findAllByDiagramId(diagramId) + .flatMap(diagramTable -> tableService.getListTableByDiagramTableId(diagramTable.getTableId())) + .collectList() + .map(diagramTableList -> { + diagramReturns.setTables(diagramTableList); + return diagramReturns; + }); + }); + } +} diff --git a/src/main/java/com/flowerd/backend/service/MemberService.java b/src/main/java/com/flowerd/backend/service/MemberService.java index 561d782..bfa589f 100644 --- a/src/main/java/com/flowerd/backend/service/MemberService.java +++ b/src/main/java/com/flowerd/backend/service/MemberService.java @@ -1,10 +1,11 @@ package com.flowerd.backend.service; import com.flowerd.backend.entity.Member; -import com.flowerd.backend.entity.Role; +import com.flowerd.backend.entity.enum_name.ROLE; import com.flowerd.backend.exception.NoCredException; import com.flowerd.backend.exception.UsernameNotFoundException; import com.flowerd.backend.repository.MemberRepository; +import com.flowerd.backend.security.util.JwtTokenProvider; import com.flowerd.backend.security.util.MailProvider; import lombok.RequiredArgsConstructor; import org.springframework.security.core.GrantedAuthority; @@ -25,14 +26,15 @@ public class MemberService implements ReactiveUserDetailsService { private final MemberRepository memberRepository; // 비동기적으로 변경된 레포지토리 private final MailProvider mailProvider; // 비동기적으로 변경된 MailProvider + private final JwtTokenProvider jwtTokenProvider; // 비동기적으로 변경된 JwtTokenProvider public Mono saveLocalMember(String name, String email, String password) { // 메일 인증이 확인되었는지 먼저 체크 return mailProvider.checkAck(email) .flatMap(ack -> { if (ack) { - List roles = List.of(Role.ROLE_USER); - Member member = Member.of(email, name, password, roles); + List ROLES = List.of(ROLE.ROLE_USER); + Member member = Member.of(email, name, password, ROLES); return memberRepository.save(member).then(); } else { return Mono.error(new NoCredException()); @@ -55,13 +57,19 @@ public Mono checkCertMail(String email, String uuid) { return mailProvider.checkMail(email, uuid); } - // 인증시 사용자를 비동기적으로 검색하는 메소드 + public Mono getMember(String token) { + String email = jwtTokenProvider.getEmailForAccessToken(token); + // 이메일로 멤버를 비동기적으로 검색 + return memberRepository.findByEmail(email).switchIfEmpty(Mono.error(new UsernameNotFoundException(email))); + } + + // 인증시 사용자를 비동기적으로 검색하는 메소드 public Mono findByUsername(String username) { return memberRepository.findByEmail(username) .switchIfEmpty(Mono.error(new UsernameNotFoundException(username))) .map(member -> { Collection authorities = new ArrayList<>(); - for (Role role : member.getRoles()) { + for (ROLE role : member.getROLES()) { authorities.add(new SimpleGrantedAuthority(role.name())); } return User.builder() diff --git a/src/main/java/com/flowerd/backend/service/ProjectService.java b/src/main/java/com/flowerd/backend/service/ProjectService.java new file mode 100644 index 0000000..fd73999 --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/ProjectService.java @@ -0,0 +1,130 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.Project; +import com.flowerd.backend.entity.dto.inbound.ProjectVO; +import com.flowerd.backend.entity.dto.outbound.AllReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectDrawReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectListReturns; +import com.flowerd.backend.entity.dto.outbound.ProjectReturns; +import com.flowerd.backend.repository.*; +import com.flowerd.backend.security.util.JwtTokenProvider; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +import java.util.List; + + +@Service +@RequiredArgsConstructor +public class ProjectService { + + private final ProjectRepository projectRepository; + private final JwtTokenProvider jwtTokenProvider; + private final MemberRepository memberRepository; + private final SchemaRepository schemaRepository; + private final SchemaService schemaService; + private final DiagramService diagramService; + private final DiagramRepository diagramRepository; + + public Mono saveProject(ProjectVO projectVO, String token) { + return Mono.just(jwtTokenProvider.getEmailForAccessToken(token)) + .flatMap(memberRepository::findByEmail) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 멤버가 없습니다."))) + .flatMap(member -> + projectRepository.save( + new Project( + projectVO.getProjectName(), + member.getId() + ) + ).map(Project::getId) + ); + } + + // 스키마 검색 및 삭제 -> 체이닝 돌면서 삭제해줌 + public Mono deleteProject(ObjectId projectId) { + return schemaRepository.findAllByProjectId(projectId) + .flatMap(schema -> schemaService.deleteSchema(schema.getId())) + .then(projectRepository.deleteById(projectId)) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))); + } + + // 수정은 각 항목에서 합시다. + public Mono updateProject(ProjectVO projectVO, ObjectId projectId) { + return projectRepository.findById(projectId) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + .flatMap(project -> { + if (projectVO.getProjectName() != null) { + project.setProjectName(projectVO.getProjectName()); + } + return projectRepository.save(project); + }).then(); + } + + // 프로젝트의 모든것 -> 일단 스키마 리스트로 가져와 + public Mono getListProject(ObjectId projectId) { + return projectRepository.findById(projectId) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + .flatMap(project -> { + ProjectReturns projectReturns = new ProjectReturns(project.getId(), project.getProjectName(), null); + + // SchemaRepository에서 projectId로 연결된 스키마들을 조회하여 스키마 ID 목록 추출 + return schemaRepository.findAllByProjectId(projectId) + .flatMap(schema -> schemaService.getListSchema(schema.getId())) // 각 스키마 ID로 getListSchema 호출 + .collectList() + .map(schemaReturnsList -> { + projectReturns.setSchemaReturns(schemaReturnsList); + return projectReturns; + }); + }); + } + + public Mono getListDrawProject(ObjectId projectId){ + return projectRepository.findById(projectId) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + .flatMap(project -> { + ProjectDrawReturns projectDrawReturns = new ProjectDrawReturns(project.getId(), project.getProjectName(), null); + + // DiagramRepository에서 projectId로 연결된 다이어그램들을 조회하여 다이어그램 ID 목록 추출 + return diagramRepository.findAllByProjectId(projectId) + .flatMap(diagram -> diagramService.getListDiagram(diagram.getId())) + .collectList() + .map(diagramReturnsList -> { + projectDrawReturns.setDiagramReturns(diagramReturnsList); + return projectDrawReturns; + }); + }); + } + + public Mono getAllProject(ObjectId projectId) { + return projectRepository.findById(projectId) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + .flatMap(project -> { + AllReturns allReturns = new AllReturns(); + return getListProject(projectId) + .flatMap(projectReturns -> { + allReturns.setProjectReturns(List.of(projectReturns)); + return getListDrawProject(projectId); + }) + .map(projectDrawReturns -> { + allReturns.setProjectDrawReturns(List.of(projectDrawReturns)); + return allReturns; + }); + }); + } + + public Mono> getProjectIdList(String token) { + return memberRepository.findByEmail(jwtTokenProvider.getEmailForAccessToken(token)) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 멤버가 없습니다."))) + .flatMapMany(member -> + projectRepository.findAllByOwnerId(member.getId()) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + ) + .map(project -> new ProjectListReturns(project.getId(),project.getProjectName()) + ) + .collectList(); + } + + +} diff --git a/src/main/java/com/flowerd/backend/service/SchemaService.java b/src/main/java/com/flowerd/backend/service/SchemaService.java new file mode 100644 index 0000000..74bbbea --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/SchemaService.java @@ -0,0 +1,71 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.Schema; +import com.flowerd.backend.entity.dto.inbound.SchemaVO; +import com.flowerd.backend.entity.dto.outbound.SchemaReturns; +import com.flowerd.backend.repository.ProjectRepository; +import com.flowerd.backend.repository.SchemaRepository; +import com.flowerd.backend.repository.TableRepository; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +@Service +@RequiredArgsConstructor +public class SchemaService { + + private final SchemaRepository schemaRepository; + private final TableService tableService; + private final TableRepository tableRepository; + private final ProjectRepository projectRepository; + + public Mono saveSchema(SchemaVO schemaVO) { + return projectRepository.findById(schemaVO.getProjectId()) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 프로젝트가 없습니다."))) + .flatMap(project -> + schemaRepository.save( + new Schema( + project.getId(), + schemaVO.getSchemaName() + ) + ).map(Schema::getId) + ); + } + + + public Mono deleteSchema(ObjectId schemaId) { + return tableRepository.findAllBySchemaId(schemaId) + .flatMap(table-> tableService.deleteTable(table.getId())) + .then(schemaRepository.deleteById(schemaId)) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 스키마가 없습니다."))); + } + + public Mono updateSchema(SchemaVO schemaVO, ObjectId schemaId) { + return schemaRepository.findById(schemaId) + .switchIfEmpty(Mono.error(new IllegalArgumentException("해당하는 스키마가 없습니다."))) + .flatMap(schema -> { + if (schemaVO.getSchemaName() != null) { + schema.setSchemaName(schemaVO.getSchemaName()); + } + return schemaRepository.save(schema); + }).then(); + } + + public Mono getListSchema(ObjectId schemaId) { + return schemaRepository.findById(schemaId) + .flatMap(schema -> { + SchemaReturns schemaReturns = new SchemaReturns(schema.getId(), schema.getSchemaName(), null); + + // DiagramRepository에서 projectId로 연결된 다이어그램들을 조회하여 다이어그램 ID 목록 추출 + return tableRepository.findAllBySchemaId(schemaId) + .flatMap(table -> tableService.getListTableByTableId(table.getId())) + .collectList() + .map(tableReturnsList -> { + schemaReturns.setTableReturns(tableReturnsList); + return schemaReturns; + }); + }); + } + +} diff --git a/src/main/java/com/flowerd/backend/service/TableService.java b/src/main/java/com/flowerd/backend/service/TableService.java new file mode 100644 index 0000000..92534e2 --- /dev/null +++ b/src/main/java/com/flowerd/backend/service/TableService.java @@ -0,0 +1,133 @@ +package com.flowerd.backend.service; + +import com.flowerd.backend.entity.DiagramTable; +import com.flowerd.backend.entity.Table; +import com.flowerd.backend.entity.dto.inbound.DiagramTableVO; +import com.flowerd.backend.entity.dto.inbound.TableVO; +import com.flowerd.backend.entity.dto.outbound.ColumnReturns; +import com.flowerd.backend.entity.dto.outbound.ConstraintsReturns; +import com.flowerd.backend.entity.dto.outbound.TableDiagramReturns; +import com.flowerd.backend.entity.dto.outbound.TableReturns; +import com.flowerd.backend.repository.*; +import lombok.RequiredArgsConstructor; +import org.bson.types.ObjectId; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +import java.util.List; + +@Service +@RequiredArgsConstructor +public class TableService { + + private final TableRepository tableRepository; + private final ColumnService columnService; + private final ColumnRepository columnRepository; + private final ConstraintsService constraintsService; + private final ConstraintsRepository constraintsRepository; + private final DiagramTableRepository diagramTableRepository; + private final SchemaRepository schemaRepository; + + public Mono saveTable(TableVO tableVO) { + return schemaRepository.findById(tableVO.getSchemaId()) + .switchIfEmpty(Mono.error(new RuntimeException("스키마를 찾을 수 없습니다."))) + .flatMap(schema -> + tableRepository.save( + new Table( + tableVO.getSchemaId(), + tableVO.getTableName() + ) + ) + ).map(Table::getId); + } + + + + + public Mono deleteTable(ObjectId tableId) { + return columnRepository.findAllByTableId(tableId) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(column-> columnService.deleteColumn(column.getId())) + .then(tableRepository.deleteById(tableId)); + } + + + public Mono updateTable(TableVO tableVO, ObjectId tableId) { + return tableRepository.findById(tableId) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(table -> { + if (tableVO.getTableName() != null) { + table.setTableName(tableVO.getTableName()); + } + return tableRepository.save(table) + .thenReturn(table); // Table을 저장하고 반환 + }).then(); + } + + + + + // 테이블 - 스키마 구조 + public Mono getListTableByTableId(ObjectId tableId) { + return tableRepository.findById(tableId) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(table -> { + TableReturns tableReturns = new TableReturns(table.getId(), table.getTableName(), null, null); + + Mono> columnReturnsList = columnRepository.findAllByTableId(tableId) + .flatMapSequential(column -> columnService.getListColumn(column.getId())) + .collectList(); + + Mono> constraintsReturnsList = constraintsRepository.findAllByParentTableId(tableId) + .flatMapSequential(constraints -> constraintsService.getListConstraints(constraints.getId())) + .collectList(); + + return Mono.zip(columnReturnsList, constraintsReturnsList) + .map(tuple -> { + tableReturns.setColumns(tuple.getT1()); // Set columns + tableReturns.setConstraints(tuple.getT2()); // Set constraints + return tableReturns; + }); + + }); + } + + // 테이블 - 다이어그램테이블 - 다이어그램 구조 + public Mono getListTableByDiagramTableId(ObjectId diagramTableId){ + return diagramTableRepository.findById(diagramTableId) + .switchIfEmpty(Mono.error(new RuntimeException("다이어그램 테이블이 존재하지 않습니다."))) + .flatMap(diagramTable -> tableRepository.findById(diagramTable.getTableId()) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(table -> { + TableDiagramReturns tableDiagramReturns = new TableDiagramReturns(table.getId(), table.getTableName(), diagramTable.getSize_x(), diagramTable.getSize_y(), null, null); + + Mono> columnReturnsList = columnRepository.findAllByTableId(table.getId()) + .flatMap(column -> columnService.getListColumn(column.getId())) + .collectList(); + + Mono> constraintsReturnsList = constraintsRepository.findAllByParentTableId(table.getId()) + .flatMap(constraints -> constraintsService.getListConstraints(constraints.getId())) + .collectList(); + + return Mono.zip(columnReturnsList, constraintsReturnsList) + .map(tuple -> { + tableDiagramReturns.setColumns(tuple.getT1()); // Set columns + tableDiagramReturns.setConstraints(tuple.getT2()); // Set constraints + return tableDiagramReturns; + }); + })); + } + + public Mono mapTableToDiagram(ObjectId tableId, ObjectId diagramId, DiagramTableVO diagramTableVO){ + return tableRepository.findById(tableId) + .switchIfEmpty(Mono.error(new RuntimeException("테이블이 존재하지 않습니다."))) + .flatMap(table -> diagramTableRepository.save(new DiagramTable(diagramId, tableId, diagramTableVO.getPosX(), diagramTableVO.getPosY())) + .map(DiagramTable::getId)); + } + + public Mono unmapTableToDiagram(ObjectId tableId, ObjectId diagramId){ + return diagramTableRepository.findByDiagramIdAndTableId(diagramId, tableId) + .switchIfEmpty(Mono.error(new RuntimeException("다이어그램 테이블이 존재하지 않습니다."))) + .flatMap(diagramTable -> diagramTableRepository.deleteById(diagramTable.getId())); + } +} diff --git a/src/main/resources/application-deploy.yml b/src/main/resources/application-deploy.yml new file mode 100644 index 0000000..9cd8725 --- /dev/null +++ b/src/main/resources/application-deploy.yml @@ -0,0 +1,37 @@ +spring: + data: + mongodb: + uri: "mongodb://${Mongo_Username}:${Mongo_Password}@${MongoDB_Host}:${MongoDB_Port}/${MongoDB_Database}?authSource=admin" + + redis: + repositories: + enabled: false + host: ${Redis_Host} + port: ${Redis_Port} + + autoconfigure: + exclude: org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration + + mail: + host: smtp.gmail.com + port: 587 + username: ${Mail_Email} + password: ${Mail_Password} + properties: + mail: + smtp: + auth: true + starttls: + enable: true + ssl: + trust: smtp.gmail.com + enable: true + debug: true + +jwt: + secret: ${JWT_Secret} + access_expiration: 31536000 + refresh_expiration: 315360000 + +server: + port: 8080 \ No newline at end of file diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml new file mode 100644 index 0000000..7c5f532 --- /dev/null +++ b/src/main/resources/application.yml @@ -0,0 +1,8 @@ +spring: + profiles: + default: local + +logging: + level: + org.bts.backend: debug + org.springframework.web.servlet: debug diff --git a/src/test/java/com/flowerd/backend/FlowErdBackendApplicationTests.java b/src/test/java/com/flowerd/backend/FlowErdBackendApplicationTests.java deleted file mode 100644 index ac2bcb9..0000000 --- a/src/test/java/com/flowerd/backend/FlowErdBackendApplicationTests.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.flowerd.backend; - -import org.junit.jupiter.api.Test; -import org.springframework.boot.test.context.SpringBootTest; - -@SpringBootTest -class FlowErdBackendApplicationTests { - - @Test - void contextLoads() { - } - -}