[FEAT] 알람 클라우드 태스크 구현

.gitignore

@@ -41,4 +41,5 @@ out/
 
 application-secret.yml
 braindump-prompt.txt
-prioritize-prompt.txt
+prioritize-prompt.txt
+cloud-task-key.json

build.gradle.kts

@@ -76,6 +76,16 @@ dependencies {
     implementation("com.google.api-client:google-api-client:2.2.0")
     implementation ("com.google.oauth-client:google-oauth-client-jetty:1.34.1")
     implementation("com.google.apis:google-api-services-calendar:v3-rev20250115-2.0.0")
+
+    //Google Cloud Task
+    implementation ("com.google.cloud:google-cloud-tasks:2.40.0")
+    implementation ("com.google.auth:google-auth-library-oauth2-http:1.20.0")
+
+    //queryDsl
+    implementation("com.querydsl:querydsl-jpa:5.0.0:jakarta")
+    annotationProcessor("com.querydsl:querydsl-apt:5.0.0:jakarta")
+    annotationProcessor ("jakarta.annotation:jakarta.annotation-api")
+    annotationProcessor ("jakarta.persistence:jakarta.persistence-api")
 }
 
 kotlin {

src/main/java/com/official/memento/global/config/QueryDslConfig.java

@@ -0,0 +1,19 @@
+package com.official.memento.global.config;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import lombok.AllArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@AllArgsConstructor
+public class QueryDslConfig {
+
+    private final EntityManager entityManager;
+
+    @Bean
+    public JPAQueryFactory jpaQueryFactory(final EntityManager entityManager) {
+         return new JPAQueryFactory(entityManager);
+    }
+}

src/main/java/com/official/memento/schedule/controller/ScheduleApiController.java

@@ -9,8 +9,12 @@
 import com.official.memento.schedule.controller.dto.response.ScheduleAllGetResponse;
 import com.official.memento.schedule.controller.dto.response.ScheduleDetailResponse;
 import com.official.memento.schedule.domain.entity.Schedule;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
+import com.official.memento.schedule.service.CloudTaskAdapter;
 import com.official.memento.schedule.service.command.*;
 import com.official.memento.schedule.service.usecase.*;
+import java.io.IOException;
+import java.time.LocalDateTime;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -31,6 +35,7 @@ public class ScheduleApiController implements ScheduleApiDocs {
     private final ScheduleGroupDeleteUseCase scheduleGroupDeleteUseCase;
     private final ScheduleGroupUpdateUseCase scheduleGroupUpdateUseCase;
     private final ScheduleGroupCreateUseCase scheduleGroupCreateUseCase;
+    private final CloudTaskAdapter cloudTaskAdapter;
 
     @PostMapping
     @Override

src/main/java/com/official/memento/schedule/domain/ScheduleAlarmRepository.java

@@ -0,0 +1,9 @@
+package com.official.memento.schedule.domain;
+
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
+import java.time.LocalDateTime;
+import java.util.List;
+
+public interface ScheduleAlarmRepository {
+    List<ScheduleAlarm> findSchedulesWithMemberInfoBetween(final LocalDateTime startTime, final LocalDateTime endTime);
+}

src/main/java/com/official/memento/schedule/domain/ScheduleRepository.java

@@ -1,6 +1,7 @@
 package com.official.memento.schedule.domain;
 
 import com.official.memento.schedule.domain.entity.Schedule;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;

src/main/java/com/official/memento/schedule/domain/entity/ScheduleAlarm.java

@@ -0,0 +1,36 @@
+package com.official.memento.schedule.domain.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+@AllArgsConstructor
+@Getter
+public class ScheduleAlarm {
+
+    private final Long scheduleId;
+    private final Long memberId;
+    private final String description;
+    private final LocalDateTime startDate;
+    private final LocalDateTime endDate;
+    private final int timeZoneOffset;
+
+    public static ScheduleAlarm of(
+            final Long scheduleId,
+            final Long memberId,
+            final String description,
+            final LocalDateTime startDate,
+            final LocalDateTime endDate,
+            final int timeZoneOffset
+    ) {
+        return new ScheduleAlarm(
+                scheduleId,
+                memberId,
+                description,
+                startDate,
+                endDate,
+                timeZoneOffset
+        );
+    }
+}

src/main/java/com/official/memento/schedule/infrastructure/ScheduleAlarmRepositoryAdapter.java

@@ -0,0 +1,32 @@
+package com.official.memento.schedule.infrastructure;
+
+import com.official.memento.global.stereotype.Adapter;
+import com.official.memento.schedule.domain.ScheduleAlarmRepository;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
+import com.official.memento.schedule.infrastructure.persistence.ScheduleAlarmCustomRepository;
+import com.official.memento.schedule.infrastructure.persistence.projection.ScheduleAlarmProjection;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+
+@Adapter
+@RequiredArgsConstructor
+public class ScheduleAlarmRepositoryAdapter implements ScheduleAlarmRepository {
+
+    private final ScheduleAlarmCustomRepository scheduleAlarmCustomRepository;
+
+    @Override
+    public List<ScheduleAlarm> findSchedulesWithMemberInfoBetween(final LocalDateTime startTime,
+                                                                  final LocalDateTime endTime) {
+        List<ScheduleAlarmProjection> scheduleAlarmProjections = scheduleAlarmCustomRepository.findSchedulesWithMemberInfoBetween(
+                startTime, endTime);
+        return scheduleAlarmProjections.stream().map(scheduleEntity -> ScheduleAlarm.of(
+                scheduleEntity.scheduleId(),
+                scheduleEntity.memberId(),
+                scheduleEntity.description(),
+                scheduleEntity.startDate(),
+                scheduleEntity.endDate(),
+                scheduleEntity.timeZoneOffset()
+        )).toList();
+    }
+}

src/main/java/com/official/memento/schedule/infrastructure/ScheduleRepositoryAdapter.java

@@ -5,15 +5,19 @@
 import com.official.memento.global.stereotype.Adapter;
 import com.official.memento.schedule.domain.ScheduleRepository;
 import com.official.memento.schedule.domain.entity.Schedule;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
 import com.official.memento.schedule.domain.enums.ScheduleType;
+import com.official.memento.schedule.infrastructure.persistence.ScheduleAlarmCustomRepository;
 import com.official.memento.schedule.infrastructure.persistence.ScheduleEntity;
 import com.official.memento.schedule.infrastructure.persistence.ScheduleEntityJpaRepository;
+import com.official.memento.schedule.infrastructure.persistence.projection.ScheduleAlarmProjection;
 import com.official.memento.schedule.infrastructure.persistence.projection.ScheduleOrderInfoProjection;
+import lombok.RequiredArgsConstructor;
+
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Optional;
-import lombok.RequiredArgsConstructor;
 
 @Adapter
 @RequiredArgsConstructor

src/main/java/com/official/memento/schedule/infrastructure/persistence/ScheduleAlarmCustomRepository.java

@@ -0,0 +1,45 @@
+package com.official.memento.schedule.infrastructure.persistence;
+
+import com.official.memento.member.infrastructure.persistence.entity.QMemberPersonalInfoEntity;
+import com.official.memento.schedule.infrastructure.persistence.projection.ScheduleAlarmProjection;
+import com.querydsl.core.Tuple;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class ScheduleAlarmCustomRepository {
+
+    private final JPAQueryFactory queryFactory;
+    QScheduleEntity schedule = QScheduleEntity.scheduleEntity;
+    QMemberPersonalInfoEntity memberPersonalInfo = QMemberPersonalInfoEntity.memberPersonalInfoEntity;
+
+    public List<ScheduleAlarmProjection> findSchedulesWithMemberInfoBetween(
+            final LocalDateTime startDate,
+            final LocalDateTime endDate
+    ) {
+        List<Tuple> results = queryFactory
+                .select(schedule.id, schedule.memberId, schedule.description, schedule.startDate, schedule.endDate, memberPersonalInfo.timeZoneOffset)
+                .from(schedule)
+                .join(memberPersonalInfo).on(schedule.memberId.eq(memberPersonalInfo.memberId))
+                .where(schedule.startDate.between(startDate, endDate))
+                .fetch();
+
+        return results.stream()
+                .map(tuple -> new ScheduleAlarmProjection(
+                        tuple.get(schedule.id),
+                        tuple.get(schedule.memberId),
+                        tuple.get(schedule.description),
+                        tuple.get(schedule.startDate),
+                        tuple.get(schedule.endDate),
+                        tuple.get(memberPersonalInfo.timeZoneOffset)
+                ))
+                .collect(Collectors.toList());
+    }
+
+
+}

src/main/java/com/official/memento/schedule/infrastructure/persistence/ScheduleEntityJpaRepository.java

@@ -92,10 +92,26 @@ List<ScheduleOrderInfoProjection> findSchedulesByMemberIdAndDateOrderedByOrderNu
             LocalDate date
     );
 
+    @Query("""
+    SELECT s.id as scheduleId,
+           s.memberId as memberId,
+           s.description as description,
+           s.startDate as startDate,
+           s.endDate as endDate,
+           m.wakeUpTime as wakeUpTime,
+           m.windDownTime as windDownTime,
+           m.timeZoneOffset as timeZoneOffset
+    FROM ScheduleEntity s
+    JOIN MemberPersonalInfoEntity m ON s.memberId = m.memberId
+    WHERE s.startDate BETWEEN :start AND :end
+    """)
+    List<ScheduleEntity> findSchedulesWithMemberInfoBetween(final LocalDateTime startTime, final LocalDateTime endTime);
+
     List<ScheduleEntity> findAllByMemberIdAndType(long memberId, ScheduleType type);
 
     void deleteAllByScheduleGroupId(final String groupId);
 
+
     @Modifying
     @Query("UPDATE ScheduleEntity s SET s.tagId = :newTagId WHERE s.tagId = :oldTagId")
     void updateTagForSchedules(@Param("oldTagId") Long oldTagId, @Param("newTagId") Long newTagId);

src/main/java/com/official/memento/schedule/infrastructure/persistence/projection/ScheduleAlarmProjection.java

@@ -0,0 +1,14 @@
+package com.official.memento.schedule.infrastructure.persistence.projection;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+public record ScheduleAlarmProjection(
+        Long scheduleId,
+        Long memberId,
+        String description,
+        LocalDateTime startDate,
+        LocalDateTime endDate,
+        Integer timeZoneOffset
+) {
+}

src/main/java/com/official/memento/schedule/scheduler/scheduleAlarmScheduler.java

@@ -0,0 +1,37 @@
+package com.official.memento.schedule.scheduler;
+
+import com.official.memento.global.exception.ErrorCode;
+import com.official.memento.global.exception.MementoException;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
+import com.official.memento.schedule.service.CloudTaskAdapter;
+import com.official.memento.schedule.service.usecase.ScheduleAlarmGetUseCase;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class scheduleAlarmScheduler {
+
+    private final CloudTaskAdapter cloudTaskAdapter;
+
+    private final ScheduleAlarmGetUseCase scheduleAlarmGetUseCase;
+
+    @Scheduled(cron = "0 15 0 * * *", zone = "UTC") // 매일 UTC 기준 0시 15분
+    public void setScheduleAlarm() {
+        LocalDateTime now = LocalDateTime.now(ZoneId.of("UTC")).plusMinutes(30);
+        LocalDateTime tomorrow = now.plusDays(1);
+        List<ScheduleAlarm> schedules = scheduleAlarmGetUseCase.getSchedulesBetween(now, tomorrow);
+        try{
+            for (ScheduleAlarm schedule : schedules) {
+                cloudTaskAdapter.createScheduleAlarm(schedule);
+            }
+        } catch (Exception e) {
+            throw new MementoException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+}

src/main/java/com/official/memento/schedule/service/CloudTaskAdapter.java

@@ -0,0 +1,88 @@
+package com.official.memento.schedule.service;
+
+import com.google.api.gax.core.FixedCredentialsProvider;
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.cloud.tasks.v2.CloudTasksClient;
+import com.google.cloud.tasks.v2.CloudTasksSettings;
+import com.google.cloud.tasks.v2.HttpMethod;
+import com.google.cloud.tasks.v2.HttpRequest;
+import com.google.cloud.tasks.v2.QueueName;
+import com.google.cloud.tasks.v2.Task;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Timestamp;
+import com.official.memento.global.exception.ErrorCode;
+import com.official.memento.global.exception.MementoException;
+import com.official.memento.schedule.domain.entity.ScheduleAlarm;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CloudTaskAdapter {
+
+    @Value("${GCP.PROJECT_ID}")
+    private String projectId;
+
+    @Value("${GCP.LOCATION_ID}")
+    private String locationId;
+
+    @Value("${GCP.QUEUE_ID}")
+    private String queueId;
+
+    @Value("${GCP.TARGET_URL}")
+    private String targetUrl;
+
+    @Value("${ADMIN.TOKEN_PREFIX}")
+    private String AUTHORIZATION_HEADER_ADMIN_PREFIX;
+
+
+    public void createScheduleAlarm(final ScheduleAlarm scheduleAlarm) throws IOException {
+        GoogleCredentials credentials = GoogleCredentials.fromStream(
+                new FileInputStream(System.getenv("GOOGLE_APPLICATION_CREDENTIALS")
+                ));
+        CloudTasksSettings settings = CloudTasksSettings.newBuilder()
+                .setCredentialsProvider(FixedCredentialsProvider.create(credentials))
+                .build();
+
+        LocalDateTime executeTime = scheduleAlarm.getStartDate().minusMinutes(15);
+
+        try (CloudTasksClient client = CloudTasksClient.create(settings)) {
+            String queuePath = QueueName.of(projectId, locationId, queueId).toString();
+
+            Instant instant = executeTime.toInstant(ZoneOffset.UTC);
+            Timestamp timestamp = Timestamp.newBuilder()
+                    .setSeconds(instant.getEpochSecond())
+                    .setNanos(instant.getNano())
+                    .build();
+
+            String payload = "{"
+                    + "\"description\":\"" + scheduleAlarm.getDescription() + "\","
+                    + "\"memberId\":" + scheduleAlarm.getMemberId()
+                    + "\"startTime\":" + scheduleAlarm.getStartDate().toLocalTime()
+                    + "\"endTime\":" + scheduleAlarm.getEndDate().toLocalTime()
+                    + "}";
+
+            HttpRequest httpRequest = HttpRequest.newBuilder()
+                    .setUrl(targetUrl)
+                    .setHttpMethod(HttpMethod.POST)
+                    .putHeaders("Content-Type", "application/json")
+                    .putHeaders("Authorization","Bearer " + AUTHORIZATION_HEADER_ADMIN_PREFIX + scheduleAlarm.getMemberId())
+                    .setBody(ByteString.copyFromUtf8(payload))
+                    .build();
+
+            Task task = Task.newBuilder()
+                    .setHttpRequest(httpRequest)
+                    .setScheduleTime(timestamp)
+                    .build();
+
+            client.createTask(queuePath, task);
+        }catch (Exception e) {
+            throw new MementoException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+}