first

2026-03-21 22:41:23 +01:00 · 2026-03-21 22:41:23 +01:00 · f4be03ceba
commit f4be03ceba
1826 changed files with 830924 additions and 0 deletions
--- a/backend/internal/db/aliases.go
+++ b/backend/internal/db/aliases.go
@ -0,0 +1,70 @@
+package db
+
+func (d *DB) GetAllAliases() ([]AliasWithDomain, error) {
+	var aliases []Alias
+	if err := d.Preload("Domain").Find(&aliases).Error; err != nil {
+		return nil, err
+	}
+
+	result := make([]AliasWithDomain, len(aliases))
+	for i, a := range aliases {
+		result[i] = AliasWithDomain{
+			Alias:      a,
+			DomainName: "",
+		}
+		if a.Domain != nil {
+			result[i].DomainName = a.Domain.Name
+		}
+	}
+
+	if result == nil {
+		result = []AliasWithDomain{}
+	}
+	return result, nil
+}
+
+func (d *DB) GetAliasesByDomain(domainID uint) ([]Alias, error) {
+	var aliases []Alias
+	if err := d.Where("domain_id = ?", domainID).Find(&aliases).Error; err != nil {
+		return nil, err
+	}
+	if aliases == nil {
+		aliases = []Alias{}
+	}
+	return aliases, nil
+}
+
+func (d *DB) GetAliasByID(id uint) (*Alias, error) {
+	var alias Alias
+	if err := d.Preload("Domain").First(&alias, id).Error; err != nil {
+		return nil, err
+	}
+	return &alias, nil
+}
+
+func (d *DB) CreateAlias(source, destination string) (*Alias, error) {
+	alias := Alias{
+		Source:      source,
+		Destination: destination,
+	}
+	if err := d.Create(&alias).Error; err != nil {
+		return nil, err
+	}
+	return &alias, nil
+}
+
+func (d *DB) CreateAliasInDomain(source, destination string, domainID uint) (*Alias, error) {
+	alias := Alias{
+		DomainID:    domainID,
+		Source:      source,
+		Destination: destination,
+	}
+	if err := d.Create(&alias).Error; err != nil {
+		return nil, err
+	}
+	return &alias, nil
+}
+
+func (d *DB) DeleteAlias(id uint) error {
+	return d.Delete(&Alias{}, id).Error
+}
--- a/backend/internal/db/db.go
+++ b/backend/internal/db/db.go
@ -0,0 +1,164 @@
+package db
+
+import (
+	"fmt"
+	"time"
+
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	"github.com/imc-vibe/backend/internal/config"
+)
+
+type DB struct {
+	*gorm.DB
+}
+
+type Domain struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	Name      string    `gorm:"uniqueIndex;size:50;not null" json:"name"`
+	CreatedAt time.Time `json:"createdAt"`
+	Users     []User    `gorm:"foreignKey:DomainID" json:"users,omitempty"`
+	Aliases   []Alias   `gorm:"foreignKey:DomainID" json:"aliases,omitempty"`
+}
+
+func (Domain) TableName() string { return "virtual_domains" }
+
+type User struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	DomainID  uint      `gorm:"not null" json:"domainId"`
+	Email     string    `gorm:"uniqueIndex;size:100;not null" json:"email"`
+	Password  string    `gorm:"size:150;not null" json:"-"`
+	Quota     int64     `gorm:"default:0" json:"quota"`
+	Domain    *Domain   `gorm:"foreignKey:DomainID" json:"domain,omitempty"`
+	CreatedAt time.Time `json:"createdAt,omitempty"`
+}
+
+func (User) TableName() string { return "virtual_users" }
+
+type Alias struct {
+	ID          uint    `gorm:"primaryKey" json:"id"`
+	DomainID    uint    `gorm:"not null" json:"domainId"`
+	Source      string  `gorm:"size:100;not null" json:"source"`
+	Destination string  `gorm:"size:100;not null" json:"destination"`
+	Domain      *Domain `gorm:"foreignKey:DomainID" json:"domain,omitempty"`
+}
+
+func (Alias) TableName() string { return "virtual_aliases" }
+
+type ImcUser struct {
+	ID           uint            `gorm:"primaryKey" json:"id"`
+	Username     string          `gorm:"uniqueIndex;size:100;not null" json:"username"`
+	PasswordHash string          `gorm:"size:255;not null" json:"-"`
+	Role         string          `gorm:"type:enum('admin','user');default:'user'" json:"role"`
+	CreatedAt    time.Time       `json:"createdAt"`
+	Domains      []ImcUserDomain `gorm:"foreignKey:UserID" json:"domains,omitempty"`
+}
+
+func (ImcUser) TableName() string { return "imc_users" }
+
+type ImcUserDomain struct {
+	ID        uint      `gorm:"primaryKey" json:"id"`
+	UserID    uint      `gorm:"not null" json:"userId"`
+	DomainID  uint      `gorm:"not null" json:"domainId"`
+	CreatedAt time.Time `json:"createdAt"`
+	Domain    *Domain   `gorm:"foreignKey:DomainID" json:"domain,omitempty"`
+}
+
+func (ImcUserDomain) TableName() string { return "imc_users2domains" }
+
+type ImcLoginAttempt struct {
+	ID          uint      `gorm:"primaryKey" json:"id"`
+	Email       string    `gorm:"size:100;not null" json:"email"`
+	IPAddress   string    `gorm:"size:45;not null" json:"ipAddress"`
+	AttemptedAt time.Time `json:"attemptedAt"`
+	Successful  bool      `gorm:"default:false" json:"successful"`
+}
+
+func (ImcLoginAttempt) TableName() string { return "imc_login_attempts" }
+
+type DomainStats struct {
+	ID         uint   `json:"id"`
+	Name       string `json:"name"`
+	UserCount  int64  `json:"userCount"`
+	AliasCount int64  `json:"aliasCount"`
+}
+
+type AliasWithDomain struct {
+	Alias
+	DomainName string `json:"domainName"`
+}
+
+type UserWithDomain struct {
+	User
+	DomainName string `json:"domainName"`
+}
+
+func Connect(cfg *config.Config) (*DB, error) {
+	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true&charset=utf8mb4",
+		cfg.DBUser, cfg.DBPassword, cfg.DBHost, cfg.DBPort, cfg.DBName)
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB.SetMaxOpenConns(25)
+	sqlDB.SetMaxIdleConns(5)
+	sqlDB.SetConnMaxLifetime(5 * time.Minute)
+
+	return &DB{db}, nil
+}
+
+func (d *DB) InitSchema() error {
+	imcUsersSQL := `
+		CREATE TABLE IF NOT EXISTS imc_users (
+			id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+			username VARCHAR(100) NOT NULL UNIQUE,
+			password_hash VARCHAR(255) NOT NULL,
+			role ENUM('admin','user') DEFAULT 'user',
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+			INDEX idx_username (username),
+			INDEX idx_role (role)
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+	`
+	if err := d.Exec(imcUsersSQL).Error; err != nil {
+		return err
+	}
+
+	loginAttemptsSQL := `
+		CREATE TABLE IF NOT EXISTS imc_login_attempts (
+			id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+			email VARCHAR(100) NOT NULL,
+			ip_address VARCHAR(45) NOT NULL,
+			attempted_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+			successful BOOLEAN DEFAULT FALSE,
+			INDEX idx_email_time (email, attempted_at),
+			INDEX idx_ip_time (ip_address, attempted_at)
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+	`
+	if err := d.Exec(loginAttemptsSQL).Error; err != nil {
+		return err
+	}
+
+	users2DomainsSQL := `
+		CREATE TABLE IF NOT EXISTS imc_users2domains (
+			id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+			user_id INT UNSIGNED NOT NULL,
+			domain_id INT UNSIGNED NOT NULL,
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+			UNIQUE KEY unique_user_domain (user_id, domain_id),
+			INDEX idx_user_id (user_id),
+			INDEX idx_domain_id (domain_id)
+		) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+	`
+	return d.Exec(users2DomainsSQL).Error
+}
--- a/backend/internal/db/domains.go
+++ b/backend/internal/db/domains.go
@ -0,0 +1,68 @@
+package db
+
+func (d *DB) GetAllDomains() ([]DomainStats, error) {
+	var domains []Domain
+	if err := d.Find(&domains).Error; err != nil {
+		return nil, err
+	}
+
+	stats := make([]DomainStats, len(domains))
+	for i, dom := range domains {
+		var userCount, aliasCount int64
+		d.Model(&User{}).Where("domain_id = ?", dom.ID).Count(&userCount)
+		d.Model(&Alias{}).Where("domain_id = ?", dom.ID).Count(&aliasCount)
+
+		stats[i] = DomainStats{
+			ID:         dom.ID,
+			Name:       dom.Name,
+			UserCount:  userCount,
+			AliasCount: aliasCount,
+		}
+	}
+
+	if stats == nil {
+		stats = []DomainStats{}
+	}
+	return stats, nil
+}
+
+func (d *DB) GetDomainByID(id uint) (*Domain, error) {
+	var domain Domain
+	if err := d.Where("id = ?", id).First(&domain).Error; err != nil {
+		return nil, err
+	}
+	return &domain, nil
+}
+
+func (d *DB) GetDomainByName(name string) (*Domain, error) {
+	var domain Domain
+	if err := d.Where("name = ?", name).First(&domain).Error; err != nil {
+		return nil, err
+	}
+	return &domain, nil
+}
+
+func (d *DB) CreateDomain(name string) (*Domain, error) {
+	domain := Domain{Name: name}
+	if err := d.Create(&domain).Error; err != nil {
+		return nil, err
+	}
+	return &domain, nil
+}
+
+func (d *DB) DeleteDomain(id uint) error {
+	tx := d.Begin()
+	defer func() { tx.Rollback() }()
+
+	if err := tx.Where("domain_id = ?", id).Delete(&User{}).Error; err != nil {
+		return err
+	}
+	if err := tx.Where("domain_id = ?", id).Delete(&Alias{}).Error; err != nil {
+		return err
+	}
+	if err := tx.Delete(&Domain{}, id).Error; err != nil {
+		return err
+	}
+
+	return tx.Commit().Error
+}
--- a/backend/internal/db/imc_users.go
+++ b/backend/internal/db/imc_users.go
@ -0,0 +1,122 @@
+package db
+
+func (d *DB) GetImcUserByUsername(username string) (*ImcUser, error) {
+	var user ImcUser
+	if err := d.Preload("Domains.Domain").Where("username = ?", username).First(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) GetImcUserByID(id uint) (*ImcUser, error) {
+	var user ImcUser
+	if err := d.Preload("Domains.Domain").First(&user, id).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) CreateImcUser(username, passwordHash, role string) (*ImcUser, error) {
+	user := ImcUser{
+		Username:     username,
+		PasswordHash: passwordHash,
+		Role:         role,
+	}
+	if err := d.Create(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) UpdateImcUserPassword(id uint, passwordHash string) error {
+	return d.Model(&ImcUser{}).Where("id = ?", id).Update("password_hash", passwordHash).Error
+}
+
+func (d *DB) DeleteImcUser(id uint) error {
+	return d.Delete(&ImcUser{}, id).Error
+}
+
+func (d *DB) EnsureAdminUser(username, passwordHash string) error {
+	var user ImcUser
+	err := d.Where("username = ? AND role = ?", username, "admin").First(&user).Error
+	if err == nil {
+		return d.Model(&ImcUser{}).Where("id = ?", user.ID).Update("password_hash", passwordHash).Error
+	}
+	_, err = d.CreateImcUser(username, passwordHash, "admin")
+	return err
+}
+
+func (d *DB) GetUserAccessibleDomains(userID uint, isAdmin bool) ([]Domain, error) {
+	if isAdmin {
+		var domains []Domain
+		if err := d.Find(&domains).Error; err != nil {
+			return nil, err
+		}
+		return domains, nil
+	}
+
+	var domains []Domain
+	err := d.Table("imc_users2domains").
+		Select("virtual_domains.*").
+		Joins("JOIN virtual_domains ON virtual_domains.id = imc_users2domains.domain_id").
+		Where("imc_users2domains.user_id = ?", userID).
+		Find(&domains).Error
+	if err != nil {
+		return nil, err
+	}
+	if domains == nil {
+		domains = []Domain{}
+	}
+	return domains, nil
+}
+
+func (d *DB) CanAccessDomain(userID uint, domainName string, isAdmin bool) (bool, error) {
+	if isAdmin {
+		return true, nil
+	}
+
+	var count int64
+	err := d.Table("imc_users2domains").
+		Select("COUNT(*)").
+		Joins("JOIN virtual_domains ON virtual_domains.id = imc_users2domains.domain_id").
+		Where("imc_users2domains.user_id = ? AND virtual_domains.name = ?", userID, domainName).
+		Count(&count).Error
+	if err != nil {
+		return false, err
+	}
+	return count > 0, nil
+}
+
+func (d *DB) AddUserToDomain(userID, domainID uint) error {
+	ud := ImcUserDomain{
+		UserID:   userID,
+		DomainID: domainID,
+	}
+	return d.Create(&ud).Error
+}
+
+func (d *DB) RemoveUserFromDomain(userID, domainID uint) error {
+	return d.Where("user_id = ? AND domain_id = ?", userID, domainID).Delete(&ImcUserDomain{}).Error
+}
+
+func (d *DB) GetUsersForDomain(domainID uint) ([]ImcUser, error) {
+	var users []ImcUser
+	err := d.Table("imc_users2domains").
+		Select("imc_users.*").
+		Joins("JOIN imc_users ON imc_users.id = imc_users2domains.user_id").
+		Where("imc_users2domains.domain_id = ?", domainID).
+		Find(&users).Error
+	if err != nil {
+		return nil, err
+	}
+	if users == nil {
+		users = []ImcUser{}
+	}
+	return users, nil
+}
+
+func (d *DB) IsUserInDomain(userID, domainID uint) (bool, error) {
+	var count int64
+	err := d.Model(&ImcUserDomain{}).Where("user_id = ? AND domain_id = ?", userID, domainID).Count(&count).Error
+	return count > 0, err
+}
--- a/backend/internal/db/users.go
+++ b/backend/internal/db/users.go
@ -0,0 +1,76 @@
+package db
+
+func (d *DB) GetAllUsers() ([]User, error) {
+	var users []User
+	if err := d.Preload("Domain").Find(&users).Error; err != nil {
+		return nil, err
+	}
+	if users == nil {
+		users = []User{}
+	}
+	return users, nil
+}
+
+func (d *DB) GetUsersByDomain(domainID uint) ([]User, error) {
+	var users []User
+	if err := d.Where("domain_id = ?", domainID).Find(&users).Error; err != nil {
+		return nil, err
+	}
+	if users == nil {
+		users = []User{}
+	}
+	return users, nil
+}
+
+func (d *DB) GetUserByID(id uint) (*User, error) {
+	var user User
+	if err := d.Preload("Domain").First(&user, id).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) GetUserByEmail(email string) (*User, error) {
+	var user User
+	if err := d.Where("email = ?", email).First(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) CreateUser(email, passwordHash string, quota int64) (*User, error) {
+	user := User{
+		Email:    email,
+		Password: passwordHash,
+		Quota:    quota,
+	}
+	if err := d.Create(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) CreateUserInDomain(email, passwordHash string, quota int64, domainID uint) (*User, error) {
+	user := User{
+		DomainID: domainID,
+		Email:    email,
+		Password: passwordHash,
+		Quota:    quota,
+	}
+	if err := d.Create(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (d *DB) UpdateUserPassword(id uint, passwordHash string) error {
+	return d.Model(&User{}).Where("id = ?", id).Update("password", passwordHash).Error
+}
+
+func (d *DB) UpdateUserQuota(id uint, quota int64) error {
+	return d.Model(&User{}).Where("id = ?", id).Update("quota", quota).Error
+}
+
+func (d *DB) DeleteUser(id uint) error {
+	return d.Delete(&User{}, id).Error
+}