增加:增加模型 users partner_category business_bonus

+package domain
+
+import "time"
+
+// 业务分红信息
+type BusinessBonus struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 公司编号
+	CompanyId int64 `json:"companyId"`
+	// 合伙人信息Id
+	PartnerInfoId string `json:"partnerInfoId"`
+	// 应收分红
+	Bonus float64 `json:"bonus"`
+	// 未收分红
+	BonusNot float64 `json:"bonusNot"`
+	// 分红支出
+	BonusExpense float64 `json:"bonusExpense"`
+	// 是否关闭【0;否】【1：是】
+	IsDisable int8 `json:"isDisable"`
+	// 分红状态 1:待支付分红 2:已支付分红
+	BonusStatus int8 `json:"bonusStatus"`
+	// 创建时间
+	CreateAt time.Time `json:"createAt"`
+	// 更新时间
+	UpdateAt time.Time `json:"updateAt"`
+	// 删除时间
+	DeleteAt time.Time `json:"deleteAt"`
+}
+
+type BusinessBonusRepository interface {
+	Save(dm *BusinessBonus) (*BusinessBonus, error)
+	Remove(dm *BusinessBonus) (*BusinessBonus, error)
+	FindOne(queryOptions map[string]interface{}) (*BusinessBonus, error)
+	Find(queryOptions map[string]interface{}) (int64, []*BusinessBonus, error)
+}
+
+func (m *BusinessBonus) Identify() interface{} {
+	if m.Id == 0 {
+		return nil
+	}
+	return m.Id
+}

-package domain
-
-type Company struct {
-	Id    int64  `json:"id"`
-	Name  string `json:"name"`
-	Phone string `json:"phone"`
-}
-
-type CompanyRepository interface {
-	Save(dm *Company) (*Company, error)
-	Remove(dm *Company) (*Company, error)
-	FindOne(queryOptions map[string]interface{}) (*Company, error)
-	Find(queryOptions map[string]interface{}) (int64, []*Company, error)
-}

+package domain
+
+import "time"
+
+// 公司信息
+type Company struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 名称
+	Name string `json:"name"`
+	// 手机号码
+	Phone string `json:"phone"`
+	// 公司logo
+	Logo string `json:"logo"`
+	// 备注
+	Remarks string `json:"remarks"`
+	// 总后台的公司id
+	AdminCompanyId int `json:"adminCompanyId"`
+	// 状态 1正常 2禁用
+	Status int8 `json:"status"`
+	// 创建时间
+	CreateAt time.Time `json:"createAt"`
+	// 更新时间
+	UpdateAt time.Time `json:"updateAt"`
+	// 删除时间
+	DeleteAt time.Time `json:"deleteAt"`
+}
+
+type CompanyRepository interface {
+	Save(dm *Company) (*Company, error)
+	Remove(dm *Company) (*Company, error)
+	FindOne(queryOptions map[string]interface{}) (*Company, error)
+	Find(queryOptions map[string]interface{}) (int64, []*Company, error)
+}
+
+func (m *Company) Identify() interface{} {
+	if m.Id == 0 {
+		return nil
+	}
+	return m.Id
+}

+package domain
+
+// 合伙人分类信息
+type PartnerCategoryInfo struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 名称
+	Name string `json:"name"`
+}
+
+type PartnerCategoryInfoRepository interface {
+	Save(dm *PartnerCategoryInfo) (*PartnerCategoryInfo, error)
+	Remove(dm *PartnerCategoryInfo) (*PartnerCategoryInfo, error)
+	FindOne(queryOptions map[string]interface{}) (*PartnerCategoryInfo, error)
+	Find(queryOptions map[string]interface{}) (int64, []*PartnerCategoryInfo, error)
+}
+
+func (m *PartnerCategoryInfo) Identify() interface{} {
+	if m.Id == 0 {
+		return nil
+	}
+	return m.Id
+}

@@ -34,6 +34,8 @@ type PartnerInfo struct {
 
 
 	//关联业务员
 	//关联业务员
 	Salesman []*Salesman `json:"salesman"`
 	Salesman []*Salesman `json:"salesman"`
+	//合伙人分类信息
+	PartnerCategoryInfos []*PartnerCategoryInfo `partnerCategoryInfos`
 }
 }
 
 
 func (m *PartnerInfo) Identify() interface{} {
 func (m *PartnerInfo) Identify() interface{} {
@@ -86,7 +88,7 @@ func (m *PartnerInfo) PartnerCategoryInfo() *PartnerCategoryInfo {
 		break
 		break
 	}
 	}
 	return &PartnerCategoryInfo{
 	return &PartnerCategoryInfo{
-		Id:   m.PartnerCategory,
+		Id:   int64(m.PartnerCategory),
 		Name: name,
 		Name: name,
 	}
 	}
 }
 }
@@ -96,11 +98,6 @@ func (m *PartnerInfo) IsEnable() bool {
 	return m.Status == 1
 	return m.Status == 1
 }
 }
 
 
-type PartnerCategoryInfo struct {
-	Id   int    `json:"id"`
-	Name string `json:"name"`
-}
-
 type RegionInfo struct {
 type RegionInfo struct {
 	RegionId   int    `json:"regionId"`
 	RegionId   int    `json:"regionId"`
 	RegionName string `json:"regionName"`
 	RegionName string `json:"regionName"`

+package domain
+
+import "time"
+
+// 用户信息
+type Users struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 公司id
+	CompanyId int64 `json:"companyId"`
+	// 统一用户中心 uid
+	OpenId int64 `json:"openId"`
+	// 名称
+	Name string `json:"name"`
+	// 性别：0保密 1男 2女
+	Sex int8 `json:"sex"`
+	// 员工工号
+	JobNum string `json:"jobNum"`
+	// 手机号码
+	Phone string `json:"phone"`
+	// 私人手机号码
+	PrivatePhone string `json:"privatePhone"`
+	// 邮箱
+	Email string `json:"email"`
+	// 分机号
+	ExtensionNum string `json:"extensionNum"`
+	// 入职时间
+	EntryTime time.Time `json:"entryTime"`
+	// 工作地点
+	Workspace string `json:"workspace"`
+	// 状态 1正常 2禁用
+	Status int8 `json:"status"`
+	// 手机号
+	Avatar string `json:"avatar"`
+	// 备注
+	Remarks string `json:"remarks"`
+	// 是否为当前公司主管 1 是2 否
+	ChargeStatus int8 `json:"chargeStatus"`
+	// 创建时间
+	CreateAt time.Time `json:"createAt"`
+	// 更新时间
+	UpdateAt time.Time `json:"updateAt"`
+	// 删除时间
+	DeleteAt time.Time `json:"deleteAt"`
+	// 可查看的合伙人信息
+	AccessPartners []*PartnerInfo
+}
+
+type UsersRepository interface {
+	Save(dm *Users) (*Users, error)
+	Remove(dm *Users) (*Users, error)
+	FindOne(queryOptions map[string]interface{}) (*Users, error)
+	Find(queryOptions map[string]interface{}) (int64, []*Users, error)
+}
+
+func (m *Users) Identify() interface{} {
+	if m.Id == 0 {
+		return nil
+	}
+	return m.Id
+}

@@ -25,16 +25,16 @@ func init() {
 	//orm.RegisterTable((*models.OrderGood)(nil))
 	//orm.RegisterTable((*models.OrderGood)(nil))
 	if !constant.DISABLE_CREATE_TABLE {
 	if !constant.DISABLE_CREATE_TABLE {
 		for _, model := range []interface{}{
 		for _, model := range []interface{}{
-			//(*models.Employee)(nil),
 			(*models.PartnerInfo)(nil),
 			(*models.PartnerInfo)(nil),
-			(*models.Order)(nil),
-			(*models.OrderPayment)(nil),
 			(*models.PartnerSubAccount)(nil),
 			(*models.PartnerSubAccount)(nil),
 			(*models.Company)(nil),
 			(*models.Company)(nil),
 			(*models.OrderBase)(nil),
 			(*models.OrderBase)(nil),
 			(*models.OrderGood)(nil),
 			(*models.OrderGood)(nil),
 			(*models.ImInfo)(nil),
 			(*models.ImInfo)(nil),
 			(*models.ImCustomerService)(nil),
 			(*models.ImCustomerService)(nil),
+			(*models.BusinessBonus)(nil),
+			(*models.PartnerCategoryInfo)(nil),
+			(*models.Users)(nil),
 		} {
 		} {
 			err := DB.CreateTable(model, &orm.CreateTableOptions{
 			err := DB.CreateTable(model, &orm.CreateTableOptions{
 				Temp:          false,
 				Temp:          false,

-package models
-
-type Company struct {
-	tableName struct{} `pg:"company"`
-	Id        int64    `json:"id"`
-	Name      string   `json:"name"`
-	Phone     string   `json:"phone"`
-}

-package models
-
-import (
-	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
-	"time"
-)
-
-type Order struct {
-	tableName struct{} `pg:"order"`
-	//id
-	Id int64 `pg:",pk"`
-	//订单类型 1:实际订单 2：意向订单
-	OrderType int `pg:",notnull,default:1"`
-	//订单编号
-	OrderCode string `pg:",notnull`
-	//订单名称
-	OrderName string
-	//订单状态
-	OrderStatus int `pg:",notnull,default:1"`
-	//订单数量
-	OrderCount int
-	//实际订单数量
-	OrderActualCount int
-	//订单金额
-	OrderAmount float64
-	//订单实际金额
-	OrderActualAmount float64
-	//订单已支付金额（货款）
-	OrderPaymentAmount float64 `pg:",notnull,default:0"`
-	//订单区域信息
-	OrderRegionInfo *domain.RegionInfo
-
-	Buyer *domain.Buyer
-	//合伙人编号
-	PartnerId int64
-	//合伙人分红百分比
-	PartnerBonusPercent float64
-	//业务员分红百分比
-	SalesmanBonusPercent float64
-
-	//创建时间
-	CreateAt time.Time
-	//更新时间
-	UpdateAt time.Time
-
-	//上一次查看时间 已读情况
-	LastViewTime time.Time
-	//订单更新理由
-	Reason string
-}

-package models
-
-import "time"
-
-type OrderPayment struct {
-	tableName struct{} `pg:"order_payment"`
-	//编号
-	Id int64 `pg:",pk"`
-	//订单编号
-	OrderId int64
-	//合伙人编号
-	PartnerId int64
-	//支付货款
-	PaymentAmount float64 `pg:",notnull,default:0"`
-	//分红金额
-	BonusAmount float64
-	//分红状态  1.等待支付分红 2.已支付分红
-	BonusStatus int `pg:",notnull,default:1"`
-	//创建时间
-	CreateAt time.Time
-	//更新时间
-	UpdateAt time.Time
-}

@@ -32,4 +32,6 @@ type PartnerInfo struct {
 
 
 	//关联业务员
 	//关联业务员
 	Salesman []*domain.Salesman
 	Salesman []*domain.Salesman
+	//合伙人分类信息
+	PartnerCategoryInfos []*PartnerCategoryInfo
 }
 }

+package models
+
+import "time"
+
+// 业务分红信息
+type BusinessBonus struct {
+	tableName struct{} `pg:"business_bonus"`
+	//	唯一标识
+	Id int64
+	//	公司编号
+	CompanyId int64
+	//	合伙人信息Id
+	PartnerInfoId string
+	//	应收分红
+	Bonus float64
+	//	未收分红
+	BonusNot float64
+	//	分红支出
+	BonusExpense float64
+	//	是否关闭【0;否】【1：是】
+	IsDisable int8
+	//	分红状态 1:待支付分红 2:已支付分红
+	BonusStatus int8
+	//	创建时间
+	CreateAt time.Time
+	//	更新时间
+	UpdateAt time.Time
+	//	删除时间
+	DeleteAt time.Time
+}

+package models
+
+import "time"
+
+// 公司信息
+type Company struct {
+	tableName struct{} `pg:"Company"`
+	//	唯一标识
+	Id int64
+	//	名称
+	Name string
+	//	手机号码
+	Phone string
+	//	公司logo
+	Logo string
+	//	备注
+	Remarks string
+	//	总后台的公司id
+	AdminCompanyId int
+	//	状态 1正常 2禁用
+	Status int8
+	//	创建时间
+	CreateAt time.Time
+	//	更新时间
+	UpdateAt time.Time
+	//	删除时间
+	DeleteAt time.Time
+}

+package models
+
+// 合伙人分类信息
+type PartnerCategoryInfo struct {
+	tableName struct{} `pg:"partner_category_info"`
+	//	唯一标识
+	Id int64
+	//	名称
+	Name string
+}

+package models
+
+import (
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
+	"time"
+)
+
+// 用户信息
+type Users struct {
+	tableName struct{} `pg:"users"`
+	//	唯一标识
+	Id int64
+	//	公司id
+	CompanyId int64
+	//	统一用户中心 uid
+	OpenId int64
+	//	名称
+	Name string
+	//	性别：0保密 1男 2女
+	Sex int8
+	//	员工工号
+	JobNum string
+	//	手机号码
+	Phone string
+	//	私人手机号码
+	PrivatePhone string
+	//	邮箱
+	Email string
+	//	分机号
+	ExtensionNum string
+	//	入职时间
+	EntryTime time.Time
+	//	工作地点
+	Workspace string
+	//	状态 1正常 2禁用
+	Status int8
+	//	手机号
+	Avatar string
+	//	备注
+	Remarks string
+	//	是否为当前公司主管 1 是2 否
+	ChargeStatus int8
+	//	创建时间
+	CreateAt time.Time
+	//	更新时间
+	UpdateAt time.Time
+	//	删除时间
+	DeleteAt time.Time
+	// 可查看的合伙人信息
+	AccessPartners []*domain.PartnerInfo
+}

+package repository
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
+	. "gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/utils"
+)
+
+type BusinessBonusRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func (repository *BusinessBonusRepository) Save(dm *domain.BusinessBonus) (*domain.BusinessBonus, error) {
+	var (
+		err error
+		m   = &models.BusinessBonus{}
+		tx  = repository.transactionContext.PgTx
+	)
+	if err = GobModelTransform(m, dm); err != nil {
+		return nil, err
+	}
+	if dm.Identify() == nil {
+		if err = tx.Insert(m); err != nil {
+			return nil, err
+		}
+		return dm, nil
+	}
+	if err = tx.Update(m); err != nil {
+		return nil, err
+	}
+	return dm, nil
+}
+
+func (repository *BusinessBonusRepository) Remove(BusinessBonus *domain.BusinessBonus) (*domain.BusinessBonus, error) {
+	var (
+		tx                 = repository.transactionContext.PgTx
+		BusinessBonusModel = &models.BusinessBonus{Id: BusinessBonus.Identify().(int64)}
+	)
+	if _, err := tx.Model(BusinessBonusModel).Where("id = ?", BusinessBonus.Id).Delete(); err != nil {
+		return BusinessBonus, err
+	}
+	return BusinessBonus, nil
+}
+
+func (repository *BusinessBonusRepository) FindOne(queryOptions map[string]interface{}) (*domain.BusinessBonus, error) {
+	tx := repository.transactionContext.PgTx
+	BusinessBonusModel := new(models.BusinessBonus)
+	query := NewQuery(tx.Model(BusinessBonusModel), queryOptions)
+	query.SetWhere("id = ?", "id")
+	if err := query.First(); err != nil {
+		return nil, fmt.Errorf("query row not found")
+	}
+	if BusinessBonusModel.Id == 0 {
+		return nil, fmt.Errorf("query row not found")
+	}
+	return repository.transformPgModelToDomainModel(BusinessBonusModel)
+}
+
+func (repository *BusinessBonusRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.BusinessBonus, error) {
+	tx := repository.transactionContext.PgTx
+	var BusinessBonusModels []*models.BusinessBonus
+	BusinessBonuss := make([]*domain.BusinessBonus, 0)
+	query := NewQuery(tx.Model(&BusinessBonusModels), queryOptions).
+		SetOrder("create_time", "sortByCreateTime").
+		SetOrder("update_time", "sortByUpdateTime")
+	var err error
+	if query.AffectRow, err = query.SelectAndCount(); err != nil {
+		return 0, BusinessBonuss, err
+	}
+	for _, BusinessBonusModel := range BusinessBonusModels {
+		if BusinessBonus, err := repository.transformPgModelToDomainModel(BusinessBonusModel); err != nil {
+			return 0, BusinessBonuss, err
+		} else {
+			BusinessBonuss = append(BusinessBonuss, BusinessBonus)
+		}
+	}
+	return int64(query.AffectRow), BusinessBonuss, nil
+}
+
+func (repository *BusinessBonusRepository) transformPgModelToDomainModel(BusinessBonusModel *models.BusinessBonus) (*domain.BusinessBonus, error) {
+	m := &domain.BusinessBonus{}
+	err := GobModelTransform(m, BusinessBonusModel)
+	return m, err
+}
+
+func NewBusinessBonusRepository(transactionContext *transaction.TransactionContext) (*BusinessBonusRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &BusinessBonusRepository{transactionContext: transactionContext}, nil
+}

+package repository
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
+	. "gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/utils"
+)
+
+type PartnerCategoryInfoRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func (repository *PartnerCategoryInfoRepository) Save(dm *domain.PartnerCategoryInfo) (*domain.PartnerCategoryInfo, error) {
+	var (
+		err error
+		m   = &models.PartnerCategoryInfo{}
+		tx  = repository.transactionContext.PgTx
+	)
+	if err = GobModelTransform(m, dm); err != nil {
+		return nil, err
+	}
+	if dm.Identify() == nil {
+		if err = tx.Insert(m); err != nil {
+			return nil, err
+		}
+		return dm, nil
+	}
+	if err = tx.Update(m); err != nil {
+		return nil, err
+	}
+	return dm, nil
+}
+
+func (repository *PartnerCategoryInfoRepository) Remove(PartnerCategoryInfo *domain.PartnerCategoryInfo) (*domain.PartnerCategoryInfo, error) {
+	var (
+		tx                       = repository.transactionContext.PgTx
+		PartnerCategoryInfoModel = &models.PartnerCategoryInfo{Id: PartnerCategoryInfo.Identify().(int64)}
+	)
+	if _, err := tx.Model(PartnerCategoryInfoModel).Where("id = ?", PartnerCategoryInfo.Id).Delete(); err != nil {
+		return PartnerCategoryInfo, err
+	}
+	return PartnerCategoryInfo, nil
+}
+
+func (repository *PartnerCategoryInfoRepository) FindOne(queryOptions map[string]interface{}) (*domain.PartnerCategoryInfo, error) {
+	tx := repository.transactionContext.PgTx
+	PartnerCategoryInfoModel := new(models.PartnerCategoryInfo)
+	query := NewQuery(tx.Model(PartnerCategoryInfoModel), queryOptions)
+	query.SetWhere("id = ?", "id")
+	if err := query.First(); err != nil {
+		return nil, fmt.Errorf("query row not found")
+	}
+	if PartnerCategoryInfoModel.Id == 0 {
+		return nil, fmt.Errorf("query row not found")
+	}
+	return repository.transformPgModelToDomainModel(PartnerCategoryInfoModel)
+}
+
+func (repository *PartnerCategoryInfoRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.PartnerCategoryInfo, error) {
+	tx := repository.transactionContext.PgTx
+	var PartnerCategoryInfoModels []*models.PartnerCategoryInfo
+	PartnerCategoryInfos := make([]*domain.PartnerCategoryInfo, 0)
+	query := NewQuery(tx.Model(&PartnerCategoryInfoModels), queryOptions).
+		SetOrder("create_time", "sortByCreateTime").
+		SetOrder("update_time", "sortByUpdateTime")
+	var err error
+	if query.AffectRow, err = query.SelectAndCount(); err != nil {
+		return 0, PartnerCategoryInfos, err
+	}
+	for _, PartnerCategoryInfoModel := range PartnerCategoryInfoModels {
+		if PartnerCategoryInfo, err := repository.transformPgModelToDomainModel(PartnerCategoryInfoModel); err != nil {
+			return 0, PartnerCategoryInfos, err
+		} else {
+			PartnerCategoryInfos = append(PartnerCategoryInfos, PartnerCategoryInfo)
+		}
+	}
+	return int64(query.AffectRow), PartnerCategoryInfos, nil
+}
+
+func (repository *PartnerCategoryInfoRepository) transformPgModelToDomainModel(PartnerCategoryInfoModel *models.PartnerCategoryInfo) (*domain.PartnerCategoryInfo, error) {
+	m := &domain.PartnerCategoryInfo{}
+	err := GobModelTransform(m, PartnerCategoryInfoModel)
+	return m, err
+}
+
+func NewPartnerCategoryInfoRepository(transactionContext *transaction.TransactionContext) (*PartnerCategoryInfoRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &PartnerCategoryInfoRepository{transactionContext: transactionContext}, nil
+}

+package repository
+
+import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/pg/transaction"
+	. "gitlab.fjmaimaimai.com/mmm-go/partner/pkg/infrastructure/utils"
+)
+
+type UsersRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func (repository *UsersRepository) Save(dm *domain.Users) (*domain.Users, error) {
+	var (
+		err error
+		m   = &models.Users{}
+		tx  = repository.transactionContext.PgTx
+	)
+	if err = GobModelTransform(m, dm); err != nil {
+		return nil, err
+	}
+	if dm.Identify() == nil {
+		if err = tx.Insert(m); err != nil {
+			return nil, err
+		}
+		return dm, nil
+	}
+	if err = tx.Update(m); err != nil {
+		return nil, err
+	}
+	return dm, nil
+}
+
+func (repository *UsersRepository) Remove(Users *domain.Users) (*domain.Users, error) {
+	var (
+		tx         = repository.transactionContext.PgTx
+		UsersModel = &models.Users{Id: Users.Identify().(int64)}
+	)
+	if _, err := tx.Model(UsersModel).Where("id = ?", Users.Id).Delete(); err != nil {
+		return Users, err
+	}
+	return Users, nil
+}
+
+func (repository *UsersRepository) FindOne(queryOptions map[string]interface{}) (*domain.Users, error) {
+	tx := repository.transactionContext.PgTx
+	UsersModel := new(models.Users)
+	query := NewQuery(tx.Model(UsersModel), queryOptions)
+	query.SetWhere("id = ?", "id")
+	if err := query.First(); err != nil {
+		return nil, fmt.Errorf("query row not found")
+	}
+	if UsersModel.Id == 0 {
+		return nil, fmt.Errorf("query row not found")
+	}
+	return repository.transformPgModelToDomainModel(UsersModel)
+}
+
+func (repository *UsersRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.Users, error) {
+	tx := repository.transactionContext.PgTx
+	var UsersModels []*models.Users
+	Userss := make([]*domain.Users, 0)
+	query := NewQuery(tx.Model(&UsersModels), queryOptions).
+		SetOrder("create_time", "sortByCreateTime").
+		SetOrder("update_time", "sortByUpdateTime")
+	var err error
+	if query.AffectRow, err = query.SelectAndCount(); err != nil {
+		return 0, Userss, err
+	}
+	for _, UsersModel := range UsersModels {
+		if Users, err := repository.transformPgModelToDomainModel(UsersModel); err != nil {
+			return 0, Userss, err
+		} else {
+			Userss = append(Userss, Users)
+		}
+	}
+	return int64(query.AffectRow), Userss, nil
+}
+
+func (repository *UsersRepository) transformPgModelToDomainModel(UsersModel *models.Users) (*domain.Users, error) {
+	m := &domain.Users{}
+	err := GobModelTransform(m, UsersModel)
+	return m, err
+}
+
+func NewUsersRepository(transactionContext *transaction.TransactionContext) (*UsersRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &UsersRepository{transactionContext: transactionContext}, nil
+}