use DAO

controllers/dns.go

@@ -1,29 +0,0 @@
-package controllers
-
-import (
-	"reCoreD-UI/models"
-	"strings"
-
-	"gorm.io/gorm"
-)
-
-const dnsSep = ","
-
-func (c *Controller) SetupDNS(dns ...string) error {
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		settings := &models.Settings{}
-
-		return tx.Where(&models.Settings{Key: models.SettingsKeyDNSServer}).
-			Attrs(&models.Settings{Value: strings.Join(dns, dnsSep)}).
-			FirstOrCreate(&settings).Error
-	})
-}
-
-func (c *Controller) GetDNS() ([]string, error) {
-	settings := &models.Settings{}
-	if err := c.DB.Where(&models.Settings{Key: models.SettingsKeyDNSServer}).Find(&settings).Error; err != nil {
-		return nil, err
-	}
-
-	return strings.Split(settings.Value, dnsSep), nil
-}

controllers/domain.go

@@ -2,144 +2,148 @@ package controllers
 
 import (
 	"fmt"
+	"reCoreD-UI/database"
 	"reCoreD-UI/models"
 	"strconv"
 
 	dns "github.com/cloud66-oss/coredns_mysql"
-
-	"gorm.io/gorm"
 )
 
-func (c *Controller) CreateDomain(d *models.Domain) (*models.Domain, error) {
-	nss, err := c.GetDNS()
+type domainsDAO struct {
+	database.BaseDAO[models.Domain]
+}
+
+func CreateDomain(d *models.Domain) (*models.Domain, error) {
+	nss, err := GetDNS()
 	if err != nil {
 		return nil, err
 	}
 
-	if err := c.DB.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Create(d).Error; err != nil {
-			return err
-		}
-
-		r := &models.RecordWithType[dns.SOARecord]{}
-		r.Zone = d.WithDotEnd()
-		r.Name = "@"
-		r.RecordType = models.RecordTypeSOA
-		r.Content.Ns = d.MainDNS
-		r.Content.MBox = d.EmailSOAForamt()
-		r.Content.Refresh = d.RefreshInterval
-		r.Content.Retry = d.RetryInterval
-		r.Content.Expire = d.ExpiryPeriod
-		r.Content.MinTtl = d.NegativeTtl
-		if err := r.CheckZone(); err != nil {
-			return err
-		}
-
-		if err := tx.Create(r.ToRecord()).Error; err != nil {
-			return err
-		}
-
-		for i, ns := range nss {
-			record := &models.RecordWithType[dns.NSRecord]{}
-			record.Zone = d.DomainName
-			record.RecordType = models.RecordTypeNS
-			record.Content.Host = ns
-			record.Name = fmt.Sprintf("ns%d", i+1)
-
-			if err := tx.Create(record.ToRecord()).Error; err != nil {
-				return err
-			}
-		}
-
-		return nil
-	}); err != nil {
+	tx := database.Client.Begin()
+	if _, err := (domainsDAO{}).Create(tx, *d); err != nil {
+		tx.Rollback()
 		return nil, err
 	}
 
+	r := &models.RecordWithType[dns.SOARecord]{}
+	r.Zone = d.WithDotEnd()
+	r.Name = "@"
+	r.RecordType = models.RecordTypeSOA
+	r.Content.Ns = d.MainDNS
+	r.Content.MBox = d.EmailSOAForamt()
+	r.Content.Refresh = d.RefreshInterval
+	r.Content.Retry = d.RetryInterval
+	r.Content.Expire = d.ExpiryPeriod
+	r.Content.MinTtl = d.NegativeTtl
+	if err := r.CheckZone(); err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+
+	if _, err := (recordsDAO{}).Create(tx, *r.ToRecord()); err != nil {
+		tx.Rollback()
+		return nil, err
+	}
+
+	for i, ns := range nss {
+		record := &models.RecordWithType[dns.NSRecord]{}
+		record.Zone = d.WithDotEnd()
+		record.RecordType = models.RecordTypeNS
+		record.Content.Host = ns
+		record.Name = fmt.Sprintf("ns%d", i+1)
+
+		if _, err := (recordsDAO{}).Create(tx, *record.ToRecord()); err != nil {
+			tx.Rollback()
+			return nil, err
+		}
+	}
+
+	tx.Commit()
 	return d, err
 }
 
-func (c *Controller) GetDomains(domain string) ([]models.Domain, error) {
-	var domains []models.Domain
-
-	tx := c.DB
-
+func GetDomains(domain string) ([]models.Domain, error) {
 	if domain != "" {
-		tx = tx.Where(&models.Domain{DomainName: domain})
+		return (domainsDAO{}).GetAll(database.Client, models.Domain{DomainName: domain})
+	} else {
+		return (domainsDAO{}).GetAll(database.Client, models.Domain{})
 	}
-
-	if err := tx.Find(&domains).Error; err != nil {
-		return nil, err
-	}
-
-	return domains, nil
 }
 
-func (c *Controller) UpdateDomain(d *models.Domain) error {
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Model(d).Updates(d).Error; err != nil {
-			return err
-		}
+func UpdateDomain(d *models.Domain) error {
+	tx := database.Client.Begin()
+	if _, err := (domainsDAO{}).Update(tx, *d); err != nil {
+		tx.Rollback()
+		return err
+	}
 
-		record := &models.Record{}
-		if err := tx.Where("record_type = ?", models.RecordTypeSOA).Where("zone = ?", d.DomainName).First(record).Error; err != nil {
-			return err
-		}
-
-		r := &models.RecordWithType[dns.SOARecord]{}
-		if err := r.FromRecord(record); err != nil {
-			return err
-		}
-
-		r.Content.Ns = d.MainDNS
-		r.Content.MBox = d.EmailSOAForamt()
-		r.Content.Refresh = d.RefreshInterval
-		r.Content.Retry = d.RetryInterval
-		r.Content.Expire = d.ExpiryPeriod
-		r.Content.MinTtl = d.NegativeTtl
-
-		if err := r.CheckZone(); err != nil {
-			return err
-		}
-
-		if err := tx.Where("record_type = ?", models.RecordTypeSOA).Where("zone = ?", d.DomainName).Save(r.ToRecord()).Error; err != nil {
-			return err
-		}
-
-		return nil
+	soa, err := (recordsDAO{}).GetOne(tx, models.Record{
+		RecordType: models.RecordTypeSOA, Zone: d.WithDotEnd(),
 	})
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	r := &models.RecordWithType[dns.SOARecord]{}
+	if err := r.FromRecord(&soa); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	r.Content.Ns = d.MainDNS
+	r.Content.MBox = d.EmailSOAForamt()
+	r.Content.Refresh = d.RefreshInterval
+	r.Content.Retry = d.RetryInterval
+	r.Content.Expire = d.ExpiryPeriod
+	r.Content.MinTtl = d.NegativeTtl
+	if err := r.CheckZone(); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	if _, err := (recordsDAO{}).Update(tx, *r.ToRecord()); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	tx.Commit()
+	return nil
+
 }
 
-func (c *Controller) DeleteDomain(id string) error {
+func DeleteDomain(id string) error {
 	ID, err := strconv.Atoi(id)
 	if err != nil {
 		return err
 	}
 
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		domain := &models.Domain{
-			ID: ID,
-		}
-		if err := tx.First(&domain).Error; err != nil {
-			return err
-		}
+	tx := database.Client.Begin()
+	domain, err := (domainsDAO{}).GetOne(tx, models.Domain{ID: ID})
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
 
-		if err := tx.Where("zone = ?", domain.DomainName).Delete(&models.Record{}).Error; err != nil {
-			return err
-		}
+	if err := (domainsDAO{}).Delete(tx, models.Domain{ID: ID}); err != nil {
+		tx.Rollback()
+		return err
+	}
 
-		if err := tx.Delete(&domain).Error; err != nil {
-			return err
-		}
+	if err := (recordsDAO{}).Delete(tx, models.Record{Zone: domain.WithDotEnd()}); err != nil {
+		tx.Rollback()
+		return err
+	}
 
-		return nil
-	})
+	tx.Commit()
+	return nil
 }
 
-func (c *Controller) getDomainCounts() (float64, error) {
-	var count int64
-	if err := c.DB.Model(models.Domain{}).Count(&count).Error; err != nil {
+// for metrics
+func getDomainCounts() (float64, error) {
+	c, err := (domainsDAO{}).GetAll(database.Client, models.Domain{})
+	if err != nil {
 		return 0, err
 	}
-	return float64(count), nil
+	return float64(len(c)), nil
 }

controllers/init.go

@@ -1,27 +0,0 @@
-package controllers
-
-import (
-	"reCoreD-UI/database"
-
-	"gorm.io/gorm"
-)
-
-type Controller struct {
-	DB *gorm.DB
-}
-
-func NewController(DSN string) (*Controller, error) {
-	db, err := database.Connect(DSN)
-	return &Controller{
-		DB: db,
-	}, err
-}
-
-func (c *Controller) Close() error {
-	d, err := c.DB.DB()
-	if err != nil {
-		return err
-	}
-
-	return d.Close()
-}

controllers/metrics.go

@@ -22,8 +22,7 @@ var (
 	}, []string{"domain"})
 )
 
-func (c *Controller) RegisterMetrics() {
-
+func RegisterMetrics() {
 	prometheus.MustRegister(GaugeDomainCounts, GaugeRecordCounts)
 
 	GormMetrics := ormMetric.New(ormMetric.Config{
@@ -42,14 +41,14 @@ func (c *Controller) RegisterMetrics() {
 	}
 }
 
-func (c *Controller) RefreshMetrics() error {
-	domainCounts, err := c.getDomainCounts()
+func  RefreshMetrics() error {
+	domainCounts, err := getDomainCounts()
 	if err != nil {
 		return err
 	}
 	GaugeDomainCounts.Set(domainCounts)
 
-	recordCounts, err := c.getRecordCounts()
+	recordCounts, err := getRecordCounts()
 	if err != nil {
 		return err
 	}

controllers/migrate.go

@@ -1,11 +1,22 @@
 package controllers
 
-import "reCoreD-UI/models"
+import (
+	"reCoreD-UI/database"
+	"reCoreD-UI/models"
+)
 
-func (c *Controller) Migrate() error {
-	return c.DB.Set("gorm:table_options", "CHARSET=utf8mb4").AutoMigrate(
-		&models.Domain{},
-		&models.Record{},
-		&models.Settings{},
-	)
+func Migrate() error {
+	if err := (domainsDAO{}).Migrate(database.Client, models.Domain{}); err != nil {
+		return err
+	}
+
+	if err := (recordsDAO{}).Migrate(database.Client, models.Record{}); err != nil {
+		return err
+	}
+
+	if err := (settingsDAO{}).Migrate(database.Client, models.Settings{}); err != nil {
+		return err
+	}
+
+	return nil
 }

controllers/record.go

@@ -2,96 +2,102 @@ package controllers
 
 import (
 	"fmt"
+	"reCoreD-UI/database"
 	"reCoreD-UI/models"
+	"strconv"
 
 	"gorm.io/gorm"
 )
 
-func (c *Controller) CreateRecord(r *models.Record) (*models.Record, error) {
+type recordsDAO struct {
+	database.BaseDAO[models.Record]
+}
+
+func CreateRecord(r *models.Record) (*models.Record, error) {
 	if r.RecordType != models.RecordTypeSOA {
-		domains, err := c.GetDomains(r.Zone)
+		_, err := GetDomains(r.WithOutDotTail())
 		if err != nil {
 			return nil, err
 		}
-
-		if len(domains) == 0 || domains[0].DomainName == r.Zone {
-			return nil, fmt.Errorf("no such domain")
-		}
 	}
 
 	if err := r.CheckZone(); err != nil {
 		return nil, err
 	}
 
-	if err := c.DB.Transaction(func(tx *gorm.DB) error {
-		return tx.Create(r).Error
-	}); err != nil {
-		return nil, err
-	}
-
-	return r, nil
+	res, err := (recordsDAO{}).Create(database.Client, *r)
+	return &res, err
 }
 
-func (c *Controller) CreateRecords(rs []*models.Record) error {
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		for _, r := range rs {
-			if err := r.CheckZone(); err != nil {
-				return err
-			}
-
-			if err := tx.Create(r).Error; err != nil {
-				return err
-			}
+func CreateRecords(rs []*models.Record) error {
+	tx := database.Client.Begin()
+	for _, r := range rs {
+		if err := r.CheckZone(); err != nil {
+			tx.Rollback()
+			return err
 		}
-		return nil
-	})
-}
 
-func (c *Controller) GetRecords(cond map[string]string) ([]models.Record, error) {
-	var records []models.Record
-
-	if err := c.DB.Where(cond).Find(&records).Error; err != nil {
-		return nil, err
+		if _, err := (recordsDAO{}).Create(tx, *r); err != nil {
+			tx.Rollback()
+			return err
+		}
 	}
-
-	return records, nil
+	tx.Commit()
+	return nil
 }
 
-func (c *Controller) UpdateRecord(r *models.Record) error {
+func GetRecords(cond models.Record) ([]models.Record, error) {
+	return (recordsDAO{}).GetAll(database.Client, cond)
+}
+
+func UpdateRecord(r *models.Record) error {
 	if err := r.CheckZone(); err != nil {
 		return err
 	}
 
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		return tx.Model(r).Updates(r).Error
-	})
+	if _, err := (recordsDAO{}).Update(database.Client, *r); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (c *Controller) DeleteRecord(domain, id string) error {
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		return tx.Where("record_type != ?", models.RecordTypeSOA).
-			Where("id = ?", id).
-			Where("zone = ?", domain).
-			Delete(&models.Record{}).Error
-	})
+func DeleteRecord(domain, id string) error {
+	ID, err := strconv.Atoi(id)
+	if err != nil {
+		return err
+	}
+
+	tx := database.Client.Begin()
+	record, err := (recordsDAO{}).GetOne(tx, models.Record{ID: ID, Zone: fmt.Sprintf("%s.", domain)})
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	if record.RecordType == models.RecordTypeSOA {
+		tx.Rollback()
+		return gorm.ErrRecordNotFound
+	}
+
+	if err := (recordsDAO{}).Delete(tx, record); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	tx.Commit()
+	return nil
 }
 
-func (c *Controller) getRecordCounts() (map[string]float64, error) {
-	rows, err := c.DB.Model(models.Record{}).Select("zone", "count(*) as count").Group("zone").Rows()
+// for metrics
+func getRecordCounts() (map[string]float64, error) {
+	rows, err := (recordsDAO{}).GetAll(database.Client, models.Record{})
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
 
 	result := make(map[string]float64)
-	for rows.Next() {
-		var domain string
-		var count int64
-		if err := rows.Scan(&domain, &count); err != nil {
-			return nil, err
-		}
-		result[domain] = float64(count)
+	for _, row := range rows {
+		result[row.Zone] += 1
 	}
-
 	return result, nil
 }

controllers/settings.go

@@ -0,0 +1,73 @@
+package controllers
+
+import (
+	"reCoreD-UI/database"
+	"reCoreD-UI/models"
+	"strings"
+)
+
+const dnsSep = ","
+
+type settingsDAO struct {
+	database.BaseDAO[models.Settings]
+}
+
+func SetupDNS(dns ...string) error {
+	settings := models.Settings{Key: models.SettingsKeyDNSServer, Value: strings.Join(dns, dnsSep)}
+
+	if _, err := (settingsDAO{}).UpdateOrCreate(database.Client, settings); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetDNS() ([]string, error) {
+	settings, err := (settingsDAO{}).GetOne(database.Client, models.Settings{Key: models.SettingsKeyDNSServer})
+	if err != nil {
+		return nil, err
+	}
+
+	return strings.Split(settings.Value, dnsSep), nil
+}
+
+func SetupAdmin(username, password string) error {
+	settingUsername := models.Settings{
+		Key:   models.SettingsKeyAdminUsername,
+		Value: username,
+	}
+	settingPassword := models.Settings{
+		Key:   models.SettingsKeyAdminPassword,
+		Value: password,
+	}
+
+	tx := database.Client.Begin()
+	if _, err := (settingsDAO{}).UpdateOrCreate(tx, settingUsername); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	if _, err := (settingsDAO{}).UpdateOrCreate(tx, settingPassword); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	tx.Commit()
+	return nil
+}
+
+func GetAdmin() (string, string, error) {
+	settings, err := (settingsDAO{}).GetOne(database.Client, models.Settings{Key: models.SettingsKeyAdminUsername})
+	if err != nil {
+		return "", "", err
+	}
+	username := settings.Value
+
+	settings, err = (settingsDAO{}).GetOne(database.Client, models.Settings{Key: models.SettingsKeyAdminPassword})
+	if err != nil {
+		return "", "", err
+	}
+	password := settings.Value
+
+	return username, password, nil
+}

controllers/user.go

@@ -1,41 +0,0 @@
-package controllers
-
-import (
-	"reCoreD-UI/models"
-
-	"gorm.io/gorm"
-)
-
-func (c *Controller) SetupAdmin(username, password string) error {
-	return c.DB.Transaction(func(tx *gorm.DB) error {
-		settings := &models.Settings{}
-
-		if err := tx.Where(&models.Settings{Key: models.SettingsKeyAdminUsername}).
-			Attrs(&models.Settings{Value: username}).
-			FirstOrCreate(settings).Error; err != nil {
-			return err
-		}
-
-		if err := tx.Where(&models.Settings{Key: models.SettingsKeyAdminPassword}).
-			Attrs(&models.Settings{Value: password}).
-			FirstOrCreate(settings).Error; err != nil {
-			return err
-		}
-		return nil
-	})
-}
-
-func (c *Controller) GetAdmin() (string, string, error) {
-	settings := &models.Settings{}
-	if err := c.DB.Where(&models.Settings{Key: models.SettingsKeyAdminUsername}).First(settings).Error; err != nil {
-		return "", "", err
-	}
-	username := settings.Value
-
-	if err := c.DB.Where(&models.Settings{Key: models.SettingsKeyAdminPassword}).First(settings).Error; err != nil {
-		return "", "", err
-	}
-	password := settings.Value
-
-	return username, password, nil
-}