gitee.com/woood2/luca@v1.0.4/internal/repository/app.go

package repository

import (
	"context"
	"gitee.com/woood2/luca/internal/errcode"
	"gitee.com/woood2/luca/internal/layer"
	"github.com/pkg/errors"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"time"
)

//entity
type App struct {
	ID         int
	Appkey     string
	Secret     string
	Name       string
	Url        string
	Logo       string
	Contacts   string
	Disabled   int
	Createtime time.Time `gorm:"column:createtime;default:null"`
	Updatetime time.Time `gorm:"column:updatetime;default:null"`
	Remark     string
}

func (App) TableName() string {
	return "app"
}

//interface
type AppRepo interface {
	//errcode.AppNotExists
	GetByKey(ctx context.Context, appkey string) (*App, error)

	List(ctx context.Context, appkey string, name string) ([]*App, error)

	ExistByKey(ctx context.Context, appkey string) (bool, error)

	ExistByName(ctx context.Context, name string) (bool, error)

	Create(ctx context.Context, app *App) (int, error)

	Edit(ctx context.Context, app *App) error

	Delete(ctx context.Context, app *App) error

	SetDisabled(ctx context.Context, appkey string, disabled int) error
}

type AppRepoFactory interface {
	Produce(logger *zap.Logger, db *gorm.DB) AppRepo
}

//factory impl
func NewAppRepoImplFactory() *AppRepoImplFactory {
	return &AppRepoImplFactory{}
}

type AppRepoImplFactory struct {
}

func (f AppRepoImplFactory) Produce(logger *zap.Logger, db *gorm.DB) AppRepo {
	return NewAppRepoImpl(logger, db)
}

//repo impl
func NewAppRepoImpl(logger *zap.Logger, db *gorm.DB) *AppRepoImpl {
	return &AppRepoImpl{
		Repository: layer.Repository{Logger: logger, DB: db},
	}
}

type AppRepoImpl struct {
	layer.Repository
}

func (repo *AppRepoImpl) GetByKey(ctx context.Context, appkey string) (*App, error) {
	app := new(App)
	result := repo.DB.WithContext(ctx).Where("appkey = ?", appkey).First(app)

	if result.Error == nil {
		return app, nil
	}
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return nil, errcode.AppNotExists
	} else {
		return nil, errors.Wrapf(result.Error, "AppRepoImpl:GetByKey(%s) failed", appkey)
	}
}

func (repo *AppRepoImpl) List(ctx context.Context, appkey string, name string) ([]*App, error) {
	cond := ""
	var args []interface{}
	if appkey != "" {
		cond = "appkey LIKE ?"
		args = append(args, "%"+appkey+"%")
	}
	if name != "" {
		if len(args) > 0 {
			cond += " AND "
		}
		cond += "name LIKE ?"
		args = append(args, "%"+name+"%")
	}

	var apps []*App
	var err error
	if len(args) > 0 {
		result := repo.DB.WithContext(ctx).Where(cond, args...).Order("id asc").Find(&apps)
		err = result.Error
	} else {
		result := repo.DB.WithContext(ctx).Order("id asc").Find(&apps)
		err = result.Error
	}
	if err == nil {
		return apps, nil
	} else {
		return apps, errors.Wrapf(err, "AppRepoImpl:List(%s, %s) failed", appkey, name)
	}
}

func (repo *AppRepoImpl) ExistByKey(ctx context.Context, appkey string) (bool, error) {
	app := new(App)
	result := repo.DB.WithContext(ctx).Where("appkey = ?", appkey).First(app)
	if result.Error == nil {
		return true, nil
	}
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false, nil
	}
	return false, errors.Wrapf(result.Error, "AppRepoImpl:ExistByKey(%s) failed", appkey)
}

func (repo *AppRepoImpl) ExistByName(ctx context.Context, name string) (bool, error) {
	app := new(App)
	result := repo.DB.WithContext(ctx).Where("name = ?", name).First(app)
	if result.Error == nil {
		return true, nil
	}
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false, nil
	}
	return false, errors.Wrapf(result.Error, "AppRepoImpl:ExistByName(%s) failed", name)
}

func (repo *AppRepoImpl) Create(ctx context.Context, app *App) (int, error) {
	result := repo.DB.WithContext(ctx).Create(app)
	if result.Error == nil {
		return app.ID, nil
	} else {
		return 0, errors.Wrap(result.Error, "AppRepoImpl:Create failed")
	}
}

func (repo *AppRepoImpl) Edit(ctx context.Context, app *App) error {
	result := repo.DB.WithContext(ctx).Save(app)
	if result.Error == nil {
		return nil
	} else {
		return errors.Wrap(result.Error, "AppRepoImpl:Edit failed")
	}
}

func (repo *AppRepoImpl) Delete(ctx context.Context, app *App) error {
	result := repo.DB.WithContext(ctx).Delete(app)
	if result.Error == nil {
		return nil
	} else {
		return errors.Wrapf(result.Error, "AppRepoImpl:Delete(%d) failed", app.ID)
	}
}

func (repo *AppRepoImpl) SetDisabled(ctx context.Context, appkey string, disabled int) error {
	result := repo.DB.WithContext(ctx).Model(&App{}).Where("appkey = ? ", appkey).Update("disabled", disabled)
	if result.Error == nil {
		return nil
	} else {
		return errors.Wrapf(result.Error, "AppRepoImpl:SetDisabled(%s, %d) failed", appkey, disabled)
	}
}