Feat/controller

.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
 
 
 

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'

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"

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<Void> 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();
+		};
+	}
+
 }

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) 형식으로 설정

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("*");
+    }
+}
+

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<ResponseEntity<ApiResponse<String>>> 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<ResponseEntity<ApiResponse<Object>>> 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<ResponseEntity<ApiResponse<Object>>> 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<ResponseEntity<ApiResponse<ColumnReturns>>> 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())));
+                        });
+        }
+
+}

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<ResponseEntity<ApiResponse<String>>> 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<ResponseEntity<ApiResponse<Object>>> 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<ResponseEntity<ApiResponse<Object>>> 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<ResponseEntity<ApiResponse<ConstraintsReturns>>> 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())));
+                });
+    }
+}