pg_project_belong_repository.go 4.6 KB
package repository

import (
	"fmt"

	"github.com/go-pg/pg"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/pg/models"
)

type ProjectBelongRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *ProjectBelongRepository) Save(projectBelong *domain.ProjectBelong) (*domain.ProjectBelong, error) {
	tx := repository.transactionContext.PgTx
	if projectBelong.Identify() == nil {
		if _, err := tx.QueryOne(
			pg.Scan(&projectBelong.ProjectBelongId, &projectBelong.ProjectBelongName, &projectBelong.CompanyId),
			"INSERT INTO project_belongs (project_belong_name, company_id) VALUES (?, ?) RETURNING id, project_belong_name, company_id",
			projectBelong.ProjectBelongName, projectBelong.CompanyId); err != nil {
			return projectBelong, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&projectBelong.ProjectBelongId, &projectBelong.ProjectBelongName, &projectBelong.CompanyId),
			"UPDATE project_belongs SET project_belong_name=?, company_id=? WHERE id=? RETURNING id, project_belong_name, company_id",
			projectBelong.ProjectBelongName, projectBelong.CompanyId, projectBelong.Identify()); err != nil {
			return projectBelong, err
		}
	}
	return projectBelong, nil
}
func (repository *ProjectBelongRepository) Remove(projectBelong *domain.ProjectBelong) (*domain.ProjectBelong, error) {
	tx := repository.transactionContext.PgTx
	projectBelongModel := new(models.ProjectBelong)
	projectBelongModel.Id = projectBelong.Identify().(int)
	if _, err := tx.Model(projectBelongModel).WherePK().Delete(); err != nil {
		return projectBelong, err
	}
	return projectBelong, nil
}
func (repository *ProjectBelongRepository) FindOne(queryOptions map[string]interface{}) (*domain.ProjectBelong, error) {
	tx := repository.transactionContext.PgTx
	projectBelongModel := new(models.ProjectBelong)
	query := tx.Model(projectBelongModel)
	if projectBelongId, ok := queryOptions["projectBelongId"]; ok {
		query = query.Where("project_belong.id = ?", projectBelongId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if projectBelongModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(projectBelongModel)
	}
}
func (repository *ProjectBelongRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.ProjectBelong, error) {
	tx := repository.transactionContext.PgTx
	var projectBelongModels []*models.ProjectBelong
	projectBelongs := make([]*domain.ProjectBelong, 0)
	query := tx.Model(&projectBelongModels)
	if companyId, ok := queryOptions["companyId"]; ok {
		query = query.Where("project_belong.company_id = ?", companyId)
	}
	if projectBelongName, ok := queryOptions["projectBelongName"]; ok && (projectBelongName != "") {
		query = query.Where(`project_belong.project_belong_name = ?`, projectBelongName)
	}
	if projectBelongNameMatch, ok := queryOptions["projectBelongNameMatch"]; ok && (projectBelongNameMatch != "") {
		query = query.Where(`project_belong.project_belong_name LIKE ?`, fmt.Sprintf("%%%s%%", projectBelongNameMatch.(string)))
	}
	if offset, ok := queryOptions["offset"]; ok {
		offset := offset.(int)
		if offset > -1 {
			query = query.Offset(offset)
		}
	} else {
		query = query.Offset(0)
	}
	if limit, ok := queryOptions["limit"]; ok {
		limit := limit.(int)
		if limit > -1 {
			query = query.Limit(limit)
		}
	} else {
		query = query.Limit(20)
	}
	if count, err := query.Order("id DESC").SelectAndCount(); err != nil {
		return 0, projectBelongs, err
	} else {
		for _, projectBelongModel := range projectBelongModels {
			if projectBelong, err := repository.transformPgModelToDomainModel(projectBelongModel); err != nil {
				return 0, projectBelongs, err
			} else {
				projectBelongs = append(projectBelongs, projectBelong)
			}
		}
		return int64(count), projectBelongs, nil
	}
}
func (repository *ProjectBelongRepository) transformPgModelToDomainModel(projectBelongModel *models.ProjectBelong) (*domain.ProjectBelong, error) {
	return &domain.ProjectBelong{
		ProjectBelongId:   projectBelongModel.Id,
		ProjectBelongName: projectBelongModel.ProjectBelongName,
		CompanyId:         projectBelongModel.CompanyId,
	}, nil
}
func NewProjectBelongRepository(transactionContext *pgTransaction.TransactionContext) (*ProjectBelongRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &ProjectBelongRepository{
			transactionContext: transactionContext,
		}, nil
	}
}