선착순 이벤트 퀴즈 제출 최종 점검

common/src/main/java/com/watermelon/server/BaseEntity.java

@@ -16,10 +16,12 @@
 @EntityListeners(AuditingEntityListener.class)
 public class BaseEntity {
 
-    @Column(updatable = false)
+    @Column(updatable = false,name ="created_at")
     @CreatedDate
     private LocalDateTime createdAt;
 
+
+    @Column(name="updated_at")
     @LastModifiedDate
     private LocalDateTime updatedAt;
 }

order/src/main/java/com/watermelon/server/OrderApplication.java

@@ -3,8 +3,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
 @EnableCaching

order/src/main/java/com/watermelon/server/Scheduler.java

@@ -1,6 +1,6 @@
 package com.watermelon.server;
 
-import com.watermelon.server.order.service.CurrentOrderEventManageService;
+import com.watermelon.server.orderResult.service.CurrentOrderEventManageService;
 import com.watermelon.server.order.service.OrderEventSchedulingService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -12,6 +12,8 @@
 @Component
 @RequiredArgsConstructor
 public class Scheduler {
+
+
     private final OrderEventSchedulingService orderEventSchedulingService;
     private final CurrentOrderEventManageService currentOrderEventManageService;
     @Scheduled(fixedRate = 1000)
@@ -23,7 +25,7 @@ public void checkOrderEvent(){
             log.info("changed current order event id is {}", newCurrentEventId);
         }
     }
-    @Scheduled(fixedRate = 30000)
+    @Scheduled(fixedRate = 300000)
     public void checkCurrentOrderEvent(){
         Long currentEventId = currentOrderEventManageService.getCurrentOrderEventId();
         log.info("current order event id is {}", currentEventId);

order/src/main/java/com/watermelon/server/common/config/DatasourceConfig.java

@@ -0,0 +1,85 @@
+package com.watermelon.server.common.config;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+@EnableTransactionManagement
+@EnableJpaRepositories(
+        entityManagerFactoryRef = "entityManagerFactory",
+        transactionManagerRef = "transactionManager",
+        basePackages = {"com.watermelon.server.order.repository"}
+)
+@Configuration
+@Profile("!local")
+public class DatasourceConfig {
+
+    @Value("${spring.datasource1.url}")
+    private String url;
+
+    @Value("${spring.datasource1.username}")
+    private String username;
+
+    @Value("${spring.datasource1.password}")
+    private String password;
+
+    @Value("${spring.datasource1.hikari.maximum-pool-size}")
+    private int maximumPoolSize;
+
+    @Value("${spring.datasource1.hikari.leak-detection-threshold}")
+    private long leakDetectionThreshold;
+
+    @Bean
+    @Primary
+    public DataSource dataSource() {
+        HikariConfig hikariConfig = new HikariConfig();
+        hikariConfig.setJdbcUrl(url);
+        hikariConfig.setUsername(username);
+        hikariConfig.setPassword(password);
+        hikariConfig.setMaximumPoolSize(maximumPoolSize);
+        hikariConfig.setLeakDetectionThreshold(leakDetectionThreshold);
+        hikariConfig.setPoolName("orderPool");
+        return new HikariDataSource(hikariConfig);
+    }
+
+    @Bean
+    @Primary
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
+            EntityManagerFactoryBuilder builder
+    ) {
+        Map<String,Object> properties = new HashMap<>();
+        properties.put("dialect", "org.hibernate.dialect.MySQL8InnoDBDialect");
+        properties.put("hibernate.show_sql", true);
+        properties.put("hibernate.format_sql", true);
+//        properties.put("hibernate.ddl-auto", "update");
+        properties.put("open_in_view", "false");
+        properties.put("hibernate.hbm2ddl.auto", "update");
+        properties.put("hibernate.physical_naming_strategy" , "org.hibernate.boot.model.naming.CamelCaseToUnderscoresNamingStrategy");
+        return builder
+                .dataSource(dataSource())
+                .packages("com.watermelon.server.order")
+                .properties(properties)
+                .build();
+    }
+
+    @Bean
+    @Primary
+    public JpaTransactionManager transactionManager(LocalContainerEntityManagerFactoryBean entityManagerFactory) {
+        return new JpaTransactionManager(entityManagerFactory.getObject());
+    }
+}

order/src/main/java/com/watermelon/server/common/config/HikariConfig.java

@@ -0,0 +1,94 @@
+//package com.watermelon.server.common.config;
+//
+//
+//import com.zaxxer.hikari.HikariDataSource;
+//import jakarta.persistence.EntityManagerFactory;
+//import org.springframework.beans.factory.annotation.Value;
+//import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
+//import org.springframework.context.annotation.Bean;
+//import org.springframework.context.annotation.Configuration;
+//import org.springframework.context.annotation.Primary;
+//import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+//import org.springframework.orm.jpa.JpaTransactionManager;
+//import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+//
+//@Configuration
+//@EnableJpaRepositories(
+//        entityManagerFactoryRef = "orderResultEntityManager",
+//        transactionManagerRef = "orderResultTransactionManager",
+//        basePackages = {"com.watermelon.server.order.repository"}
+//)
+//public class HikariConfig {
+//    @Value("${spring.datasource.url}")
+//    private String url;
+//
+//    @Value("${spring.datasource.username}")
+//    private String username;
+//
+//    @Value("${spring.datasource.password}")
+//    private String password;
+//
+//    private int maximumPoolSize =10;
+//
+//    @Bean
+//    @Primary
+//    public HikariDataSource orderDataSource() {
+//        com.zaxxer.hikari.HikariConfig hikariConfig = new com.zaxxer.hikari.HikariConfig();
+//        hikariConfig.setJdbcUrl(url);
+//        hikariConfig.setUsername(username);
+//        hikariConfig.setPassword(password);
+//        hikariConfig.setMaximumPoolSize(maximumPoolSize);
+//        return new HikariDataSource(hikariConfig);
+//    }
+//    @Bean(name = "orderResultDatasource")
+//    public HikariDataSource orderResultDataSource() {
+//        com.zaxxer.hikari.HikariConfig hikariConfig = new com.zaxxer.hikari.HikariConfig();
+//        hikariConfig.setJdbcUrl(url);
+//        hikariConfig.setUsername(username);
+//        hikariConfig.setPassword(password);
+//        hikariConfig.setMaximumPoolSize(maximumPoolSize);
+//        hikariConfig.setConnectionTimeout(250L);
+//        //orderEventQuiz만을 위한 설정 0.1초마다 확인
+//        return new HikariDataSource(hikariConfig);
+//    }
+//
+//    @Bean
+//    @Primary
+//    public LocalContainerEntityManagerFactoryBean orderEntityManager(EntityManagerFactoryBuilder builder)  {
+//        return builder
+//                .dataSource(orderDataSource())
+//                .packages("com/watermelon/server/order")
+//                .persistenceUnit("order")
+//                .build();
+////        LocalContainerEntityManagerFactoryBean orderManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
+////        orderManagerFactoryBean.setDataSource(orderDataSource());
+////        orderManagerFactoryBean.setPackagesToScan("com/watermelon/server/order");
+////        orderManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
+////        orderManagerFactoryBean.setPersistenceUnitName("order");
+////        return orderManagerFactoryBean;
+//    }
+//
+//    @Bean(name ="orderResultEntityManager")
+//    public LocalContainerEntityManagerFactoryBean orderResultEntityManager(EntityManagerFactoryBuilder builder)  {
+//        return builder
+//                .dataSource(orderResultDataSource())
+//                .packages("com/watermelon/server/order")
+//                .persistenceUnit("orderResult")
+//                .build();
+//    }
+//
+//    @Bean
+//    @Primary
+//    public JpaTransactionManager orderTransactionManager(
+//            EntityManagerFactory entityManagerFactory
+//    ) {
+//        return new JpaTransactionManager(entityManagerFactory);
+//    }
+//
+//    @Bean(name = "orderResultTransactionManager")
+//    public JpaTransactionManager orderResultTransactionManager(
+//            EntityManagerFactory entityManagerFactory
+//    ) {
+//        return new JpaTransactionManager(entityManagerFactory);
+//    }
+//}

order/src/main/java/com/watermelon/server/common/config/OriginHikariConfig.java

@@ -0,0 +1,63 @@
+//package com.watermelon.server.common.config;
+//
+//
+//import com.zaxxer.hikari.HikariConfig;
+//import com.zaxxer.hikari.HikariDataSource;
+//import jakarta.persistence.EntityManagerFactory;
+//import org.springframework.beans.factory.annotation.Value;
+//import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
+//import org.springframework.context.annotation.Bean;
+//import org.springframework.context.annotation.Configuration;
+//import org.springframework.context.annotation.Primary;
+//import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+//import org.springframework.orm.jpa.JpaTransactionManager;
+//import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+//import org.springframework.transaction.annotation.EnableTransactionManagement;
+//
+//@EnableTransactionManagement
+//@EnableJpaRepositories(
+//        entityManagerFactoryRef = "orderEntityManager",
+//        transactionManagerRef = "orderTransactionManager",
+//        basePackages = {"com.watermelon.server.order.repository"}
+//)
+//@Configuration
+//public class OriginHikariConfig {
+//    @Value("${spring.datasource1.url}")
+//    private String url;
+//
+//    @Value("${spring.datasource1.username}")
+//    private String username;
+//
+//    @Value("${spring.datasource1.password}")
+//    private String password;
+//
+//    private int maximumPoolSize =10;
+//
+//    @Bean
+//    @Primary
+//    public HikariDataSource orderDataSource() {
+//        HikariConfig hikariConfig = new HikariConfig();
+//        hikariConfig.setJdbcUrl(url);
+//        hikariConfig.setUsername(username);
+//        hikariConfig.setPassword(password);
+//        hikariConfig.setMaximumPoolSize(maximumPoolSize);
+//        return new HikariDataSource(hikariConfig);
+//    }
+//
+//    @Bean
+//    @Primary
+//    public LocalContainerEntityManagerFactoryBean orderEntityManager(EntityManagerFactoryBuilder builder)  {
+//        return builder
+//                .dataSource(orderDataSource())
+//                .packages("com/watermelon/server/order")
+//                .persistenceUnit("order")
+//                .build();
+//    }
+//    @Bean
+//    @Primary
+//    public JpaTransactionManager orderTransactionManager(
+//            EntityManagerFactory entityManagerFactory
+//    ) {
+//        return new JpaTransactionManager(entityManagerFactory);
+//    }
+//}

order/src/main/java/com/watermelon/server/order/controller/OrderEventController.java

@@ -11,7 +11,7 @@
 import com.watermelon.server.order.exception.WinnerAlreadyParticipateException;
 import com.watermelon.server.order.exception.WrongPhoneNumberFormatException;
 import com.watermelon.server.order.exception.WrongOrderEventFormatException;
-import com.watermelon.server.order.result.service.OrderResultCommandService;
+import com.watermelon.server.orderResult.service.OrderResultCommandService;
 import com.watermelon.server.order.service.OrderEventCommandService;
 import com.watermelon.server.order.service.OrderEventQueryService;
 import lombok.RequiredArgsConstructor;

order/src/main/java/com/watermelon/server/order/domain/OrderEvent.java

@@ -1,8 +1,8 @@
 package com.watermelon.server.order.domain;
 
+import com.fasterxml.jackson.databind.ser.Serializers;
 import com.watermelon.server.BaseEntity;
 import com.watermelon.server.order.dto.request.RequestOrderEventDto;
-import com.watermelon.server.order.result.domain.OrderApplyCount;
 import jakarta.persistence.*;
 import lombok.*;
 import org.slf4j.Logger;
@@ -15,6 +15,7 @@
 
 @Entity
 @Getter
+@Table(name = "order_event")
 @RequiredArgsConstructor
 public class OrderEvent extends BaseEntity {
 
@@ -33,8 +34,10 @@ public class OrderEvent extends BaseEntity {
     private LocalDateTime startDate;
     private LocalDateTime endDate;
     private int winnerCount;
+
     private int currentWinnerCount;
     @Setter
+//    @Enumerated(EnumType.STRING)
     private OrderEventStatus orderEventStatus;
 
     public OrderEvent(Quiz quiz, LocalDateTime startDate, LocalDateTime endDate) {
@@ -54,8 +57,6 @@ public OrderEvent(Quiz quiz, LocalDateTime startDate, LocalDateTime endDate) {
 
     }
 
-
-
     public static OrderEvent makeOrderEventWithOutImage(RequestOrderEventDto requestOrderEventDto){
         Quiz quiz = Quiz.makeQuiz(requestOrderEventDto.getQuiz());
         OrderEventReward reward = OrderEventReward.makeReward(requestOrderEventDto.getReward());
@@ -117,9 +118,6 @@ public static OrderEvent makeOrderEventWithInputIdForDocumentation(RequestOrderE
     }
 
 
-
-
-
     @Transactional
     public void changeOrderEventStatusByTime(LocalDateTime now){
         if(orderEventStatus.equals(OrderEventStatus.END)) return;

order/src/main/java/com/watermelon/server/order/domain/OrderEventReward.java

@@ -2,17 +2,15 @@
 
 
 import com.watermelon.server.order.dto.request.RequestOrderRewardDto;
-import jakarta.persistence.Entity;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.Id;
-import jakarta.persistence.OneToOne;
+import jakarta.persistence.*;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
 @Getter
 @NoArgsConstructor
+@Table(name = "order_event_reward")
 public class OrderEventReward {
 
     @Id @GeneratedValue

order/src/main/java/com/watermelon/server/order/domain/OrderEventWinner.java

@@ -11,6 +11,7 @@
 @NoArgsConstructor
 @Entity
 @Getter
+@Table(name = "order_event_winner")
 public class OrderEventWinner extends BaseEntity {
     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -39,6 +40,4 @@ public static OrderEventWinner makeWinner(OrderEvent orderEvent
                 .applyTicket(applyTicket)
                 .build();
     }
-
-
 }

order/src/main/java/com/watermelon/server/order/domain/Quiz.java

@@ -9,6 +9,7 @@
 @Getter
 @Entity
 @NoArgsConstructor
+@Table(name = "quiz")
 public class Quiz {
     @Id @GeneratedValue
     private Long id;