first commit

2026-04-26 21:43:40 +03:00
commit f34e54c5a5
100 changed files with 27342 additions and 0 deletions
--- a/app/account/services/permission_service.go
+++ b/app/account/services/permission_service.go
@@ -0,0 +1,42 @@
+package services
+
+import (
+	"errors"
+	"gobeyhan/database"
+	"gobeyhan/database/models"
+
+	"gorm.io/gorm"
+)
+
+type PermissionService struct{}
+
+func NewPermissionService() *PermissionService {
+	return &PermissionService{}
+}
+
+// GetAllPermissions retrieves all permissions
+func (s *PermissionService) GetAllPermissions() ([]models.Permission, error) {
+	var permissions []models.Permission
+	err := database.DB.Find(&permissions).Error
+	return permissions, err
+}
+
+// GetPermissionByID retrieves a permission by ID
+func (s *PermissionService) GetPermissionByID(id uint64) (*models.Permission, error) {
+	var permission models.Permission
+	err := database.DB.First(&permission, id).Error
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &permission, nil
+}
+
+// CreatePermission creates a new permission
+func (s *PermissionService) CreatePermission(permission *models.Permission) error {
+	return database.DB.Create(permission).Error
+}
--- a/app/account/services/role_service.go
+++ b/app/account/services/role_service.go
@@ -0,0 +1,96 @@
+package services
+
+import (
+	"errors"
+	"gobeyhan/database"
+	"gobeyhan/database/models"
+
+	"gorm.io/gorm"
+)
+
+type RoleService struct{}
+
+func NewRoleService() *RoleService {
+	return &RoleService{}
+}
+
+// GetAllRoles retrieves all roles
+func (s *RoleService) GetAllRoles() ([]models.Role, error) {
+	var roles []models.Role
+	err := database.DB.Preload("Permissions").Find(&roles).Error
+	return roles, err
+}
+
+// GetRoleByID retrieves a role by ID
+func (s *RoleService) GetRoleByID(id uint64) (*models.Role, error) {
+	var role models.Role
+	err := database.DB.Preload("Permissions").First(&role, id).Error
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &role, nil
+}
+
+// CreateRole creates a new role
+func (s *RoleService) CreateRole(role *models.Role) error {
+	return database.DB.Create(role).Error
+}
+
+// UpdateRole updates an existing role
+func (s *RoleService) UpdateRole(id uint64, updates map[string]interface{}) error {
+	result := database.DB.Model(&models.Role{}).Where("id = ?", id).Updates(updates)
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+// DeleteRole deletes a role by ID
+func (s *RoleService) DeleteRole(id uint64) error {
+	result := database.DB.Delete(&models.Role{}, id)
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+// AssignPermission assigns a permission to a role
+func (s *RoleService) AssignPermission(roleID, permissionID uint64) error {
+	var role models.Role
+	if err := database.DB.First(&role, roleID).Error; err != nil {
+		return err
+	}
+
+	var permission models.Permission
+	if err := database.DB.First(&permission, permissionID).Error; err != nil {
+		return err
+	}
+
+	return database.DB.Model(&role).Association("Permissions").Append(&permission)
+}
+
+// RemovePermission removes a permission from a role
+func (s *RoleService) RemovePermission(roleID, permissionID uint64) error {
+	var role models.Role
+	if err := database.DB.Preload("Permissions").First(&role, roleID).Error; err != nil {
+		return err
+	}
+
+	var permission models.Permission
+	if err := database.DB.First(&permission, permissionID).Error; err != nil {
+		return err
+	}
+
+	return database.DB.Model(&role).Association("Permissions").Delete(&permission)
+}
--- a/app/account/services/social_account_service.go
+++ b/app/account/services/social_account_service.go
@@ -0,0 +1,54 @@
+package services
+
+import (
+	"errors"
+	"gobeyhan/database"
+	"gobeyhan/database/models"
+
+	"gorm.io/gorm"
+)
+
+type SocialAccountService struct{}
+
+func NewSocialAccountService() *SocialAccountService {
+	return &SocialAccountService{}
+}
+
+// GetSocialAccountsByUser retrieves all social accounts for a user
+func (s *SocialAccountService) GetSocialAccountsByUser(userID uint64) ([]models.SocialAccount, error) {
+	var accounts []models.SocialAccount
+	err := database.DB.Where("user_id = ?", userID).Find(&accounts).Error
+	return accounts, err
+}
+
+// GetSocialAccountByID retrieves a social account by ID
+func (s *SocialAccountService) GetSocialAccountByID(id uint64) (*models.SocialAccount, error) {
+	var account models.SocialAccount
+	err := database.DB.First(&account, id).Error
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &account, nil
+}
+
+// CreateSocialAccount creates a new social account
+func (s *SocialAccountService) CreateSocialAccount(account *models.SocialAccount) error {
+	return database.DB.Create(account).Error
+}
+
+// DeleteSocialAccount deletes a social account by ID
+func (s *SocialAccountService) DeleteSocialAccount(id uint64) error {
+	result := database.DB.Delete(&models.SocialAccount{}, id)
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
--- a/app/account/services/user_service.go
+++ b/app/account/services/user_service.go
@@ -0,0 +1,184 @@
+package services
+
+import (
+	"errors"
+	"gobeyhan/database"
+	"gobeyhan/database/models"
+
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm"
+)
+
+type UserService struct{}
+
+func NewUserService() *UserService {
+	return &UserService{}
+}
+
+// GetAllUsers retrieves all users, optionally including soft-deleted ones
+func (s *UserService) GetAllUsers(includeDeleted bool, page, limit int) ([]models.User, int64, error) {
+	var users []models.User
+	var total int64
+
+	query := database.DB.Preload("Roles").Preload("SocialAccounts")
+
+	if includeDeleted {
+		query = query.Unscoped()
+	}
+
+	query.Model(&models.User{}).Count(&total)
+
+	err := query.
+		Offset((page - 1) * limit).
+		Limit(limit).
+		Order("created_at DESC").
+		Find(&users).Error
+
+	return users, total, err
+}
+
+// GetUserByID retrieves a user by ID
+func (s *UserService) GetUserByID(id uint64) (*models.User, error) {
+	var user models.User
+	err := database.DB.
+		Preload("Roles").
+		Preload("SocialAccounts").
+		First(&user, id).Error
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+// GetUserByEmail retrieves a user by email
+func (s *UserService) GetUserByEmail(email string) (*models.User, error) {
+	var user models.User
+	err := database.DB.
+		Preload("Roles").
+		Preload("SocialAccounts").
+		Where("email = ?", email).
+		First(&user).Error
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+// CreateUser creates a new user with hashed password
+func (s *UserService) CreateUser(user *models.User, password string) error {
+	// Hash password if provided
+	if password != "" {
+		hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+		if err != nil {
+			return err
+		}
+		user.Password = string(hashedPassword)
+	}
+
+	return database.DB.Create(user).Error
+}
+
+// VerifyPassword checks if the provided password matches the hashed password
+func (s *UserService) VerifyPassword(hashedPassword, password string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
+	return err == nil
+}
+
+// UpdateUser updates an existing user
+func (s *UserService) UpdateUser(id uint64, updates map[string]interface{}) error {
+	// If password is being updated, hash it first
+	if password, ok := updates["password"].(string); ok && password != "" {
+		hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+		if err != nil {
+			return err
+		}
+		updates["password"] = string(hashedPassword)
+	}
+
+	result := database.DB.Model(&models.User{}).Where("id = ?", id).Updates(updates)
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+// DeleteUser soft deletes a user
+func (s *UserService) DeleteUser(id uint64) error {
+	result := database.DB.Delete(&models.User{}, id)
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+// RestoreUser restores a soft-deleted user
+func (s *UserService) RestoreUser(id uint64) error {
+	result := database.DB.Model(&models.User{}).Unscoped().
+		Where("id = ?", id).
+		Update("deleted_at", nil)
+
+	if result.Error != nil {
+		return result.Error
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+// AssignRole assigns a role to a user
+func (s *UserService) AssignRole(userID, roleID uint64) error {
+	var user models.User
+	if err := database.DB.First(&user, userID).Error; err != nil {
+		return err
+	}
+
+	var role models.Role
+	if err := database.DB.First(&role, roleID).Error; err != nil {
+		return err
+	}
+
+	return database.DB.Model(&user).Association("Roles").Append(&role)
+}
+
+// RemoveRole removes a role from a user
+func (s *UserService) RemoveRole(userID, roleID uint64) error {
+	var user models.User
+	if err := database.DB.Preload("Roles").First(&user, userID).Error; err != nil {
+		return err
+	}
+
+	var role models.Role
+	if err := database.DB.First(&role, roleID).Error; err != nil {
+		return err
+	}
+
+	return database.DB.Model(&user).Association("Roles").Delete(&role)
+}
+
+// AssignDefaultRole assigns the default 'user' role to a user
+func (s *UserService) AssignDefaultRole(userID uint64) error {
+	var role models.Role
+	// Find role by name 'user'
+	if err := database.DB.Where("name = ?", "user").First(&role).Error; err != nil {
+		return err
+	}
+
+	return s.AssignRole(userID, role.ID)
+}