Merge branch 'test'

@@ -68,6 +68,16 @@ spec:
               value: "1"
               value: "1"
             - name: ERROR_BASE_CODE_MULTIPLE
             - name: ERROR_BASE_CODE_MULTIPLE
               value: "1000"
               value: "1000"
+            - name: UCENTER_HOST
+              value: "https://suplus-ucenter-dev.fjmaimaimai.com"
+            - name: UCENTER_SECRET
+              value: "cykbjnfqgctn"
+            - name: UCENTER_APP_KEY
+              value: "39aefef9e22744a3b2d2d3791824ae7b"
+            - name: UCENTER_CHECK_ALT
+              value: "6DwjBO735"
+            - name: BUSINESS_ADMIN_HOST
+              value: "http://suplus-business-admin-dev.fjmaimaimai.com"
       volumes:
       volumes:
         - name: accesslogs
         - name: accesslogs
           emptyDir: {}
           emptyDir: {}

@@ -65,10 +65,16 @@ spec:
               value: "1"
               value: "1"
             - name: ERROR_BASE_CODE_MULTIPLE
             - name: ERROR_BASE_CODE_MULTIPLE
               value: "1000"
               value: "1000"
-            - name: ABILITY_SERVICE_HOST
-              value: "https://ability.fjmaimaimai.com"
-            - name: MMM_OPEN_API_SERVICE_HOST
-              value: "https://public-interface.fjmaimaimai.com/openapi"
+            - name: UCENTER_HOST
+              value: "https://public-interface.fjmaimaimai.com/ucenter"
+            - name: UCENTER_SECRET
+              value: "cykbjnfqgctn"
+            - name: UCENTER_APP_KEY
+              value: "39aefef9e22744a3b2d2d3791824ae7b"
+            - name: UCENTER_CHECK_ALT
+              value: "rsF0pL!6DwjBO735"
+            - name: BUSINESS_ADMIN_HOST
+              value: "http://suplus-business-admin-prd.fjmaimaimai.com"
       volumes:
       volumes:
         - name: accesslogs
         - name: accesslogs
           emptyDir: {}
           emptyDir: {}

@@ -65,6 +65,16 @@ spec:
               value: "1"
               value: "1"
             - name: ERROR_BASE_CODE_MULTIPLE
             - name: ERROR_BASE_CODE_MULTIPLE
               value: "1000"
               value: "1000"
+            - name: UCENTER_HOST
+              value: "https://suplus-ucenter-test.fjmaimaimai.com"
+            - name: UCENTER_SECRET
+              value: "cykbjnfqgctn"
+            - name: UCENTER_APP_KEY
+              value: "39aefef9e22744a3b2d2d3791824ae7b"
+            - name: UCENTER_CHECK_ALT
+              value: "rsF0pL!6DwjBO735"
+            - name: BUSINESS_ADMIN_HOST
+              value: "http://suplus-business-admin-test.fjmaimaimai.com"
       volumes:
       volumes:
         - name: accesslogs
         - name: accesslogs
           emptyDir: {}
           emptyDir: {}

@@ -7,7 +7,7 @@ import (
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 )
 )
 
 
-//AdminUserService 管理员相关服务
+//AdminPermissionService 管理员权限
 type AdminPermissionService struct {
 type AdminPermissionService struct {
 }
 }
 
 
@@ -39,12 +39,10 @@ func (adminPermissionSrv AdminPermissionService) ListAdminPermission(queryOption
 	} else {
 	} else {
 		permissionRepository = value
 		permissionRepository = value
 	}
 	}
-	permissions, err = permissionRepository.Find(domain.AdminPermissionFindQuery{
-		NotCode:  queryOption.NotCode,
-		ParentId: queryOption.ParentId,
-	})
+	permissions, err = permissionRepository.Find(domain.PermissionFindOption{})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	err = transactionContext.CommitTransaction()
 	return permissions, nil
 	return permissions, nil
 }
 }

-package command
-
-import (
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
-)
-
-type SaveAdminUserCommand struct {
-	Id int64 `json:"id"`
-	// 员工姓名
-	Name string `json:"name"`
-	// 员工账号
-	Account string `json:"account" `
-	//密码
-	Password string `json:"password"`
-	// 员工角色
-	PermissionId []int `json:"PermissionId"`
-
-	IsUsable bool `json:"isUsable"`
-}
-
-func (command SaveAdminUserCommand) ValidateCommand() error {
-	if len(command.Name) == 0 {
-		return lib.ThrowError(lib.ARG_ERROR, "用户名称必填")
-	}
-	if len(command.Account) == 0 {
-		return lib.ThrowError(lib.ARG_ERROR, "账号必填")
-	}
-	return nil
-}

-package command
-
-import "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
-
-//UpdateAdminUserPwdCommand 修改密码
-type UpdateAdminUserPwdCommand struct {
-	Id int64 `json:"id"`
-	//密码
-	Password string `json:"password"`
-}
-
-func (command UpdateAdminUserPwdCommand) ValidateCommand() error {
-	if len(command.Password) == 0 {
-		return lib.ThrowError(lib.ARG_ERROR, "密码必填")
-	}
-	return nil
-}

-package service
-
-import (
-	"crypto/sha1"
-	"fmt"
-
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/command"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
-)
-
-//AdminUserService 管理员相关服务
-type AdminUserService struct {
-}
-
-func NewAdminUserService(option map[string]interface{}) *AdminUserService {
-	newAdminUserService := new(AdminUserService)
-	return newAdminUserService
-}
-
-func (adminUserSrv AdminUserService) GetAdminUser(getAdminUserQuery *query.GetAdminUserQuery) (*domain.AdminUser, error) {
-	//实际业务
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	var (
-		adminuserRepository domain.AdminUserRepository
-		adminuser           *domain.AdminUser
-	)
-	if value, err := factory.CreateAdminUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		adminuserRepository = value
-	}
-	adminuser, err = adminuserRepository.FindOne(domain.AdminUserFindOneQuery{
-		AccountEqual: getAdminUserQuery.AdminAccount,
-		AdminUserId:  getAdminUserQuery.Id,
-	})
-	if err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	return adminuser, nil
-}
-
-func (adminUserSrv AdminUserService) SaveAdminUser(saveUserCmd *command.SaveAdminUserCommand) (*domain.AdminUser, error) {
-	if err := saveUserCmd.ValidateCommand(); err != nil {
-		return nil, lib.ThrowError(lib.ARG_ERROR, err.Error())
-	}
-	//实际业务
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	var (
-		adminuserRepository domain.AdminUserRepository
-		adminuser           *domain.AdminUser
-	)
-	if value, err := factory.CreateAdminUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		adminuserRepository = value
-	}
-
-	//获取权限
-	var (
-		permissionRepository domain.AdminPermissionRepository
-		permissions          []domain.AdminPermission
-	)
-	if value, err := factory.CreateAdminPermissionRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		permissionRepository = value
-	}
-	permissions, err = permissionRepository.Find(domain.AdminPermissionFindQuery{
-		IdsIn: saveUserCmd.PermissionId,
-	})
-	if err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	for i := range permissions {
-		if permissions[i].Code == domain.PERMINSSION_ADMIN_USER {
-			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "操作异常")
-		}
-	}
-	permissionBases := []domain.AdminPermissionBase{}
-
-	for i := range permissions {
-		p := domain.AdminPermissionBase{
-			Id: permissions[i].Id, Code: permissions[i].Code,
-		}
-		permissionBases = append(permissionBases, p)
-	}
-	//账号是否有变更
-	var accountChange bool
-	if saveUserCmd.Id > 0 {
-		//更新数据
-		adminuser, err = adminuserRepository.FindOne(domain.AdminUserFindOneQuery{
-			AdminUserId: saveUserCmd.Id,
-		})
-		if err != nil {
-			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-		}
-		if adminuser.Account != saveUserCmd.Account {
-			accountChange = true
-		}
-		adminuser.Account = saveUserCmd.Account
-		adminuser.AdminName = saveUserCmd.Name
-		adminuser.IsUsable = saveUserCmd.IsUsable
-		if !adminuser.IsDefault {
-			adminuser.Permission = permissionBases
-		}
-
-	} else {
-		//添加新数据
-		accountChange = true
-		defaultPwd := fmt.Sprintf("%x", sha1.Sum([]byte("123456")))
-		adminuser = &domain.AdminUser{
-			Id:         saveUserCmd.Id,
-			Account:    saveUserCmd.Account,
-			Password:   defaultPwd,
-			AdminName:  saveUserCmd.Name,
-			IsUsable:   saveUserCmd.IsUsable,
-			Permission: permissionBases,
-		}
-	}
-	if accountChange {
-		//检查账号是否已存在
-		var (
-			adminuserDao *dao.AdminUserDao
-		)
-		if v, err := factory.CreateAdminUserkDao(map[string]interface{}{
-			"transactionContext": transactionContext,
-		}); err != nil {
-			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-		} else {
-			adminuserDao = v
-		}
-		ok, err := adminuserDao.AdminUserAccountExist(saveUserCmd.Account)
-		if err != nil {
-			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-		}
-		if ok {
-			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "账号已存在")
-		}
-	}
-
-	adminuser, err = adminuserRepository.Save(*adminuser)
-	if err != nil {
-		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	transactionContext.CommitTransaction()
-	return adminuser, nil
-}
-
-func (adminUserSrv AdminUserService) PageListAdminUser(listAdminUserQuery *query.ListAdminUserQuery) ([]domain.AdminUser, int, error) {
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return nil, 0, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	var (
-		adminuserRepository domain.AdminUserRepository
-		adminusers          []domain.AdminUser
-		cnt                 int
-	)
-	if value, err := factory.CreateAdminUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		adminuserRepository = value
-	}
-	adminusers, err = adminuserRepository.Find(domain.AdminUserFindQuery{
-		AccountLike: listAdminUserQuery.AdminAccountMatch,
-		Offset:      listAdminUserQuery.Offset,
-		Limit:       listAdminUserQuery.Limit,
-	})
-	if err != nil {
-		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	cnt, err = adminuserRepository.CountAll(domain.AdminUserFindQuery{
-		AccountLike: listAdminUserQuery.AdminAccountMatch,
-	})
-	if err != nil {
-		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	return adminusers, cnt, nil
-}
-
-func (adminUserSrv AdminUserService) UpdateAdminPassword(updatecmd command.UpdateAdminUserPwdCommand) error {
-	if err := updatecmd.ValidateCommand(); err != nil {
-		return lib.ThrowError(lib.ARG_ERROR, err.Error())
-	}
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-
-	var (
-		adminuserDao *dao.AdminUserDao
-	)
-	if v, err := factory.CreateAdminUserkDao(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	} else {
-		adminuserDao = v
-	}
-	err = adminuserDao.UpdatePassword(updatecmd.Id, updatecmd.Password)
-	if err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	transactionContext.CommitTransaction()
-	return nil
-}
-
-func (adminUserSrv AdminUserService) UpdateAdminIsUsable(uid int64, isUsable bool) error {
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	defer func() {
-		transactionContext.RollbackTransaction()
-	}()
-	var (
-		adminuserDao *dao.AdminUserDao
-	)
-	if v, err := factory.CreateAdminUserkDao(map[string]interface{}{
-		"transactionContext": transactionContext,
-	}); err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	} else {
-		adminuserDao = v
-	}
-	if ok, err := adminuserDao.AdminUserIsDefault(uid); err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	} else if ok {
-		return lib.ThrowError(lib.BUSINESS_ERROR, "请勿禁用超级管理员")
-	}
-	err = adminuserDao.UpdateIsUsable(uid, isUsable)
-	if err != nil {
-		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	}
-	transactionContext.CommitTransaction()
-	return nil
-}

+package command
+
+type UpdateBusinessBonusCommand struct {
+	Id          int64   `json:"id"`
+	Bonus       float64 `json:"bonus"`
+	BonusStatus int8    `json:"bonusStatus"`
+	CompanyId   int64   `json:"companyId"`
+}
+
+func (cmd UpdateBusinessBonusCommand) ValidateCommand() error {
+	return nil
+}

+package query
+
+type GetBusinessBonusQuery struct {
+	Id        int64 `json:"id"`
+	CompanyId int64 `json:"companyId"`
+}

+package query
+
+type ListBusinessBonusQuery struct {
+
+	//用户名称匹配
+	PartnerNameMatch string `json:"userNameMatch" `
+	// 查询偏离量
+	Offset int `json:"offset" `
+	// 查询限制
+	Limit     int   `json:"limit"`
+	PartnerId int64 `json:"partnerId"`
+	CompanyId int64 `json:"companyId"`
+}

+package service
+
+import (
+	"fmt"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/command"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/query"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+type BusinessBonusService struct {
+}
+
+func NewBusinessBonusService(option map[string]interface{}) *BusinessBonusService {
+	newService := new(BusinessBonusService)
+	return newService
+}
+
+// ListBusinessBonus 列表
+func (srv BusinessBonusService) ListBusinessBonus(queryOption query.ListBusinessBonusQuery) (int, interface{}, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return 0, nil, err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+
+	var (
+		bonusDaoao *dao.BusinessBonusDao
+	)
+	if bonusDaoao, err = factory.CreateBusinessBonusDao(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	result, err := bonusDaoao.SearchBusinessBonus(queryOption.PartnerId, queryOption.PartnerNameMatch,
+		queryOption.CompanyId, queryOption.Limit, queryOption.Offset)
+	if err != nil {
+		return 0, nil, err
+	}
+	cnt, err := bonusDaoao.CountBusinessBonus(queryOption.PartnerId, queryOption.PartnerNameMatch,
+		queryOption.CompanyId, queryOption.Limit, queryOption.Offset)
+	if err != nil {
+		return 0, nil, err
+	}
+	err = transactionContext.CommitTransaction()
+
+	returnData := []map[string]interface{}{}
+	for _, v := range result {
+		m := map[string]interface{}{
+			"id":                   v.Id,
+			"uncollectedDividends": v.BonusNot,
+			"receiveDividends":     v.BonusHas,
+			"dividendsReceivable":  v.Bonus,
+			"stateOfPayment":       v.BonusStatus,
+			"stateOfPaymentName":   domain.DescribeBusinessBonusStatus(v.BonusStatus),
+			"partner":              v.PartnerName,
+			"updateTime":           "",
+		}
+		if !v.UpdateAt.IsZero() {
+			m["updateTime"] = v.UpdateAt.Local().Format("2006-01-02 15:04:05")
+		}
+		returnData = append(returnData, m)
+	}
+	return cnt, returnData, nil
+}
+
+func (srv BusinessBonusService) UpdateBusinessBonus(cmd command.UpdateBusinessBonusCommand) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		bonusRespository domain.BusinessBonusRepository
+		bonusData        *domain.BusinessBonus
+	)
+	if bonusRespository, err = factory.CreateBusinessBonusRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	bonusData, err = bonusRespository.FindOne(domain.BusinessBonusFindOneQuery{
+		Id: cmd.Id, CompanyId: cmd.CompanyId,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取业务分红（id=%d;company_id=%d）数据失败:%s", cmd.Id, cmd.CompanyId, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	bonusData.Bonus = cmd.Bonus
+	switch cmd.BonusStatus {
+	case domain.BUSINESS_BONUS_HAS_PAY:
+		bonusData.BusinessBonusPayStatus.PayPartnerBonus(bonusData)
+	case domain.BUSINESS_BONUS_WAIT_PAY:
+		bonusData.BusinessBonusPayStatus.WartPayPartnerBonus(bonusData)
+	case domain.BUSINESS_BONUS_NULL_PAY:
+		bonusData.BusinessBonusPayStatus.NullPayPartnerBonus(bonusData)
+	default:
+		return lib.ThrowError(lib.BUSINESS_ERROR, "支付状态错误")
+	}
+	err = bonusRespository.Edit(bonusData)
+	if err != nil {
+		e := fmt.Sprintf("更新业务分红（id=%d）数据失败：%s", bonusData.Id, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}
+
+//GetBusinessBonus 获取详情
+func (srv BusinessBonusService) GetBusinessBonus(queryOption query.GetBusinessBonusQuery) (map[string]interface{}, error) {
+
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		bonusRespository      domain.BusinessBonusRepository
+		partnerInfoRepository domain.PartnerInfoRepository
+		bonusData             *domain.BusinessBonus
+		partnerData           *domain.PartnerInfo
+	)
+	if bonusRespository, err = factory.CreateBusinessBonusRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	bonusData, err = bonusRespository.FindOne(domain.BusinessBonusFindOneQuery{
+		Id: queryOption.Id, CompanyId: queryOption.CompanyId,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取业务分红（id=%d;company_id=%d）数据失败:%s", queryOption.Id, queryOption.CompanyId, err)
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	partnerData, err = partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: bonusData.PartnerInfoId})
+	if err != nil {
+		e := fmt.Sprintf("获取合伙人(id=%d)数据失败：%s", bonusData.PartnerInfoId, err)
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	err = transactionContext.CommitTransaction()
+	returnData := map[string]interface{}{
+		"partner":              partnerData.Partner.PartnerName,
+		"dividendsReceivable":  bonusData.Bonus,
+		"receiveDividends":     bonusData.BonusHas,
+		"uncollectedDividends": bonusData.BonusNot,
+		"updateTime":           "",
+		"stateOfPayment":       bonusData.BonusStatus,
+		"stateOfPaymentName":   domain.DescribeBusinessBonusStatus(bonusData.BonusStatus),
+		"id":                   bonusData.Id,
+	}
+	if !bonusData.UpdateAt.IsZero() {
+		returnData["updateTime"] = bonusData.UpdateAt.Local().Format("2006-01-02 15:04:05")
+	}
+
+	return returnData, nil
+}

+package service
+
+import (
+	"fmt"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+type CompanyService struct{}
+
+func NewCompanyService(options map[string]interface{}) *CompanyService {
+	newCompanyService := &CompanyService{}
+	return newCompanyService
+}
+
+//AllowCompany 公司启用合伙人功能
+func (service CompanyService) AllowCompany(companyId int64) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		oldCompanyData     domain.Company
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	oldCompanyData, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		Id: companyId,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = oldCompanyData.Update(map[string]interface{}{
+		"Enable": domain.CompanyEnableYes,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	//更新公司数据
+	err = companyRespository.Edit(&oldCompanyData)
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("更新公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}
+
+//ForbidCompany 公司禁用合伙人功能
+func (service CompanyService) ForbidCompany(companyId int64) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		oldCompanyData     domain.Company
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	oldCompanyData, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		Id: companyId,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = oldCompanyData.Update(map[string]interface{}{
+		"Enable": domain.CompanyEnableNo,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	//更新公司数据
+	err = companyRespository.Edit(&oldCompanyData)
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("更新公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}
+
+//GetCompanyData 获取公司数据
+func (service CompanyService) GetCompanyData(companyId int64) (*domain.Company, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		companyData        domain.Company
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	companyData, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		Id: companyId,
+	})
+	if err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = transactionContext.CommitTransaction()
+	return &companyData, nil
+}
+
+func (service CompanyService) UpdateCompanyPhone(companyId int64, phone string) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		companyData        domain.Company
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	companyData, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		Id: companyId,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	companyData.Phone = phone
+	err = companyRespository.Edit(&companyData)
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("更新公司(id=%d)的数据失败:%s", companyId, err.Error()))
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}

@@ -5,26 +5,34 @@ import (
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
 )
 )
 
 
-func CreateAdminUserkDao(options map[string]interface{}) (*dao.AdminUserDao, error) {
+func CreatePartnerInfoDao(options map[string]interface{}) (*dao.PartnerInfoDao, error) {
 	var transactionContext *transaction.TransactionContext
 	var transactionContext *transaction.TransactionContext
 	if value, ok := options["transactionContext"]; ok {
 	if value, ok := options["transactionContext"]; ok {
 		transactionContext = value.(*transaction.TransactionContext)
 		transactionContext = value.(*transaction.TransactionContext)
 	}
 	}
-	return dao.NewAdminUserDao(transactionContext)
+	return dao.NewPartnerInfoDao(transactionContext)
 }
 }
 
 
-func CreatePartnerInfoDao(options map[string]interface{}) (*dao.PartnerInfoDao, error) {
+func CreateOrderBaseDao(options map[string]interface{}) (*dao.OrderBaseDao, error) {
 	var transactionContext *transaction.TransactionContext
 	var transactionContext *transaction.TransactionContext
 	if value, ok := options["transactionContext"]; ok {
 	if value, ok := options["transactionContext"]; ok {
 		transactionContext = value.(*transaction.TransactionContext)
 		transactionContext = value.(*transaction.TransactionContext)
 	}
 	}
-	return dao.NewPartnerInfoDao(transactionContext)
+	return dao.NewOrderBaseDao(transactionContext)
 }
 }
 
 
-func CreateOrderBaseDao(options map[string]interface{}) (*dao.OrderBaseDao, error) {
+func CreateUsersDao(options map[string]interface{}) (*dao.UsersDao, error) {
 	var transactionContext *transaction.TransactionContext
 	var transactionContext *transaction.TransactionContext
 	if value, ok := options["transactionContext"]; ok {
 	if value, ok := options["transactionContext"]; ok {
 		transactionContext = value.(*transaction.TransactionContext)
 		transactionContext = value.(*transaction.TransactionContext)
 	}
 	}
-	return dao.NewOrderBaseDao(transactionContext)
+	return dao.NewUsersDao(transactionContext)
+}
+
+func CreateBusinessBonusDao(options map[string]interface{}) (*dao.BusinessBonusDao, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return dao.NewBusinessBonusDao(transactionContext)
 }
 }

+package factory
+
+import (
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain/service"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/domainService"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
+)
+
+func CreateBusinessBonusService(options map[string]interface{}) (service.BusinessBonusService, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return domainService.NewBusinessBonusService(transactionContext), nil
+}

@@ -15,15 +15,6 @@ func CreatePartnerInfoRepository(options map[string]interface{}) (domain.Partner
 	return repository.NewPartnerInfoRepository(transactionContext)
 	return repository.NewPartnerInfoRepository(transactionContext)
 }
 }
 
 
-//CreateAdminUserRepository 管理员信息
-func CreateAdminUserRepository(options map[string]interface{}) (domain.AdminUserRepository, error) {
-	var transactionContext *transaction.TransactionContext
-	if value, ok := options["transactionContext"]; ok {
-		transactionContext = value.(*transaction.TransactionContext)
-	}
-	return repository.NewAdminUserRepository(transactionContext)
-}
-
 //CreateAdminUserRepository 管理员权限信息
 //CreateAdminUserRepository 管理员权限信息
 func CreateAdminPermissionRepository(options map[string]interface{}) (domain.AdminPermissionRepository, error) {
 func CreateAdminPermissionRepository(options map[string]interface{}) (domain.AdminPermissionRepository, error) {
 	var transactionContext *transaction.TransactionContext
 	var transactionContext *transaction.TransactionContext
@@ -50,3 +41,39 @@ func CreateOrderGoodRepository(options map[string]interface{}) (domain.OrderGood
 	}
 	}
 	return repository.NewOrderGoodRepository(transactionContext)
 	return repository.NewOrderGoodRepository(transactionContext)
 }
 }
+
+//CreateOrderGoodRepository 订单信息
+func CreateUsersRepository(options map[string]interface{}) (domain.UsersRepository, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return repository.NewUsersRepository(transactionContext)
+}
+
+// CreateUsersRepository 公司企业信息
+func CreateCompanyRepository(options map[string]interface{}) (domain.CompanyRepository, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return repository.NewCompanyRepository(transactionContext)
+}
+
+// CreatePartnerCategoryRepository 合伙人分类数据
+func CreatePartnerCategoryRepository(options map[string]interface{}) (domain.PartnerCategoryRepository, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return repository.NewPartnerCategoryRepository(transactionContext)
+}
+
+// CreateBusinessBonusRepository 业务分红
+func CreateBusinessBonusRepository(options map[string]interface{}) (domain.BusinessBonusRepository, error) {
+	var transactionContext *transaction.TransactionContext
+	if value, ok := options["transactionContext"]; ok {
+		transactionContext = value.(*transaction.TransactionContext)
+	}
+	return repository.NewBusinessBonusRepository(transactionContext)
+}

@@ -17,4 +17,5 @@ type CreateOrderCommand struct {
 	SalesmanBonusPercent float64 `json:"salesmanBonusPercent"`
 	SalesmanBonusPercent float64 `json:"salesmanBonusPercent"`
 	//货品
 	//货品
 	Goods     []OrderGoodData `json:"goods"`
 	Goods     []OrderGoodData `json:"goods"`
+	CompanyId int64           `json:"companyId"`
 }
 }

@@ -5,4 +5,5 @@ type DisableOrderCommand struct {
 	OrderId   int64 `json:"orderId"`
 	OrderId   int64 `json:"orderId"`
 	IsDisable int   `json:"isDisable"`
 	IsDisable int   `json:"isDisable"`
 	OrderType int   `json:"orderType"`
 	OrderType int   `json:"orderType"`
+	CompanyId int64 `json:"companyId"`
 }
 }

@@ -7,4 +7,5 @@ type OrderDeliveryCommand struct {
 	DeliveryTime time.Time       `json:"deliveryTime"`
 	DeliveryTime time.Time       `json:"deliveryTime"`
 	DeliveryCode string          `json:"deliveryCode"`
 	DeliveryCode string          `json:"deliveryCode"`
 	Goods        []OrderGoodData `json:"goods"`
 	Goods        []OrderGoodData `json:"goods"`
+	CompanyId    int64
 }
 }

@@ -4,6 +4,7 @@ package command
 type UpdateGoodBouns struct {
 type UpdateGoodBouns struct {
 	Id        int64       `json:"id"` //订单id
 	Id        int64       `json:"id"` //订单id
 	GoodBouns []GoodBouns `json:"goodBouns"`
 	GoodBouns []GoodBouns `json:"goodBouns"`
+	CompanyId int64       `json:"companyId"`
 }
 }
 
 
 //GoodBoun 商品数量调整
 //GoodBoun 商品数量调整

@@ -19,4 +19,5 @@ type UpdateOrderCommand struct {
 	OrderType int `json:"orderType"`
 	OrderType int `json:"orderType"`
 	//货品
 	//货品
 	Goods     []OrderGoodData `json:"goods"`
 	Goods     []OrderGoodData `json:"goods"`
+	CompanyId int64           `json:"companyId"`
 }
 }

@@ -3,4 +3,5 @@ package query
 //GetOrderQuery 获取订单详情
 //GetOrderQuery 获取订单详情
 type GetOrderQuery struct {
 type GetOrderQuery struct {
 	OrderId   int64 `json:"orderId"`
 	OrderId   int64 `json:"orderId"`
+	CompanyId int64 `json:"companyId"`
 }
 }

@@ -14,4 +14,5 @@ type ListOrderBaseQuery struct {
 	OrderType int `json:"orderType"`
 	OrderType int `json:"orderType"`
 	//发货单号
 	//发货单号
 	DeliveryCode string `json:"deliveryCode"`
 	DeliveryCode string `json:"deliveryCode"`
+	CompanyId    int64  `json:"companyId"`
 }
 }

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"fmt"
 	"time"
 	"time"
 
 
+	"github.com/astaxie/beego/logs"
+
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/command"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/command"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/query"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/orderinfo/query"
@@ -27,11 +29,18 @@ func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrder
 	if err != nil {
 	if err != nil {
 		return nil, 0, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return nil, 0, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, 0, err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
 	var (
 	var (
 		orderRepository domain.OrderBaseRepository
 		orderRepository domain.OrderBaseRepository
 		orders          []domain.OrderBase
 		orders          []domain.OrderBase
 		cnt             int
 		cnt             int
 	)
 	)
+
 	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
 	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
@@ -46,6 +55,7 @@ func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrder
 		Limit:        listOrderQuery.Limit,
 		Limit:        listOrderQuery.Limit,
 		OrderType:    listOrderQuery.OrderType,
 		OrderType:    listOrderQuery.OrderType,
 		DeliveryCode: listOrderQuery.DeliveryCode,
 		DeliveryCode: listOrderQuery.DeliveryCode,
+		CompanyId:    listOrderQuery.CompanyId,
 	}
 	}
 	orders, cnt, err = orderRepository.Find(query)
 	orders, cnt, err = orderRepository.Find(query)
 	if err != nil {
 	if err != nil {
@@ -58,15 +68,17 @@ func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrder
 		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 	for i := range orders {
 	for i := range orders {
-		var partnerData *domain.PartnerInfo
+		partnerData := &domain.PartnerInfo{}
 		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
 		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
 			UserId: orders[i].PartnerId,
 			UserId: orders[i].PartnerId,
 		})
 		})
 		if err != nil {
 		if err != nil {
-			return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-		}
+			logs.Error("获取合伙(id=%d)失败%s", orders[i].PartnerId, err)
+		} else {
 			orders[i].PartnerInfo = partnerData.Partner
 			orders[i].PartnerInfo = partnerData.Partner
 		}
 		}
+	}
+	transactionContext.CommitTransaction()
 	return orders, cnt, nil
 	return orders, cnt, nil
 }
 }
 
 
@@ -79,7 +91,7 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
 	}
 	}
 	var (
 	var (
 		orderBaseRepository   domain.OrderBaseRepository
 		orderBaseRepository   domain.OrderBaseRepository
-		PartnerInfoRepository domain.PartnerInfoRepository
+		partnerInfoRepository domain.PartnerInfoRepository
 		orderGoodRepository   domain.OrderGoodRepository
 		orderGoodRepository   domain.OrderGoodRepository
 		order                 *domain.OrderBase
 		order                 *domain.OrderBase
 	)
 	)
@@ -89,14 +101,12 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
 	defer func() {
 	defer func() {
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
 	}()
 	}()
-	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
+	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	} else {
-		orderBaseRepository = value
 	}
 	}
-	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
@@ -108,6 +118,7 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
 	}
 	}
 	order, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	order, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 		OrderId:   getOrderQuery.OrderId,
 		OrderId:   getOrderQuery.OrderId,
+		CompanyId: getOrderQuery.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单数据失败：%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单数据失败：%s", err))
@@ -117,13 +128,17 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
 		goods       []domain.OrderGood
 		goods       []domain.OrderGood
 	)
 	)
 
 
-	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: order.PartnerId})
+	partnerData, err = partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
+		UserId:    order.PartnerId,
+		CompanyId: getOrderQuery.CompanyId,
+	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败：%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败：%s", err))
 	}
 	}
 	order.PartnerInfo = partnerData.Partner
 	order.PartnerInfo = partnerData.Partner
 	goods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 	goods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 		OrderId:   order.Id,
 		OrderId:   order.Id,
+		CompanyId: getOrderQuery.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单中的商品列表失败：%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单中的商品列表失败：%s", err))
@@ -188,7 +203,7 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
 	// }
 	// }
 	//检查delivery_code是否重复
 	//检查delivery_code是否重复
 	if len(cmd.DeliveryCode) > 0 {
 	if len(cmd.DeliveryCode) > 0 {
-		if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode); err != nil {
+		if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode, cmd.CompanyId); err != nil {
 			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		} else if ok {
 		} else if ok {
 			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
 			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
@@ -197,15 +212,16 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
 	newOrder := &domain.OrderBase{
 	newOrder := &domain.OrderBase{
 		OrderType: cmd.OrderType, OrderCode: cmd.OrderCode,
 		OrderType: cmd.OrderType, OrderCode: cmd.OrderCode,
 		DeliveryCode: cmd.DeliveryCode,
 		DeliveryCode: cmd.DeliveryCode,
-		Buyer: &domain.Buyer{
+		Buyer: domain.Buyer{
 			BuyerName: cmd.BuyerName,
 			BuyerName: cmd.BuyerName,
 		},
 		},
-		RegionInfo: &domain.RegionInfo{
+		RegionInfo: domain.RegionInfo{
 			RegionName: cmd.OrderRegion,
 			RegionName: cmd.OrderRegion,
 		},
 		},
 		PartnerId:            cmd.PartnerId,
 		PartnerId:            cmd.PartnerId,
 		PartnerInfo:          partnerData.Partner,
 		PartnerInfo:          partnerData.Partner,
 		SalesmanBonusPercent: cmd.SalesmanBonusPercent,
 		SalesmanBonusPercent: cmd.SalesmanBonusPercent,
+		CompanyId:            cmd.CompanyId,
 	}
 	}
 	var orderGoods []domain.OrderGood
 	var orderGoods []domain.OrderGood
 	for _, good := range cmd.Goods {
 	for _, good := range cmd.Goods {
@@ -216,6 +232,7 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
 		m.Price = good.Price
 		m.Price = good.Price
 		m.PartnerBonusPercent = good.PartnerBonusPercent
 		m.PartnerBonusPercent = good.PartnerBonusPercent
 		m.Remark = good.Remark
 		m.Remark = good.Remark
+		m.CompanyId = cmd.CompanyId
 		err = m.Compute()
 		err = m.Compute()
 		if err != nil {
 		if err != nil {
 			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
 			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
@@ -251,7 +268,7 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
 }
 }
 
 
 //DeleteOrder 删除订单
 //DeleteOrder 删除订单
-func (service OrderInfoService) DeleteOrder(orderId int64) error {
+func (service OrderInfoService) DeleteOrder(orderId int64, companyId int64) error {
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		err                   error
 		err                   error
@@ -276,11 +293,11 @@ func (service OrderInfoService) DeleteOrder(orderId int64) error {
 	}); err != nil {
 	}); err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
-	err = orderBaseRepository.Remove(orderId)
+	err = orderBaseRepository.Remove(orderId, companyId)
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单数据失败：%s", err))
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单数据失败：%s", err))
 	}
 	}
-	err = orderGoodRepository.Remove(orderId)
+	err = orderGoodRepository.Remove(orderId, companyId)
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中商品数据失败：%s", err))
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中商品数据失败：%s", err))
 	}
 	}
@@ -312,7 +329,9 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 	var partnerData *domain.PartnerInfo
 	var partnerData *domain.PartnerInfo
-	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: cmd.PartnerId})
+	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
+		UserId: cmd.PartnerId, CompanyId: cmd.CompanyId,
+	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
 	}
 	}
@@ -338,6 +357,7 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 	//获取旧的订单
 	//获取旧的订单
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 		OrderId:   cmd.Id,
 		OrderId:   cmd.Id,
+		CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
@@ -359,7 +379,7 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 	// }
 	// }
 	//检查delivery_code是否重复
 	//检查delivery_code是否重复
 	if len(cmd.DeliveryCode) > 0 {
 	if len(cmd.DeliveryCode) > 0 {
-		if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode, cmd.Id); err != nil {
+		if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode, cmd.CompanyId, cmd.Id); err != nil {
 			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 			return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		} else if ok {
 		} else if ok {
 			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
 			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
@@ -368,6 +388,7 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 	//获取旧的订单中的商品
 	//获取旧的订单中的商品
 	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 		OrderId:   cmd.Id,
 		OrderId:   cmd.Id,
+		CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
@@ -380,6 +401,7 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 		m.Price = good.Price
 		m.Price = good.Price
 		m.PartnerBonusPercent = good.PartnerBonusPercent
 		m.PartnerBonusPercent = good.PartnerBonusPercent
 		m.Remark = good.Remark
 		m.Remark = good.Remark
+		m.CompanyId = cmd.CompanyId
 		err = m.Compute()
 		err = m.Compute()
 		if err != nil {
 		if err != nil {
 			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
 			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
@@ -414,7 +436,7 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
 	oldOrderData.Goods = newOrderGoods
 	oldOrderData.Goods = newOrderGoods
 	//删不需要的订单总不需要的商品
 	//删不需要的订单总不需要的商品
 	delGoods = service.deleteOldOrderGoods(newOrderGoods, oldOrderGoods)
 	delGoods = service.deleteOldOrderGoods(newOrderGoods, oldOrderGoods)
-	err = orderGoodRepository.Remove(oldOrderData.Id, delGoods...)
+	err = orderGoodRepository.Remove(oldOrderData.Id, cmd.CompanyId, delGoods...)
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中的商品数据失败：%s", err))
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中的商品数据失败：%s", err))
 	}
 	}
@@ -474,6 +496,7 @@ func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) error
 	}
 	}
 	//获取旧的订单
 	//获取旧的订单
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
+		CompanyId: cmd.CompanyId,
 		OrderId:   cmd.OrderId,
 		OrderId:   cmd.OrderId,
 	})
 	})
 	if err != nil {
 	if err != nil {
@@ -488,7 +511,7 @@ func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) error
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	//检查delivery_code是否重复
 	//检查delivery_code是否重复
-	if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode, cmd.OrderId); err != nil {
+	if ok, err := orderBaseDao.DeliveryCodeExist(cmd.DeliveryCode, cmd.CompanyId, cmd.OrderId); err != nil {
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	} else if ok {
 	} else if ok {
 		return lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
 		return lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
@@ -496,6 +519,7 @@ func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) error
 	//获取旧的订单中的商品
 	//获取旧的订单中的商品
 	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
 		OrderId:   cmd.OrderId,
 		OrderId:   cmd.OrderId,
+		CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
@@ -568,6 +592,7 @@ func (service OrderInfoService) DisableOrEnable(cmd command.DisableOrderCommand)
 	//获取旧的订单
 	//获取旧的订单
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 		OrderId:   cmd.OrderId,
 		OrderId:   cmd.OrderId,
+		CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
@@ -618,6 +643,7 @@ func (service OrderInfoService) UpdateGoodBouns(cmd command.UpdateGoodBouns) err
 	//获取旧的订单
 	//获取旧的订单
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 		OrderId:   cmd.Id,
 		OrderId:   cmd.Id,
+		CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))

 package query
 package query
 
 
-type GetAdminUserQuery struct {
-	Id           int64  `json:"id"`
-	AdminAccount string `json:"adminAccount"`
+type ListPartnerCategoryCommand struct {
 }
 }

+package service
+
+import (
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerCategory/query"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+type PartnerCategoryService struct {
+}
+
+func NewPartnerCategoryService(option map[string]interface{}) *PartnerCategoryService {
+	newService := new(PartnerCategoryService)
+	return newService
+}
+
+func (srv PartnerCategoryService) ListPartnerCategory(q query.ListPartnerCategoryCommand) (int, []domain.PartnerCategory, error) {
+	//实际业务
+	var err error
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		categoryRepository domain.PartnerCategoryRepository
+		categorys          []domain.PartnerCategory
+		cnt                int
+	)
+	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	cnt, categorys, err = categoryRepository.Find(domain.PartnerCategoryFindQuery{})
+	if err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	return cnt, categorys, nil
+}

@@ -16,25 +16,24 @@ type CreatePartnerInfoCommand struct {
 	Password string `json:"password,omitempty"`
 	Password string `json:"password,omitempty"`
 	// 状态（1：启用或者0：禁用）
 	// 状态（1：启用或者0：禁用）
 	Status int `json:"status"`
 	Status int `json:"status"`
-	// 合伙类别 （1.研发合伙人 2.业务合伙人  3.事业）
-	PartnerCategory int `json:"partnerCategory,omitempty"`
+	// 合伙类别
+	PartnerCategory []int64 `json:"partnerCategory,omitempty"`
 	//合作时间
 	//合作时间
 	CooperateTime time.Time `json:"cooperateTime"`
 	CooperateTime time.Time `json:"cooperateTime"`
 	// 区域
 	// 区域
 	RegionInfo *domain.RegionInfo `json:"regionInfo"`
 	RegionInfo *domain.RegionInfo `json:"regionInfo"`
 	//关联业务员
 	//关联业务员
 	Salesman []domain.Salesman `json:"salesman,omitempty"`
 	Salesman []domain.Salesman `json:"salesman,omitempty"`
+	//公司id
+	CompanyId int64 `json:"companyId"`
 }
 }
 
 
 func (command CreatePartnerInfoCommand) ValidateCommand() error {
 func (command CreatePartnerInfoCommand) ValidateCommand() error {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 	}
 	}
-	if !(command.PartnerCategory == domain.PARTNER_CATEGORY_1 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_2 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_3 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_4) {
-		return lib.ThrowError(lib.ARG_ERROR, "合伙类别错误")
+	if len(command.PartnerCategory) == 0 {
+		return lib.ThrowError(lib.ARG_ERROR, "合伙类别必填")
 	}
 	}
 	if len(command.PartnerName) == 0 {
 	if len(command.PartnerName) == 0 {
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人名称必填")
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人名称必填")

@@ -7,16 +7,14 @@ import (
 
 
 type StatusPartnerInfoCommand struct {
 type StatusPartnerInfoCommand struct {
 	// 合伙人ID
 	// 合伙人ID
-	Id     int64 `json:"id"`
+	Ids       []int64 `json:"id"`
 	Status    int     `json:"status"`
 	Status    int     `json:"status"`
+	CompanyId int64   `json:"companyId"`
 }
 }
 
 
 func (command *StatusPartnerInfoCommand) ValidateCommand() error {
 func (command *StatusPartnerInfoCommand) ValidateCommand() error {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 	}
 	}
-	if command.Id == 0 {
-		return lib.ThrowError(lib.ARG_ERROR, "合伙人id错误")
-	}
 	return nil
 	return nil
 }
 }

@@ -13,25 +13,21 @@ type UpdatePartnerInfoCommand struct {
 	// 状态（1：启用或者0：禁用）
 	// 状态（1：启用或者0：禁用）
 	Status int `json:"status"`
 	Status int `json:"status"`
 	// 合伙类别 （1.研发合伙人 2.业务合伙人  3.事业）
 	// 合伙类别 （1.研发合伙人 2.业务合伙人  3.事业）
-	PartnerCategory int `json:"partnerCategory,omitempty"`
+	PartnerCategory []int64 `json:"partnerCategory,omitempty"`
 	// 区域
 	// 区域
 	RegionInfo *domain.RegionInfo `json:"regionInfo"`
 	RegionInfo *domain.RegionInfo `json:"regionInfo"`
 	//关联业务员
 	//关联业务员
 	Salesman []domain.Salesman `json:"salesman,omitempty"`
 	Salesman []domain.Salesman `json:"salesman,omitempty"`
 	//合作时间
 	//合作时间
 	CooperateTime time.Time `json:"cooperateTime"`
 	CooperateTime time.Time `json:"cooperateTime"`
+	//公司id
+	CompanyId int64 `json:"companyId"`
 }
 }
 
 
 func (command *UpdatePartnerInfoCommand) ValidateCommand() error {
 func (command *UpdatePartnerInfoCommand) ValidateCommand() error {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 	if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 		return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
 	}
 	}
-	if !(command.PartnerCategory == domain.PARTNER_CATEGORY_1 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_2 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_3 ||
-		command.PartnerCategory == domain.PARTNER_CATEGORY_4) {
-		return lib.ThrowError(lib.ARG_ERROR, "合伙类别错误")
-	}
 	if command.RegionInfo == nil {
 	if command.RegionInfo == nil {
 		return lib.ThrowError(lib.ARG_ERROR, "区域必填")
 		return lib.ThrowError(lib.ARG_ERROR, "区域必填")
 	}
 	}

@@ -3,6 +3,7 @@ package query
 type GetPartnerInfoQuery struct {
 type GetPartnerInfoQuery struct {
 	// 合伙人ID
 	// 合伙人ID
 	Id        int64 `json:"id" `
 	Id        int64 `json:"id" `
+	CompanyId int64 `json:"companyId"`
 }
 }
 
 
 func (q *GetPartnerInfoQuery) ValidateQuery() error {
 func (q *GetPartnerInfoQuery) ValidateQuery() error {

@@ -7,6 +7,7 @@ type ListPartnerInfoQuery struct {
 	RegionInfo string `json:"regionInfo"`
 	RegionInfo string `json:"regionInfo"`
 	// 合伙人姓名
 	// 合伙人姓名
 	PartnerName string `json:"partnerName"`
 	PartnerName string `json:"partnerName"`
+	CompanyId   int64  `json:"companyId"`
 	// 查询偏离量
 	// 查询偏离量
 	Offset int `json:"offset"`
 	Offset int `json:"offset"`
 	// 查询限制
 	// 查询限制

 package service
 package service
 
 
 import (
 import (
+	"fmt"
+
 	"github.com/linmadan/egglib-go/core/application"
 	"github.com/linmadan/egglib-go/core/application"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/command"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/command"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/query"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/query"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain/service"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 )
 )
@@ -19,12 +22,12 @@ func NewPartnerInfoService(options map[string]interface{}) *PartnerInfoService {
 	return newPartnerInfoService
 	return newPartnerInfoService
 }
 }
 
 
-// 创建客户价值
-func (PartnerInfoService *PartnerInfoService) CreatePartnerInfo(command *command.CreatePartnerInfoCommand) (data interface{}, err error) {
+// CreatePartnerInfo 创建合伙人
+func (PartnerInfoService *PartnerInfoService) CreatePartnerInfo(cmd *command.CreatePartnerInfoCommand) (data interface{}, err error) {
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 	)
 	)
-	if err = command.ValidateCommand(); err != nil {
+	if err = cmd.ValidateCommand(); err != nil {
 		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
 		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
 	}
 	}
 	if err = transactionContext.StartTransaction(); err != nil {
 	if err = transactionContext.StartTransaction(); err != nil {
@@ -37,14 +40,12 @@ func (PartnerInfoService *PartnerInfoService) CreatePartnerInfo(command *command
 	var (
 	var (
 		partnerinfoDao *dao.PartnerInfoDao
 		partnerinfoDao *dao.PartnerInfoDao
 	)
 	)
-	if v, err := factory.CreatePartnerInfoDao(map[string]interface{}{
+	if partnerinfoDao, err = factory.CreatePartnerInfoDao(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
-	} else {
-		partnerinfoDao = v
 	}
 	}
-	ok, err := partnerinfoDao.PartnerAccountExist(command.Account)
+	ok, err := partnerinfoDao.PartnerAccountExist(cmd.Account, cmd.CompanyId)
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
@@ -52,37 +53,66 @@ func (PartnerInfoService *PartnerInfoService) CreatePartnerInfo(command *command
 		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "账号已存在")
 		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "账号已存在")
 	}
 	}
 
 
-	var PartnerInfoRepository domain.PartnerInfoRepository
-	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+	var (
+		partnerInfoRepository domain.PartnerInfoRepository
+		categoryRepository    domain.PartnerCategoryRepository
+		categorys             []domain.PartnerCategory
+	)
+	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	_, categorys, err = categoryRepository.Find(domain.PartnerCategoryFindQuery{
+		Ids: cmd.PartnerCategory,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取合伙人分类数据失败：%s", err)
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
 	newPartnerInfo := domain.PartnerInfo{
 	newPartnerInfo := domain.PartnerInfo{
 		Partner: domain.Partner{
 		Partner: domain.Partner{
-			Account:     command.Account,
-			PartnerName: command.PartnerName,
+			Account:     cmd.Account,
+			PartnerName: cmd.PartnerName,
 		},
 		},
-		PartnerCategory: command.PartnerCategory,
-		Password:        command.Password,
-		Status:          command.Status,
-		RegionInfo:      command.RegionInfo,
-		Salesman:        command.Salesman,
-		CooperateTime:   command.CooperateTime,
-	}
-	if data, err = PartnerInfoRepository.Save(newPartnerInfo); err != nil {
+		PartnerCategory:      0,
+		Password:             cmd.Password,
+		Status:               cmd.Status,
+		RegionInfo:           *cmd.RegionInfo,
+		Salesman:             cmd.Salesman,
+		CooperateTime:        cmd.CooperateTime,
+		CompanyId:            cmd.CompanyId,
+		PartnerCategoryInfos: categorys,
+	}
+	if err = partnerInfoRepository.Save(&newPartnerInfo); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	var businessBonusSrv service.BusinessBonusService
+	if businessBonusSrv, err = factory.CreateBusinessBonusService(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	err = businessBonusSrv.EnableOrDisable(newPartnerInfo.Partner.Id)
+	if err != nil {
+		e := fmt.Sprintf("更新业务分红(partner_id=%d)数据失败:%s", newPartnerInfo.Partner.Id, err)
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
 	err = transactionContext.CommitTransaction()
 	err = transactionContext.CommitTransaction()
-	return
+	return newPartnerInfo, nil
 }
 }
 
 
 // GetPartnerInfo 返回合伙人
 // GetPartnerInfo 返回合伙人
-func (PartnerInfoService *PartnerInfoService) GetPartnerInfo(command query.GetPartnerInfoQuery) (data *domain.PartnerInfo, err error) {
+func (PartnerInfoService *PartnerInfoService) GetPartnerInfo(q query.GetPartnerInfoQuery) (data *domain.PartnerInfo, err error) {
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 	)
 	)
-	if err = command.ValidateQuery(); err != nil {
+	if err = q.ValidateQuery(); err != nil {
 		return nil, lib.ThrowError(lib.ARG_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.ARG_ERROR, err.Error())
 	}
 	}
 	if err := transactionContext.StartTransaction(); err != nil {
 	if err := transactionContext.StartTransaction(); err != nil {
@@ -91,26 +121,54 @@ func (PartnerInfoService *PartnerInfoService) GetPartnerInfo(command query.GetPa
 	defer func() {
 	defer func() {
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
 	}()
 	}()
-	var PartnerInfoRepository domain.PartnerInfoRepository
+	var (
+		PartnerInfoRepository domain.PartnerInfoRepository
+		categoryRepository    domain.PartnerCategoryRepository
+		categorys             []domain.PartnerCategory
+		partnerData           *domain.PartnerInfo
+	)
 	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
-	data, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: command.Id})
+	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
+		UserId: q.Id, CompanyId: q.CompanyId,
+	})
 	if err != nil {
 	if err != nil {
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	if !partnerData.IsCompany(q.CompanyId) {
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "企业信息异常操作")
+	}
+	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	categoryIds := []int64{}
+	for _, v := range partnerData.PartnerCategoryInfos {
+		categoryIds = append(categoryIds, v.Id)
+	}
+	if len(categoryIds) > 0 {
+		_, categorys, err = categoryRepository.Find(domain.PartnerCategoryFindQuery{
+			Ids: categoryIds,
+		})
+		if err != nil {
+			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+		}
+	}
+	partnerData.PartnerCategoryInfos = categorys
 	err = transactionContext.CommitTransaction()
 	err = transactionContext.CommitTransaction()
-	return
+	return partnerData, nil
 }
 }
 
 
 //UpdatePartnerInfo 更新合伙人
 //UpdatePartnerInfo 更新合伙人
-func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(updatePartnerInfoCommand *command.UpdatePartnerInfoCommand) (err error) {
+func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(cmd *command.UpdatePartnerInfoCommand) (err error) {
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 	)
 	)
-	if err = updatePartnerInfoCommand.ValidateCommand(); err != nil {
+	if err = cmd.ValidateCommand(); err != nil {
 		return application.ThrowError(application.ARG_ERROR, err.Error())
 		return application.ThrowError(application.ARG_ERROR, err.Error())
 	}
 	}
 	if err := transactionContext.StartTransaction(); err != nil {
 	if err := transactionContext.StartTransaction(); err != nil {
@@ -119,31 +177,61 @@ func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(updatePartnerInf
 	defer func() {
 	defer func() {
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
 	}()
 	}()
-	var partnerInfoRepository domain.PartnerInfoRepository
+	var (
+		partnerInfoRepository domain.PartnerInfoRepository
+		categoryRepository    domain.PartnerCategoryRepository
+		categorys             []domain.PartnerCategory
+	)
 	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
+	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	_, categorys, err = categoryRepository.Find(domain.PartnerCategoryFindQuery{
+		Ids: cmd.PartnerCategory,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取合伙人分类数据失败：%s", err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
 	partnerInfo, err := partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
 	partnerInfo, err := partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
-		UserId: updatePartnerInfoCommand.Id,
+		UserId: cmd.Id, CompanyId: cmd.CompanyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
-	partnerInfo.PartnerCategory = updatePartnerInfoCommand.PartnerCategory
-	partnerInfo.Salesman = updatePartnerInfoCommand.Salesman
-	partnerInfo.Status = updatePartnerInfoCommand.Status
-	partnerInfo.RegionInfo = updatePartnerInfoCommand.RegionInfo
-	partnerInfo.CooperateTime = updatePartnerInfoCommand.CooperateTime
-	if _, err = partnerInfoRepository.Save(*partnerInfo); err != nil {
+	if !partnerInfo.IsCompany(cmd.CompanyId) {
+		return lib.ThrowError(lib.BUSINESS_ERROR, "异常操作")
+	}
+	partnerInfo.Salesman = cmd.Salesman
+	partnerInfo.Status = cmd.Status
+	partnerInfo.RegionInfo = *cmd.RegionInfo
+	partnerInfo.CooperateTime = cmd.CooperateTime
+	partnerInfo.PartnerCategoryInfos = categorys
+	if err = partnerInfoRepository.Save(partnerInfo); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	var businessBonusSrv service.BusinessBonusService
+	if businessBonusSrv, err = factory.CreateBusinessBonusService(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	err = businessBonusSrv.EnableOrDisable(partnerInfo.Partner.Id)
+	if err != nil {
+		e := fmt.Sprintf("更新业务分红(partner_id=%d)数据失败:%s", partnerInfo.Partner.Id, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
 	transactionContext.CommitTransaction()
 	transactionContext.CommitTransaction()
 	return
 	return
 }
 }
 
 
-// 返回客户价值列表
+// ListPartnerInfo 合伙人列表
 func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQuery *query.ListPartnerInfoQuery) (int, []domain.PartnerInfo, error) {
 func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQuery *query.ListPartnerInfoQuery) (int, []domain.PartnerInfo, error) {
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
@@ -158,21 +246,30 @@ func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQue
 		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	defer func() {
 	defer func() {
-		if err != nil {
+
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
-		}
+
 	}()
 	}()
-	var partnerInfoRepository domain.PartnerInfoRepository
+	var (
+		partnerInfoRepository domain.PartnerInfoRepository
+		categoryRepository    domain.PartnerCategoryRepository
+		categorys             []domain.PartnerCategory
+	)
 	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
 	queryOption := domain.PartnerFindQuery{
 	queryOption := domain.PartnerFindQuery{
 		Offset:      listPartnerInfoQuery.Offset,
 		Offset:      listPartnerInfoQuery.Offset,
 		Limit:       listPartnerInfoQuery.Limit,
 		Limit:       listPartnerInfoQuery.Limit,
-
 		PartnerName: listPartnerInfoQuery.PartnerName,
 		PartnerName: listPartnerInfoQuery.PartnerName,
+		CompanyId:   listPartnerInfoQuery.CompanyId,
 	}
 	}
 	if listPartnerInfoQuery.Partnertype > 0 {
 	if listPartnerInfoQuery.Partnertype > 0 {
 		queryOption.PartnerCategory = []int{listPartnerInfoQuery.Partnertype}
 		queryOption.PartnerCategory = []int{listPartnerInfoQuery.Partnertype}
@@ -187,17 +284,37 @@ func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQue
 	if count, err = partnerInfoRepository.CountAll(queryOption); err != nil {
 	if count, err = partnerInfoRepository.CountAll(queryOption); err != nil {
 		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
+	_, categorys, err = categoryRepository.Find(domain.PartnerCategoryFindQuery{})
+	if err != nil {
+		return count, partnerInfos, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	categorysMap := make(map[int64]domain.PartnerCategory)
+	for i := range categorys {
+		categorysMap[categorys[i].Id] = categorys[i]
+	}
+	for i := range partnerInfos {
+		categoryInPartner := []domain.PartnerCategory{}
+		for _, vv := range partnerInfos[i].PartnerCategoryInfos {
+			if categoryData, ok := categorysMap[vv.Id]; ok {
+				categoryInPartner = append(categoryInPartner, categoryData)
+			}
+		}
+		partnerInfos[i].PartnerCategoryInfos = categoryInPartner
+	}
 	if err = transactionContext.CommitTransaction(); err != nil {
 	if err = transactionContext.CommitTransaction(); err != nil {
 		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	return count, partnerInfos, nil
 	return count, partnerInfos, nil
 }
 }
 
 
-func (PartnerInfoService *PartnerInfoService) UpdateStatus(command command.StatusPartnerInfoCommand) (err error) {
+func (PartnerInfoService *PartnerInfoService) UpdateStatus(cmd command.StatusPartnerInfoCommand) (err error) {
+	if len(cmd.Ids) == 0 {
+		return nil
+	}
 	var (
 	var (
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 		transactionContext, _ = factory.CreateTransactionContext(nil)
 	)
 	)
-	if err = command.ValidateCommand(); err != nil {
+	if err = cmd.ValidateCommand(); err != nil {
 		return application.ThrowError(application.ARG_ERROR, err.Error())
 		return application.ThrowError(application.ARG_ERROR, err.Error())
 	}
 	}
 	if err := transactionContext.StartTransaction(); err != nil {
 	if err := transactionContext.StartTransaction(); err != nil {
@@ -206,21 +323,18 @@ func (PartnerInfoService *PartnerInfoService) UpdateStatus(command command.Statu
 	defer func() {
 	defer func() {
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
 	}()
 	}()
-	var partnerInfoRepository domain.PartnerInfoRepository
-	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+	var (
+		partnerinfoDao *dao.PartnerInfoDao
+	)
+	if partnerinfoDao, err = factory.CreatePartnerInfoDao(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
 	}); err != nil {
 	}); err != nil {
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
 	}
 	}
-	partnerInfo, err := partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
-		UserId: command.Id,
-	})
+	err = partnerinfoDao.UpdatePartnerStatus(cmd.Ids, cmd.CompanyId, cmd.Status)
 	if err != nil {
 	if err != nil {
-		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
-	}
-	partnerInfo.Status = command.Status
-	if _, err = partnerInfoRepository.Save(*partnerInfo); err != nil {
-		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+		e := fmt.Sprintf("更新合伙人(id=%v)的数据失败;%s", cmd.Ids, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
 	}
 	}
 	transactionContext.CommitTransaction()
 	transactionContext.CommitTransaction()
 	return
 	return

+package command
+
+type ChanceSuperAdminCommand struct {
+	CompanyId int64  `json:"company_id"` //公司id
+	Phone     string `json:"phone"`      //新的超级管理员手机号（账号）
+}

+package command
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type SyncCallbackCommand struct {
+	//position:职位,department:部门,employee:员工,company:公司
+	Module string `json:"module"`
+	//add:添加,edit:编辑,delete删除,batchDelete:批量删除,
+	//setCompanyCharge：更改公司主管,batchForbid:批量禁用用户，
+	//batchRemove：批量更改用户部门，changeAdmin换管理员
+	Action string `json:"action"`
+	//具体的对象JSON数据
+	Data json.RawMessage `json:"data" `
+}
+
+func (command *SyncCallbackCommand) ValidateCommand() error {
+	if len(command.Module) == 0 {
+		return fmt.Errorf("module 必填")
+	}
+	if len(command.Action) == 0 {
+		return fmt.Errorf("action 必填")
+	}
+	return nil
+}

+package service
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+type SyncCompanyService struct{}
+
+var _ SyncAction = (*SyncCompanyService)(nil)
+
+//企业平台的公司基础数据
+type CompanyBase struct {
+	Id             int64  `json:"id"`               //id
+	Name           string `json:"name"`             //公司名称名称
+	AdminCompanyId int    `json:"admin_company_id"` //总后台的公司id
+	Logo           string `json:"logo"`             //公司图标
+	Remarks        string `json:"remarks"`          //备注
+	Abbreviation   string `json:"abbreviation"`
+}
+
+// CompanytData 企业平台发送过来的公司数据数据
+type CompanytData struct {
+	Company CompanyBase  `json:"company"`
+	User    EmployeeData `json:"user"`
+}
+
+//CompanyCharge 企业平台发送过来的变更公司主管数据
+type CompanyCharge struct {
+	Id     int64   `json:"id"`
+	Charge []int64 `json:"charge"`
+}
+
+func (service SyncCompanyService) DoAction(action string, byteData []byte) error {
+	switch action {
+	case "add":
+		//添加公司
+		var (
+			data CompanytData
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		return service.addCompany(data)
+	case "edit":
+		//编辑
+		var (
+			data CompanytData
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		return service.updateCompany(data)
+	case "setCompanyCharge":
+		//设置公司主管
+		var (
+			data CompanyCharge
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		return service.updateCompanyCharge(data)
+	default:
+		return errors.New("action not found")
+	}
+}
+
+func (service SyncCompanyService) addCompany(data CompanytData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		userRespository    domain.UsersRepository
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	comany := domain.Company{
+		Id:             data.Company.Id,
+		Name:           data.Company.Name,
+		Phone:          "",
+		Logo:           data.Company.Logo,
+		Remarks:        data.Company.Remarks,
+		AdminCompanyId: data.Company.AdminCompanyId,
+		//Status:         data.Company.Status,
+		Enable:       domain.CompanyEnableYes, //默认初始化值
+		Abbreviation: data.Company.Abbreviation,
+	}
+	err = companyRespository.Add(&comany)
+	if err != nil {
+		return fmt.Errorf("添加公司数据失败,%s", err)
+	}
+	user := domain.Users{
+		Id:             data.User.Id,
+		CompanyId:      data.User.CompanyId,
+		OpenId:         data.User.OpenId,
+		Name:           data.User.Name,
+		Sex:            data.User.Sex,
+		JobNum:         data.User.JobNum,
+		Phone:          data.User.Phone,
+		PrivatePhone:   data.User.PrivatePhone,
+		Email:          data.User.Email,
+		ExtensionNum:   data.User.ExtensionNum,
+		Workspace:      data.User.WorkSpace,
+		Status:         data.User.Status,
+		Avatar:         data.User.Avatar,
+		Remarks:        data.User.Remarks,
+		ChargeStatus:   data.User.ChargeStatus,
+		Permission:     []domain.AdminPermissionBase{}, //初始化权限
+		AccessPartners: []domain.Partner{},
+		AdminType:      data.User.AdminType,
+	}
+	err = userRespository.Add(&user)
+	if err != nil {
+		return fmt.Errorf("添加用户数据失败,%s", err)
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}
+
+func (service SyncCompanyService) updateCompany(data CompanytData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		userRespository    domain.UsersRepository
+		oldCompany         domain.Company
+		oldUser            domain.Users
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	oldCompany, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		Id: data.Company.Id,
+	})
+	oldUser, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id: data.User.Id,
+	})
+	oldCompany.Update(map[string]interface{}{
+		"Name":           data.Company.Name,
+		"Logo":           data.Company.Logo,
+		"Remarks":        data.Company.Remarks,
+		"AdminCompanyId": data.Company.AdminCompanyId,
+		"Abbreviation":   data.Company.Abbreviation,
+	})
+	entryTime, _ := time.Parse("2006-01-02", data.User.EntryTime)
+	oldUser.Update(map[string]interface{}{
+		"CompanyId":    data.User.CompanyId,
+		"OpenId":       data.User.OpenId,
+		"Name":         data.User.Name,
+		"Sex":          data.User.Sex,
+		"JobNum":       data.User.JobNum,
+		"Phone":        data.User.Phone,
+		"PrivatePhone": data.User.PrivatePhone,
+		"Email":        data.User.Email,
+		"ExtensionNum": data.User.ExtensionNum,
+		"Workspace":    data.User.WorkSpace,
+		"Status":       data.User.Status,
+		"Avatar":       data.User.Avatar,
+		"Remarks":      data.User.Remarks,
+		"ChargeStatus": data.User.ChargeStatus,
+		"EntryTime":    entryTime,
+		"AdminType":    data.User.AdminType,
+	})
+	err = companyRespository.Edit(&oldCompany)
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = userRespository.Edit(&oldUser)
+	if err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}
+
+func (service SyncCompanyService) updateCompanyCharge(data CompanyCharge) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository domain.UsersRepository
+	)
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	var oldUsers []domain.Users
+	_, oldUsers, err = userRespository.Find(domain.UsersFindQuery{
+		CompanyId:    data.Id,
+		ChargeStatus: domain.UserIsCompanyCharge,
+		Limit:        -1,
+	})
+	for i := range oldUsers {
+		_ = oldUsers[i].Update(map[string]interface{}{
+			"ChargeStatus": domain.UserIsNotCompanyCharge,
+		})
+		err = userRespository.Edit(&oldUsers[i])
+		if err != nil {
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "更新用户的charge_status失败:"+err.Error())
+		}
+	}
+	for _, v := range data.Charge {
+		var userToUpdate domain.Users
+		userToUpdate, err := userRespository.FindOne(domain.UsersFindOneQuery{
+			Id: v,
+		})
+		if err != nil {
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取用户(id=%d)的数据失败:%s", v, err.Error()))
+		}
+		_ = userToUpdate.Update(map[string]interface{}{
+			"ChargeStatus": domain.UserIsCompanyCharge,
+		})
+		err = userRespository.Edit(&userToUpdate)
+		if err != nil {
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("更新用户(id=%d)的数据失败:%s", v, err.Error()))
+		}
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}

+package service
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/command"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+// UserDepartData 用户的部门数据
+type UserDepartData struct {
+	Id           int64 `json:"id"`
+	CompanyId    int64 `json:"company_id"`
+	DepartmentId int64 `json:"department_id"`
+	UserId       int64 `json:"user_id"`
+}
+
+//UserPositionData 用户的职位数据
+type UserPositionData struct {
+	Id         int64 `json:"id"`
+	CompanyId  int64 `json:"company_id"`
+	PositionId int64 `json:"position_id"`
+	UserId     int64 `json:"user_id"`
+}
+
+//EmployeeData 从平台平台接收的数据
+type EmployeeData struct {
+	Id              int64              `json:"id"`      //用户的id，对应本地的user_company_id
+	OpenId          int64              `json:"open_id"` //同一用户中心的用户id
+	Phone           string             `json:"phone"`
+	Name            string             `json:"name"`
+	Sex             int8               `json:"sex"`
+	JobNum          string             `json:"job_num"`
+	PrivatePhone    string             `json:"private_phone"` //私人手机
+	CompanyId       int64              `json:"company_id"`    //总后台的company_id
+	Email           string             `json:"email"`
+	ExtensionNum    string             `json:"extension_num"` //分机号
+	EntryTime       string             `json:"entry_time"`    //入职时间
+	WorkSpace       string             `json:"workspace"`
+	IsBusiness      int8               `json:"is_business"` //
+	Status          int8               `json:"status"`
+	Avatar          string             `json:"avatar"`
+	ExtraText       string             `json:"extra_text"`
+	Remarks         string             `json:"remarks"`
+	AdminType       int8               `json:"admin_type"`
+	ChargeStatus    int8               `json:"charge_status"`
+	UserDepartments []UserDepartData   `json:"user_departments"`
+	UserPositions   []UserPositionData `json:"user_positions"`
+}
+
+//DeleteUserData 批量删除用户
+type DeleteUserData struct {
+	CompanyId int64   `json:"companyId"`
+	Ids       []int64 `json:"ids"`
+}
+
+//ForbidAllowUserData 禁用启用用户
+type ForbidAllowUserData struct {
+	CompanyId int64   `json:"companyId"`
+	Ids       []int64 `json:"ids"`
+	Status    int8    `json:"status"`
+}
+
+//ImportEmployeeData 批量导入用户
+type ImportEmployeeData struct {
+	Add  []EmployeeData `json:"add"`
+	Edit []EmployeeData `json:"edit"`
+}
+
+//SyncEmployeeService 同步用户数据
+type SyncEmployeeService struct{}
+
+func NewSyncEmployeeService(option map[string]interface{}) *SyncEmployeeService {
+	syncEmployee := new(SyncEmployeeService)
+	return syncEmployee
+}
+
+var _ SyncAction = (*SyncEmployeeService)(nil)
+
+func (service SyncEmployeeService) DoAction(action string, byteData []byte) error {
+	switch action {
+	case "add":
+		//添加
+		var (
+			data EmployeeData
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		err = service.addEmployeeData([]EmployeeData{data})
+		return err
+	case "edit":
+		//编辑更新
+		var (
+			data EmployeeData
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		err = service.updateEmployeeData([]EmployeeData{data})
+		return err
+	case "batchDelete":
+		//批量删除
+		var (
+			err  error
+			data DeleteUserData
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		return service.deleteEmployeeData(data)
+	case "batchForbid":
+		//启用禁用
+		var (
+			err  error
+			data ForbidAllowUserData
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		return service.updateUsersStatus(data)
+	// case "batchRemove":
+	// 	//移动通讯录用户部门 暂时不需要
+	// 	return nil
+	case "import":
+		//批量导入
+		var (
+			data ImportEmployeeData
+			err  error
+		)
+		err = json.Unmarshal(byteData, &data)
+		if err != nil {
+			return fmt.Errorf("数据解析失败：%s", err)
+		}
+		err1 := service.addEmployeeData(data.Add)
+		err2 := service.updateEmployeeData(data.Edit)
+		if err1 != nil || err2 != nil {
+			return fmt.Errorf("添加用户错误：%s,更新用户发生错误：%s", err1, err2)
+		}
+		return nil
+	default:
+		return errors.New("action not found")
+	}
+}
+
+func (service SyncEmployeeService) addEmployeeData(datas []EmployeeData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var usersRepository domain.UsersRepository
+	if usersRepository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	for i := range datas {
+		data := datas[i]
+		newUser := domain.Users{
+			Id:             data.Id,
+			CompanyId:      data.CompanyId,
+			OpenId:         data.OpenId,
+			Name:           data.Name,
+			Sex:            data.Sex,
+			JobNum:         data.JobNum,
+			Phone:          data.Phone,
+			PrivatePhone:   data.PrivatePhone,
+			Email:          data.Email,
+			ExtensionNum:   data.ExtensionNum,
+			Workspace:      data.WorkSpace,
+			Status:         data.Status,
+			Avatar:         data.Avatar,
+			Remarks:        data.Remarks,
+			ChargeStatus:   data.ChargeStatus,
+			Permission:     []domain.AdminPermissionBase{}, //初始化权限
+			AccessPartners: []domain.Partner{},             //默认初始化
+			AdminType:      data.AdminType,
+		}
+		newUser.EntryTime, _ = time.Parse("2006-01-02", data.EntryTime)
+		if err = usersRepository.Add(&newUser); err != nil {
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+		}
+	}
+	err = transactionContext.CommitTransaction()
+	return err
+}
+
+func (service SyncEmployeeService) updateEmployeeData(datas []EmployeeData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var usersRepository domain.UsersRepository
+	if usersRepository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	for i := range datas {
+		data := datas[i]
+		var oldUser domain.Users
+		oldUser, err = usersRepository.FindOne(domain.UsersFindOneQuery{
+			Id: data.Id,
+		})
+		if err != nil {
+			return lib.ThrowError(lib.BUSINESS_ERROR, err.Error())
+		}
+		entryTime, _ := time.Parse("2006-01-02", data.EntryTime)
+		_ = oldUser.Update(map[string]interface{}{
+			"CompanyId":    data.CompanyId,
+			"Name":         data.Name,
+			"Sex":          data.Sex,
+			"JobNum":       data.JobNum,
+			"Phone":        data.Phone,
+			"PrivatePhone": data.PrivatePhone,
+			"Email":        data.Email,
+			"ExtensionNum": data.ExtensionNum,
+			"Workspace":    data.WorkSpace,
+			"Status":       data.Status,
+			"Avatar":       data.Avatar,
+			"Remarks":      data.Remarks,
+			"ChargeStatus": data.ChargeStatus,
+			"EntryTime":    entryTime,
+			"AdminType":    data.AdminType,
+		})
+		if err = usersRepository.Edit(&oldUser); err != nil {
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+		}
+	}
+	err = transactionContext.CommitTransaction()
+	return err
+}
+
+//deleteEmployeeData 删除用户
+func (service SyncEmployeeService) deleteEmployeeData(data DeleteUserData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var usersRepository domain.UsersRepository
+	if usersRepository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if err = usersRepository.Remove(data.Ids); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	return err
+}
+
+//UpdateUsersStatus 批量更新用户的状态
+func (service SyncEmployeeService) updateUsersStatus(data ForbidAllowUserData) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var uDao *dao.UsersDao
+	if uDao, err = factory.CreateUsersDao(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if err = uDao.UpdateUserStatus(data.Ids, data.Status); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	return err
+}
+
+//ChangeAdmin 变更公司负责人，超级管理员
+func (service SyncEmployeeService) ChangeSuperAdmin(cmd command.ChanceSuperAdminCommand) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var usersRepository domain.UsersRepository
+	if usersRepository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	var (
+		oldSuperUser domain.Users
+		newSuperUser domain.Users
+		userList     []domain.Users
+	)
+	_, userList, err = usersRepository.Find(domain.UsersFindQuery{
+		CompanyId: cmd.CompanyId,
+		AdminType: domain.UserIsAdmin,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取用户(admin_type=%d;company_id=%d)数据失败：%s",
+			domain.UserIsAdmin, cmd.CompanyId, err.Error())
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	if len(userList) == 0 {
+		e := fmt.Sprintf("没有获得公司主管数据(admin_type=%d;company_id=%d)",
+			domain.UserIsAdmin, cmd.CompanyId)
+		return lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	if len(userList) > 1 {
+		e := fmt.Sprintf("存在复数公司主管数据(admin_type=%d;company_id=%d)",
+			domain.UserIsAdmin, cmd.CompanyId)
+		return lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	oldSuperUser = userList[0]
+	newSuperUser, err = usersRepository.FindOne(domain.UsersFindOneQuery{
+		CompanyId: cmd.CompanyId,
+		Phone:     cmd.Phone,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取公司用户数据(phone=%s;company_id=%d)",
+			cmd.Phone, cmd.CompanyId)
+		return lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	err = oldSuperUser.Update(map[string]interface{}{
+		"AdminType": domain.UserIsNotAdmin,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.BUSINESS_ERROR, err.Error())
+	}
+	err = newSuperUser.Update(map[string]interface{}{
+		"AdminType": domain.UserIsAdmin,
+	})
+	if err != nil {
+		return lib.ThrowError(lib.BUSINESS_ERROR, err.Error())
+	}
+	err = usersRepository.Edit(&oldSuperUser)
+	if err != nil {
+		e := fmt.Sprintf("更新公司主管user数据(id=%d)失败：%s",
+			oldSuperUser.Id, err)
+		return lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	err = usersRepository.Edit(&newSuperUser)
+	if err != nil {
+		e := fmt.Sprintf("更新公司主管user数据(id=%d)失败：%s",
+			newSuperUser.Id, err)
+		return lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}

+package service
+
+import (
+	"errors"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/command"
+)
+
+//PlatformAction 企业平台数据同步服务 动作接口设定
+type SyncAction interface {
+	DoAction(string, []byte) error
+}
+
+//actionMap 数据同步需要的动作集合，静态不要在运行时变更这里的数据
+//position:职位,department:部门,employee:员工,company:公司
+var actionMap = map[string]SyncAction{
+	// "department":
+	// "position":
+	"employee": SyncEmployeeService{},
+	"company":  SyncCompanyService{},
+}
+
+func NewSyncAction(cmd command.SyncCallbackCommand) error {
+	err := cmd.ValidateCommand()
+	if err != nil {
+		return err
+	}
+	var (
+		action SyncAction
+		ok     bool
+	)
+	if action, ok = actionMap[cmd.Module]; !ok {
+		return errors.New("module cannot found")
+	}
+	return action.DoAction(cmd.Action, cmd.Data)
+}

+package command
+
+import "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+
+type LoginBySecretKeyCommand struct {
+	Code string `json:"code"`
+}
+
+func (login LoginBySecretKeyCommand) ValidateCommand() error {
+	if len(login.Code) == 0 {
+		return lib.ThrowError(lib.ARG_ERROR, "登录参数错误")
+	}
+	return nil
+}

+package command
+
+type EditUserPermissionCommand struct {
+	Id             int64   `json:"id"`
+	CompanyId      int64   `json:"-"`
+	PermissionType []int64 `json:"permissionType"` //权限数据
+	CheckedPartner []int64 `json:"checkedPartner"` //可查看合伙人列表合伙人
+}

 package query
 package query
 
 
-//ListAdminUserQuery 获取用户列表
-type ListAdminUserQuery struct {
-	//账号匹配
-	AdminAccountMatch string `json:"adminAccountMatch" `
+type UserListQuery struct {
+	//用户名称匹配
+	UserNameMatch string `json:"userNameMatch" `
 	// 查询偏离量
 	// 查询偏离量
 	Offset int `json:"offset" `
 	Offset int `json:"offset" `
 	// 查询限制
 	// 查询限制
 	Limit     int   `json:"limit"`
 	Limit     int   `json:"limit"`
+	CompanyId int64 `json:"companyId"`
 }
 }

+package query
+
+type ValidatePermissionQuery struct {
+	PermissionCode string
+	UserId         int64
+	CompanyId      int64
+}

+package service
+
+import (
+	"fmt"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/command"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/query"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/serviceGateway"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
+)
+
+type UsersService struct {
+}
+
+func NewUsersService(option map[string]interface{}) *UsersService {
+	newUsersService := new(UsersService)
+	return newUsersService
+}
+
+func (service UsersService) UserLoginBySecretKey(cmd command.LoginBySecretKeyCommand) (interface{}, error) {
+	var err error
+	if err = cmd.ValidateCommand(); err != nil {
+		return nil, err
+	}
+	//向统一用户中心确认密钥信息并获取用户数据
+	ucenterService := serviceGateway.NewMmmUserCenterServiceGateway()
+	loginResp, err := ucenterService.RequestUCenterLoginBySecret(cmd.Code)
+	if err != nil {
+		e := fmt.Sprintf("通过密钥(code=%s)从统一用户中心获取数据失败：%s", cmd.Code, err.Error())
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+
+	if err := loginResp.IsOK(); err != nil {
+		e := fmt.Sprintf("登录失败:%s", err)
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	adminBusinessService := serviceGateway.NewMmmBusinessAdminServiceGateway()
+	getUserAuthResp, err := adminBusinessService.GetUserAuth(loginResp.Data.Muid)
+	if err != nil {
+		e := fmt.Sprintf("用户鉴权失败：%s", err)
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, e)
+	}
+	if err := getUserAuthResp.IsOK(); err != nil {
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "该公司没有操作权限")
+	}
+	if !getUserAuthResp.Data.UserAuth {
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "该公司没有操作权限")
+	}
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		companyRespository domain.CompanyRepository
+		userRespository    domain.UsersRepository
+		companyData        domain.Company
+		usersData          domain.Users
+	)
+	if companyRespository, err = factory.CreateCompanyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	//检索本系统的公司数据判断公司权限
+	companyData, err = companyRespository.FindOne(domain.CompanyFindOneOptions{
+		AdminCompanyId: loginResp.Data.CompanyId,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取公司(admin_company_id=%d)数据失败：%s", loginResp.Data.CompanyId, err.Error())
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	//检索本系统的用户数据
+	usersData, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id:        loginResp.Data.Muid,
+		CompanyId: companyData.Id,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取用户(id=%d；CompanyId=%d)数据失败：%s",
+			loginResp.Data.Muid, companyData.Id, err.Error())
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	//确认用户权限
+	if !usersData.IsUsable() {
+		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "用户被禁用")
+	}
+	err = transactionContext.CommitTransaction()
+	newJwt := lib.NewMyToken(usersData.Id, companyData.Id)
+	newToken, err := newJwt.CreateJWTToken()
+	//生成token
+	returnData := map[string]interface{}{
+		"access": map[string]interface{}{
+			"accessToken": newToken,
+			"expiresIn":   lib.JWtExpiresSecond,
+		},
+	}
+	return returnData, nil
+}
+
+//GetAdminpPofile  登录后获取用户的权限配置数据
+func (service UsersService) GetUserPofile(userId int64) (interface{}, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository      domain.UsersRepository
+		usersData            domain.Users
+		permissionRepository domain.AdminPermissionRepository
+		permissionList       []domain.AdminPermission
+	)
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if permissionRepository, err = factory.CreateAdminPermissionRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	usersData, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id: userId,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取用户(Id=%d)数据失败：%s",
+			userId, err.Error())
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	var permissionQuery domain.PermissionFindOption
+	permissionList, err = permissionRepository.Find(permissionQuery)
+	if err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	returnData := service.buildUserPofile(usersData, permissionList)
+	return returnData, nil
+}
+
+//buildUserPofile 组装前端需要的数据 ,用户登录后获取的配置
+func (service UsersService) buildUserPofile(userData domain.Users, permissionList []domain.AdminPermission) map[string]interface{} {
+	menus := make([]map[string]interface{}, 0, len(permissionList))
+	for _, v := range permissionList {
+		m := map[string]interface{}{
+			"code":     v.Code,
+			"icon":     v.Icon,
+			"parentId": v.ParentId,
+			"sort":     v.Sort,
+			"name":     v.Name,
+			"id":       v.Id,
+			"status":   0, //状态 1-启用 0-禁用，前端需要
+		}
+		if userData.IsSuperAdmin() {
+			m["status"] = 1
+			menus = append(menus, m)
+			continue
+		}
+		for _, p := range userData.Permission {
+			if p.Id == v.Id {
+				m["status"] = 1
+				break
+			}
+			if p.Id == v.ParentId {
+				m["status"] = 1
+				break
+			}
+		}
+		menus = append(menus, m)
+	}
+	user := map[string]string{
+		"id":        fmt.Sprint(userData.Id),
+		"name":      userData.Name,
+		"adminType": "2", //	前端需要的管理员类型 1-超级管理员 2-子管理员
+	}
+	if userData.IsSuperAdmin() {
+		user["adminType"] = "1"
+	}
+	respData := map[string]interface{}{
+		"user":  user,
+		"menus": menus,
+	}
+	return respData
+}
+
+//ValidateAdminpPermission 校验用户的操作权限
+func (service UsersService) ValidateAdminpPermission(queryOption query.ValidatePermissionQuery) (bool, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return false, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository domain.UsersRepository
+		usersData       domain.Users
+	)
+
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return false, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	usersData, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id: queryOption.UserId,
+	})
+	if err != nil {
+		return false, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if !usersData.IsUsable() {
+		return false, nil
+	}
+	err = transactionContext.CommitTransaction()
+	ok := usersData.HasPermissionByCode(queryOption.PermissionCode)
+	return ok, nil
+}
+
+//获取用户列表
+func (service UsersService) GetUserList(queryOption query.UserListQuery) (int, []map[string]interface{}, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository      domain.UsersRepository
+		usersData            []domain.Users
+		cnt                  int
+		permissionRepository domain.AdminPermissionRepository
+		permissionList       []domain.AdminPermission
+	)
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if permissionRepository, err = factory.CreateAdminPermissionRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	cnt, usersData, err = userRespository.Find(domain.UsersFindQuery{
+		UserNameMatch: queryOption.UserNameMatch,
+		Offset:        queryOption.Offset,
+		Limit:         queryOption.Limit,
+		CompanyId:     queryOption.CompanyId,
+	})
+	var permissionQuery = domain.PermissionFindOption{}
+	permissionList, err = permissionRepository.Find(permissionQuery)
+	if err != nil {
+		return 0, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	err = transactionContext.CommitTransaction()
+	result := service.buildGetUserList(usersData, permissionList)
+	return cnt, result, nil
+}
+
+//buildGetUserList 组装构建前端需要的用户列表数据
+func (service UsersService) buildGetUserList(usersData []domain.Users, permissionData []domain.AdminPermission) []map[string]interface{} {
+	result := make([]map[string]interface{}, 0, len(usersData))
+	permissionMap := map[int64]domain.AdminPermission{}
+	for i := range permissionData {
+		if permissionData[i].ParentId > 0 {
+			continue
+		}
+		permissionMap[permissionData[i].Id] = permissionData[i]
+	}
+	for i := range usersData {
+		permissionTypes := []string{}
+		if usersData[i].IsSuperAdmin() {
+			for _, pd := range permissionData {
+				if pd.ParentId > 0 {
+					continue
+				}
+				permissionTypes = append(permissionTypes, pd.Name)
+			}
+		} else {
+			for _, vv := range usersData[i].Permission {
+				if pm, ok := permissionMap[vv.Id]; ok {
+					permissionTypes = append(permissionTypes, pm.Name)
+				}
+			}
+		}
+		m := map[string]interface{}{
+			"id":          usersData[i].Id,
+			"account":     usersData[i].Phone,
+			"name":        usersData[i].Name,
+			"permission":  permissionTypes,
+			"isAdmin":     0,
+			"partnership": len(usersData[i].AccessPartners),
+		}
+		if usersData[i].IsSuperAdmin() {
+			m["isAdmin"] = 1
+		}
+		result = append(result, m)
+	}
+	return result
+}
+
+func (service UsersService) GetUserData(userId int64, companyId int64) (map[string]interface{}, error) {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository   domain.UsersRepository
+		perterRespository domain.PartnerInfoRepository
+		usersData         domain.Users
+		pertnerList       []domain.PartnerInfo
+	)
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if perterRespository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	usersData, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id: userId, CompanyId: companyId,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取用户(id=%d;company_id=%d)数据失败;%s", userId, companyId, err)
+		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	var partnerIds []int64
+	for _, v := range usersData.AccessPartners {
+		partnerIds = append(partnerIds, v.Id)
+	}
+	if len(partnerIds) > 0 {
+		pertnerList, err = perterRespository.Find(domain.PartnerFindQuery{
+			Ids: partnerIds,
+		})
+		if err != nil {
+			e := fmt.Sprintf("获取合伙人数据失败：%s", err)
+			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+		}
+	}
+	transactionContext.CommitTransaction()
+	return service.buildGetUserData(&usersData, pertnerList)
+}
+
+//buildGetUserData 构建前端需要的数据
+func (service UsersService) buildGetUserData(userData *domain.Users, partnerList []domain.PartnerInfo) (map[string]interface{}, error) {
+	result := map[string]interface{}{
+		"id":             userData.Id,
+		"permissionType": []int64{},
+		"name":           userData.Name,
+		"account":        userData.Phone,
+		"isAdmin":        0,
+		"status":         0,
+		"checkedPartner": []map[string]interface{}{},
+	}
+	if userData.IsSuperAdmin() {
+		result["isAdmin"] = 1
+	}
+	if userData.IsUsable() {
+		result["status"] = 1
+	}
+	permissionIds := make([]int64, 0, len(userData.Permission))
+	for _, v := range userData.Permission {
+		permissionIds = append(permissionIds, v.Id)
+	}
+
+	if userData.IsSuperAdmin() {
+		transactionContext, _ := factory.CreateTransactionContext(nil)
+		var permissionRepository domain.AdminPermissionRepository
+		var err error
+		if permissionRepository, err = factory.CreateAdminPermissionRepository(map[string]interface{}{
+			"transactionContext": transactionContext,
+		}); err != nil {
+			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+		}
+		permissionList, err := permissionRepository.Find(domain.PermissionFindOption{})
+		if err != nil {
+			e := fmt.Sprintf("获取权限列表数据失败：%s", err)
+			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+		}
+		permissionIds = make([]int64, 0)
+		for _, v := range permissionList {
+			permissionIds = append(permissionIds, v.Id)
+		}
+	}
+	result["permissionType"] = permissionIds
+	checkedPartner := make([]map[string]interface{}, 0, len(partnerList))
+	for i := range partnerList {
+		m := map[string]interface{}{
+			"id":   partnerList[i].Partner.Id,
+			"name": partnerList[i].Partner.PartnerName,
+		}
+		checkedPartner = append(checkedPartner, m)
+	}
+	result["checkedPartner"] = checkedPartner
+	return result, nil
+}
+
+//EditUserPermission 编辑用户的权限
+func (service UsersService) EditUserPermission(cmd command.EditUserPermissionCommand) error {
+	var (
+		transactionContext, _ = factory.CreateTransactionContext(nil)
+		err                   error
+	)
+	if err = transactionContext.StartTransaction(); err != nil {
+		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
+	}
+	defer func() {
+		transactionContext.RollbackTransaction()
+	}()
+	var (
+		userRespository      domain.UsersRepository
+		usersData            domain.Users
+		permissionRepository domain.AdminPermissionRepository
+		permissionList       []domain.AdminPermission
+		partnerRespository   domain.PartnerInfoRepository
+		partnerList          []domain.PartnerInfo
+	)
+	if userRespository, err = factory.CreateUsersRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	usersData, err = userRespository.FindOne(domain.UsersFindOneQuery{
+		Id: cmd.Id,
+	})
+	if err != nil {
+		e := fmt.Sprintf("获取用户(id=%d)数据失败，%s", cmd.Id, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	if !usersData.InCompany(cmd.CompanyId) {
+		return lib.ThrowError(lib.BUSINESS_ERROR, "提交的数据异常")
+	}
+
+	if permissionRepository, err = factory.CreateAdminPermissionRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if len(cmd.PermissionType) > 0 {
+		permissionList, err = permissionRepository.Find(domain.PermissionFindOption{
+			Ids: cmd.PermissionType,
+		})
+		if err != nil {
+			e := fmt.Sprintf("获取权限列表数据失败：%s", err)
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+		}
+	}
+	if partnerRespository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	}); err != nil {
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if len(cmd.CheckedPartner) > 0 {
+		partnerList, err = partnerRespository.Find(domain.PartnerFindQuery{
+			Ids:       cmd.CheckedPartner,
+			CompanyId: cmd.CompanyId,
+		})
+		if err != nil {
+			e := fmt.Sprintf("获取合伙人列表数据失败：%s", err)
+			return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+		}
+	}
+	var (
+		partners        = make([]domain.Partner, 0, len(partnerList))
+		permissionsBase = make([]domain.AdminPermissionBase, 0)
+	)
+	for i := range partnerList {
+		p := partnerList[i].Partner
+		partners = append(partners, p)
+	}
+	for i := range permissionList {
+		if permissionList[i].Code == domain.PERMINSSION_ADMIN_USER && !usersData.IsSuperAdmin() {
+			return lib.ThrowError(lib.BUSINESS_ERROR, "操作异常")
+		}
+		p := domain.AdminPermissionBase{
+			Id:   permissionList[i].Id,
+			Code: permissionList[i].Code,
+		}
+		permissionsBase = append(permissionsBase, p)
+	}
+	updateMap := map[string]interface{}{
+		"AccessPartners": partners,
+	}
+	if !usersData.IsSuperAdmin() {
+		updateMap["Permission"] = permissionsBase
+	}
+	_ = usersData.Update(updateMap)
+	err = userRespository.Edit(&usersData)
+	if err != nil {
+		e := fmt.Sprintf("更新用户(id=%d)数据失败：%s", usersData.Id, err)
+		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
+	}
+	err = transactionContext.CommitTransaction()
+	return nil
+}

@@ -8,27 +8,35 @@ var LOG_LEVEL = "debug"
 var LOG_File = "./logs/partnermg.log"
 var LOG_File = "./logs/partnermg.log"
 
 
 var (
 var (
-	UCENTER_HOST      = "http://suplus-ucenter-dev.fjmaimaimai.com" //统一用户中心地址
+	UCENTER_HOST      = "https://suplus-ucenter-dev.fjmaimaimai.com" //统一用户中心地址
 	UCENTER_SECRET    = "cykbjnfqgctn"
 	UCENTER_SECRET    = "cykbjnfqgctn"
 	UCENTER_APP_KEY   = "39aefef9e22744a3b2d2d3791824ae7b"
 	UCENTER_APP_KEY   = "39aefef9e22744a3b2d2d3791824ae7b"
 	UCENTER_CHECK_ALT = "rsF0pL!6DwjBO735"
 	UCENTER_CHECK_ALT = "rsF0pL!6DwjBO735"
 )
 )
 
 
+var (
+	BUSINESS_ADMIN_HOST = "http://suplus-business-admin-dev.fjmaimaimai.com" //企业平台的地址
+)
+
 func init() {
 func init() {
 	if os.Getenv("LOG_LEVEL") != "" {
 	if os.Getenv("LOG_LEVEL") != "" {
 		LOG_LEVEL = os.Getenv("LOG_LEVEL")
 		LOG_LEVEL = os.Getenv("LOG_LEVEL")
 	}
 	}
 	if os.Getenv("UCENTER_HOST") != "" {
 	if os.Getenv("UCENTER_HOST") != "" {
-		LOG_LEVEL = os.Getenv("UCENTER_HOST")
+		UCENTER_HOST = os.Getenv("UCENTER_HOST")
 	}
 	}
 	if os.Getenv("UCENTER_SECRET") != "" {
 	if os.Getenv("UCENTER_SECRET") != "" {
-		LOG_LEVEL = os.Getenv("UCENTER_SECRET")
+		UCENTER_SECRET = os.Getenv("UCENTER_SECRET")
 	}
 	}
 	if os.Getenv("UCENTER_APP_KEY") != "" {
 	if os.Getenv("UCENTER_APP_KEY") != "" {
-		LOG_LEVEL = os.Getenv("UCENTER_APP_KEY")
+		UCENTER_APP_KEY = os.Getenv("UCENTER_APP_KEY")
 	}
 	}
 	if os.Getenv("UCENTER_CHECK_ALT") != "" {
 	if os.Getenv("UCENTER_CHECK_ALT") != "" {
-		LOG_LEVEL = os.Getenv("UCENTER_CHECK_ALT")
+		UCENTER_CHECK_ALT = os.Getenv("UCENTER_CHECK_ALT")
+	}
+
+	if os.Getenv("BUSINESS_ADMIN_HOST") != "" {
+		BUSINESS_ADMIN_HOST = os.Getenv("BUSINESS_ADMIN_HOST")
 	}
 	}
 
 
 }
 }

@@ -4,9 +4,9 @@ import "os"
 
 
 var POSTGRESQL_DB_NAME = "partner_dev"
 var POSTGRESQL_DB_NAME = "partner_dev"
 var POSTGRESQL_USER = "postgres"
 var POSTGRESQL_USER = "postgres"
-var POSTGRESQL_PASSWORD = "postgres_15432"
-var POSTGRESQL_HOST = "101.37.68.23"
-var POSTGRESQL_PORT = "15432"
+var POSTGRESQL_PASSWORD = "eagle1010"
+var POSTGRESQL_HOST = "114.55.200.59"
+var POSTGRESQL_PORT = "31543"
 var DISABLE_CREATE_TABLE = true
 var DISABLE_CREATE_TABLE = true
 var DISABLE_SQL_GENERATE_PRINT = false
 var DISABLE_SQL_GENERATE_PRINT = false
 
 

 package domain
 package domain
 
 
 //权限代码
 //权限代码
-//权限配置 1合作管理人 2订单管理 3分红管理 4管理员管理
+//权限配置 ：admin_permission表中对应的权限编码
 const (
 const (
 	PERMINSSION_PARTNER             string = "PARTER"                   //合作管理人
 	PERMINSSION_PARTNER             string = "PARTER"                   //合作管理人
 	PERMISSION_ORDER                string = "ORDER"                    //订单管理
 	PERMISSION_ORDER                string = "ORDER"                    //订单管理
@@ -9,29 +9,35 @@ const (
 	PERMINSSION_ADMIN_USER          string = "ADMIN"                    //管理员管理
 	PERMINSSION_ADMIN_USER          string = "ADMIN"                    //管理员管理
 	PERMINSSION_ORDER_ACTUA         string = "ORDER_ACTUA"              //实际订单
 	PERMINSSION_ORDER_ACTUA         string = "ORDER_ACTUA"              //实际订单
 	PERMINSSION_ORDER_INTENTION     string = "ORDER_INTENTION"          //意向订单
 	PERMINSSION_ORDER_INTENTION     string = "ORDER_INTENTION"          //意向订单
+	PERMISSION_ENTERPRISE_SET       string = "ENTERPRISE-SETTING"       //企业配置
+	PERMISSION_ENTERPRISE_SET_PHONE string = "ENTERPRISE-SETTING-PHONE" //企业配置电话号码
 )
 )
 
 
 type AdminPermissionBase struct {
 type AdminPermissionBase struct {
-	Id   int    `json:"id"`
+	Id   int64  `json:"id"`
 	Code string `json:"code"`
 	Code string `json:"code"`
 }
 }
 
 
 // 权限结构
 // 权限结构
 type AdminPermission struct {
 type AdminPermission struct {
-	Id       int    `json:"id"`
-	ParentId int    `json:"parentId"`
+	Id       int64  `json:"id"`
+	ParentId int64  `json:"parentId"`
 	Code     string `json:"code"`
 	Code     string `json:"code"`
 	Name     string `json:"name"`
 	Name     string `json:"name"`
 	Sort     int    `json:"sort"`
 	Sort     int    `json:"sort"`
 	Icon     string `json:"icon"`
 	Icon     string `json:"icon"`
 }
 }
 
 
-type AdminPermissionFindQuery struct {
-	IdsIn    []int
-	NotCode  []string
-	ParentId interface{}
+type PermissionFindOption struct {
+	Ids []int64
+}
+
+type PermissionFindOneOption struct {
+	Id   int64
+	Code string
 }
 }
 
 
 type AdminPermissionRepository interface {
 type AdminPermissionRepository interface {
-	Find(queryOptions AdminPermissionFindQuery) ([]AdminPermission, error)
+	Find(PermissionFindOption) ([]AdminPermission, error)
+	FindOne(PermissionFindOneOption) (AdminPermission, error)
 }
 }

+package domain
+
+import "time"
+
+// 业务分红信息 是否有效【0;无效】【1：有效】
+const (
+	BUSINESS_BONUS_ENABLE  int8 = 1
+	BUSINESS_BONUS_DISABLE int8 = 0
+)
+
+// 分红状态 1:待支付分红 2:已支付分红
+const (
+	//空状态
+	BUSINESS_BONUS_NULL_PAY int8 = 0
+	//待支付
+	BUSINESS_BONUS_WAIT_PAY int8 = 1
+	//已支付
+	BUSINESS_BONUS_HAS_PAY int8 = 2
+)
+
+func DescribeBusinessBonusStatus(i int8) string {
+	m := map[int8]string{
+		BUSINESS_BONUS_WAIT_PAY: "等待支付分红",
+		BUSINESS_BONUS_HAS_PAY:  "已支付分红",
+	}
+	if v, ok := m[i]; ok {
+		return v
+	}
+	return ""
+}
+
+//分红状态
+type BusinessBonusBonusStatus interface {
+	//状态变更为空
+	NullPayPartnerBonus(*BusinessBonus) error
+	//状态变更为待支付
+	WartPayPartnerBonus(*BusinessBonus) error
+	//状态变更为已支付
+	PayPartnerBonus(*BusinessBonus) error
+}
+
+// 业务分红信息
+type BusinessBonus struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 公司编号
+	CompanyId int64 `json:"companyId"`
+	// 合伙人信息Id
+	PartnerInfoId int64 `json:"partnerInfoId"`
+	// 应收分红
+	Bonus float64 `json:"bonus"`
+	// 未收分红
+	BonusNot float64 `json:"bonusNot"`
+	//已收分红
+	BonusHas float64 `json:"bonusHas"`
+	// 分红支出
+	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"`
+
+	BusinessBonusPayStatus BusinessBonusBonusStatus
+}
+
+type BusinessBonusNullPay struct{}
+
+var _ BusinessBonusBonusStatus = (*BusinessBonusNullPay)(nil)
+
+type BusinessBonusWaitPay struct{}
+
+var _ BusinessBonusBonusStatus = (*BusinessBonusWaitPay)(nil)
+
+//OrderGoodBonusHasPay 货品分红已支付
+type BusinessBonusHasPay struct{}
+
+var _ BusinessBonusBonusStatus = (*BusinessBonusHasPay)(nil)
+
+// -----默认空状态-----
+//状态变更为空
+func (pay BusinessBonusNullPay) NullPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusStatus = 0
+	bonus.BonusExpense = 0
+	bonus.BonusHas = 0
+	bonus.BonusNot = 0
+	bonus.Bonus = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusNullPay{}
+	return nil
+}
+
+//状态变更为待支付
+func (pay BusinessBonusNullPay) WartPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_WAIT_PAY
+	bonus.BonusHas = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusWaitPay{}
+	return nil
+}
+
+//状态变更为已支付
+func (pay BusinessBonusNullPay) PayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = 0
+	bonus.BonusHas = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_HAS_PAY
+	bonus.BusinessBonusPayStatus = &BusinessBonusHasPay{}
+	return nil
+}
+
+// -----待支付状态-----
+//状态变更为空
+func (pay BusinessBonusWaitPay) NullPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusStatus = 0
+	bonus.BonusExpense = 0
+	bonus.BonusHas = 0
+	bonus.BonusNot = 0
+	bonus.Bonus = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusNullPay{}
+	return nil
+}
+
+//状态变更为待支付
+func (pay BusinessBonusWaitPay) WartPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_WAIT_PAY
+	bonus.BonusHas = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusWaitPay{}
+	return nil
+}
+
+//状态变更为已支付
+func (pay BusinessBonusWaitPay) PayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = 0
+	bonus.BonusHas = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_HAS_PAY
+	bonus.BusinessBonusPayStatus = &BusinessBonusHasPay{}
+	return nil
+}
+
+// -----已经支付状态-----
+//状态变更为空
+func (pay BusinessBonusHasPay) NullPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusStatus = 0
+	bonus.BonusExpense = 0
+	bonus.BonusHas = 0
+	bonus.BonusNot = 0
+	bonus.Bonus = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusNullPay{}
+	return nil
+}
+
+//状态变更为待支付
+func (pay BusinessBonusHasPay) WartPayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_WAIT_PAY
+	bonus.BonusHas = 0
+	bonus.BusinessBonusPayStatus = &BusinessBonusWaitPay{}
+	return nil
+}
+
+//状态变更为已支付
+func (pay BusinessBonusHasPay) PayPartnerBonus(bonus *BusinessBonus) error {
+	bonus.BonusNot = 0
+	bonus.BonusHas = bonus.Bonus
+	bonus.BonusStatus = BUSINESS_BONUS_HAS_PAY
+	bonus.BusinessBonusPayStatus = &BusinessBonusHasPay{}
+	return nil
+}
+
+type BusinessBonusFindOneQuery struct {
+	Id        int64
+	PartnerId int64
+	CompanyId int64
+}
+type BusinessBonusFindQuery struct {
+	Offset int
+	Limit  int
+}
+
+type BusinessBonusRepository interface {
+	Add(dm *BusinessBonus) error
+	Edit(dm *BusinessBonus) error
+	FindOne(BusinessBonusFindOneQuery) (*BusinessBonus, error)
+	Find(BusinessBonusFindQuery) (int, []BusinessBonus, error)
+}

+package domain
+
+import (
+	"fmt"
+	"time"
+)
+
+// 公司的状态 1正常 2禁用
+const (
+	companyStatusUsable   int8 = 1
+	companyStatusUnusable int8 = 2
+)
+
+//是否开启机会模块，是否有效【1:有效】【2:无效】
+const (
+	CompanyEnableYes int8 = 1
+	CompanyEnableNo  int8 = 2
+)
+
+// 公司信息
+type Company struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 名称
+	Name string `json:"name"`
+	//简称
+	Abbreviation string `json:"abbreviation"`
+	// 手机号码
+	Phone string `json:"phone"`
+	// 公司logo
+	Logo string `json:"logo"`
+	// 备注
+	Remarks string `json:"remarks"`
+	// 总后台的公司id
+	AdminCompanyId int `json:"adminCompanyId"`
+	//是否有效【1:有效】【2:无效】
+	Enable int8 `json:"enable"`
+	// 创建时间
+	CreateAt time.Time `json:"createAt"`
+	// 更新时间
+	UpdateAt time.Time `json:"updateAt"`
+	// 删除时间
+	DeleteAt time.Time `json:"deleteAt"`
+}
+
+// func (c Company) StatusIsOk() bool {
+// 	return c.Status == companyStatusUsable
+// }
+
+func (c Company) EnableIsOk() bool {
+	return c.Enable == CompanyEnableYes
+}
+
+func (c *Company) Update(m map[string]interface{}) error {
+	if v, ok := m["Name"]; ok {
+		c.Name = fmt.Sprint(v)
+	}
+	if v, ok := m["Phone"]; ok {
+		c.Phone = fmt.Sprint(v)
+	}
+	if v, ok := m["Logo"]; ok {
+		c.Logo = fmt.Sprint(v)
+	}
+	if v, ok := m["Remarks"]; ok {
+		c.Remarks = fmt.Sprint(v)
+	}
+	if v, ok := m["AdminCompanyId"]; ok {
+		c.AdminCompanyId = v.(int)
+	}
+	if v, ok := m["Remarks"]; ok {
+		c.Remarks = fmt.Sprint(v)
+	}
+	if v, ok := m["Enable"]; ok {
+		c.Enable = v.(int8)
+	}
+	if v, ok := m["Abbreviation"]; ok {
+		c.Abbreviation = v.(string)
+	}
+	return nil
+}
+
+type CompanyFindOneOptions struct {
+	Id             int64
+	AdminCompanyId int64
+}
+
+type CompanyFindOptions struct {
+}
+
+type CompanyRepository interface {
+	Add(*Company) error
+	Edit(*Company) error
+	FindOne(queryOptions CompanyFindOneOptions) (Company, error)
+	Find(queryOptions CompanyFindOptions) (int64, []Company, error)
+}

@@ -37,9 +37,9 @@ type OrderBase struct {
 	//交货编号
 	//交货编号
 	DeliveryCode string `json:"deliveryCode"`
 	DeliveryCode string `json:"deliveryCode"`
 	//买家
 	//买家
-	Buyer *Buyer `json:"buyer"`
+	Buyer Buyer `json:"buyer"`
 	//订单区域信息
 	//订单区域信息
-	RegionInfo *RegionInfo `json:"regionInfo"`
+	RegionInfo RegionInfo `json:"regionInfo"`
 	//订单对应的合伙人
 	//订单对应的合伙人
 	PartnerId   int64   `json:"partnerId"`
 	PartnerId   int64   `json:"partnerId"`
 	PartnerInfo Partner `json:"partnerInfo"`
 	PartnerInfo Partner `json:"partnerInfo"`
@@ -59,6 +59,8 @@ type OrderBase struct {
 	IsDisable int `json:"isDisable"`
 	IsDisable int `json:"isDisable"`
 	//分红支付状态
 	//分红支付状态
 	BonusStatus int `json:"bonusStatus"`
 	BonusStatus int `json:"bonusStatus"`
+	//公司
+	CompanyId int64 `json:"companyId"`
 }
 }
 
 
 type OrderCompute struct {
 type OrderCompute struct {
@@ -179,6 +181,7 @@ func (order *OrderBase) Compute() error {
 
 
 type OrderBaseFindOneQuery struct {
 type OrderBaseFindOneQuery struct {
 	OrderId   int64
 	OrderId   int64
+	CompanyId int64
 }
 }
 
 
 type OrderBaseFindQuery struct {
 type OrderBaseFindQuery struct {
@@ -188,11 +191,12 @@ type OrderBaseFindQuery struct {
 	Offset       int
 	Offset       int
 	Limit        int
 	Limit        int
 	OrderType    int
 	OrderType    int
+	CompanyId    int64
 }
 }
 
 
 type OrderBaseRepository interface {
 type OrderBaseRepository interface {
 	Save(order *OrderBase) error
 	Save(order *OrderBase) error
 	FindOne(qureyOptions OrderBaseFindOneQuery) (*OrderBase, error)
 	FindOne(qureyOptions OrderBaseFindOneQuery) (*OrderBase, error)
 	Find(queryOptions OrderBaseFindQuery) ([]OrderBase, int, error)
 	Find(queryOptions OrderBaseFindQuery) ([]OrderBase, int, error)
-	Remove(id int64) error
+	Remove(id int64, companyId int64) error
 }
 }

@@ -48,6 +48,8 @@ type OrderGood struct {
 	CurrentBonusStatus OrderGoodBonusStatus `json:"-"`
 	CurrentBonusStatus OrderGoodBonusStatus `json:"-"`
 	///核算订单相关数据
 	///核算订单相关数据
 	GoodCompute GoodCompute `json:"goodCompute"`
 	GoodCompute GoodCompute `json:"goodCompute"`
+	//公司
+	CompanyId int64
 }
 }
 
 
 type GoodCompute struct {
 type GoodCompute struct {
@@ -173,10 +175,11 @@ type OrderGoodFindQuery struct {
 	OrderId   int64
 	OrderId   int64
 	Offset    int
 	Offset    int
 	Limit     int
 	Limit     int
+	CompanyId int64
 }
 }
 
 
 type OrderGoodRepository interface {
 type OrderGoodRepository interface {
 	Save(order []OrderGood) error
 	Save(order []OrderGood) error
 	Find(queryOptions OrderGoodFindQuery) ([]OrderGood, int, error)
 	Find(queryOptions OrderGoodFindQuery) ([]OrderGood, int, error)
-	Remove(orderid int64, ids ...int64) error
+	Remove(orderid int64, companyId int64, ids ...int64) error
 }
 }

+package domain
+
+// 合伙人分类信息
+type PartnerCategory struct {
+	// 唯一标识
+	Id int64 `json:"id"`
+	// 名称
+	Name string `json:"name,omitempty"`
+}
+
+type PartnerCategoryFindQuery struct {
+	Ids []int64
+}
+type PartnerCategoryRepository interface {
+	Find(PartnerCategoryFindQuery) (int, []PartnerCategory, error)
+}

 package domain
 package domain
 
 
 import (
 import (
-	"fmt"
 	"time"
 	"time"
 )
 )
 
 
@@ -12,25 +11,23 @@ const (
 )
 )
 
 
 //合伙类别 （1.事业合伙人 2.业务合伙人  3.研发合伙人)
 //合伙类别 （1.事业合伙人 2.业务合伙人  3.研发合伙人)
-const (
-	PARTNER_CATEGORY_1 int = 1
-	PARTNER_CATEGORY_2 int = 2
-	PARTNER_CATEGORY_3 int = 3
-	PARTNER_CATEGORY_4 int = 4
-)
+// const (
+// 	PARTNER_CATEGORY_1 int = 1
+// 	PARTNER_CATEGORY_2 int = 2
+// 	PARTNER_CATEGORY_3 int = 3
+// 	PARTNER_CATEGORY_4 int = 4
+// )
 
 
-//partnerCategoryMap 合伙类别键值对 （只读，请勿在运行时修改）
-var partnerCategoryMap = map[int]string{
-	PARTNER_CATEGORY_1: "事业合伙人",
-	PARTNER_CATEGORY_2: "业务合伙人",
-	PARTNER_CATEGORY_3: "研发合伙人",
-	PARTNER_CATEGORY_4: "业务-产品应用合伙人",
-}
+// //partnerCategoryMap 合伙类别键值对 （只读，请勿在运行时修改）
+// var partnerCategoryMap = map[int]string{
+// 	PARTNER_CATEGORY_1: "事业合伙人",
+// 	PARTNER_CATEGORY_2: "业务合伙人",
+// 	PARTNER_CATEGORY_3: "研发合伙人",
+// 	PARTNER_CATEGORY_4: "业务-产品应用合伙人",
+// }
 
 
 type PartnerInfo struct {
 type PartnerInfo struct {
 	Partner Partner `json:"partner"`
 	Partner Partner `json:"partner"`
-	//合伙类别
-	PartnerCategory int `json:"partnerCategory"`
 	// 登录密码
 	// 登录密码
 	Password string `json:"password"`
 	Password string `json:"password"`
 	// 状态（1：启用或者0：禁用）
 	// 状态（1：启用或者0：禁用）
@@ -41,38 +38,30 @@ type PartnerInfo struct {
 	UpdateAt time.Time `json:"updateAt"`
 	UpdateAt time.Time `json:"updateAt"`
 	//合作时间
 	//合作时间
 	CooperateTime time.Time `json:"cooperateTime"`
 	CooperateTime time.Time `json:"cooperateTime"`
-	//关联业务员//所属区域信息
-	RegionInfo *RegionInfo `json:"regionInfo"`
-
+	//所属区域信息
+	RegionInfo RegionInfo `json:"regionInfo"`
+	//关联业务员
 	Salesman []Salesman `json:"salesman"`
 	Salesman []Salesman `json:"salesman"`
+	//合伙人分类
+	PartnerCategoryInfos []PartnerCategory `json:"partnerCategoryInfos"`
+	//合伙类别
+	PartnerCategory int `json:"partnerCategory"`
+	//公司id
+	CompanyId int64 `json:"companyId"`
 }
 }
 
 
-func (p *PartnerInfo) GetPartnerCategory() map[int]string {
-	categoryMap := map[int]string{}
-	for k, v := range partnerCategoryMap {
-		//合伙类别 按二进制位区分
-		if (p.PartnerCategory & k) > 0 {
-			categoryMap[k] = v
-		}
-	}
-	return categoryMap
+func (p *PartnerInfo) IsUsable() bool {
+	return p.Status == PARTNER_STATUS_YES
 }
 }
 
 
-func (p *PartnerInfo) SetPartnerCategory(category []int) error {
-	n := 0
-	for _, v := range category {
-		if _, ok := partnerCategoryMap[v]; !ok {
-			return fmt.Errorf("未知的合伙人类型：%d", v)
-		}
-		n += v
-	}
-	p.PartnerCategory = n
-	return nil
+func (p *PartnerInfo) IsCompany(companyId int64) bool {
+	return p.CompanyId == companyId
 }
 }
 
 
 type PartnerFindOneQuery struct {
 type PartnerFindOneQuery struct {
 	UserId       int64
 	UserId       int64
 	AccountEqual string
 	AccountEqual string
+	CompanyId    int64
 }
 }
 
 
 type PartnerFindQuery struct {
 type PartnerFindQuery struct {
@@ -81,10 +70,12 @@ type PartnerFindQuery struct {
 	PartnerCategory []int       //合伙人类型
 	PartnerCategory []int       //合伙人类型
 	RegionInfo      *RegionInfo //区域
 	RegionInfo      *RegionInfo //区域
 	PartnerName     string      //合伙人姓名
 	PartnerName     string      //合伙人姓名
+	CompanyId       int64
+	Ids             []int64
 }
 }
 
 
 type PartnerInfoRepository interface {
 type PartnerInfoRepository interface {
-	Save(dm PartnerInfo) (*PartnerInfo, error)
+	Save(dm *PartnerInfo) error
 	FindOne(queryOptions PartnerFindOneQuery) (*PartnerInfo, error)
 	FindOne(queryOptions PartnerFindOneQuery) (*PartnerInfo, error)
 	Find(queryOptions PartnerFindQuery) ([]PartnerInfo, error)
 	Find(queryOptions PartnerFindQuery) ([]PartnerInfo, error)
 	CountAll(queryOptions PartnerFindQuery) (int, error)
 	CountAll(queryOptions PartnerFindQuery) (int, error)

+package service
+
+type BusinessBonusService interface {
+	EnableOrDisable(userid int64) error
+}

+package domain
+
+import "time"
+
+//用户是否可用状态：【1：正常】【 2：禁用】
+const (
+	userStatusUsable   int8 = 1
+	userStatusUnusable int8 = 2
+)
+
+//用户是否是主管 ：【1：是主管】【 2：不是主管】
+const (
+	UserIsCompanyCharge    int8 = 1
+	UserIsNotCompanyCharge int8 = 2
+)
+
+//用户类型 1普通用户 2主管理员
+const (
+	UserIsNotAdmin int8 = 1
+	UserIsAdmin    int8 = 2
+)
+
+//Users 企业平台的用户
+type Users struct {
+	Id             int64     //用户id
+	CompanyId      int64     //公司id
+	OpenId         int64     //统一用户中心
+	Name           string    //用户名称
+	Sex            int8      //性别：【0：未知】【1：男】【2：女】
+	JobNum         string    //工号
+	Phone          string    //手机号，同账号
+	PrivatePhone   string    //私人手机号
+	Email          string    //邮件
+	ExtensionNum   string    //分机号
+	EntryTime      time.Time //入职时间
+	Workspace      string    //工作地
+	Status         int8      //状态：【1：正常】【 2：禁用】
+	Avatar         string    ///头像
+	Remarks        string    //备注
+	ChargeStatus   int8      //是否为当前公司主管 【1：是】【2：否】
+	CreateAt       time.Time
+	UpdateAt       time.Time
+	Permission     []AdminPermissionBase //权限
+	AccessPartners []Partner
+	AdminType      int8 //是否是公司负责人，即超级管理员 1普通用户 2主管理员
+}
+
+//IsUsable 用户是否可用
+func (u Users) IsUsable() bool {
+	return u.Status == userStatusUsable
+}
+
+//IsSuperAdmin 用户是否是负责人
+func (u Users) IsSuperAdmin() bool {
+	return u.AdminType == UserIsAdmin
+}
+
+func (u Users) InCompany(companyid int64) bool {
+	return u.CompanyId == companyid
+}
+
+func (u Users) HasPermissionByCode(code string) bool {
+	if u.IsSuperAdmin() {
+		return true
+	}
+	for _, v := range u.Permission {
+		if v.Code == code {
+			return true
+		}
+	}
+	return false
+}
+
+func (u *Users) Update(m map[string]interface{}) error {
+	if v, ok := m["CompanyId"]; ok {
+		u.CompanyId = v.(int64)
+	}
+	if v, ok := m["OpenId"]; ok {
+		u.OpenId = v.(int64)
+	}
+	if v, ok := m["Name"]; ok {
+		u.Name = v.(string)
+	}
+	if v, ok := m["Sex"]; ok {
+		u.Sex = v.(int8)
+	}
+	if v, ok := m["JobNum"]; ok {
+		u.JobNum = v.(string)
+	}
+	if v, ok := m["Phone"]; ok {
+		u.Phone = v.(string)
+	}
+	if v, ok := m["PrivatePhone"]; ok {
+		u.PrivatePhone = v.(string)
+	}
+	if v, ok := m["Email"]; ok {
+		u.Email = v.(string)
+	}
+	if v, ok := m["ExtensionNum"]; ok {
+		u.ExtensionNum = v.(string)
+	}
+	if v, ok := m["EntryTime"]; ok {
+		u.EntryTime = v.(time.Time)
+	}
+	if v, ok := m["Workspace"]; ok {
+		u.Workspace = v.(string)
+	}
+	if v, ok := m["Status"]; ok {
+		u.Status = v.(int8)
+	}
+	if v, ok := m["Avatar"]; ok {
+		u.Avatar = v.(string)
+	}
+	if v, ok := m["Remarks"]; ok {
+		u.Remarks = v.(string)
+	}
+	if v, ok := m["ChargeStatus"]; ok {
+		u.ChargeStatus = v.(int8)
+	}
+	if v, ok := m["Permission"]; ok {
+		u.Permission = v.([]AdminPermissionBase)
+	}
+	if v, ok := m["AccessPartners"]; ok {
+		u.AccessPartners = v.([]Partner)
+	}
+	if v, ok := m["AdminType"]; ok {
+		u.AdminType = v.(int8)
+	}
+	return nil
+}
+
+type UsersFindOneQuery struct {
+	Id        int64
+	Phone     string
+	CompanyId int64
+	OpenId    int64
+}
+
+type UsersFindQuery struct {
+	AdminType     int8
+	ChargeStatus  int8
+	CompanyId     int64
+	Ids           []int64
+	Offset        int
+	Limit         int
+	UserNameMatch string
+}
+type UsersRepository interface {
+	Add(*Users) error
+	Edit(*Users) error
+	Remove([]int64) error
+	FindOne(queryOptions UsersFindOneQuery) (Users, error)
+	Find(queryOptions UsersFindQuery) (int, []Users, error)
+}

-package dao
-
-import (
-	"fmt"
-
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
-)
-
-type AdminUserDao struct {
-	transactionContext *transaction.TransactionContext
-}
-
-func NewAdminUserDao(transactionContext *transaction.TransactionContext) (*AdminUserDao, error) {
-	if transactionContext == nil {
-		return nil, fmt.Errorf("transactionContext参数不能为nil")
-	} else {
-		return &AdminUserDao{
-			transactionContext: transactionContext,
-		}, nil
-	}
-}
-
-//UpdatePassword ....
-func (dao *AdminUserDao) UpdatePassword(id int64, pwd string) error {
-	tx := dao.transactionContext.PgDd
-	m := &models.AdminUser{}
-	err := tx.Model(m).Where("id=?", id).First()
-	if err != nil {
-		return err
-	}
-	_, err = tx.Model(m).Where("id=?", id).
-		Set("password=?", pwd).
-		Update()
-	return err
-}
-
-//UpdatePassword ....
-func (dao *AdminUserDao) UpdateIsUsable(id int64, isUsable bool) error {
-	tx := dao.transactionContext.PgDd
-	m := &models.AdminUser{}
-	err := tx.Model(m).Where("id=?", id).First()
-	if err != nil {
-		return err
-	}
-	_, err = tx.Model(m).Where("id=?", id).
-		Set("is_usable=?", isUsable).
-		Update()
-	return err
-}
-
-//AdminUserAccountExist ...
-func (dao *AdminUserDao) AdminUserAccountExist(account string) (bool, error) {
-	tx := dao.transactionContext.PgDd
-	m := &models.AdminUser{}
-	ok, err := tx.Model(m).
-		Where("account=?", account).
-		Exists()
-
-	return ok, err
-}
-
-func (dao *AdminUserDao) AdminUserIsDefault(id int64) (bool, error) {
-	tx := dao.transactionContext.PgDd
-	m := &models.AdminUser{}
-	err := tx.Model(m).
-		Where("id=?", id).
-		Column("is_default").
-		First()
-
-	return m.IsDefault, err
-}

+package dao
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
+)
+
+type BusinessBonusDao struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func NewBusinessBonusDao(transactionContext *transaction.TransactionContext) (*BusinessBonusDao, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	} else {
+		return &BusinessBonusDao{
+			transactionContext: transactionContext,
+		}, nil
+	}
+}
+
+type CustomBusinessBonus struct {
+	Id           int64
+	Bonus        string
+	BonusNot     string
+	BonusExpense string
+	BonusHas     string
+	BonusStatus  int8
+	PartnerName  string
+	UpdateAt     time.Time
+}
+
+func (dao BusinessBonusDao) SearchBusinessBonus(partnerId int64, partnerNameMatch string,
+	companyId int64, limit int, offset int) ([]CustomBusinessBonus, error) {
+	sql := `SELECT business_bonus.id, business_bonus.bonus,business_bonus.bonus_not
+	,business_bonus.bonus_expense,business_bonus.bonus_status,business_bonus.update_at
+	,partner_info.partner_name,business_bonus.bonus_has
+	FROM business_bonus 
+	JOIN partner_info ON business_bonus.partner_info_id=partner_info.id
+	WHERE business_bonus.is_disable=? AND business_bonus.company_id = ? `
+	partnerCondition := []string{}
+	allParam := []interface{}{domain.BUSINESS_BONUS_ENABLE, companyId}
+	if partnerId > 0 {
+		partnerCondition = append(partnerCondition, ` business_bonus.partner_info_id=? `)
+		allParam = append(allParam, partnerId)
+	}
+	if len(partnerNameMatch) > 0 {
+		allParam = append(allParam, "%"+partnerNameMatch+"%")
+		partnerCondition = append(partnerCondition, ` partner_info.partner_name like ? `)
+	}
+	if len(partnerCondition) > 0 {
+		sql += fmt.Sprintf(" AND (%s)", strings.Join(partnerCondition, " OR "))
+	}
+	sql += `ORDER BY  business_bonus.id DESC limit ? OFFSET ? `
+	allParam = append(allParam, limit, offset)
+	tx := dao.transactionContext.PgTx
+	var (
+		result []CustomBusinessBonus
+		err    error
+	)
+	_, err = tx.Query(&result, sql, allParam...)
+	return result, err
+}
+
+func (dao BusinessBonusDao) CountBusinessBonus(partnerId int64, partnerNameMatch string,
+	companyId int64, limit int, offset int) (int, error) {
+	sql := `SELECT count(*) 
+	FROM business_bonus 
+	JOIN partner_info ON business_bonus.partner_info_id=partner_info.id
+	WHERE business_bonus.is_disable=? AND business_bonus.company_id = ? `
+	partnerCondition := []string{}
+	allParam := []interface{}{domain.BUSINESS_BONUS_ENABLE, companyId}
+	if partnerId > 0 {
+		partnerCondition = append(partnerCondition, ` business_bonus.partner_info_id=? `)
+		allParam = append(allParam, partnerId)
+	}
+	if len(partnerNameMatch) > 0 {
+		allParam = append(allParam, "%"+partnerNameMatch+"%")
+		partnerCondition = append(partnerCondition, ` partner_info.partner_name like ? `)
+	}
+	if len(partnerCondition) > 0 {
+		sql += fmt.Sprintf(" AND (%s)", strings.Join(partnerCondition, " OR "))
+	}
+	tx := dao.transactionContext.PgTx
+	var (
+		result int
+		err    error
+	)
+	_, err = tx.Query(&result, sql, allParam...)
+	return result, err
+}
+
+func (dao BusinessBonusDao) ExistBusinessBonus(userId int64) (bool, error) {
+	tx := dao.transactionContext.PgTx
+	ok, err := tx.Model(&models.BusinessBonus{}).
+		Where("partner_info_id=?", userId).
+		Exists()
+	return ok, err
+}

@@ -32,10 +32,10 @@ func (dao OrderBaseDao) OrderCodeExist(code string, notId ...int64) (bool, error
 	return ok, err
 	return ok, err
 }
 }
 
 
-func (dao OrderBaseDao) DeliveryCodeExist(code string, notId ...int64) (bool, error) {
+func (dao OrderBaseDao) DeliveryCodeExist(code string, companyId int64, notId ...int64) (bool, error) {
 	tx := dao.transactionContext.PgDd
 	tx := dao.transactionContext.PgDd
 	m := &models.OrderBase{}
 	m := &models.OrderBase{}
-	query := tx.Model(m).Where("delivery_code=?", code)
+	query := tx.Model(m).Where("delivery_code=?", code).Where("company_id=?", companyId)
 	if len(notId) > 0 {
 	if len(notId) > 0 {
 		query = query.WhereIn("id not in(?)", notId)
 		query = query.WhereIn("id not in(?)", notId)
 	}
 	}

@@ -21,12 +21,24 @@ func NewPartnerInfoDao(transactionContext *transaction.TransactionContext) (*Par
 	}
 	}
 }
 }
 
 
-func (dao PartnerInfoDao) PartnerAccountExist(account string) (bool, error) {
+func (dao PartnerInfoDao) PartnerAccountExist(account string, companyId int64) (bool, error) {
 	tx := dao.transactionContext.PgDd
 	tx := dao.transactionContext.PgDd
 	m := &models.PartnerInfo{}
 	m := &models.PartnerInfo{}
 	ok, err := tx.Model(m).
 	ok, err := tx.Model(m).
 		Where("account=?", account).
 		Where("account=?", account).
+		Where("company_id=?", companyId).
 		Exists()
 		Exists()
 
 
 	return ok, err
 	return ok, err
 }
 }
+
+func (dao PartnerInfoDao) UpdatePartnerStatus(ids []int64, companyId int64, status int) error {
+	tx := dao.transactionContext.PgDd
+	m := &models.PartnerInfo{}
+	_, err := tx.Model(m).
+		WhereIn("id in (?)", ids).
+		Where("company_id=?", companyId).
+		Set("status=?", status).
+		Update()
+	return err
+}

+package dao
+
+import (
+	"fmt"
+
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
+)
+
+type UsersDao struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func NewUsersDao(transactionContext *transaction.TransactionContext) (*UsersDao, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	} else {
+		return &UsersDao{
+			transactionContext: transactionContext,
+		}, nil
+	}
+}
+
+func (dao UsersDao) UpdateUserStatus(ids []int64, ststus int8) error {
+	tx := dao.transactionContext.PgTx
+	m := &models.Users{}
+	_, err := tx.Model(m).
+		Set("status=?", ststus).
+		WhereIn("id in(?)", ids).
+		Update()
+	return err
+}

+package domainService
+
+import (
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/repository"
+)
+
+type BusinessBonusService struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func NewBusinessBonusService(tcx *transaction.TransactionContext) *BusinessBonusService {
+	return &BusinessBonusService{
+		transactionContext: tcx,
+	}
+}
+func (srv BusinessBonusService) EnableOrDisable(parntnerId int64) error {
+	var (
+		bonusDao, _           = dao.NewBusinessBonusDao(srv.transactionContext)
+		bonusReponsitory, _   = repository.NewBusinessBonusRepository(srv.transactionContext)
+		partnerReponsitory, _ = repository.NewPartnerInfoRepository(srv.transactionContext)
+
+		err                        error
+		partnerHasInBonus          bool
+		partnerData                *domain.PartnerInfo
+		partnerHasBusinessCategory bool
+	)
+	partnerHasInBonus, err = bonusDao.ExistBusinessBonus(parntnerId)
+	if err != nil {
+		return err
+	}
+	partnerData, err = partnerReponsitory.FindOne(domain.PartnerFindOneQuery{UserId: parntnerId})
+	if err != nil {
+		return err
+	}
+	for _, v := range partnerData.PartnerCategoryInfos {
+		if v.Id == 2 {
+			partnerHasBusinessCategory = true
+			break
+		}
+	}
+	if partnerHasInBonus && partnerHasBusinessCategory {
+		//已存在业务分红数据况 && 是业务合伙人类型
+		var bonusData *domain.BusinessBonus
+		bonusData, err = bonusReponsitory.FindOne(domain.BusinessBonusFindOneQuery{
+			PartnerId: parntnerId,
+		})
+		if bonusData.IsDisable == domain.BUSINESS_BONUS_ENABLE {
+			return nil
+		}
+		bonusData.IsDisable = domain.BUSINESS_BONUS_ENABLE
+		err = bonusReponsitory.Edit(bonusData)
+		return err
+	}
+	if partnerHasInBonus && !partnerHasBusinessCategory {
+		//已存在业务分红数据况 && 不是业务合伙人类型
+		var bonusData *domain.BusinessBonus
+		bonusData, err = bonusReponsitory.FindOne(domain.BusinessBonusFindOneQuery{
+			PartnerId: parntnerId,
+		})
+		if bonusData.IsDisable == domain.BUSINESS_BONUS_DISABLE {
+			return nil
+		}
+		bonusData.IsDisable = domain.BUSINESS_BONUS_DISABLE
+		err = bonusReponsitory.Edit(bonusData)
+		return err
+	}
+
+	if !partnerHasInBonus && partnerHasBusinessCategory {
+		//不存在业务分红数据况 && 是业务合伙人类型
+		newBonus := &domain.BusinessBonus{
+			PartnerInfoId: partnerData.Partner.Id,
+			IsDisable:     domain.BUSINESS_BONUS_ENABLE,
+			CompanyId:     partnerData.CompanyId,
+			Bonus:         0,
+		}
+		err = bonusReponsitory.Add(newBonus)
+		return err
+	}
+
+	return nil
+}

@@ -3,13 +3,13 @@ package models
 type AdminPermission struct {
 type AdminPermission struct {
 	tableName struct{} `pg:"admin_permission,alias:admin_permission"`
 	tableName struct{} `pg:"admin_permission,alias:admin_permission"`
 	//id
 	//id
-	Id int `pg:",pk"`
+	Id int64 `pg:",pk"`
 	//权限名称、菜单名称
 	//权限名称、菜单名称
 	Name string
 	Name string
 	//权限编码
 	//权限编码
 	Code string
 	Code string
 	//父级id
 	//父级id
-	ParentId int
+	ParentId int64
 	//排序编号
 	//排序编号
 	Sort int
 	Sort int
 	//图标
 	//图标

-package models
-
-import (
-	"context"
-	"time"
-
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
-
-	"github.com/go-pg/pg/v10"
-)
-
-type AdminUser struct {
-	tableName struct{} `pg:"admin_user,alias:admin_user"`
-	//id
-	Id int64 `pg:",pk"`
-	//用户账号
-	Account string `pg:",unique"`
-	//用户名称
-	AdminName string
-	//账号密码
-	Password string
-	//是否是默认账号
-	IsDefault bool `pg:",use_zero"`
-	//账号是否可用
-	IsUsable bool `pg:",use_zero"`
-	//用户的权限
-	Permission []domain.AdminPermissionBase
-
-	CreateAt time.Time
-	UpdateAt time.Time
-}
-
-var _ pg.BeforeUpdateHook = (*AdminUser)(nil)
-
-func (user *AdminUser) BeforeUpdate(ctx context.Context) (context.Context, error) {
-	user.UpdateAt = time.Now()
-	return ctx, nil
-}
-
-var _ pg.BeforeInsertHook = (*AdminUser)(nil)
-
-func (user *AdminUser) BeforeInsert(ctx context.Context) (context.Context, error) {
-	user.CreateAt = time.Now()
-	user.UpdateAt = time.Now()
-	return ctx, nil
-}

+package models
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-pg/pg/v10"
+)
+
+// 业务分红信息
+type BusinessBonus struct {
+	tableName struct{} `pg:"business_bonus"`
+	//	唯一标识
+	Id int64 `pg:",pk"`
+	//	公司编号
+	CompanyId int64
+	//	合伙人信息Id
+	PartnerInfoId int64
+	//	应收分红
+	Bonus float64 `pg:",use_zero"`
+	//	未收分红
+	BonusNot float64 `pg:",use_zero"`
+	//	分红支出
+	BonusExpense float64 `pg:",use_zero"`
+	//已收分红
+	BonusHas float64 `pg:",use_zero"`
+	//是否有效【0;无效】【1：有效】
+	IsDisable int8 `pg:",use_zero"`
+	//	分红状态 1:待支付分红 2:已支付分红
+	BonusStatus int8 `pg:",use_zero"`
+	//	创建时间
+	CreateAt time.Time
+	//	更新时间
+	UpdateAt time.Time
+	//	删除时间
+	DeleteAt time.Time
+}
+
+var _ pg.BeforeUpdateHook = (*BusinessBonus)(nil)
+
+func (bonus *BusinessBonus) BeforeUpdate(ctx context.Context) (context.Context, error) {
+	bonus.UpdateAt = time.Now()
+	return ctx, nil
+}
+
+var _ pg.BeforeInsertHook = (*BusinessBonus)(nil)
+
+func (bonus *BusinessBonus) BeforeInsert(ctx context.Context) (context.Context, error) {
+	bonus.CreateAt = time.Now()
+	return ctx, nil
+}

+package models
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-pg/pg/v10"
+)
+
+// 公司信息
+type Company struct {
+	tableName struct{} `pg:"company"`
+	//	唯一标识
+	Id int64 `pg:",pk"`
+	//	名称
+	Name string
+	//简称
+	Abbreviation string
+	//	手机号码
+	Phone string
+	//	公司logo
+	Logo string
+	//	备注
+	Remarks string
+	//	总后台的公司id
+	AdminCompanyId int
+	//	状态 1正常 2禁用
+	//Status int8
+	//是否开启机会模块，是否有效【1:有效】【2:无效】
+	Enable int8
+	//	创建时间
+	CreateAt time.Time
+	//	更新时间
+	UpdateAt time.Time
+	//	删除时间
+	DeleteAt time.Time
+}
+
+var _ pg.BeforeUpdateHook = (*Company)(nil)
+
+func (c *Company) BeforeUpdate(ctx context.Context) (context.Context, error) {
+	c.UpdateAt = time.Now()
+	return ctx, nil
+}
+
+var _ pg.BeforeInsertHook = (*Company)(nil)
+
+func (c *Company) BeforeInsert(ctx context.Context) (context.Context, error) {
+	c.CreateAt = time.Now()
+	c.UpdateAt = time.Now()
+	return ctx, nil
+}

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

@@ -20,9 +20,9 @@ type OrderBase struct {
 	//交货编号
 	//交货编号
 	DeliveryCode string
 	DeliveryCode string
 	//买家
 	//买家
-	Buyer *domain.Buyer
+	Buyer domain.Buyer
 	//订单区域信息
 	//订单区域信息
-	RegionInfo *domain.RegionInfo
+	RegionInfo domain.RegionInfo
 	//订单对应的合伙人
 	//订单对应的合伙人
 	PartnerId int64
 	PartnerId int64
 	//业务员抽成比例
 	//业务员抽成比例
@@ -62,6 +62,7 @@ type OrderBase struct {
 	IsDisable int `pg:",use_zero"`
 	IsDisable int `pg:",use_zero"`
 	//分红支付状态
 	//分红支付状态
 	BonusStatus int
 	BonusStatus int
+	CompanyId   int64
 }
 }
 
 
 var _ pg.BeforeUpdateHook = (*OrderBase)(nil)
 var _ pg.BeforeUpdateHook = (*OrderBase)(nil)

@@ -37,4 +37,5 @@ type OrderGood struct {
 	BonusStatus int
 	BonusStatus int
 	//备注信息
 	//备注信息
 	Remark    string
 	Remark    string
+	CompanyId int64
 }
 }

-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
-}

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

@@ -9,7 +9,7 @@ import (
 )
 )
 
 
 type PartnerInfo struct {
 type PartnerInfo struct {
-	tableName struct{} `pg:"partner_info,alias:partner_info"`
+	tableName struct{} `pg:"partner_info"`
 	// 合伙人ID
 	// 合伙人ID
 	Id int64 `pg:",pk"`
 	Id int64 `pg:",pk"`
 	// 合伙人姓名
 	// 合伙人姓名
@@ -20,10 +20,8 @@ type PartnerInfo struct {
 	Password string
 	Password string
 	// 状态（1：启用或者0：禁用）
 	// 状态（1：启用或者0：禁用）
 	Status int `pg:",use_zero"`
 	Status int `pg:",use_zero"`
-	// 合伙类别 （1.研发合伙人 2.业务合伙人  3.事业）
-	PartnerCategory int `pg:",default:1"` //partner_category
 	//所属区域信息
 	//所属区域信息
-	RegionInfo *domain.RegionInfo
+	RegionInfo domain.RegionInfo
 	//创建时间
 	//创建时间
 	CreateAt time.Time
 	CreateAt time.Time
 	//更新时间
 	//更新时间
@@ -32,6 +30,12 @@ type PartnerInfo struct {
 	CooperateTime time.Time
 	CooperateTime time.Time
 	//关联业务员
 	//关联业务员
 	Salesman []domain.Salesman
 	Salesman []domain.Salesman
+	// 合伙类别 （1.研发合伙人 2.业务合伙人  3.事业）
+	PartnerCategory int `pg:",default:1"` //partner_category
+	//合伙类别
+	PartnerCategoryInfos []domain.PartnerCategory
+	//公司id
+	CompanyId int64
 }
 }
 
 
 var _ pg.BeforeUpdateHook = (*PartnerInfo)(nil)
 var _ pg.BeforeUpdateHook = (*PartnerInfo)(nil)

+package models
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-pg/pg/v10"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+)
+
+type Users struct {
+	tableName      struct{}                     `pg:"users"`
+	Id             int64                        `pg:",pk"` //用户id
+	CompanyId      int64                        //公司id
+	OpenId         int64                        //统一用户中心
+	Name           string                       //用户名称
+	Sex            int8                         //性别：【0：未知】【1：男】【2：女】
+	JobNum         string                       //工号
+	Phone          string                       //手机号，同账号
+	PrivatePhone   string                       //私人手机号
+	Email          string                       //邮件
+	ExtensionNum   string                       //分机号
+	EntryTime      time.Time                    //入职时间
+	Workspace      string                       //工作地
+	Status         int8                         //状态：【1：正常】【 2：禁用】
+	Avatar         string                       ///头像
+	Remarks        string                       //备注
+	AdminType      int8                         //是否为当前公司负责人 【1：是】【2：否】
+	ChargeStatus   int8                         //是否为当前公司主管 【1：是】【2：否】
+	Permission     []domain.AdminPermissionBase //权限
+	AccessPartners []domain.Partner             //可查看的合伙人
+	CreateAt       time.Time
+	UpdateAt       time.Time
+	DeleteAt       time.Time
+}
+
+var _ pg.BeforeUpdateHook = (*Users)(nil)
+
+func (user *Users) BeforeUpdate(ctx context.Context) (context.Context, error) {
+	user.UpdateAt = time.Now()
+	return ctx, nil
+}
+
+var _ pg.BeforeInsertHook = (*Users)(nil)
+
+func (user *Users) BeforeInsert(ctx context.Context) (context.Context, error) {
+	user.CreateAt = time.Now()
+	user.UpdateAt = time.Now()
+	return ctx, nil
+}

 package transaction
 package transaction
 
 
-import "github.com/go-pg/pg/v10"
+import (
+	"github.com/go-pg/pg/v10"
+	"github.com/go-pg/pg/v10/orm"
+)
 
 
 type TransactionContext struct {
 type TransactionContext struct {
 	PgDd *pg.DB
 	PgDd *pg.DB
@@ -26,6 +29,13 @@ func (transactionContext *TransactionContext) RollbackTransaction() error {
 	return err
 	return err
 }
 }
 
 
+func (transactionContext *TransactionContext) GetDB() orm.DB {
+	if transactionContext.PgTx != nil {
+		return transactionContext.PgTx
+	}
+	return transactionContext.PgDd
+}
+
 func NewPGTransactionContext(pgDd *pg.DB) *TransactionContext {
 func NewPGTransactionContext(pgDd *pg.DB) *TransactionContext {
 	return &TransactionContext{
 	return &TransactionContext{
 		PgDd: pgDd,
 		PgDd: pgDd,

 package repository
 package repository
 
 
 import (
 import (
+	"errors"
 	"fmt"
 	"fmt"
 
 
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
@@ -29,23 +30,19 @@ func (reponsitory AdminPermissionRepository) transformPgModelToDomainModel(permi
 		Name:     permissionModel.Name,
 		Name:     permissionModel.Name,
 		Icon:     permissionModel.Icon,
 		Icon:     permissionModel.Icon,
 		Code:     permissionModel.Code,
 		Code:     permissionModel.Code,
+		Sort:     permissionModel.Sort,
 	}
 	}
 	return result, nil
 	return result, nil
 }
 }
 
 
-func (reponsitory AdminPermissionRepository) Find(queryOptions domain.AdminPermissionFindQuery) ([]domain.AdminPermission, error) {
+func (reponsitory AdminPermissionRepository) Find(queryOptions domain.PermissionFindOption) ([]domain.AdminPermission, error) {
 	db := reponsitory.transactionContext.PgDd
 	db := reponsitory.transactionContext.PgDd
 	permissionModels := make([]models.AdminPermission, 0)
 	permissionModels := make([]models.AdminPermission, 0)
 	query := db.Model(&permissionModels)
 	query := db.Model(&permissionModels)
-	if queryOptions.ParentId != nil {
-		query = query.Where("parent_id=?", queryOptions.ParentId)
-	}
-	if len(queryOptions.NotCode) > 0 {
-		query = query.WhereIn("code not in (?) ", queryOptions.NotCode)
-	}
-	if len(queryOptions.IdsIn) > 0 {
-		query = query.WhereIn(" id in (?) ", queryOptions.IdsIn)
+	if len(queryOptions.Ids) > 0 {
+		query = query.WhereIn("id in (?) ", queryOptions.Ids)
 	}
 	}
+	query = query.Order("sort")
 	if err := query.Select(); err != nil {
 	if err := query.Select(); err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
@@ -56,3 +53,29 @@ func (reponsitory AdminPermissionRepository) Find(queryOptions domain.AdminPermi
 	}
 	}
 	return result, nil
 	return result, nil
 }
 }
+
+func (reponsitory AdminPermissionRepository) FindOne(queryOptions domain.PermissionFindOneOption) (domain.AdminPermission, error) {
+	db := reponsitory.transactionContext.PgDd
+	var permissionModels models.AdminPermission
+	var hasCondition bool
+	query := db.Model(&permissionModels)
+	if len(queryOptions.Code) > 0 {
+		hasCondition = true
+		query = query.Where("code=?", queryOptions.Code)
+	}
+	if queryOptions.Id > 0 {
+		hasCondition = true
+		query = query.Where("id=?", queryOptions.Id)
+	}
+	var result domain.AdminPermission
+	if !hasCondition {
+		return result, errors.New("FindOne 必须要有查询条件")
+	}
+
+	err := query.First()
+	if err != nil {
+		return result, err
+	}
+	result, _ = reponsitory.transformPgModelToDomainModel(&permissionModels)
+	return result, nil
+}

-package repository
-
-import (
-	"fmt"
-
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
-)
-
-type AdminUserRepository struct {
-	transactionContext *transaction.TransactionContext
-}
-
-var (
-	_ domain.AdminUserRepository = (*AdminUserRepository)(nil)
-)
-
-func NewAdminUserRepository(transactionContext *transaction.TransactionContext) (*AdminUserRepository, error) {
-	if transactionContext == nil {
-		return nil, fmt.Errorf("transactionContext参数不能为nil")
-	}
-	return &AdminUserRepository{transactionContext: transactionContext}, nil
-}
-func (reponsitory AdminUserRepository) transformPgModelToDomainModel(adminuserModel *models.AdminUser) (domain.AdminUser, error) {
-	result := domain.AdminUser{
-		Id:         adminuserModel.Id,
-		Account:    adminuserModel.Account,
-		AdminName:  adminuserModel.AdminName,
-		IsDefault:  adminuserModel.IsDefault,
-		CreateAt:   adminuserModel.CreateAt,
-		IsUsable:   adminuserModel.IsUsable,
-		Password:   adminuserModel.Password,
-		Permission: adminuserModel.Permission,
-	}
-	return result, nil
-}
-
-func (reponsitory AdminUserRepository) FindOne(queryOption domain.AdminUserFindOneQuery) (*domain.AdminUser, error) {
-	db := reponsitory.transactionContext.PgDd
-	adminuserModel := new(models.AdminUser)
-	query := db.Model(adminuserModel)
-
-	if queryOption.AdminUserId > 0 {
-		query = query.Where("id=?", queryOption.AdminUserId)
-	}
-	if len(queryOption.AccountEqual) > 0 {
-		query = query.Where("account=?", queryOption.AccountEqual)
-	}
-	err := query.First()
-	if err != nil {
-		return nil, err
-	}
-	adminUser, err := reponsitory.transformPgModelToDomainModel(adminuserModel)
-	return &adminUser, err
-}
-
-func (reponsitory AdminUserRepository) updateAdminUser(adminuser domain.AdminUser) (*domain.AdminUser, error) {
-	tx := reponsitory.transactionContext.PgTx
-	adminUserModel := &models.AdminUser{
-		Id:         adminuser.Id,
-		Account:    adminuser.Account,
-		AdminName:  adminuser.AdminName,
-		Password:   adminuser.Password,
-		IsUsable:   adminuser.IsUsable,
-		Permission: adminuser.Permission,
-	}
-	_, err := tx.Model(adminUserModel).
-		Where("id=?", adminUserModel.Id).
-		Column("admin_name", "account", "password", "is_usable", "permission").
-		Update()
-	if err != nil {
-		return nil, fmt.Errorf("更新用户数据失败：%s", err)
-	}
-	return &adminuser, nil
-}
-
-func (reponsitory AdminUserRepository) addAdminUser(adminuser domain.AdminUser) (*domain.AdminUser, error) {
-	tx := reponsitory.transactionContext.PgTx
-	adminuserModel := &models.AdminUser{
-		Account:    adminuser.Account,
-		AdminName:  adminuser.AdminName,
-		Password:   adminuser.Password,
-		IsDefault:  false,
-		IsUsable:   adminuser.IsUsable,
-		Permission: adminuser.Permission,
-	}
-	//添加用户数据
-	_, err := tx.Model(adminuserModel).Insert()
-	if err != nil {
-		return nil, err
-	}
-	return nil, nil
-}
-
-func (reponsitory AdminUserRepository) Save(adminuser domain.AdminUser) (*domain.AdminUser, error) {
-	if adminuser.Id == 0 {
-		return reponsitory.addAdminUser(adminuser)
-	}
-	return reponsitory.updateAdminUser(adminuser)
-}
-
-func (reponsitory AdminUserRepository) Find(queryOption domain.AdminUserFindQuery) ([]domain.AdminUser, error) {
-	db := reponsitory.transactionContext.PgDd
-	adminuserModels := []models.AdminUser{}
-	query := db.Model(&adminuserModels)
-	if len(queryOption.AccountLike) > 0 {
-		query = query.Where("account like ?", "%"+queryOption.AccountLike+"%")
-	}
-
-	if queryOption.Offset > -1 {
-		query = query.Offset(queryOption.Offset)
-	}
-	if queryOption.Limit > 0 {
-		query = query.Limit(queryOption.Limit)
-	} else {
-		query = query.Limit(20)
-	}
-	var (
-		err             error
-		adminuserReturn = make([]domain.AdminUser, 0)
-	)
-	query = query.Order("admin_user.id DESC")
-	err = query.Select()
-	if err != nil {
-		return adminuserReturn, err
-	}
-	for i := range adminuserModels {
-		domainAdminUser, err := reponsitory.transformPgModelToDomainModel(&adminuserModels[i])
-		if err != nil {
-			return adminuserReturn, err
-		}
-		adminuserReturn = append(adminuserReturn, domainAdminUser)
-	}
-	return adminuserReturn, nil
-}
-
-func (reponsitory AdminUserRepository) CountAll(queryOption domain.AdminUserFindQuery) (int, error) {
-	db := reponsitory.transactionContext.PgDd
-	adminuserModels := models.AdminUser{}
-	query := db.Model(&adminuserModels)
-	if len(queryOption.AccountLike) > 0 {
-		query = query.Where("account like ?", "%"+queryOption.AccountLike+"%")
-	}
-	cnt, err := query.Count()
-	return cnt, err
-}