comb19 · keito0tada · May 21, 2025 · May 20, 2025 · May 20, 2025 · May 20, 2025
diff --git a/api/cmd/app/app.go b/api/cmd/app/app.go
@@ -149,7 +149,7 @@ func SetupRouter() *gin.Engine {
 	router.Use(cors.New(cors.Config{
 		AllowOrigins:     []string{envVar.FrontendUrl},
 		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE"},
-		AllowHeaders:     []string{"Content-Type", "Authorization"},
+		AllowHeaders:     []string{"Origin", "Access-Control-Allow-Headers", "Content-Type", "Authorization"},
 		AllowCredentials: false,
 	}))
 
@@ -173,8 +173,8 @@ func SetupRouter() *gin.Engine {
 		authorized.POST("/guilds/:guildID/channels", guildHandler.HandleCreateChannelInGuild)
 		authorized.GET("/guilds/:guildID/users", func(ctx *gin.Context) {})
 
-		authorized.POST("/invitations/guilds/", guildInvitationHandler.CreateGuildInvitation)
-		authorized.GET("/invitations/guilds/:invitationID", guildInvitationHandler.VerifyGuildInvitation)
+		authorized.POST("/invitations/guilds/", guildInvitationHandler.HandleCreateGuildInvitation)
+		authorized.GET("/invitations/guilds/:invitationID", guildInvitationHandler.HandleVerifyGuildInvitation)
 	}
 
 	router.POST("/users", userHandler.HandleCreateUserByClerk)

diff --git a/api/domain/repository/channel_repository.go b/api/domain/repository/channel_repository.go
@@ -7,6 +7,6 @@ import (
 type ChannelRepository interface {
 	Insert(name string, description string, private bool, guildID *string) (*model.Channel, error)
 	Delete(id string) error
-	GetByID(id string) (*model.Channel, error)
-	GetAllInGuild(guildID *string) ([]*model.Channel, error)
+	Find(id string) (*model.Channel, error)
+	FindAllInGuild(guildID *string) ([]*model.Channel, error)
 }
diff --git a/api/domain/repository/guild_inviation_repository.go b/api/domain/repository/guild_inviation_repository.go
@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-type GuildInviationRepository interface {
+type GuildInvitationRepository interface {
 	Insert(ownerID, guildID string, expiration time.Time) (*model.GuildInvitation, error)
 	Find(id string) (*model.GuildInvitation, error)
 }
diff --git a/api/domain/repository/message_repository.go b/api/domain/repository/message_repository.go
@@ -6,6 +6,6 @@ import (
 
 type MessageRepository interface {
 	Insert(channelID string, userID string, content string) (*model.Message, error)
-	GetByID(ID string) (*model.Message, error)
-	GetAllInChannel(channelID string) (*[]*model.Message, error)
+	Find(ID string) (*model.Message, error)
+	FindAllInChannel(channelID string) (*[]*model.Message, error)
 }
diff --git a/api/domain/repository/user_repository.go b/api/domain/repository/user_repository.go
@@ -6,5 +6,5 @@ import (
 
 type UserRepository interface {
 	Insert(id, userName string) (*model.User, error)
-	GetByID(id string) (*model.User, error)
+	Find(id string) (*model.User, error)
 }
diff --git a/api/infrastructure/persistence/channel.go b/api/infrastructure/persistence/channel.go
@@ -44,7 +44,7 @@ func (cp *channelPersistence) Delete(id string) error {
 	return nil
 }
 
-func (cp *channelPersistence) GetByID(id string) (*model.Channel, error) {
+func (cp *channelPersistence) Find(id string) (*model.Channel, error) {
 	var channel model.Channel
 	result := cp.db.Where("id = ?", id).First(&channel)
 	if result.Error != nil {
@@ -53,7 +53,7 @@ func (cp *channelPersistence) GetByID(id string) (*model.Channel, error) {
 	return &channel, nil
 }
 
-func (cp *channelPersistence) GetAllInGuild(guildID *string) ([]*model.Channel, error) {
+func (cp *channelPersistence) FindAllInGuild(guildID *string) ([]*model.Channel, error) {
 	var channels []*model.Channel
 	result := cp.db.Where("guild_id = ?", *guildID).Find(&channels)
 	if result.Error != nil {

diff --git a/api/infrastructure/persistence/guild_invitation.go b/api/infrastructure/persistence/guild_invitation.go
@@ -13,7 +13,7 @@ type guildInvitationPersistence struct {
 	db *gorm.DB
 }
 
-func NewGuildInvitationPersistence(db *gorm.DB) repository.GuildInviationRepository {
+func NewGuildInvitationPersistence(db *gorm.DB) repository.GuildInvitationRepository {
 	return &guildInvitationPersistence{
 		db: db,
 	}

diff --git a/api/infrastructure/persistence/message.go b/api/infrastructure/persistence/message.go
@@ -33,15 +33,15 @@ func (mp messagePersistence) Insert(channelID string, userID string, content str
 	return &message, result.Error
 }
 
-func (mp messagePersistence) GetByID(ID string) (*model.Message, error) {
+func (mp messagePersistence) Find(ID string) (*model.Message, error) {
 	var message model.Message
 	result := mp.db.First(&message, ID)
 	if result.Error != nil {
 		return nil, result.Error
 	}
 	return &message, nil
 }
-func (mp messagePersistence) GetAllInChannel(channelID string) (*[]*model.Message, error) {
+func (mp messagePersistence) FindAllInChannel(channelID string) (*[]*model.Message, error) {
 	slog.Debug("GetAllInChannel")
 
 	var messages []*model.Message

diff --git a/api/infrastructure/persistence/user.go b/api/infrastructure/persistence/user.go
@@ -30,7 +30,7 @@ func (up userPersistence) Insert(id, userName string) (*model.User, error) {
 	return user, nil
 }
 
-func (up userPersistence) GetByID(id string) (*model.User, error) {
+func (up userPersistence) Find(id string) (*model.User, error) {
 	user := &model.User{}
 	if err := up.db.First(user, "id = ?", id).Error; err != nil {
 		return nil, err

diff --git a/api/interface/handler/guild_invitation.go b/api/interface/handler/guild_invitation.go
@@ -3,7 +3,6 @@ package handler
 import (
 	"chat_back/interface/types"
 	"chat_back/usecase"
-	"fmt"
 	"log/slog"
 	"net/http"
 
@@ -12,8 +11,8 @@ import (
 )
 
 type GuildInvitationHandler interface {
-	CreateGuildInvitation(ctx *gin.Context)
-	VerifyGuildInvitation(ctx *gin.Context)
+	HandleCreateGuildInvitation(ctx *gin.Context)
+	HandleVerifyGuildInvitation(ctx *gin.Context)
 }
 
 type guildInvitationHandler struct {
@@ -26,7 +25,7 @@ func NewGuildInvitationHandler(guildInvitationUsecase usecase.GuildInvitationUse
 	}
 }
 
-func (gih guildInvitationHandler) CreateGuildInvitation(ctx *gin.Contex
10000
t) {
+func (gih guildInvitationHandler) HandleCreateGuildInvitation(ctx *gin.Context) {
 	slog.DebugContext(ctx, "CreateGuildInvitation")
 
 	var requestGuildInvitation types.RequestGuildInvitation
@@ -56,11 +55,10 @@ func (gih guildInvitationHandler) CreateGuildInvitation(ctx *gin.Context) {
 		OwnerID:    guildInvitation.OwnerID,
 		GuildID:    guildInvitation.GuildID,
 		Expiration: guildInvitation.Expiration,
-		URL:        fmt.Sprintf("/invitations/guilds/%s", guildInvitation.ID),
 	})
 }
 
-func (gih guildInvitationHandler) VerifyGuildInvitation(ctx *gin.Context) {
+func (gih guildInvitationHandler) HandleVerifyGuildInvitation(ctx *gin.Context) {
 	slog.DebugContext(ctx, "VerifyGuildInvitation")
 
 	var guildInvitationUri types.GuildInvitationURI
@@ -79,13 +77,16 @@ func (gih guildInvitationHandler) VerifyGuildInvitation(ctx *gin.Context) {
 		return
 	}
 
-	verified, err := gih.guildInvitationUsecase.VerifyGuildInvitation(guildInvitationUri.ID, user.ID)
+	isVerified, guildInvitation, err := gih.guildInvitationUsecase.VerifyGuildInvitation(guildInvitationUri.ID, user.ID)
 	if err != nil {
 		ctx.Status(http.StatusBadRequest)
 		return
 	}
-	if verified {
-		ctx.Status(http.StatusAccepted)
+	if isVerified {
+		ctx.JSON(http.StatusAccepted, types.ResponseVerifiedInvitation{
+			OwnerID: guildInvitation.OwnerID,
+			GuildID: guildInvitation.GuildID,
+		})
 		return
 	} else {
 		ctx.Status(http.StatusBadRequest)

diff --git a/api/interface/types/guild_invitation.go b/api/interface/types/guild_invitation.go
@@ -15,5 +15,9 @@ type ResponseGuildInvitation struct {
 	OwnerID    string    `json:"owner_id"`
 	GuildID    string    `json:"guild_id"`
 	Expiration time.Time `json:"expiration"`
-	URL        string    `json:"url"`
+}
+
+type ResponseVerifiedInvitation struct {
+	OwnerID string `json:"owner_id"`
+	GuildID string `json:"guild_id"`
 }
diff --git a/api/service/authorization.go b/api/service/authorization.go
@@ -0,0 +1,28 @@
+package service
+
+import "chat_back/domain/repository"
+
+type AuthorizationService interface {
 	CheckAuthorizationAccessToChannel(userID, channelID string) (bool, error)
+}
+
+type authorizationService struct {
+	userChannelsRepository repository.UserChannelsRepository
+}
+
+func NewAuthorizationService(userChannelsRepository repository.UserChannelsRepository) AuthorizationService {
+	return &authorizationService{
+		userChannelsRepository: userChannelsRepository,
+	}
+}
+
+func (as authorizationService) CheckAuthorizationAccessToChannel(userID, channelID string) (bool, error) {
+	userChannel, err := as.userChannelsRepository.Find(userID, channelID)
+	if err != nil {
+		return false, err
+	}
+	if userChannel != nil {
+		return false, nil
+	}
+	return true, nil
+}
diff --git a/api/test/guild_invitation_test.go b/api/test/guild_invitation_test.go
@@ -6,6 +6,7 @@ import (
 	"chat_back/interface/types"
 	"chat_back/test/utils"
 	"encoding/json"
+	"fmt"
 	"io"
 	"log"
 	"net/http"
@@ -59,7 +60,7 @@ func TestCreateGuildInvitation(t *testing.T) {
 	assert.Equal(t, ownerID, responseGuildInvitation.OwnerID)
 
 	w = httptest.NewRecorder()
-	req, _ = http.NewRequest("GET", responseGuildInvitation.URL, nil)
+	req, _ = http.NewRequest("GET", fmt.Sprintf("/invitations/guilds/%s", responseGuildInvitation.ID), nil)
 	req.Header.Set("Authorization", "Bearer "+*inviteeToken)
 	router.ServeHTTP(w, req)
 

diff --git a/api/usecase/channel.go b/api/usecase/channel.go
@@ -53,15 +53,15 @@ func (cu channelUseCase) Delete(id string) error {
 }
 
 func (cu channelUseCase) GetByID(id string) (*model.Channel, error) {
-	channel, err := cu.channelRepository.GetByID(id)
+	channel, err := cu.channelRepository.Find(id)
 	if err != nil {
 		return nil, err
 	}
 	return channel, nil
 }
 
 func (cu channelUseCase) AddUserToChannel(id string, userIDs []string) (*model.Channel, error) {
-	channel, err := cu.channelRepository.GetByID(id)
+	channel, err := cu.channelRepository.Find(id)
 	if err != nil {
 		return nil, err
 	}
@@ -87,7 +87,7 @@ func (cu channelUseCase) GetMessagesOfChannel(id, userID string) (*[]*model.Mess
 		return nil, nil
 	}
 
-	messages, err := cu.messageRepository.GetAllInChannel(id)
+	messages, err := cu.messageRepository.FindAllInChannel(id)
 	if err != nil {
 		return nil, err
 	}

diff --git a/api/usecase/guild.go b/api/usecase/guild.go
@@ -64,7 +64,7 @@ func (gu guildUseCase) GetChannelsOfGuild(ID, userID string) ([]*model.Channel,
 		return nil, nil
 	}
 
-	channels, err := gu.channelRepository.GetAllInGuild(&ID)
+	channels, err := gu.channelRepository.FindAllInGuild(&ID)
 	if err != nil {
 		slog.Error(err.Error())
 		return nil, err

diff --git a/api/usecase/guild_invitation.go b/api/usecase/guild_invitation.go
@@ -3,22 +3,24 @@ package usecase
 import (
 	"chat_back/domain/model"
 	"chat_back/domain/repository"
+	"fmt"
+	"log/slog"
 	"time"
 )
 
 const expireDays = 1
 
 type GuildInvitationUsecase interface {
 	CreateGuildInvitation(ownerID, guildID string) (*model.GuildInvitation, error)
-	VerifyGuildInvitation(id, userID string) (bool, error)
+	VerifyGuildInvitation(id, userID string) (bool, *model.GuildInvitation, error)
 }
 
 type guildInvitationUsecase struct {
-	guildInvitationRepository repository.GuildInviationRepository
+	guildInvitationRepository repository.GuildInvitationRepository
 	userGuildRepository       repository.UserGuildsRepository
 }
 
-func NewGuildInvitationUsecase(guildInvitationRepository repository.GuildInviationRepository, userGuildRepository repository.UserGuildsRepository) GuildInvitationUsecase {
+func NewGuildInvitationUsecase(guildInvitationRepository repository.GuildInvitationRepository, userGuildRepository repository.UserGuildsRepository) GuildInvitationUsecase {
 	return guildInvitationUsecase{
 		guildInvitationRepository: guildInvitationRepository,
 		userGuildRepository:       userGuildRepository,
@@ -29,29 +31,37 @@ func (giu guildInvitationUsecase) CreateGuildInvitation(ownerID, guildID string)
 	return giu.guildInvitationRepository.Insert(ownerID, guildID, time.Now())
 }
 
-func (giu guildInvitationUsecase) VerifyGuildInvitation(id, userID string) (bool, error) {
+func (giu guildInvitationUsecase) VerifyGuildInvitation(id, userID string) (bool, *model.GuildInvitation, error) {
 	guildInvitation, err := giu.guildInvitationRepository.Find(id)
 	if err != nil {
-		return false, err
+		slog.Error(err.Error())
+		return false, nil, err
 	}
 	if guildInvitation == nil {
-		return false, nil
+		slog.Debug(fmt.Sprintf("the guild invitation %s is not found.", id))
+		return false, nil, nil
 	}
 	if !guildInvitation.Expiration.Before(time.Now().AddDate(0, 0, expireDays)) {
-		return false, nil
+		slog.Debug(fmt.Sprintf("the guild invitation %s is expired.\n", id))
+		slog.Debug(fmt.Sprintf("Expire: %s, Now: %s.\n", guildInvitation.Expiration, time.Now()))
+		return false, nil, nil
 	}
 
 	userGuild, err := giu.userGuildRepository.Find(userID, guildInvitation.GuildID)
 	if err != nil {
-		return false, err
+		slog.Error(err.Error())
+		return false, nil, err
 	}
 	if userGuild != nil {
-		return true, err
+		slog.Debug(fmt.Sprintf("The user %s already belongs to the guild %s.", userID, guildInvitation.GuildID))
+		return true, guildInvitation, err
 	}
 
 	_, err = giu.userGuildRepository.Insert(userID, guildInvitation.GuildID)
 	if err != nil {
-		return false, err
+		slog.Error(err.Error())
+		return false, nil, err
 	}
-	return true, nil
+	slog.Debug(fmt.Sprintf("The user %s joined the guild %s.", userID, guildInvitation.GuildID))
+	return true, guildInvitation, nil
 }
diff --git a/api/usecase/message.go b/api/usecase/message.go
@@ -25,5 +25,5 @@ func (mu messageUseCase) Insert(channelID string, userID string, content string)
 }
 
 func (mu messageUseCase) GetByID(ID string) (*model.Message, error) {
-	return mu.messageRepository.GetByID(ID)
+	return mu.messageRepository.Find(ID)
 }
diff --git a/api/usecase/user.go b/api/usecase/user.go
@@ -29,7 +29,7 @@ func (uu *userUseCase) CreateUserByClerk(id, userName string) (*model.User, erro
 }
 
 func (uu *userUseCase) GetUserByID(id string) (*model.User, error) {
-	user, err := uu.userRepository.GetByID(id)
+	user, err := uu.userRepository.Find(id)
 	if err != nil {
 		return nil, err
 	}