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

package service

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

type App struct {
	ID         int
	Appkey     string
	Secret     string
	Name       string
	Url        string
	Logo       string
	Contacts   string
	Disabled   int
	Createtime time.Time
	Updatetime time.Time
	Remark     string
}

type AppService interface {
	//errcode.AppKeyAlreadyExists
	//errcode.AppNameAlreadyExists
	Create(ctx context.Context, dto *App) (id int, err error)

	Twins(ctx context.Context) error

	//errcode.AppNotExists
	//errcode.AppNotAllowedToDelete
	DeleteByKey(ctx context.Context, appkey string) error

	//errcode.AppNotExists
	//errcode.AppNotAllowedToChangeDisabled
	Enable(ctx context.Context, appkey string) error

	//errcode.AppNotExists
	//errcode.AppNotAllowedToChangeDisabled
	Disable(ctx context.Context, appkey string) error

	//errcode.AppNotExists
	//errcode.AppNameAlreadyExists
	EditByKey(ctx context.Context, appkey string, dto *App) error

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

	//errcode.AppNotExists
	GetByKeyFromCache(ctx context.Context, c cache.Cache, appkey string) (*App, error)

	//errcode.AppNotExists
	GetByKeyFromCacheSafely(ctx context.Context, c cache.Cache, appkey string) (*App, error)

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

func NewAppServiceImpl(logger *zap.Logger, db *gorm.DB,
	repoFactory repository.AppRepoFactory) *AppServiceImpl {
	return &AppServiceImpl{
		Service:     layer.Service{Logger: logger},
		repo:        repoFactory.Produce(logger, db),
		repoFactory: repoFactory,
		db:          db,
	}
}

type AppServiceImpl struct {
	layer.Service
	repo        repository.AppRepo
	repoFactory repository.AppRepoFactory
	db          *gorm.DB
}

func (svc *AppServiceImpl) Create(ctx context.Context, dto *App) (id int, err error) {
	if ok, err := svc.repo.ExistByKey(ctx, dto.Appkey); err != nil {
		return 0, err
	} else if ok {
		return 0, errcode.AppKeyAlreadyExists
	}
	if ok, err := svc.repo.ExistByName(ctx, dto.Name); err != nil {
		return 0, err
	} else if ok {
		return 0, errcode.AppNameAlreadyExists
	}
	app := &repository.App{
		Appkey:   dto.Appkey,
		Secret:   dto.Secret,
		Name:     dto.Name,
		Url:      dto.Url,
		Logo:     dto.Logo,
		Contacts: dto.Contacts,
		Disabled: dto.Disabled,
		Remark:   dto.Remark,
	}
	id, err = svc.repo.Create(ctx, app)
	return
}

func (svc *AppServiceImpl) Twins(ctx context.Context) error {
	saga := &repository.App{
		Appkey: "saga",
		Secret: "13",
		Name:   "撒加",
	}
	kanon := &repository.App{
		Appkey: "kanon",
		Secret: "North Atlantic",
		Name:   "加隆",
	}
	err := svc.db.Transaction(func(tx *gorm.DB) error {
		repo := svc.repoFactory.Produce(svc.Logger, tx)
		if _, err := repo.Create(ctx, saga); err != nil {
			return err
		}
		if _, err := repo.Create(ctx, kanon); err != nil {
			return err
		}
		return nil
	})
	return err
}

func (svc *AppServiceImpl) DeleteByKey(ctx context.Context, appkey string) error {
	app, err := svc.repo.GetByKey(ctx, appkey)
	if err != nil {
		return err
	}
	if time.Now().After(app.Createtime.Add(2 * time.Hour)) {
		return errcode.AppNotAllowedToDelete
	}
	return svc.repo.Delete(ctx, app)
}

func (svc *AppServiceImpl) Enable(ctx context.Context, appkey string) error {
	user, err := svc.repo.GetByKey(ctx, appkey)
	if err != nil {
		return err
	}
	if user.Disabled == 0 {
		return errcode.AppNotAllowedToChangeDisabled
	}
	return svc.repo.SetDisabled(ctx, appkey, 0)
}

func (svc *AppServiceImpl) Disable(ctx context.Context, appkey string) error {
	user, err := svc.repo.GetByKey(ctx, appkey)
	if err != nil {
		return err
	}
	if user.Disabled == 1 {
		return errcode.AppNotAllowedToChangeDisabled
	}
	return svc.repo.SetDisabled(ctx, appkey, 1)
}

func (svc *AppServiceImpl) EditByKey(ctx context.Context, appkey string, dto *App) error {
	app, err := svc.repo.GetByKey(ctx, appkey)
	if err != nil {
		return err
	}
	if dto.Name != app.Name {
		if ok, err := svc.repo.ExistByName(ctx, dto.Name); err != nil {
			return err
		} else if ok {
			return errcode.AppNameAlreadyExists
		}
	}
	now := time.Now()
	app.Updatetime = now

	app.Secret = dto.Secret
	app.Name = dto.Name
	app.Url = dto.Url
	app.Logo = dto.Logo
	app.Contacts = dto.Contacts
	app.Remark = dto.Remark

	return svc.repo.Edit(ctx, app)
}

func (svc *AppServiceImpl) GetByKey(ctx context.Context, appkey string) (*App, error) {
	app, err := svc.repo.GetByKey(ctx, appkey)
	if err != nil {
		return nil, err
	}

	return &App{
		ID:         app.ID,
		Appkey:     app.Appkey,
		Secret:     app.Secret,
		Name:       app.Name,
		Url:        app.Url,
		Logo:       app.Logo,
		Contacts:   app.Contacts,
		Disabled:   app.Disabled,
		Createtime: app.Createtime,
		Updatetime: app.Updatetime,
		Remark:     app.Remark,
	}, nil
}

/**
Mainly used in auth scene
[error]
errcode.AppNotExists not exist in DB
...other errors
*/
func (svc *AppServiceImpl) GetByKeyFromCache(ctx context.Context, c cache.Cache, appkey string) (*App, error) {
	k := cache.App.BuildKey(appkey)
	var v *App
	if e := c.Get(k, &v); e != nil {
		//miss
		if e == c.Miss() {
			//exist
			app, err := svc.GetByKey(ctx, appkey)
			if err == nil {
				if err := c.Set(k, app, cache.App.Duration); err != nil {
					return nil, err
				} else {
					return app, nil
				}
			}
			//not exist
			if err == errcode.AppNotExists {
				if err := c.Set(k, nil, cache.App.Duration); err != nil {
					return nil, err
				} else {
					return nil, errcode.AppNotExists
				}
			}
			//other errors
			return nil, err
		}
		//other errors
		return nil, e
	}
	//hit
	if v == nil {
		return nil, errcode.AppNotExists
	}
	return v, nil
}

/**
Mainly used in auth scene
Safe mode to prevent avalanches
[error]
errcode.AppNotExists not exist in DB
...other errors
*/
func (svc *AppServiceImpl) GetByKeyFromCacheSafely(ctx context.Context, c cache.Cache, appkey string) (*App, error) {
	k := cache.App.BuildKey(appkey)
	var v *App
	if e := c.Get(k, &v); e != nil {
		//miss
		if e == c.Miss() {
			ok, ch, er := c.ApplyToSet(k)
			if er != nil {
				return nil, er
			}
			if ok {
				defer func() {
					close(ch)
					c.Release(k)
				}()
				app, err := svc.GetByKey(ctx, appkey)
				//exist
				if err == nil {
					if err := c.Set(k, app, cache.App.Duration); err != nil {
						return nil, err
					}
					return app, nil
				}
				//not exist
				if err == errcode.AppNotExists {
					if err := c.Set(k, nil, cache.App.Duration); err != nil {
						return nil, err
					}
					return nil, errcode.AppNotExists
				}
				//other errors
				return nil, err
			}
			<-ch
			var v *App
			if e := c.Get(k, &v); e != nil {
				return nil, e
			}
			if v == nil {
				return nil, errcode.AppNotExists
			}
			return v, nil
		}
		//other errors
		return nil, e
	}
	//hit
	if v == nil {
		return nil, errcode.AppNotExists
	}
	return v, nil
}

func (svc *AppServiceImpl) List(ctx context.Context, appkey string, name string) ([]*App, error) {
	apps, err := svc.repo.List(ctx, appkey, name)
	if err != nil {
		return nil, err
	}

	var dtos []*App
	for _, app := range apps {
		dtos = append(dtos, &App{
			ID:         app.ID,
			Appkey:     app.Appkey,
			Secret:     app.Secret,
			Name:       app.Name,
			Url:        app.Url,
			Logo:       app.Logo,
			Contacts:   app.Contacts,
			Disabled:   app.Disabled,
			Createtime: app.Createtime,
			Updatetime: app.Updatetime,
			Remark:     app.Remark,
		})
	}
	return dtos, nil
}