package repository import ( "errors" "fmt" "github.com/go-pg/pg/v10" "github.com/linmadan/egglib-go/persistent/pg/sqlbuilder" pgTransaction "github.com/linmadan/egglib-go/transaction/pg" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/pg/models" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils" "time" ) type EvaluationRuleRepository struct { transactionContext *pgTransaction.TransactionContext } func NewEvaluationRuleRepository(transactionContext *pgTransaction.TransactionContext) *EvaluationRuleRepository { return &EvaluationRuleRepository{transactionContext: transactionContext} } func (repo *EvaluationRuleRepository) TransformToDomain(m *models.EvaluationRule) domain.EvaluationRule { return domain.EvaluationRule{ Id: m.Id, Name: m.Name, Remark: m.Remark, CompanyId: m.CompanyId, CreatorId: m.CreatorId, Type: m.Type, Rating: m.Rating, Score: m.Score, CreatedAt: m.CreatedAt, UpdatedAt: m.UpdatedAt, DeletedAt: m.DeletedAt, } } func (repo *EvaluationRuleRepository) TransformToModel(d *domain.EvaluationRule) models.EvaluationRule { return models.EvaluationRule{ Id: d.Id, Name: d.Name, Remark: d.Remark, CompanyId: d.CompanyId, CreatorId: d.CreatorId, Type: d.Type, Rating: d.Rating, Score: d.Score, CreatedAt: d.CreatedAt, UpdatedAt: d.UpdatedAt, DeletedAt: d.DeletedAt, } } func (repo *EvaluationRuleRepository) nextIdentify() (int64, error) { return utils.NewSnowflakeId() } func (repo *EvaluationRuleRepository) Insert(d *domain.EvaluationRule) (*domain.EvaluationRule, error) { var isCreate = d.Id == 0 if isCreate { id, err := repo.nextIdentify() if err != nil { return d, err } d.Id = id d.CreatedAt = time.Now() d.UpdatedAt = d.CreatedAt } else { d.UpdatedAt = time.Now() } m := repo.TransformToModel(d) tx := repo.transactionContext.PgTx var err error if isCreate { _, err = tx.Model(&m).Returning("id").Insert() } else { _, err = tx.Model(&m).Returning("id").WherePK().Update() // 更新和删除必须增加条件 } if err != nil { return nil, err } d.Id = m.Id return d, nil } func (repo *EvaluationRuleRepository) Remove(d *domain.EvaluationRule) (*domain.EvaluationRule, error) { tx := repo.transactionContext.PgTx nowTime := time.Now() m := repo.TransformToModel(d) m.DeletedAt = &nowTime if _, err := tx.Model(&m).WherePK().Update(); err != nil { return d, err } return d, nil } func (repo *EvaluationRuleRepository) FindOne(queryOptions map[string]interface{}) (*domain.EvaluationRule, error) { tx := repo.transactionContext.PgTx m := new(models.EvaluationRule) query := tx.Model(m) query.Where("deleted_at isnull") if id, ok := queryOptions["id"]; ok { query.Where("id=?", id) } if err := query.First(); err != nil { if errors.Is(err, pg.ErrNoRows) { return nil, fmt.Errorf("没有此资源") } else { return nil, err } } u := repo.TransformToDomain(m) return &u, nil } func (repo *EvaluationRuleRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.EvaluationRule, error) { tx := repo.transactionContext.PgTx var m []*models.EvaluationRule query := tx.Model(&m).Where("deleted_at isnull") if v, ok := queryOptions["nameOrRemark"]; ok && len(v.(string)) > 0 { query.Where("name LIKE ? or remark LIKE ?", v, v) } if v, ok := queryOptions["name"]; ok { query.Where("name = ?", v) } if v, ok := queryOptions["companyId"]; ok { query.Where("company_id = ?", v) } if v, ok := queryOptions["limit"].(int); ok { query.Limit(v) } if v, ok := queryOptions["offset"].(int); ok { query.Offset(v) } count, err := query.SelectAndCount() if err != nil { return 0, nil, err } var arrays []*domain.EvaluationRule for _, v := range m { d := repo.TransformToDomain(v) arrays = append(arrays, &d) } return int64(count), arrays, nil } func (repo *EvaluationRuleRepository) Count(queryOptions map[string]interface{}) (int64, error) { tx := repo.transactionContext.PgTx m := new(models.EvaluationRule) query := sqlbuilder.BuildQuery(tx.Model(m), queryOptions) query.Where("deleted_at isnull") if v, ok := queryOptions["id"]; ok { query.Where("id = ?", v) } if v, ok := queryOptions["notId"]; ok { query.Where("id != ?", v) } if v, ok := queryOptions["name"]; ok { query.Where("name = ?", v) } if v, ok := queryOptions["companyId"]; ok { query.Where("company_id = ?", v) } count, err := query.Count() if err != nil { return 0, err } return int64(count), nil }