Notificationテーブルのスキーマ変更

internal/database/notification.go

@@ -25,10 +25,9 @@ type Notification struct {
 
 	NotifyAfter  time.Time `gorm:"type:timestamptz;not null;index"`
 	NotifyBefore time.Time `gorm:"type:timestamptz;not null;index"`
-	IsNotified   bool      `gorm:"type:boolean;not null;default:false;index"`
 }
 
-func (n *Notification) ToDomain(targetUserIDs []string) domain.Notification {
+func (n *Notification) ToDomain(targetUsers []domain.NotificationTargetUser) domain.Notification {
 	return domain.Notification{
 		ID:                   n.ID,
 		Title:                n.Title,
@@ -45,8 +44,7 @@ func (n *Notification) ToDomain(targetUserIDs []string) domain.Notification {
 		URL:                  n.URL,
 		NotifyAfter:          n.NotifyAfter,
 		NotifyBefore:         n.NotifyBefore,
-		IsNotified:           n.IsNotified,
-		TargetUserIDs:        targetUserIDs,
+		TargetUsers:          targetUsers,
 	}
 }
 
@@ -67,6 +65,5 @@ func NotificationFromDomain(n domain.Notification) Notification {
 		URL:                  n.URL,
 		NotifyAfter:          n.NotifyAfter,
 		NotifyBefore:         n.NotifyBefore,
-		IsNotified:           n.IsNotified,
 	}
 }

internal/database/notification_target_user.go

@@ -1,8 +1,11 @@
 package database
 
+import "time"
+
 type NotificationTargetUser struct {
 	NotificationID string       `gorm:"type:text;primaryKey"`
 	UserID         string       `gorm:"type:text;primaryKey"`
+	NotifiedAt     *time.Time   `gorm:"type:timestamptz;index"`
 	Notification   Notification `gorm:"constraint:OnDelete:CASCADE"`
 	User           User         `gorm:"constraint:OnDelete:CASCADE"`
 }

internal/domain/notification.go

@@ -21,7 +21,11 @@ type Notification struct {
 
 	NotifyAfter  time.Time
 	NotifyBefore time.Time
-	IsNotified   bool
 
-	TargetUserIDs []string
+	TargetUsers []NotificationTargetUser
+}
+
+type NotificationTargetUser struct {
+	UserID     string
+	NotifiedAt *time.Time
 }

internal/handler/converter.go

@@ -82,9 +82,12 @@ func toDomainFCMToken(req api.FCMTokenRequest) domain.FCMToken {
 }
 
 func toAPINotification(n domain.Notification) api.Notification {
-	targetUsers := make([]api.NotificationTargetUser, 0, len(n.TargetUserIDs))
-	for _, uid := range n.TargetUserIDs {
-		targetUsers = append(targetUsers, api.NotificationTargetUser{UserId: uid})
+	targetUsers := make([]api.NotificationTargetUser, 0, len(n.TargetUsers))
+	for _, t := range n.TargetUsers {
+		targetUsers = append(targetUsers, api.NotificationTargetUser{
+			UserId:     t.UserID,
+			NotifiedAt: t.NotifiedAt,
+		})
 	}
 	return api.Notification{
 		Id:                   n.ID,
@@ -115,6 +118,10 @@ func toAPINotifications(notifications []domain.Notification) []api.Notification
 }
 
 func toDomainNotification(id string, req api.NotificationRequest) domain.Notification {
+	targetUsers := make([]domain.NotificationTargetUser, 0, len(req.TargetUserIds))
+	for _, uid := range req.TargetUserIds {
+		targetUsers = append(targetUsers, domain.NotificationTargetUser{UserID: uid})
+	}
 	return domain.Notification{
 		ID:                   id,
 		Title:                req.Title,
@@ -131,7 +138,7 @@ func toDomainNotification(id string, req api.NotificationRequest) domain.Notific
 		URL:                  req.Url,
 		NotifyAfter:          req.NotifyAfter,
 		NotifyBefore:         req.NotifyBefore,
-		TargetUserIDs:        req.TargetUserIds,
+		TargetUsers:          targetUsers,
 	}
 }
 

internal/repository/notification_create.go

@@ -14,18 +14,20 @@ func (r *NotificationRepository) CreateNotification(ctx context.Context, notific
 
 	dbNotification := database.NotificationFromDomain(notification)
 
+	uniqueTargets := uniqueTargetUsers(notification.TargetUsers)
+
 	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		if err := tx.Create(&dbNotification).Error; err != nil {
 			return err
 		}
 
-		uniqueIDs := uniqueStrings(notification.TargetUserIDs)
-		if len(uniqueIDs) > 0 {
-			targets := make([]database.NotificationTargetUser, 0, len(uniqueIDs))
-			for _, userID := range uniqueIDs {
+		if len(uniqueTargets) > 0 {
+			targets := make([]database.NotificationTargetUser, 0, len(uniqueTargets))
+			for _, t := range uniqueTargets {
 				targets = append(targets, database.NotificationTargetUser{
 					NotificationID: notification.ID,
-					UserID:         userID,
+					UserID:         t.UserID,
+					NotifiedAt:     t.NotifiedAt,
 				})
 			}
 			if err := tx.Create(&targets).Error; err != nil {
@@ -39,5 +41,5 @@ func (r *NotificationRepository) CreateNotification(ctx context.Context, notific
 		return domain.Notification{}, err
 	}
 
-	return dbNotification.ToDomain(uniqueStrings(notification.TargetUserIDs)), nil
+	return dbNotification.ToDomain(uniqueTargets), nil
 }

internal/repository/notification_dispatch.go

@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+	"time"
 
 	"github.com/fun-dotto/user-api/internal/database"
 	"github.com/fun-dotto/user-api/internal/domain"
@@ -31,9 +32,12 @@ func (r *NotificationRepository) GetNotificationsByIDs(ctx context.Context, ids
 		return nil, err
 	}
 
-	targetMap := make(map[string][]string)
+	targetMap := make(map[string][]domain.NotificationTargetUser)
 	for _, t := range allTargets {
-		targetMap[t.NotificationID] = append(targetMap[t.NotificationID], t.UserID)
+		targetMap[t.NotificationID] = append(targetMap[t.NotificationID], domain.NotificationTargetUser{
+			UserID:     t.UserID,
+			NotifiedAt: t.NotifiedAt,
+		})
 	}
 
 	notifications := make([]domain.Notification, 0, len(dbNotifications))
@@ -44,26 +48,32 @@ func (r *NotificationRepository) GetNotificationsByIDs(ctx context.Context, ids
 	return notifications, nil
 }
 
-func (r *NotificationRepository) DispatchNotifications(ctx context.Context, ids []string) ([]domain.Notification, error) {
-	uniqueIDs := uniqueStrings(ids)
-	if len(uniqueIDs) == 0 {
+func (r *NotificationRepository) DispatchNotifications(ctx context.Context, deliveries map[string][]string) ([]domain.Notification, error) {
+	if len(deliveries) == 0 {
 		return []domain.Notification{}, nil
 	}
 
-	if err := r.db.WithContext(ctx).Model(&database.Notification{}).
-		Where("id IN ?", uniqueIDs).
-		Update("is_notified", true).Error; err != nil {
-		return nil, err
-	}
-
-	notifications, err := r.GetNotificationsByIDs(ctx, uniqueIDs)
-	if err != nil {
-		return nil, err
+	now := time.Now()
+	notificationIDs := make([]string, 0, len(deliveries))
+	for nid, userIDs := range deliveries {
+		uniqueUsers := uniqueStrings(userIDs)
+		if len(uniqueUsers) == 0 {
+			continue
+		}
+		db := r.db.WithContext(ctx).Model(&database.NotificationTargetUser{}).
+			Where("notification_id = ? AND user_id IN ?", nid, uniqueUsers).
+			Update("notified_at", now)
+		if db.Error != nil {
+			return nil, db.Error
+		}
+		if db.RowsAffected > 0 {
+			notificationIDs = append(notificationIDs, nid)
+		}
 	}
 
-	for i := range notifications {
-		notifications[i].IsNotified = true
+	if len(notificationIDs) == 0 {
+		return []domain.Notification{}, nil
 	}
 
-	return notifications, nil
+	return r.GetNotificationsByIDs(ctx, notificationIDs)
 }

internal/repository/notification_list.go

@@ -17,7 +17,13 @@ func (r *NotificationRepository) ListNotifications(ctx context.Context, filter d
 		query = query.Where("notify_after <= ?", *filter.NotifyAtTo)
 	}
 	if filter.IsNotified != nil {
-		query = query.Where("is_notified = ?", *filter.IsNotified)
+		if *filter.IsNotified {
+			query = query.Where(`NOT EXISTS (SELECT 1 FROM notification_target_users tu WHERE tu.notification_id = notifications.id AND tu.notified_at IS NULL)
+				AND EXISTS (SELECT 1 FROM notification_target_users tu WHERE tu.notification_id = notifications.id)`)
+		} else {
+			query = query.Where(`(EXISTS (SELECT 1 FROM notification_target_users tu WHERE tu.notification_id = notifications.id AND tu.notified_at IS NULL)
+				OR NOT EXISTS (SELECT 1 FROM notification_target_users tu WHERE tu.notification_id = notifications.id))`)
+		}
 	}
 
 	var dbNotifications []database.Notification
@@ -39,9 +45,12 @@ func (r *NotificationRepository) ListNotifications(ctx context.Context, filter d
 		return nil, err
 	}
 
-	targetMap := make(map[string][]string)
+	targetMap := make(map[string][]domain.NotificationTargetUser)
 	for _, t := range allTargets {
-		targetMap[t.NotificationID] = append(targetMap[t.NotificationID], t.UserID)
+		targetMap[t.NotificationID] = append(targetMap[t.NotificationID], domain.NotificationTargetUser{
+			UserID:     t.UserID,
+			NotifiedAt: t.NotifiedAt,
+		})
 	}
 
 	notifications := make([]domain.Notification, 0, len(dbNotifications))

internal/repository/notification_update.go

@@ -3,14 +3,17 @@ package repository
 import (
 	"context"
 	"errors"
+	"time"
 
 	"github.com/fun-dotto/user-api/internal/database"
 	"github.com/fun-dotto/user-api/internal/domain"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 func (r *NotificationRepository) UpdateNotification(ctx context.Context, notification domain.Notification) (domain.Notification, error) {
 	var dbNotification database.Notification
+	uniqueTargets := uniqueTargetUsers(notification.TargetUsers)
 
 	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		var existing database.Notification
@@ -23,21 +26,39 @@ func (r *NotificationRepository) UpdateNotification(ctx context.Context, notific
 
 		dbNotification = database.NotificationFromDomain(notification)
 
-		if err := tx.Omit("IsNotified").Save(&dbNotification).Error; err != nil {
+		if err := tx.Save(&dbNotification).Error; err != nil {
 			return err
 		}
 
+		var existingTargets []database.NotificationTargetUser
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			Where("notification_id = ?", notification.ID).
+			Find(&existingTargets).Error; err != nil {
+			return err
+		}
+		existingNotifiedAt := make(map[string]*time.Time, len(existingTargets))
+		for _, t := range existingTargets {
+			existingNotifiedAt[t.UserID] = t.NotifiedAt
+		}
+
 		if err := tx.Where("notification_id = ?", notification.ID).Delete(&database.NotificationTargetUser{}).Error; err != nil {
 			return err
 		}
 
-		uniqueIDs := uniqueStrings(notification.TargetUserIDs)
-		if len(uniqueIDs) > 0 {
-			targets := make([]database.NotificationTargetUser, 0, len(uniqueIDs))
-			for _, userID := range uniqueIDs {
+		if len(uniqueTargets) > 0 {
+			targets := make([]database.NotificationTargetUser, 0, len(uniqueTargets))
+			for i, t := range uniqueTargets {
+				notifiedAt := t.NotifiedAt
+				if notifiedAt == nil {
+					if prev, ok := existingNotifiedAt[t.UserID]; ok {
+						notifiedAt = prev
+						uniqueTargets[i].NotifiedAt = prev
+					}
+				}
 				targets = append(targets, database.NotificationTargetUser{
 					NotificationID: notification.ID,
-					UserID:         userID,
+					UserID:         t.UserID,
+					NotifiedAt:     notifiedAt,
 				})
 			}
 			if err := tx.Create(&targets).Error; err != nil {
@@ -54,5 +75,5 @@ func (r *NotificationRepository) UpdateNotification(ctx context.Context, notific
 		return domain.Notification{}, err
 	}
 
-	return dbNotification.ToDomain(uniqueStrings(notification.TargetUserIDs)), nil
+	return dbNotification.ToDomain(uniqueTargets), nil
 }

internal/repository/util.go

@@ -1,5 +1,7 @@
 package repository
 
+import "github.com/fun-dotto/user-api/internal/domain"
+
 func uniqueStrings(s []string) []string {
 	seen := make(map[string]struct{}, len(s))
 	result := make([]string, 0, len(s))
@@ -12,3 +14,16 @@ func uniqueStrings(s []string) []string {
 	}
 	return result
 }
+
+func uniqueTargetUsers(targets []domain.NotificationTargetUser) []domain.NotificationTargetUser {
+	seen := make(map[string]struct{}, len(targets))
+	result := make([]domain.NotificationTargetUser, 0, len(targets))
+	for _, t := range targets {
+		if _, ok := seen[t.UserID]; ok {
+			continue
+		}
+		seen[t.UserID] = struct{}{}
+		result = append(result, t)
+	}
+	return result
+}

internal/service/notification.go

@@ -13,23 +13,27 @@ type NotificationRepository interface {
 	UpdateNotification(ctx context.Context, notification domain.Notification) (domain.Notification, error)
 	DeleteNotification(ctx context.Context, id string) error
 	GetNotificationsByIDs(ctx context.Context, ids []string) ([]domain.Notification, error)
-	DispatchNotifications(ctx context.Context, ids []string) ([]domain.Notification, error)
+	DispatchNotifications(ctx context.Context, deliveries map[string][]string) ([]domain.Notification, error)
 }
 
 type FCMTokenRepositoryForNotification interface {
 	ListFCMTokens(ctx context.Context, filter domain.FCMTokenListFilter) ([]domain.FCMToken, error)
 }
 
+type MessagingClient interface {
+	SendEachForMulticast(ctx context.Context, message *messaging.MulticastMessage) (*messaging.BatchResponse, error)
+}
+
 type NotificationService struct {
-	repo             NotificationRepository
-	fcmTokenRepo     FCMTokenRepositoryForNotification
-	messagingClient  *messaging.Client
+	repo            NotificationRepository
+	fcmTokenRepo    FCMTokenRepositoryForNotification
+	messagingClient MessagingClient
 }
 
 func NewNotificationService(
 	repo NotificationRepository,
 	fcmTokenRepo FCMTokenRepositoryForNotification,
-	messagingClient *messaging.Client,
+	messagingClient MessagingClient,
 ) *NotificationService {
 	return &NotificationService{
 		repo:            repo,