Yimaru-BackEnd/internal/services/user/direct.go

package user

import (
	"Yimaru-Backend/internal/domain"
	"context"
	"time"
)

func (s *Service) UpdateUserKnowledgeLevel(ctx context.Context, userID int64, knowledgeLevel string) error {
	return s.userStore.UpdateUserKnowledgeLevel(ctx, userID, knowledgeLevel)
}

func (s *Service) CreateUser(
	ctx context.Context,
	req domain.CreateUserReq,
	isCompany bool,
) (domain.User, error) {

	// Hash the password
	hashedPassword, err := hashPassword(req.Password)
	if err != nil {
		return domain.User{}, err
	}

	// Create the user
	return s.userStore.CreateUserWithoutOtp(ctx, domain.User{
		FirstName: req.FirstName,
		LastName:  req.LastName,
		// UserName:         req.UserName,
		Email:            req.Email,
		PhoneNumber:      req.PhoneNumber,
		Password:         hashedPassword,
		Role:             domain.Role(req.Role),
		EmailVerified:    true, // assuming auto-verified on creation
		PhoneVerified:    true,
		Status:           domain.UserStatusActive,
		AgeGroup:         req.AgeGroup,
		EducationLevel:   req.EducationLevel,
		Country:          req.Country,
		Region:           req.Region,
		ProfileCompleted: false,
	})
}

func (s *Service) DeleteUser(ctx context.Context, id int64) error {
	// Delete User
	return s.userStore.DeleteUser(ctx, id)
}

func (s *Service) RequestUserDeletion(ctx context.Context, userID int64, gracePeriod time.Duration) (time.Time, error) {
	return s.userStore.RequestUserDeletion(ctx, userID, gracePeriod)
}

func (s *Service) CancelUserDeletion(ctx context.Context, userID int64) error {
	return s.userStore.CancelUserDeletion(ctx, userID)
}

func (s *Service) PurgeDueUserDeletions(ctx context.Context, limit int32) (int64, error) {
	return s.userStore.PurgeDueUserDeletions(ctx, limit)
}

func (s *Service) GetAllUsers(
	ctx context.Context,
	filter domain.UserFilter,
) ([]domain.User, int64, error) {

	var before *time.Time
	if filter.CreatedBefore.Valid {
		before = &filter.CreatedBefore.Value
	}

	var after *time.Time
	if filter.CreatedAfter.Valid {
		after = &filter.CreatedAfter.Value
	}

	var role *string
	if filter.Role != "" {
		role = &filter.Role
	}

	var status *string
	if filter.Status != "" {
		status = &filter.Status
	}

	var query *string
	if filter.Query != "" {
		query = &filter.Query
	}

	var country *string
	if filter.Country != "" {
		country = &filter.Country
	}

	var region *string
	if filter.Region != "" {
		region = &filter.Region
	}

	var subscriptionStatus *string
	if filter.SubscriptionStatus != "" {
		subscriptionStatus = &filter.SubscriptionStatus
	}

	offset := int32(filter.Page * filter.PageSize)

	return s.userStore.GetAllUsers(
		ctx,
		role,
		status,
		query,
		before,
		after,
		country,
		region,
		subscriptionStatus,
		int32(filter.PageSize),
		offset,
	)
}

func (s *Service) GetUserSummary(ctx context.Context) (domain.UserSummary, error) {
	return s.userStore.GetUserSummary(ctx)
}

func (s *Service) ListAccountDeletionRequests(ctx context.Context, filter domain.AccountDeletionRequestFilter) ([]domain.AccountDeletionRequest, int64, error) {
	return s.userStore.ListAccountDeletionRequests(ctx, filter)
}

func (s *Service) UpdateUserStatus(ctx context.Context, req domain.UpdateUserStatusReq) error {
	return s.userStore.UpdateUserStatus(ctx, req)
}

func (s *Service) GetUserById(ctx context.Context, id int64) (domain.User, error) {

	return s.userStore.GetUserByID(ctx, id)
}