mapleopentech/monorepo
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit: Open sourcing all of the Maple Open Technologies code.

Browse source
This commit is contained in:
Bartlomiej Mika 2025-12-02 14:33:08 -05:00
commit 755d54a99d
2010 changed files with 448675 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

112
cloud/maplefile-backend/internal/service/blockedemail/create.go Normal file
View file

@ -0,0 +1,112 @@
// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/service/blockedemail/create.go
package blockedemail
import (
"context"
"strings"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_blockedemail "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/blockedemail"
uc_user "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/user"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/validation"
)
type CreateBlockedEmailService interface {
Execute(ctx context.Context, req *CreateBlockedEmailRequestDTO) (*BlockedEmailResponseDTO, error)
}
type createBlockedEmailServiceImpl struct {
config *config.Configuration
logger *zap.Logger
createBlockedEmailUseCase uc_blockedemail.CreateBlockedEmailUseCase
userGetByEmailUseCase uc_user.UserGetByEmailUseCase
}
func NewCreateBlockedEmailService(
config *config.Configuration,
logger *zap.Logger,
createBlockedEmailUseCase uc_blockedemail.CreateBlockedEmailUseCase,
userGetByEmailUseCase uc_user.UserGetByEmailUseCase,
) CreateBlockedEmailService {
logger = logger.Named("CreateBlockedEmailService")
return &createBlockedEmailServiceImpl{
config: config,
logger: logger,
createBlockedEmailUseCase: createBlockedEmailUseCase,
userGetByEmailUseCase: userGetByEmailUseCase,
}
}
func (svc *createBlockedEmailServiceImpl) Execute(ctx context.Context, req *CreateBlockedEmailRequestDTO) (*BlockedEmailResponseDTO, error) {
//
// STEP 1: Validation
//
if req == nil {
svc.logger.Warn("Failed validation with nil request")
return nil, httperror.NewBadRequestError("Request is required")
}
e := make(map[string]string)
if strings.TrimSpace(req.Email) == "" {
e["email"] = "Email is required"
}
if len(e) != 0 {
svc.logger.Warn("Failed validation",
zap.Any("error", e))
return nil, httperror.NewValidationError(e)
}
//
// STEP 2: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewInternalServerError("Authentication context error")
}
//
// STEP 3: Check if blocked email belongs to a registered user
//
var blockedUserID gocql.UUID
blockedUser, err := svc.userGetByEmailUseCase.Execute(ctx, req.Email)
if err != nil {
svc.logger.Debug("Blocked email user not found, continuing without user ID",
zap.String("email", validation.MaskEmail(req.Email)),
zap.Any("error", err))
// User not found is fine - we still allow blocking non-existent emails
} else if blockedUser != nil {
blockedUserID = blockedUser.ID
}
//
// STEP 4: Create blocked email
//
blockedEmail, err := svc.createBlockedEmailUseCase.Execute(ctx, userID, req.Email, blockedUserID, req.Reason)
if err != nil {
svc.logger.Error("Failed to create blocked email",
zap.Any("error", err),
zap.Any("user_id", userID),
zap.String("email", validation.MaskEmail(req.Email)))
return nil, err
}
//
// STEP 5: Map to response DTO
//
response := &BlockedEmailResponseDTO{
UserID: blockedEmail.UserID,
BlockedEmail: blockedEmail.BlockedEmail,
BlockedUserID: blockedEmail.BlockedUserID,
Reason: blockedEmail.Reason,
CreatedAt: blockedEmail.CreatedAt,
}
return response, nil
}

80
cloud/maplefile-backend/internal/service/blockedemail/delete.go Normal file
View file

@ -0,0 +1,80 @@
// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/service/blockedemail/delete.go
package blockedemail
import (
"context"
"strings"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_blockedemail "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/blockedemail"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/validation"
)
type DeleteBlockedEmailService interface {
Execute(ctx context.Context, email string) (*DeleteBlockedEmailResponseDTO, error)
}
type deleteBlockedEmailServiceImpl struct {
config *config.Configuration
logger *zap.Logger
deleteBlockedEmailUseCase uc_blockedemail.DeleteBlockedEmailUseCase
}
func NewDeleteBlockedEmailService(
config *config.Configuration,
logger *zap.Logger,
deleteBlockedEmailUseCase uc_blockedemail.DeleteBlockedEmailUseCase,
) DeleteBlockedEmailService {
logger = logger.Named("DeleteBlockedEmailService")
return &deleteBlockedEmailServiceImpl{
config: config,
logger: logger,
deleteBlockedEmailUseCase: deleteBlockedEmailUseCase,
}
}
func (svc *deleteBlockedEmailServiceImpl) Execute(ctx context.Context, email string) (*DeleteBlockedEmailResponseDTO, error) {
//
// STEP 1: Validation
//
if strings.TrimSpace(email) == "" {
svc.logger.Warn("Failed validation with empty email")
return nil, httperror.NewValidationError(map[string]string{"email": "Email is required"})
}
//
// STEP 2: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewInternalServerError("Authentication context error")
}
//
// STEP 3: Delete blocked email
//
err := svc.deleteBlockedEmailUseCase.Execute(ctx, userID, email)
if err != nil {
svc.logger.Error("Failed to delete blocked email",
zap.Any("error", err),
zap.Any("user_id", userID),
zap.String("email", validation.MaskEmail(email)))
return nil, err
}
//
// STEP 4: Return success response
//
response := &DeleteBlockedEmailResponseDTO{
Success: true,
Message: "Email unblocked successfully",
}
return response, nil
}

35
cloud/maplefile-backend/internal/service/blockedemail/dto.go Normal file
View file

@ -0,0 +1,35 @@
// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/service/blockedemail/dto.go
package blockedemail
import (
"time"
"github.com/gocql/gocql"
)
// CreateBlockedEmailRequestDTO represents the request to add a blocked email
type CreateBlockedEmailRequestDTO struct {
Email string `json:"email"`
Reason string `json:"reason,omitempty"`
}
// BlockedEmailResponseDTO represents a blocked email in the response
type BlockedEmailResponseDTO struct {
UserID gocql.UUID `json:"user_id"`
BlockedEmail string `json:"blocked_email"`
BlockedUserID gocql.UUID `json:"blocked_user_id,omitempty"`
Reason string `json:"reason,omitempty"`
CreatedAt time.Time `json:"created_at"`
}
// ListBlockedEmailsResponseDTO represents the response for listing blocked emails
type ListBlockedEmailsResponseDTO struct {
BlockedEmails []*BlockedEmailResponseDTO `json:"blocked_emails"`
Count int `json:"count"`
}
// DeleteBlockedEmailResponseDTO represents the response for deleting a blocked email
type DeleteBlockedEmailResponseDTO struct {
Success bool `json:"success"`
Message string `json:"message"`
}

80
cloud/maplefile-backend/internal/service/blockedemail/list.go Normal file
View file

@ -0,0 +1,80 @@
// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/service/blockedemail/list.go
package blockedemail
import (
"context"
"go.uber.org/zap"
"github.com/gocql/gocql"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config/constants"
uc_blockedemail "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/blockedemail"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/pkg/httperror"
)
type ListBlockedEmailsService interface {
Execute(ctx context.Context) (*ListBlockedEmailsResponseDTO, error)
}
type listBlockedEmailsServiceImpl struct {
config *config.Configuration
logger *zap.Logger
listBlockedEmailsUseCase uc_blockedemail.ListBlockedEmailsUseCase
}
func NewListBlockedEmailsService(
config *config.Configuration,
logger *zap.Logger,
listBlockedEmailsUseCase uc_blockedemail.ListBlockedEmailsUseCase,
) ListBlockedEmailsService {
logger = logger.Named("ListBlockedEmailsService")
return &listBlockedEmailsServiceImpl{
config: config,
logger: logger,
listBlockedEmailsUseCase: listBlockedEmailsUseCase,
}
}
func (svc *listBlockedEmailsServiceImpl) Execute(ctx context.Context) (*ListBlockedEmailsResponseDTO, error) {
//
// STEP 1: Get user ID from context
//
userID, ok := ctx.Value(constants.SessionUserID).(gocql.UUID)
if !ok {
svc.logger.Error("Failed getting user ID from context")
return nil, httperror.NewInternalServerError("Authentication context error")
}
//
// STEP 2: List blocked emails
//
blockedEmails, err := svc.listBlockedEmailsUseCase.Execute(ctx, userID)
if err != nil {
svc.logger.Error("Failed to list blocked emails",
zap.Any("error", err),
zap.Any("user_id", userID))
return nil, err
}
//
// STEP 3: Map to response DTOs
//
responseDTOs := make([]*BlockedEmailResponseDTO, len(blockedEmails))
for i, blockedEmail := range blockedEmails {
responseDTOs[i] = &BlockedEmailResponseDTO{
UserID: blockedEmail.UserID,
BlockedEmail: blockedEmail.BlockedEmail,
BlockedUserID: blockedEmail.BlockedUserID,
Reason: blockedEmail.Reason,
CreatedAt: blockedEmail.CreatedAt,
}
}
response := &ListBlockedEmailsResponseDTO{
BlockedEmails: responseDTOs,
Count: len(responseDTOs),
}
return response, nil
}

35
cloud/maplefile-backend/internal/service/blockedemail/provider.go Normal file
View file

@ -0,0 +1,35 @@
// codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/service/blockedemail/provider.go
package blockedemail
import (
"go.uber.org/zap"
"codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/config"
uc_blockedemail "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/blockedemail"
uc_user "codeberg.org/mapleopentech/monorepo/cloud/maplefile-backend/internal/usecase/user"
)
func ProvideCreateBlockedEmailService(
cfg *config.Configuration,
logger *zap.Logger,
createBlockedEmailUseCase uc_blockedemail.CreateBlockedEmailUseCase,
userGetByEmailUseCase uc_user.UserGetByEmailUseCase,
) CreateBlockedEmailService {
return NewCreateBlockedEmailService(cfg, logger, createBlockedEmailUseCase, userGetByEmailUseCase)
}
func ProvideListBlockedEmailsService(
cfg *config.Configuration,
logger *zap.Logger,
listBlockedEmailsUseCase uc_blockedemail.ListBlockedEmailsUseCase,
) ListBlockedEmailsService {
return NewListBlockedEmailsService(cfg, logger, listBlockedEmailsUseCase)
}
func ProvideDeleteBlockedEmailService(
cfg *config.Configuration,
logger *zap.Logger,
deleteBlockedEmailUseCase uc_blockedemail.DeleteBlockedEmailUseCase,
) DeleteBlockedEmailService {
return NewDeleteBlockedEmailService(cfg, logger, deleteBlockedEmailUseCase)
}