173 lines
4.5 KiB
Go
173 lines
4.5 KiB
Go
package tenantsms
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"hfb_sys/backend/internal/auditlog"
|
|
"hfb_sys/backend/internal/model"
|
|
"hfb_sys/backend/internal/tenancy"
|
|
"hfb_sys/backend/pkg/crypto"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
type Repository struct {
|
|
db *gorm.DB
|
|
encryptor crypto.Encryptor
|
|
}
|
|
|
|
func NewRepository(db *gorm.DB, encryptor crypto.Encryptor) *Repository {
|
|
return &Repository{db: db, encryptor: encryptor}
|
|
}
|
|
|
|
func (r *Repository) Get(ctx context.Context) (Config, error) {
|
|
if r == nil || r.db == nil || r.encryptor == nil {
|
|
return Config{}, errors.New("tenant sms database unavailable")
|
|
}
|
|
tenantID := tenancy.IDFromContext(ctx)
|
|
if tenantID == 0 {
|
|
return Config{}, ErrInvalidConfig
|
|
}
|
|
var row model.TenantSMSConfig
|
|
err := r.db.WithContext(ctx).Where("tenant_id = ?", tenantID).First(&row).Error
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return DefaultConfig(), nil
|
|
}
|
|
if err != nil {
|
|
return Config{}, err
|
|
}
|
|
return r.decryptRow(row)
|
|
}
|
|
|
|
func (r *Repository) GetDTO(ctx context.Context) (DTO, error) {
|
|
cfg, err := r.Get(ctx)
|
|
if err != nil {
|
|
return DTO{}, err
|
|
}
|
|
return cfg.DTO(), nil
|
|
}
|
|
|
|
func (r *Repository) Update(ctx context.Context, actorID uint64, req UpdateRequest, meta auditlog.Meta) (DTO, error) {
|
|
if r == nil || r.db == nil || r.encryptor == nil {
|
|
return DTO{}, errors.New("tenant sms dependencies unavailable")
|
|
}
|
|
tenantID := tenancy.IDFromContext(ctx)
|
|
if tenantID == 0 || actorID == 0 {
|
|
return DTO{}, ErrInvalidConfig
|
|
}
|
|
|
|
var result Config
|
|
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var row model.TenantSMSConfig
|
|
err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("tenant_id = ?", tenantID).
|
|
First(&row).Error
|
|
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
|
|
cfg := DefaultConfig()
|
|
if err == nil {
|
|
decrypted, decryptErr := r.decryptRow(row)
|
|
if decryptErr != nil {
|
|
return decryptErr
|
|
}
|
|
cfg = decrypted
|
|
}
|
|
cfg = applyUpdate(cfg, req)
|
|
normalized, normalizeErr := normalizeConfig(cfg)
|
|
if normalizeErr != nil {
|
|
return normalizeErr
|
|
}
|
|
encrypted, encryptErr := r.encryptor.Encrypt(normalized.AccessKeySecret)
|
|
if encryptErr != nil {
|
|
return fmt.Errorf("encrypt tenant sms secret: %w", encryptErr)
|
|
}
|
|
|
|
row.TenantID = tenantID
|
|
row.Enabled = normalized.Enabled
|
|
row.Provider = normalized.Provider
|
|
row.AccessKeyID = normalized.AccessKeyID
|
|
row.AccessKeySecret = encrypted
|
|
row.Endpoint = normalized.Endpoint
|
|
row.SignName = normalized.SignName
|
|
row.LoginTemplateCode = normalized.LoginTemplateCode
|
|
row.UpdatedBy = &actorID
|
|
if row.ID == 0 {
|
|
if createErr := tx.Create(&row).Error; createErr != nil {
|
|
return createErr
|
|
}
|
|
} else if saveErr := tx.Save(&row).Error; saveErr != nil {
|
|
return saveErr
|
|
}
|
|
|
|
result = normalized
|
|
return auditlog.Append(tx, auditlog.Entry{
|
|
ActorType: "admin",
|
|
ActorID: actorID,
|
|
Action: "tenant_sms_config.update",
|
|
BizType: "tenant_sms_config",
|
|
BizID: &row.ID,
|
|
Meta: meta,
|
|
Detail: map[string]any{
|
|
"tenant_id": tenantID,
|
|
"enabled": normalized.Enabled,
|
|
"provider": normalized.Provider,
|
|
"access_key_id": normalized.AccessKeyID,
|
|
"has_secret": normalized.AccessKeySecret != "",
|
|
"endpoint": normalized.Endpoint,
|
|
"sign_name": normalized.SignName,
|
|
"login_template_code": normalized.LoginTemplateCode,
|
|
},
|
|
})
|
|
})
|
|
if err != nil {
|
|
return DTO{}, err
|
|
}
|
|
return result.DTO(), nil
|
|
}
|
|
|
|
func (r *Repository) decryptRow(row model.TenantSMSConfig) (Config, error) {
|
|
secret, err := r.encryptor.Decrypt(row.AccessKeySecret)
|
|
if err != nil {
|
|
return Config{}, fmt.Errorf("decrypt tenant sms secret: %w", err)
|
|
}
|
|
return Config{
|
|
Enabled: row.Enabled,
|
|
Provider: row.Provider,
|
|
AccessKeyID: row.AccessKeyID,
|
|
AccessKeySecret: secret,
|
|
Endpoint: row.Endpoint,
|
|
SignName: row.SignName,
|
|
LoginTemplateCode: row.LoginTemplateCode,
|
|
}, nil
|
|
}
|
|
|
|
func applyUpdate(cfg Config, req UpdateRequest) Config {
|
|
if req.Enabled != nil {
|
|
cfg.Enabled = *req.Enabled
|
|
}
|
|
if req.Provider != nil {
|
|
cfg.Provider = *req.Provider
|
|
}
|
|
if req.AccessKeyID != nil {
|
|
cfg.AccessKeyID = *req.AccessKeyID
|
|
}
|
|
if req.AccessKeySecret != nil && *req.AccessKeySecret != "" {
|
|
cfg.AccessKeySecret = *req.AccessKeySecret
|
|
}
|
|
if req.Endpoint != nil {
|
|
cfg.Endpoint = *req.Endpoint
|
|
}
|
|
if req.SignName != nil {
|
|
cfg.SignName = *req.SignName
|
|
}
|
|
if req.LoginTemplateCode != nil {
|
|
cfg.LoginTemplateCode = *req.LoginTemplateCode
|
|
}
|
|
return cfg
|
|
}
|