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

@@ -16,5 +16,6 @@ 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 商品数量调整

@@ -18,5 +18,6 @@ type UpdateOrderCommand struct {
 	//订单类型
 	//订单类型
 	OrderType int `json:"orderType"`
 	OrderType int `json:"orderType"`
 	//货品
 	//货品
-	Goods []OrderGoodData `json:"goods"`
+	Goods     []OrderGoodData `json:"goods"`
+	CompanyId int64           `json:"companyId"`
 }
 }

@@ -2,5 +2,6 @@ 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())
@@ -107,7 +117,8 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 	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("检索合伙人数据失败"))
 	}
 	}
@@ -337,7 +356,8 @@ 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, "发货号已存在")
@@ -367,7 +387,8 @@ 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,7 +496,8 @@ func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) error
 	}
 	}
 	//获取旧的订单
 	//获取旧的订单
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
 	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
-		OrderId: cmd.OrderId,
+		CompanyId: cmd.CompanyId,
+		OrderId:   cmd.OrderId,
 	})
 	})
 	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))
@@ -488,14 +511,15 @@ 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, "发货号已存在")
 	}
 	}
 	//获取旧的订单中的商品
 	//获取旧的订单中的商品
 	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))
@@ -567,7 +591,8 @@ 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))
@@ -617,7 +642,8 @@ 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"`
-	Status int   `json:"status"`
+	Ids       []int64 `json:"id"`
+	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, "区域必填")
 	}
 	}

@@ -2,7 +2,8 @@ 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())
 		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())
+	}
+	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,
-		Limit:  listPartnerInfoQuery.Limit,
-
+		Offset:      listPartnerInfoQuery.Offset,
+		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"          //合作管理人
-	PERMISSION_ORDER            string = "ORDER"           //订单管理
-	PERMISSION_DIVIDEND         string = "DIVIDEND"        //分红管理
-	PERMINSSION_ADMIN_USER      string = "ADMIN"           //管理员管理
-	PERMINSSION_ORDER_ACTUA     string = "ORDER_ACTUA"     //实际订单
-	PERMINSSION_ORDER_INTENTION string = "ORDER_INTENTION" //意向订单
+	PERMINSSION_PARTNER             string = "PARTER"                   //合作管理人
+	PERMISSION_ORDER                string = "ORDER"                    //订单管理
+	PERMISSION_DIVIDEND             string = "DIVIDEND"                 //分红管理
+	PERMINSSION_ADMIN_USER          string = "ADMIN"                    //管理员管理
+	PERMINSSION_ORDER_ACTUA         string = "ORDER_ACTUA"              //实际订单
+	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 {
@@ -178,7 +180,8 @@ 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 {
@@ -170,13 +172,14 @@ func (good *OrderGood) Compute() error {
 }
 }
 
 
 type OrderGoodFindQuery struct {
 type OrderGoodFindQuery struct {
-	OrderId int64
-	Offset  int
-	Limit   int
+	OrderId   int64
+	Offset    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)

@@ -36,5 +36,6 @@ 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
-}

+package repository
+
+import (
+	"errors"
+	"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 BusinessBonusRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func (repository *BusinessBonusRepository) transformPgModelToDomainModel(m *models.BusinessBonus) (domain.BusinessBonus, error) {
+	dm := domain.BusinessBonus{
+		Id:            m.Id,
+		CompanyId:     m.CompanyId,
+		PartnerInfoId: m.PartnerInfoId,
+		Bonus:         m.Bonus,
+		BonusNot:      m.BonusNot,
+		BonusHas:      m.BonusHas,
+		BonusExpense:  m.BonusExpense,
+		IsDisable:     m.IsDisable,
+		BonusStatus:   m.BonusStatus,
+		CreateAt:      m.CreateAt,
+		UpdateAt:      m.UpdateAt,
+	}
+	switch m.BonusStatus {
+	case domain.BUSINESS_BONUS_WAIT_PAY:
+		dm.BusinessBonusPayStatus = domain.BusinessBonusWaitPay{}
+	case domain.BUSINESS_BONUS_HAS_PAY:
+		dm.BusinessBonusPayStatus = domain.BusinessBonusHasPay{}
+	default:
+		dm.BusinessBonusPayStatus = domain.BusinessBonusNullPay{}
+	}
+	return dm, nil
+}
+
+func NewBusinessBonusRepository(transactionContext *transaction.TransactionContext) (*BusinessBonusRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &BusinessBonusRepository{transactionContext: transactionContext}, nil
+}
+
+func (repository *BusinessBonusRepository) Add(dm *domain.BusinessBonus) error {
+	tx := repository.transactionContext.PgTx
+	bonusModel := models.BusinessBonus{
+		Id:            dm.Id,
+		CompanyId:     dm.CompanyId,
+		PartnerInfoId: dm.PartnerInfoId,
+		Bonus:         dm.Bonus,
+		BonusNot:      dm.Bonus,
+		BonusHas:      dm.BonusHas,
+		BonusExpense:  dm.BonusExpense,
+		IsDisable:     dm.IsDisable,
+		BonusStatus:   dm.BonusStatus,
+	}
+	_, err := tx.Model(&bonusModel).
+		Insert()
+	dm.CreateAt = bonusModel.CreateAt
+	dm.UpdateAt = bonusModel.UpdateAt
+	dm.Id = bonusModel.Id
+	return err
+}
+
+func (repository *BusinessBonusRepository) Edit(dm *domain.BusinessBonus) error {
+	tx := repository.transactionContext.PgTx
+	bonusModel := models.BusinessBonus{
+		Id:            dm.Id,
+		CompanyId:     dm.CompanyId,
+		PartnerInfoId: dm.PartnerInfoId,
+		Bonus:         dm.Bonus,
+		BonusNot:      dm.BonusNot,
+		BonusExpense:  dm.BonusExpense,
+		BonusHas:      dm.BonusHas,
+		IsDisable:     dm.IsDisable,
+		BonusStatus:   dm.BonusStatus,
+		CreateAt:      dm.CreateAt,
+		UpdateAt:      dm.UpdateAt,
+	}
+	_, err := tx.Model(&bonusModel).WherePK().Update()
+	return err
+
+}
+
+func (repository *BusinessBonusRepository) FindOne(queryOptions domain.BusinessBonusFindOneQuery) (*domain.BusinessBonus, error) {
+	tx := repository.transactionContext.PgTx
+	BusinessBonusModel := new(models.BusinessBonus)
+	var hasCondition bool
+	query := tx.Model(BusinessBonusModel).Where("delete_at ISNULL")
+	if queryOptions.Id > 0 {
+		hasCondition = true
+		query = query.Where("id=?", queryOptions.Id)
+	}
+	if queryOptions.PartnerId > 0 {
+		hasCondition = true
+		query = query.Where("partner_info_id=?", queryOptions.PartnerId)
+	}
+	if queryOptions.CompanyId > 0 {
+		hasCondition = true
+		query = query.Where("company_id=?", queryOptions.CompanyId)
+	}
+	if !hasCondition {
+		return nil, errors.New("没有查询条件")
+	}
+	if err := query.First(); err != nil {
+		return nil, err
+	}
+	data, err := repository.transformPgModelToDomainModel(BusinessBonusModel)
+	return &data, err
+}
+
+func (repository *BusinessBonusRepository) Find(queryOptions domain.BusinessBonusFindQuery) (int, []domain.BusinessBonus, error) {
+	tx := repository.transactionContext.PgTx
+	var (
+		err                 error
+		cnt                 int
+		businessBonuss      []domain.BusinessBonus
+		businessBonusModels []models.BusinessBonus
+	)
+	query := tx.Model(&businessBonusModels)
+	if queryOptions.Offset > -1 {
+		query = query.Offset(queryOptions.Offset)
+	}
+	if queryOptions.Limit > 0 {
+		query = query.Limit(queryOptions.Limit)
+	} else {
+		query = query.Limit(1000)
+	}
+	query = query.Order("business_bonus.id DESC")
+	if cnt, err = query.SelectAndCount(); err != nil {
+		return 0, businessBonuss, err
+	}
+
+	for i := range businessBonusModels {
+		businessBonus, err := repository.transformPgModelToDomainModel(&businessBonusModels[i])
+		if err != nil {
+			return 0, businessBonuss, err
+		}
+		businessBonuss = append(businessBonuss, businessBonus)
+	}
+	return cnt, businessBonuss, nil
+}

+package repository
+
+import (
+	"errors"
+	"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 CompanyRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+var (
+	_ domain.CompanyRepository = (*CompanyRepository)(nil)
+)
+
+func NewCompanyRepository(transactionContext *transaction.TransactionContext) (*CompanyRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &CompanyRepository{transactionContext: transactionContext}, nil
+}
+
+func (repository CompanyRepository) transformPgModelToDomainModel(m *models.Company) (domain.Company, error) {
+	return domain.Company{
+		Id:             m.Id,
+		Name:           m.Name,
+		Phone:          m.Phone,
+		Logo:           m.Logo,
+		Remarks:        m.Remarks,
+		AdminCompanyId: m.AdminCompanyId,
+		Enable:         m.Enable,
+		CreateAt:       m.CreateAt,
+		UpdateAt:       m.UpdateAt,
+		Abbreviation:   m.Abbreviation,
+	}, nil
+}
+
+func (reponsitory CompanyRepository) Add(m *domain.Company) error {
+	var (
+		err error
+		tx  = reponsitory.transactionContext.PgTx
+	)
+	companyModel := models.Company{
+		Id:             m.Id,
+		Name:           m.Name,
+		Phone:          m.Phone,
+		Logo:           m.Logo,
+		Remarks:        m.Remarks,
+		AdminCompanyId: m.AdminCompanyId,
+		Enable:         m.Enable,
+		CreateAt:       m.CreateAt,
+		UpdateAt:       m.UpdateAt,
+		Abbreviation:   m.Abbreviation,
+	}
+	_, err = tx.Model(&companyModel).Insert()
+	return err
+}
+
+func (reponsitory CompanyRepository) Edit(m *domain.Company) error {
+	var (
+		err error
+		tx  = reponsitory.transactionContext.PgTx
+	)
+	companyModel := models.Company{
+		Id:             m.Id,
+		Name:           m.Name,
+		Phone:          m.Phone,
+		Logo:           m.Logo,
+		Remarks:        m.Remarks,
+		AdminCompanyId: m.AdminCompanyId,
+		Enable:         m.Enable,
+		CreateAt:       m.CreateAt,
+		DeleteAt:       m.DeleteAt,
+		UpdateAt:       m.UpdateAt,
+		Abbreviation:   m.Abbreviation,
+	}
+	_, err = tx.Model(&companyModel).WherePK().Update()
+	return err
+}
+
+func (reponsitory CompanyRepository) FindOne(queryOptions domain.CompanyFindOneOptions) (domain.Company, error) {
+	var (
+		err          error
+		tx           = reponsitory.transactionContext.PgTx
+		m            models.Company
+		hasCondition bool
+	)
+
+	query := tx.Model(&m)
+	if queryOptions.Id > 0 {
+		hasCondition = true
+		query = query.Where("id=?", queryOptions.Id)
+	}
+	if queryOptions.AdminCompanyId > 0 {
+		hasCondition = true
+		query = query.Where("admin_company_id=?", queryOptions.AdminCompanyId)
+	}
+	if !hasCondition {
+		return domain.Company{}, errors.New("findOne 必须要有查询条件")
+	}
+	err = query.First()
+	if err != nil {
+		return domain.Company{}, err
+	}
+	return reponsitory.transformPgModelToDomainModel(&m)
+}
+
+func (reponsitory CompanyRepository) Find(queryOptions domain.CompanyFindOptions) (int64, []domain.Company, error) {
+	return 0, nil, nil
+}

@@ -41,6 +41,7 @@ func (reponsitory OrderBaseRepository) transformPgModelToDomainModel(orderModel
 			Id: orderModel.PartnerId,
 			Id: orderModel.PartnerId,
 		},
 		},
 		BonusStatus: orderModel.BonusStatus,
 		BonusStatus: orderModel.BonusStatus,
+		CompanyId:   orderModel.CompanyId,
 	}
 	}
 	return order, nil
 	return order, nil
 }
 }
@@ -61,6 +62,7 @@ func (repository OrderBaseRepository) Save(orderInfo *domain.OrderBase) error {
 		PartnerBonusHas: orderInfo.OrderCompute.PartnerBonusHas, PartnerBonusNot: orderInfo.OrderCompute.PartnerBonusNot,
 		PartnerBonusHas: orderInfo.OrderCompute.PartnerBonusHas, PartnerBonusNot: orderInfo.OrderCompute.PartnerBonusNot,
 		PartnerBonusExpense: orderInfo.OrderCompute.PartnerBonusExpense, IsDisable: orderInfo.IsDisable,
 		PartnerBonusExpense: orderInfo.OrderCompute.PartnerBonusExpense, IsDisable: orderInfo.IsDisable,
 		CreateTime: orderInfo.CreateTime, BonusStatus: orderInfo.BonusStatus,
 		CreateTime: orderInfo.CreateTime, BonusStatus: orderInfo.BonusStatus,
+		CompanyId: orderInfo.CompanyId,
 	}
 	}
 	if m.Id == 0 {
 	if m.Id == 0 {
 		_, err = tx.Model(m).
 		_, err = tx.Model(m).
@@ -95,6 +97,9 @@ func (repository OrderBaseRepository) Find(queryOption domain.OrderBaseFindQuery
 	if queryOption.OrderType > 0 {
 	if queryOption.OrderType > 0 {
 		query = query.Where("order_type=?", queryOption.OrderType)
 		query = query.Where("order_type=?", queryOption.OrderType)
 	}
 	}
+	if queryOption.CompanyId > 0 {
+		query = query.Where("company_id=?", queryOption.CompanyId)
+	}
 	if queryOption.Offset > -1 {
 	if queryOption.Offset > -1 {
 		query = query.Offset(queryOption.Offset)
 		query = query.Offset(queryOption.Offset)
 	}
 	}
@@ -128,9 +133,12 @@ func (repository OrderBaseRepository) FindOne(qureyOptions domain.OrderBaseFindO
 		tx  = repository.transactionContext.PgDd
 		tx  = repository.transactionContext.PgDd
 	)
 	)
 	m := new(models.OrderBase)
 	m := new(models.OrderBase)
-	err = tx.Model(m).
-		Where("id=?", qureyOptions.OrderId).
-		First()
+	query := tx.Model(m).
+		Where("id=?", qureyOptions.OrderId)
+	if qureyOptions.CompanyId > 0 {
+		query = query.Where("company_id=?", qureyOptions.CompanyId)
+	}
+	err = query.First()
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
@@ -138,7 +146,7 @@ func (repository OrderBaseRepository) FindOne(qureyOptions domain.OrderBaseFindO
 	return &result, err
 	return &result, err
 }
 }
 
 
-func (repository OrderBaseRepository) Remove(id int64) error {
+func (repository OrderBaseRepository) Remove(id int64, companyId int64) error {
 	var (
 	var (
 		err error
 		err error
 		tx  = repository.transactionContext.PgTx
 		tx  = repository.transactionContext.PgTx
@@ -146,6 +154,9 @@ func (repository OrderBaseRepository) Remove(id int64) error {
 	m := &models.OrderBase{
 	m := &models.OrderBase{
 		Id: id,
 		Id: id,
 	}
 	}
-	_, err = tx.Model(m).WherePK().Delete()
+	_, err = tx.Model(m).
+		Where("id=?", id).
+		Where("company_id=?", companyId).
+		Delete()
 	return err
 	return err
 }
 }

@@ -38,6 +38,7 @@ func (reponsitory OrderGoodRepository) transformPgModelToDomainModel(orderModel
 			PartnerBonusNot:     orderModel.PartnerBonusNot,
 			PartnerBonusNot:     orderModel.PartnerBonusNot,
 			PartnerBonusExpense: orderModel.PartnerBonusExpense,
 			PartnerBonusExpense: orderModel.PartnerBonusExpense,
 		},
 		},
+		CompanyId: orderModel.CompanyId,
 	}
 	}
 	switch orderModel.BonusStatus {
 	switch orderModel.BonusStatus {
 	case domain.OrderGoodWaitPay:
 	case domain.OrderGoodWaitPay:
@@ -62,7 +63,8 @@ func (repository OrderGoodRepository) Save(data []domain.OrderGood) error {
 			PlanPartnerBonus: v.GoodCompute.PlanPartnerBonus, UsePartnerBonus: v.GoodCompute.UsePartnerBonus,
 			PlanPartnerBonus: v.GoodCompute.PlanPartnerBonus, UsePartnerBonus: v.GoodCompute.UsePartnerBonus,
 			PartnerBonusHas: v.GoodCompute.PartnerBonusHas, PartnerBonusNot: v.GoodCompute.PartnerBonusNot,
 			PartnerBonusHas: v.GoodCompute.PartnerBonusHas, PartnerBonusNot: v.GoodCompute.PartnerBonusNot,
 			PartnerBonusExpense: v.GoodCompute.PartnerBonusExpense, BonusStatus: v.BonusStatus,
 			PartnerBonusExpense: v.GoodCompute.PartnerBonusExpense, BonusStatus: v.BonusStatus,
-			Remark: v.Remark,
+			Remark:    v.Remark,
+			CompanyId: v.CompanyId,
 		}
 		}
 		if v.Id == 0 {
 		if v.Id == 0 {
 			_, err = tx.Model(m).
 			_, err = tx.Model(m).
@@ -91,6 +93,9 @@ func (repository OrderGoodRepository) Find(queryOption domain.OrderGoodFindQuery
 	if queryOption.OrderId > 0 {
 	if queryOption.OrderId > 0 {
 		query = query.Where("order_id=?", queryOption.OrderId)
 		query = query.Where("order_id=?", queryOption.OrderId)
 	}
 	}
+	if queryOption.CompanyId > 0 {
+		query = query.Where("company_id=?", queryOption.CompanyId)
+	}
 	if queryOption.Offset > -1 {
 	if queryOption.Offset > -1 {
 		query = query.Offset(queryOption.Offset)
 		query = query.Offset(queryOption.Offset)
 	}
 	}
@@ -118,13 +123,15 @@ func (repository OrderGoodRepository) Find(queryOption domain.OrderGoodFindQuery
 	return orderGoods, count, nil
 	return orderGoods, count, nil
 }
 }
 
 
-func (repository OrderGoodRepository) Remove(orderId int64, goodids ...int64) error {
+func (repository OrderGoodRepository) Remove(orderId int64, companyId int64, goodids ...int64) error {
 	var (
 	var (
 		err error
 		err error
 		tx  = repository.transactionContext.PgTx
 		tx  = repository.transactionContext.PgTx
 	)
 	)
 	m := &models.OrderGood{}
 	m := &models.OrderGood{}
-	query := tx.Model(m).Where("order_id=?", orderId)
+	query := tx.Model(m).
+		Where("order_id=?", orderId).
+		Where("company_id=?", companyId)
 	if len(goodids) > 0 {
 	if len(goodids) > 0 {
 		query = query.WhereIn("id in(?)", goodids)
 		query = query.WhereIn("id in(?)", goodids)
 	}
 	}

+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 PartnerCategoryRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+func (repository PartnerCategoryRepository) transformPgModelToDomainModel(m *models.PartnerCategoryInfo) (domain.PartnerCategory, error) {
+	pc := domain.PartnerCategory{
+		Id:   m.Id,
+		Name: m.Name,
+	}
+	return pc, nil
+}
+
+func NewPartnerCategoryRepository(transactionContext *transaction.TransactionContext) (*PartnerCategoryRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &PartnerCategoryRepository{transactionContext: transactionContext}, nil
+}
+
+func (repository PartnerCategoryRepository) Find(queryOptions domain.PartnerCategoryFindQuery) (int, []domain.PartnerCategory, error) {
+	tx := repository.transactionContext.PgTx
+	var (
+		PartnerCategoryInfoModels []models.PartnerCategoryInfo
+		cnt                       int
+		err                       error
+	)
+	query := tx.Model(&PartnerCategoryInfoModels)
+	if len(queryOptions.Ids) > 0 {
+		query = query.WhereIn("id in(?)", queryOptions.Ids)
+	}
+	if cnt, err = query.SelectAndCount(); err != nil {
+		return 0, nil, err
+	}
+	partnerCategoryInfos := make([]domain.PartnerCategory, 0, len(PartnerCategoryInfoModels))
+	for i := range PartnerCategoryInfoModels {
+		m, _ := repository.transformPgModelToDomainModel(&PartnerCategoryInfoModels[i])
+		partnerCategoryInfos = append(partnerCategoryInfos, m)
+	}
+	return cnt, partnerCategoryInfos, nil
+}

 package repository
 package repository
 
 
 import (
 import (
+	"errors"
 	"fmt"
 	"fmt"
 
 
+	"github.com/go-pg/pg/v10/orm"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
 	"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/models"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
@@ -30,7 +32,16 @@ func (repository *PartnerInfoRepository) transformPgModelToDomainModel(partnerIn
 		Salesman:        partnerInfoModel.Salesman,
 		Salesman:        partnerInfoModel.Salesman,
 		RegionInfo:      partnerInfoModel.RegionInfo,
 		RegionInfo:      partnerInfoModel.RegionInfo,
 		CooperateTime:   partnerInfoModel.CooperateTime,
 		CooperateTime:   partnerInfoModel.CooperateTime,
+		CompanyId:       partnerInfoModel.CompanyId,
 	}
 	}
+	p := []domain.PartnerCategory{}
+	for _, v := range partnerInfoModel.PartnerCategoryInfos {
+		catagory := domain.PartnerCategory{
+			Id: v.Id,
+		}
+		p = append(p, catagory)
+	}
+	m.PartnerCategoryInfos = p
 	return m, nil
 	return m, nil
 }
 }
 
 
@@ -41,50 +52,69 @@ func NewPartnerInfoRepository(transactionContext *transaction.TransactionContext
 	return &PartnerInfoRepository{transactionContext: transactionContext}, nil
 	return &PartnerInfoRepository{transactionContext: transactionContext}, nil
 }
 }
 
 
-func (repository *PartnerInfoRepository) Save(dm domain.PartnerInfo) (*domain.PartnerInfo, error) {
+func (repository *PartnerInfoRepository) Save(dm *domain.PartnerInfo) error {
 	var (
 	var (
 		err error
 		err error
 		tx  = repository.transactionContext.PgTx
 		tx  = repository.transactionContext.PgTx
 	)
 	)
+
+	categorys := []domain.PartnerCategory{}
+	for _, v := range dm.PartnerCategoryInfos {
+		categorys = append(categorys, domain.PartnerCategory{
+			Id: v.Id,
+		})
+	}
 	m := &models.PartnerInfo{
 	m := &models.PartnerInfo{
-		Id:              dm.Partner.Id,
-		PartnerName:     dm.Partner.PartnerName,
-		Account:         dm.Partner.Account,
-		Password:        dm.Password,
-		Status:          dm.Status,
-		PartnerCategory: dm.PartnerCategory,
-		Salesman:        dm.Salesman,
-		RegionInfo:      dm.RegionInfo,
-		CooperateTime:   dm.CooperateTime,
+		Id:                   dm.Partner.Id,
+		PartnerName:          dm.Partner.PartnerName,
+		Account:              dm.Partner.Account,
+		Password:             dm.Password,
+		Status:               dm.Status,
+		PartnerCategory:      dm.PartnerCategory,
+		Salesman:             dm.Salesman,
+		RegionInfo:           dm.RegionInfo,
+		CooperateTime:        dm.CooperateTime,
+		CompanyId:            dm.CompanyId,
+		PartnerCategoryInfos: categorys,
 	}
 	}
 	if m.Id == 0 {
 	if m.Id == 0 {
 		err = tx.Insert(m)
 		err = tx.Insert(m)
 		dm.Partner.Id = m.Id
 		dm.Partner.Id = m.Id
 		if err != nil {
 		if err != nil {
-			return nil, err
+			return err
 		}
 		}
 	} else {
 	} else {
 		_, err = tx.Model(m).WherePK().
 		_, err = tx.Model(m).WherePK().
 			Column("partner_name", "account", "password", "status", "partner_category", "salesman",
 			Column("partner_name", "account", "password", "status", "partner_category", "salesman",
-				"region_info", "cooperate_time", "update_at").
+				"region_info", "cooperate_time", "update_at", "partner_category_infos").
 			Update()
 			Update()
 		if err != nil {
 		if err != nil {
-			return nil, err
+			return err
 		}
 		}
 	}
 	}
-	return &dm, nil
+	return nil
 }
 }
 
 
 func (repository *PartnerInfoRepository) FindOne(queryOptions domain.PartnerFindOneQuery) (*domain.PartnerInfo, error) {
 func (repository *PartnerInfoRepository) FindOne(queryOptions domain.PartnerFindOneQuery) (*domain.PartnerInfo, error) {
-	tx := repository.transactionContext.PgDd
+	tx := repository.transactionContext.PgTx
 	PartnerInfoModel := new(models.PartnerInfo)
 	PartnerInfoModel := new(models.PartnerInfo)
+	var hasCondition bool
 	query := tx.Model(PartnerInfoModel)
 	query := tx.Model(PartnerInfoModel)
 	if len(queryOptions.AccountEqual) > 0 {
 	if len(queryOptions.AccountEqual) > 0 {
+		hasCondition = true
 		query = query.Where("account=?", queryOptions.AccountEqual)
 		query = query.Where("account=?", queryOptions.AccountEqual)
 	}
 	}
 	if queryOptions.UserId > 0 {
 	if queryOptions.UserId > 0 {
+		hasCondition = true
 		query = query.Where("id=?", queryOptions.UserId)
 		query = query.Where("id=?", queryOptions.UserId)
 	}
 	}
+	if queryOptions.CompanyId > 0 {
+		hasCondition = true
+		query = query.Where("company_id=?", queryOptions.CompanyId)
+	}
+	if !hasCondition {
+		return nil, errors.New("FindOne 必须要有查询条件")
+	}
 	if err := query.First(); err != nil {
 	if err := query.First(); err != nil {
 		return nil, err
 		return nil, err
 	}
 	}
@@ -93,7 +123,7 @@ func (repository *PartnerInfoRepository) FindOne(queryOptions domain.PartnerFind
 }
 }
 
 
 func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuery) ([]domain.PartnerInfo, error) {
 func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuery) ([]domain.PartnerInfo, error) {
-	db := repository.transactionContext.PgDd
+	db := repository.transactionContext.PgTx
 	partnerModels := []models.PartnerInfo{}
 	partnerModels := []models.PartnerInfo{}
 	query := db.Model(&partnerModels)
 	query := db.Model(&partnerModels)
 	if len(queryOption.PartnerName) > 0 {
 	if len(queryOption.PartnerName) > 0 {
@@ -102,8 +132,20 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
 	if queryOption.RegionInfo != nil {
 	if queryOption.RegionInfo != nil {
 		query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
 		query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
 	}
 	}
+	//合伙人类型
 	if len(queryOption.PartnerCategory) > 0 {
 	if len(queryOption.PartnerCategory) > 0 {
-		query = query.WhereIn("partner_category in(?)", queryOption.PartnerCategory)
+		query = query.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
+			for _, value := range queryOption.PartnerCategory {
+				q = q.WhereOr(`partner_category_infos@> '[{"id":?}]'`, value)
+			}
+			return q, nil
+		})
+	}
+	if queryOption.CompanyId > 0 {
+		query = query.Where("company_id=?", queryOption.CompanyId)
+	}
+	if len(queryOption.Ids) > 0 {
+		query = query.WhereIn("id in(?)", queryOption.Ids)
 	}
 	}
 	if queryOption.Offset > -1 {
 	if queryOption.Offset > -1 {
 		query = query.Offset(queryOption.Offset)
 		query = query.Offset(queryOption.Offset)
@@ -111,7 +153,7 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
 	if queryOption.Limit > 0 {
 	if queryOption.Limit > 0 {
 		query = query.Limit(queryOption.Limit)
 		query = query.Limit(queryOption.Limit)
 	} else {
 	} else {
-		query = query.Limit(20)
+		query = query.Limit(1000)
 	}
 	}
 	var (
 	var (
 		err           error
 		err           error
@@ -133,7 +175,7 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
 }
 }
 
 
 func (repository PartnerInfoRepository) CountAll(queryOption domain.PartnerFindQuery) (int, error) {
 func (repository PartnerInfoRepository) CountAll(queryOption domain.PartnerFindQuery) (int, error) {
-	db := repository.transactionContext.PgDd
+	db := repository.transactionContext.PgTx
 	partnerModels := models.PartnerInfo{}
 	partnerModels := models.PartnerInfo{}
 	query := db.Model(&partnerModels)
 	query := db.Model(&partnerModels)
 	if len(queryOption.PartnerName) > 0 {
 	if len(queryOption.PartnerName) > 0 {
@@ -142,8 +184,20 @@ func (repository PartnerInfoRepository) CountAll(queryOption domain.PartnerFindQ
 	if queryOption.RegionInfo != nil {
 	if queryOption.RegionInfo != nil {
 		query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
 		query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
 	}
 	}
+	//合伙人类型
 	if len(queryOption.PartnerCategory) > 0 {
 	if len(queryOption.PartnerCategory) > 0 {
-		query = query.WhereIn("partner_category in(?)", queryOption.PartnerCategory)
+		query = query.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
+			for _, value := range queryOption.PartnerCategory {
+				q = q.WhereOr(`partner_category_infos@> '[{"id":?}]'`, value)
+			}
+			return q, nil
+		})
+	}
+	if queryOption.CompanyId > 0 {
+		query = query.Where("company_id=?", queryOption.CompanyId)
+	}
+	if len(queryOption.Ids) > 0 {
+		query = query.WhereIn("id in(?)", queryOption.Ids)
 	}
 	}
 	cnt, err := query.Count()
 	cnt, err := query.Count()
 	return cnt, err
 	return cnt, err

+package repository
+
+import (
+	"errors"
+	"fmt"
+	"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 UsersRepository struct {
+	transactionContext *transaction.TransactionContext
+}
+
+var (
+	_ domain.UsersRepository = (*UsersRepository)(nil)
+)
+
+func NewUsersRepository(transactionContext *transaction.TransactionContext) (*UsersRepository, error) {
+	if transactionContext == nil {
+		return nil, fmt.Errorf("transactionContext参数不能为nil")
+	}
+	return &UsersRepository{transactionContext: transactionContext}, nil
+}
+
+func (repository UsersRepository) transformPgModelToDomainModel(m *models.Users) (domain.Users, error) {
+	return domain.Users{
+		Id:             m.Id,
+		CompanyId:      m.CompanyId,
+		OpenId:         m.OpenId,
+		Name:           m.Name,
+		Sex:            m.Sex,
+		JobNum:         m.JobNum,
+		Phone:          m.Phone,
+		PrivatePhone:   m.PrivatePhone,
+		Email:          m.Email,
+		ExtensionNum:   m.ExtensionNum,
+		EntryTime:      m.EntryTime,
+		Workspace:      m.Workspace,
+		Status:         m.Status,
+		Avatar:         m.Avatar,
+		Remarks:        m.Remarks,
+		ChargeStatus:   m.ChargeStatus,
+		CreateAt:       m.CreateAt,
+		UpdateAt:       m.UpdateAt,
+		Permission:     m.Permission,
+		AccessPartners: m.AccessPartners,
+		AdminType:      m.AdminType,
+	}, nil
+}
+
+func (reponsitory UsersRepository) Add(u *domain.Users) error {
+	var (
+		err error
+		tx  = reponsitory.transactionContext.PgTx
+	)
+	m := &models.Users{
+		Id:             u.Id,
+		CompanyId:      u.CompanyId,
+		OpenId:         u.OpenId,
+		Name:           u.Name,
+		Sex:            u.Sex,
+		JobNum:         u.JobNum,
+		Phone:          u.Phone,
+		PrivatePhone:   u.PrivatePhone,
+		Email:          u.Email,
+		ExtensionNum:   u.ExtensionNum,
+		EntryTime:      u.EntryTime,
+		Workspace:      u.Workspace,
+		Status:         u.Status,
+		Avatar:         u.Avatar,
+		Remarks:        u.Remarks,
+		ChargeStatus:   u.ChargeStatus,
+		CreateAt:       u.CreateAt,
+		UpdateAt:       u.UpdateAt,
+		Permission:     u.Permission,
+		AccessPartners: u.AccessPartners,
+		AdminType:      u.AdminType,
+	}
+	_, err = tx.Model(m).Insert()
+	return err
+}
+
+func (reponsitory UsersRepository) Edit(u *domain.Users) error {
+	var (
+		err error
+		tx  = reponsitory.transactionContext.PgTx
+	)
+	m := &models.Users{
+		Id:             u.Id,
+		CompanyId:      u.CompanyId,
+		OpenId:         u.OpenId,
+		Name:           u.Name,
+		Sex:            u.Sex,
+		JobNum:         u.JobNum,
+		Phone:          u.Phone,
+		PrivatePhone:   u.PrivatePhone,
+		Email:          u.Email,
+		ExtensionNum:   u.ExtensionNum,
+		EntryTime:      u.EntryTime,
+		Workspace:      u.Workspace,
+		Status:         u.Status,
+		Avatar:         u.Avatar,
+		Remarks:        u.Remarks,
+		ChargeStatus:   u.ChargeStatus,
+		CreateAt:       u.CreateAt,
+		UpdateAt:       u.UpdateAt,
+		Permission:     u.Permission,
+		AccessPartners: u.AccessPartners,
+		AdminType:      u.AdminType,
+	}
+	_, err = tx.Model(m).WherePK().Update()
+	return err
+}
+
+func (reponsitory UsersRepository) FindOne(queryOptions domain.UsersFindOneQuery) (domain.Users, error) {
+	var (
+		err          error
+		tx           = reponsitory.transactionContext.PgTx
+		m            models.Users
+		hasCondition bool
+	)
+	query := tx.Model(&m)
+	query.Where("delete_at ISNULL")
+	if queryOptions.Id > 0 {
+		hasCondition = true
+		query = query.Where("id=?", queryOptions.Id)
+	}
+	if len(queryOptions.Phone) > 0 {
+		hasCondition = true
+		query = query.Where("phone=?", queryOptions.Phone)
+	}
+	if queryOptions.CompanyId > 0 {
+		hasCondition = true
+		query = query.Where("company_id=?", queryOptions.CompanyId)
+	}
+	if queryOptions.OpenId > 0 {
+		hasCondition = true
+		query = query.Where("open_id=?", queryOptions.OpenId)
+	}
+	if !hasCondition {
+		return domain.Users{}, errors.New("FindOne 必须要有查询条件")
+	}
+	err = query.First()
+	if err != nil {
+		return domain.Users{}, err
+	}
+	return reponsitory.transformPgModelToDomainModel(&m)
+}
+
+func (reponsitory UsersRepository) Find(queryOption domain.UsersFindQuery) (int, []domain.Users, error) {
+	db := reponsitory.transactionContext.PgTx
+	usersModels := []models.Users{}
+	query := db.Model(&usersModels)
+	query.Where("delete_at ISNULL")
+	if queryOption.CompanyId > 0 {
+		query = query.Where("company_id=?", queryOption.CompanyId)
+	}
+	if queryOption.ChargeStatus > 0 {
+		query = query.Where("charge_status=?", queryOption.ChargeStatus)
+	}
+	if queryOption.AdminType > 0 {
+		query = query.Where("admin_type=?", queryOption.AdminType)
+	}
+	if len(queryOption.UserNameMatch) > 0 {
+		query = query.Where("name like ?", "%"+queryOption.UserNameMatch+"%")
+	}
+	if queryOption.Offset >= 0 {
+		query = query.Offset(queryOption.Offset)
+	}
+	if queryOption.Limit > 0 {
+		query = query.Limit(queryOption.Limit)
+	} else {
+		query = query.Limit(1000)
+	}
+	var (
+		err         error
+		usersReturn = make([]domain.Users, 0)
+		cnt         int
+	)
+	query = query.Order("id DESC")
+	cnt, err = query.SelectAndCount()
+	if err != nil {
+		return 0, usersReturn, err
+	}
+	for i := range usersModels {
+		domainUsers, err := reponsitory.transformPgModelToDomainModel(&usersModels[i])
+		if err != nil {
+			return 0, usersReturn, err
+		}
+		usersReturn = append(usersReturn, domainUsers)
+	}
+	return cnt, usersReturn, nil
+}
+
+func (reponsitory UsersRepository) Remove(ids []int64) error {
+	if len(ids) == 0 {
+		return nil
+	}
+	var (
+		err error
+		tx  = reponsitory.transactionContext.PgTx
+	)
+	_, err = tx.Model(&models.Users{}).
+		Set("delete_at=?", time.Now()).
+		WhereIn("id in(?)", ids).
+		Update()
+	return err
+}

+package serviceGateway
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/astaxie/beego/logs"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
+)
+
+type MmmBusinessAdminServiceGateway struct {
+	baseURL string
+}
+
+func NewMmmBusinessAdminServiceGateway() *MmmBusinessAdminServiceGateway {
+	return &MmmBusinessAdminServiceGateway{
+		baseURL: constant.BUSINESS_ADMIN_HOST,
+	}
+}
+func (client MmmBusinessAdminServiceGateway) buildHeader() http.Header {
+	var h = http.Header{}
+	h.Set("Content-Type", "application/json")
+	h.Set("Accept", "application/json")
+	return h
+}
+
+type ResponseGetUserAuth struct {
+	UCenterCommonMsg
+	Data struct {
+		UserAuth bool `json:"userAuth"`
+	} `json:"data"`
+}
+
+func (gateway MmmBusinessAdminServiceGateway) httpDo(reqURL string, mathod string, bodyData interface{}) ([]byte, error) {
+	httpclient := http.Client{
+		Timeout: 60 * time.Second, //请求超时时间60秒
+	}
+	bt := &bytes.Buffer{}
+	if bodyData != nil {
+		enc := json.NewEncoder(bt)
+		enc.Encode(bodyData)
+	}
+	logs.Info("====>Send To URL:%s", reqURL)
+	logs.Info("====>Send To BusinessAdmin:%s", bt.String())
+	req, err := http.NewRequest(mathod, reqURL, bt)
+	req.Header = gateway.buildHeader()
+	if err != nil {
+		return nil, err
+	}
+	resp, err := httpclient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	logs.Info("<====BusinessAdmin Return:%s", string(body))
+	return body, nil
+}
+
+func (gateway MmmBusinessAdminServiceGateway) GetUserAuth(userId int64) (*ResponseGetUserAuth, error) {
+	param := map[string]interface{}{
+		"userId":     fmt.Sprint(userId),
+		"platformId": "25", //天联共创固定值：25
+	}
+	url := gateway.baseURL + "/auth/get-user-auth"
+	byteData, err := gateway.httpDo(url, "POST", param)
+	if err != nil {
+		return nil, err
+	}
+	respData := &ResponseGetUserAuth{}
+	err = json.Unmarshal(byteData, respData)
+	if err != nil {
+		return nil, fmt.Errorf("body data %s; err:%s", string(byteData), err)
+	}
+	return respData, nil
+}

-package service_gateway
+package serviceGateway
 
 
 import (
 import (
+	"bytes"
 	"crypto/sha1"
 	"crypto/sha1"
+	"encoding/json"
 	"fmt"
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"net/http"
+	"net/url"
 	"time"
 	"time"
 
 
+	"github.com/astaxie/beego/logs"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
 )
 )
 
 
+type UCenterCommonMsg struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+func (msg UCenterCommonMsg) IsOK() error {
+	if msg.Code != 0 {
+		return fmt.Errorf("统一用户中心响应数据异常,code：%d,msg:%s", msg.Code, msg.Msg)
+	}
+	return nil
+}
+
 type MmmUserCenterServiceGateway struct {
 type MmmUserCenterServiceGateway struct {
-	httplibBaseServiceGateway
+	baseURL string
 }
 }
 
 
 func NewMmmUserCenterServiceGateway() *MmmUserCenterServiceGateway {
 func NewMmmUserCenterServiceGateway() *MmmUserCenterServiceGateway {
 	return &MmmUserCenterServiceGateway{
 	return &MmmUserCenterServiceGateway{
-		httplibBaseServiceGateway{
-			baseURL:          constant.UCENTER_HOST,
-			connectTimeout:   100 * time.Second,
-			readWriteTimeout: 30 * time.Second,
-		}}
+		baseURL: constant.UCENTER_HOST,
+	}
 }
 }
 
 
 func (gateway MmmUserCenterServiceGateway) buildHeader() http.Header {
 func (gateway MmmUserCenterServiceGateway) buildHeader() http.Header {
@@ -37,12 +51,40 @@ func (gateway MmmUserCenterServiceGateway) buildHeader() http.Header {
 	return h
 	return h
 }
 }
 
 
+func (gateway MmmUserCenterServiceGateway) httpDo(reqURL string, mathod string, bodyData interface{}) ([]byte, error) {
+	httpclient := http.Client{
+		Timeout: 60 * time.Second, //请求超时时间60秒
+	}
+	bt := &bytes.Buffer{}
+	if bodyData != nil {
+		enc := json.NewEncoder(bt)
+		enc.Encode(bodyData)
+	}
+	logs.Info("====>Send To URL:%s", reqURL)
+	logs.Info("====>Send To BusinessAdmin:%s", bt.String())
+	req, err := http.NewRequest(mathod, reqURL, bt)
+	if err != nil {
+		return nil, err
+	}
+	req.Header = gateway.buildHeader()
+	resp, err := httpclient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	logs.Info("<====BusinessAdmin Return:%s", string(body))
+	return body, nil
+}
+
 type ResponseLogin struct {
 type ResponseLogin struct {
-	Code int    `json:"code"`
-	Msg  string `json:"msg"`
+	UCenterCommonMsg
 	Data struct {
 	Data struct {
-		Id              int64  `json:"id"` //统一用户中心的id,对应本系统中users表的open_id
-		Phone           string `json:"phone"`
+		Id              int64  `json:"id"`              //统一用户中心的id,对应本系统中users表的open_id
+		Phone           string `json:"phone"`           //手机号 ，账号
 		NickName        string `json:"nickname"`        //昵称
 		NickName        string `json:"nickname"`        //昵称
 		Avatar          string `json:"avatar"`          //头像
 		Avatar          string `json:"avatar"`          //头像
 		Imtoken         string `json:"imtoken"`         //网易云imtoken
 		Imtoken         string `json:"imtoken"`         //网易云imtoken
@@ -53,13 +95,23 @@ type ResponseLogin struct {
 	} `json:"data"`
 	} `json:"data"`
 }
 }
 
 
+//RequestUCenterLoginBySecret 使用密钥方式登录统一用户中心
 func (gateway MmmUserCenterServiceGateway) RequestUCenterLoginBySecret(secret string) (*ResponseLogin, error) {
 func (gateway MmmUserCenterServiceGateway) RequestUCenterLoginBySecret(secret string) (*ResponseLogin, error) {
-	// param := map[string]interface{}{
-	// 	"type":   3,                       //登录方式 固定值
-	// 	"secret": url.QueryEscape(secret), //必要的转换
-	// }
-	// url := "/auth/serverLogin"
-	// httpRequest := gateway.createRequest(url, "post")
-	// httpRequest.
-	return nil, nil
+	param := map[string]interface{}{
+		"type":   3,                       //登录方式 固定值
+		"secret": url.QueryEscape(secret), //必要的转换
+	}
+	url := gateway.baseURL + "/auth/serverLogin"
+	byteData, err := gateway.httpDo(url, "POST", param)
+	if err != nil {
+		return nil, err
+	}
+	respData := &ResponseLogin{}
+	err = json.Unmarshal(byteData, respData)
+	if err != nil {
+		return nil, fmt.Errorf("body data %s; err:%s", string(byteData), err)
+	}
+	return respData, nil
 }
 }
+
+//企业鉴权 接口

-package service_gateway
-
-import (
-	"time"
-)
-
-type httplibBaseServiceGateway struct {
-	baseURL          string
-	connectTimeout   time.Duration
-	readWriteTimeout time.Duration
-}

@@ -6,15 +6,10 @@ import (
 	"fmt"
 	"fmt"
 	"time"
 	"time"
 
 
-	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
-
 	"github.com/GeeTeam/gt3-golang-sdk/geetest"
 	"github.com/GeeTeam/gt3-golang-sdk/geetest"
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/logs"
-	adminPermissionquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/query"
-	adminPermissionService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/service"
-	adminuserCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/command"
-	adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
-	adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
+	userCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/command"
+	userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
 )
 )
 
 
 type AdminLoginController struct {
 type AdminLoginController struct {
@@ -29,6 +24,7 @@ func (c *AdminLoginController) Prepare() {
 		"/v1/auth/captcha-init": 1,
 		"/v1/auth/captcha-init": 1,
 		"/v1/auth/login":        1,
 		"/v1/auth/login":        1,
 	}
 	}
+
 	nowUrl := c.Ctx.Input.URL()
 	nowUrl := c.Ctx.Input.URL()
 	if _, ok := urlIn[nowUrl]; ok {
 	if _, ok := urlIn[nowUrl]; ok {
 		//跳过校验
 		//跳过校验
@@ -39,50 +35,21 @@ func (c *AdminLoginController) Prepare() {
 	}
 	}
 }
 }
 
 
-//Login 用户登录
 func (c *AdminLoginController) Login() {
 func (c *AdminLoginController) Login() {
-	type Paramter struct {
-		Username string `json:"username"`
-		Password string `json:"password"`
-	}
 	var (
 	var (
-		param Paramter
-		err   error
+		param userCmd.LoginBySecretKeyCommand
 	)
 	)
-	if err = c.BindJsonData(&param); err != nil {
+	if err := c.BindJsonData(&param); err != nil {
 		c.ResponseError(fmt.Errorf("json解析失败：%s", err))
 		c.ResponseError(fmt.Errorf("json解析失败：%s", err))
 		return
 		return
 	}
 	}
-	newAdminuserquery := adminuserquery.GetAdminUserQuery{AdminAccount: param.Username}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
+	newUserService := userService.NewUsersService(nil)
+	resp, err := newUserService.UserLoginBySecretKey(param)
 	if err != nil {
 	if err != nil {
-		logs.Error("获取用户数据失败：%s", err)
-		c.ResponseError(errors.New("用户不存在"))
-		return
-	}
-	if adminuser.Password != param.Password {
-		c.ResponseError(errors.New("账号或密码错误"))
-		return
-	}
-	if !adminuser.IsUsable {
-		c.ResponseError(errors.New("用户被禁用"))
-	}
-	//TODO
-	newJwt := lib.NewMyToken(adminuser.Id, 0)
-	newToken, err := newJwt.CreateJWTToken()
-	if err != nil {
-		logs.Error("生成jwt数据失败：%s", err)
-		c.ResponseError(errors.New("服务异常"))
+		c.ResponseError(err)
 		return
 		return
 	}
 	}
-	rspdata := map[string]interface{}{
-		"access": map[string]interface{}{
-			"accessToken": newToken,
-			"expiresIn":   lib.JWtExpiresSecond,
-		},
-	}
-	c.ResponseData(rspdata)
+	c.ResponseData(resp)
 	return
 	return
 }
 }
 
 
@@ -112,86 +79,13 @@ func (c *AdminLoginController) CaptchaInit() {
 //AdminpPofile 获取登录用户的权限配置
 //AdminpPofile 获取登录用户的权限配置
 func (c *AdminLoginController) AdminpPofile() {
 func (c *AdminLoginController) AdminpPofile() {
 	adminId := c.GetUserId()
 	adminId := c.GetUserId()
-	newAdminuserquery := adminuserquery.GetAdminUserQuery{Id: adminId}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
+	newUserService := userService.NewUsersService(nil)
+	respData, err := newUserService.GetUserPofile(adminId)
 	if err != nil {
 	if err != nil {
 		logs.Error("获取用户数据失败：%s", err)
 		logs.Error("获取用户数据失败：%s", err)
 		c.ResponseError(errors.New("用户不存在"))
 		c.ResponseError(errors.New("用户不存在"))
 		return
 		return
 	}
 	}
-
-	newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
-	allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{})
-	if err != nil {
-		logs.Error("获取权限数据失败：%s", err)
-		c.ResponseError(errors.New("服务异常"))
-		return
-	}
-	//适配前端的数据格式
-	permissionSlice := make([]map[string]interface{}, 0)
-	for _, v := range allPermission {
-		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-禁用，前端需要
-		}
-		for _, p := range adminuser.Permission {
-			if p.Id == v.Id {
-				m["status"] = 1
-				break
-			}
-			if p.Id == v.ParentId {
-				m["status"] = 1
-				break
-			}
-		}
-		permissionSlice = append(permissionSlice, m)
-	}
-	userData := map[string]string{
-		"id":        fmt.Sprint(adminuser.Id),
-		"name":      adminuser.AdminName,
-		"adminType": "2", //	管理员类型 1-超级管理员 2-子管理员
-	}
-	if adminuser.IsDefault {
-		userData["adminType"] = "1"
-	}
-	respData := map[string]interface{}{
-		"user":  userData,
-		"menus": permissionSlice,
-	}
 	c.ResponseData(respData)
 	c.ResponseData(respData)
-}
-
-func (c *AdminLoginController) PwdUpdate() {
-	//用与适配前端定义的数据结构
-	type Paramater struct {
-		Pwd string `json:"pwd"`
-	}
-	var (
-		param Paramater
-		err   error
-	)
-	if err = c.BindJsonData(&param); err != nil {
-		logs.Error(err)
-		c.ResponseError(errors.New("json数据解析失败"))
-		return
-	}
-	uid := c.GetUserId()
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	cmd := adminuserCmd.UpdateAdminUserPwdCommand{
-		Id:       uid,
-		Password: param.Pwd,
-	}
-	err = newAdminUserService.UpdateAdminPassword(cmd)
-	if err != nil {
-		c.ResponseError(err)
-		return
-	}
-	c.ResponseData(nil)
 	return
 	return
 }
 }

@@ -11,8 +11,8 @@ import (
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/logs"
 
 
-	adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
-	adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
+	userQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/query"
+	userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/port/beego/protocol"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/port/beego/protocol"
 )
 )
@@ -33,7 +33,7 @@ func (controller BaseController) ResponseError(err error) {
 		if !(e.Code == lib.ARG_ERROR || e.Code == lib.BUSINESS_ERROR) {
 		if !(e.Code == lib.ARG_ERROR || e.Code == lib.BUSINESS_ERROR) {
 			controller.Data["json"] = protocol.ResponseData{
 			controller.Data["json"] = protocol.ResponseData{
 				Code: -1,
 				Code: -1,
-				Msg:  "服务异常",
+				Msg:  "操作失败",
 				Data: struct{}{},
 				Data: struct{}{},
 			}
 			}
 			controller.ServeJSON()
 			controller.ServeJSON()
@@ -144,6 +144,7 @@ func (controller *BaseController) ValidJWTToken() bool {
 		return false
 		return false
 	}
 	}
 	controller.setUserId(tokenData.UID)
 	controller.setUserId(tokenData.UID)
+	controller.setUserCompanyId(tokenData.CompanyId)
 	return true
 	return true
 }
 }
 
 
@@ -161,27 +162,22 @@ func (controller *BaseController) ValidAdminPermission(permissionCode string, ex
 		controller.ResponseError(errors.New("无操作权限"))
 		controller.ResponseError(errors.New("无操作权限"))
 		return false
 		return false
 	}
 	}
-	newAdminuserquery := adminuserquery.GetAdminUserQuery{Id: userId}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
+	comanyId := controller.GetUserCompany()
+	newQuery := userQuery.ValidatePermissionQuery{
+		UserId:         userId,
+		PermissionCode: permissionCode,
+		CompanyId:      comanyId,
+	}
+	newUserService := userService.NewUsersService(nil)
+	ok, err := newUserService.ValidateAdminpPermission(newQuery)
 	if err != nil {
 	if err != nil {
-		logs.Error("获取用户数据失败：%s", err)
+		logs.Error("用户鉴权失败：%s", err)
 		controller.ResponseError(errors.New("无操作权限"))
 		controller.ResponseError(errors.New("无操作权限"))
 		return false
 		return false
 	}
 	}
-	if adminuser.IsDefault {
-		logs.Debug("用户是超级管理员")
+	if ok {
 		return true
 		return true
 	}
 	}
-	if !adminuser.IsUsable {
-		controller.ResponseError(errors.New("用户被禁用"))
-		return false
-	}
-	for _, v := range adminuser.Permission {
-		if v.Code == permissionCode {
-			return true
-		}
-	}
 	controller.ResponseError(errors.New("无操作权限"))
 	controller.ResponseError(errors.New("无操作权限"))
 	return false
 	return false
 }
 }
@@ -196,3 +192,17 @@ func (controller *BaseController) setUserId(id int64) {
 	logs.Info("token:admin_user_id = ", id)
 	logs.Info("token:admin_user_id = ", id)
 	controller.Ctx.Input.SetData("token:admin_user_id", id)
 	controller.Ctx.Input.SetData("token:admin_user_id", id)
 }
 }
+
+func (controller *BaseController) setUserCompanyId(id int64) {
+	logs.Info("token:company_id = ", id)
+	controller.Ctx.Input.SetData("token:company_id", id)
+}
+
+func (controller *BaseController) GetUserCompany() int64 {
+	idV := controller.Ctx.Input.GetData("token:company_id")
+	uid, err := strconv.ParseInt(fmt.Sprint(idV), 10, 64)
+	if err != nil {
+		logs.Error(err)
+	}
+	return uid
+}

+package controllers
+
+import (
+	"errors"
+
+	"github.com/astaxie/beego/logs"
+	businessCommand "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/command"
+	businessQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/query"
+	businessService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/service"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+)
+
+type BusinessBonusController struct {
+	BaseController
+}
+
+func (c *BusinessBonusController) Prepare() {
+	c.BaseController.Prepare()
+	if ok := c.ValidJWTToken(); !ok {
+		return
+	}
+	if ok := c.ValidAdminPermission(domain.PERMISSION_DIVIDEND); !ok {
+		return
+	}
+}
+
+func (c *BusinessBonusController) ListBusinessBonus() {
+	type Parameter struct {
+		PageNumber int    `json:"pageNumber"`
+		Partner    int64  `json:"partner"`
+		PageSize   int    `json:"pageSize"`
+		SearchText string `json:"searchText"`
+	}
+	var (
+		param Parameter
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	if param.PageSize == 0 {
+		param.PageSize = 20
+	}
+	if param.PageNumber == 0 {
+		param.PageNumber = 1
+	}
+	companyId := c.GetUserCompany()
+	srv := businessService.NewBusinessBonusService(nil)
+	cnt, result, err := srv.ListBusinessBonus(businessQuery.ListBusinessBonusQuery{
+		CompanyId: companyId,
+		Limit:     param.PageSize,
+		Offset:    param.PageSize * (param.PageNumber - 1),
+		PartnerId: param.Partner,
+	})
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	c.ResponsePageList(result, cnt, param.PageNumber)
+}
+
+func (c *BusinessBonusController) UpdateBusinessBonus() {
+	type Parameter struct {
+		Id                  int64   `json:"id"`
+		DividendsReceivable float64 `json:"dividendsReceivable"`
+		StateOfPayment      int8    `json:"stateOfPayment"`
+	}
+	var (
+		param Parameter
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	companyId := c.GetUserCompany()
+	srv := businessService.NewBusinessBonusService(nil)
+	err = srv.UpdateBusinessBonus(businessCommand.UpdateBusinessBonusCommand{
+		CompanyId:   companyId,
+		Id:          param.Id,
+		Bonus:       param.DividendsReceivable,
+		BonusStatus: param.StateOfPayment,
+	})
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	c.ResponseData(nil)
+}
+
+func (c *BusinessBonusController) GetBusinessBonus() {
+	type Parameter struct {
+		Id int64 `json:"id"`
+	}
+	var (
+		param Parameter
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	companyId := c.GetUserCompany()
+	srv := businessService.NewBusinessBonusService(nil)
+	data, err := srv.GetBusinessBonus(businessQuery.GetBusinessBonusQuery{
+		Id:        param.Id,
+		CompanyId: companyId,
+	})
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	c.ResponseData(data)
+}

 package controllers
 package controllers
 
 
 import (
 import (
+	categoryQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerCategory/query"
+	categoryService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerCategory/service"
 	partnerQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/query"
 	partnerQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/query"
 	partnerInfoService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/service"
 	partnerInfoService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/service"
 )
 )
@@ -19,9 +21,11 @@ func (c *CommonController) Prepare() {
 
 
 // GetPartnerList 下拉选项数据通用接口，获取合伙人列表
 // GetPartnerList 下拉选项数据通用接口，获取合伙人列表
 func (c *CommonController) GetPartnerList() {
 func (c *CommonController) GetPartnerList() {
+	companyId := c.GetUserCompany()
 	query := partnerQuery.ListPartnerInfoQuery{
 	query := partnerQuery.ListPartnerInfoQuery{
-		Limit:  5000,
-		Offset: 0,
+		Limit:     1000,
+		Offset:    0,
+		CompanyId: companyId,
 	}
 	}
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	_, partners, err := newPartnerService.ListPartnerInfo(&query)
 	_, partners, err := newPartnerService.ListPartnerInfo(&query)
@@ -41,3 +45,22 @@ func (c *CommonController) GetPartnerList() {
 	}
 	}
 	c.ResponseData(resp)
 	c.ResponseData(resp)
 }
 }
+
+// GetPartnerCategory 下拉选项数据通用接口，获取合伙人分类列表
+func (c *CommonController) GetPartnerCategory() {
+	newService := categoryService.NewPartnerCategoryService(nil)
+	_, categorys, err := newService.ListPartnerCategory(categoryQuery.ListPartnerCategoryCommand{})
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	resp := []map[string]interface{}{}
+	for i := range categorys {
+		m := map[string]interface{}{
+			"id":   categorys[i].Id,
+			"name": categorys[i].Name,
+		}
+		resp = append(resp, m)
+	}
+	c.ResponseData(resp)
+}

+package controllers
+
+import (
+	"errors"
+
+	"github.com/astaxie/beego/logs"
+	companyService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/company/service"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+)
+
+type CompanyController struct {
+	BaseController
+}
+
+//Prepare 重写 BaseController 的Prepare方法
+func (c *CompanyController) Prepare() {
+	c.BaseController.Prepare()
+	if ok := c.ValidJWTToken(); !ok {
+		return
+	}
+	if ok := c.ValidAdminPermission(domain.PERMISSION_ENTERPRISE_SET); !ok {
+		return
+	}
+}
+
+func (c *CompanyController) SetPhone() {
+	//用与适配前端定义的数据结构
+	type Paramter struct {
+		Type  int    `json:"type"`
+		Phone string `json:"phone"`
+	}
+	var (
+		param Paramter
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	switch param.Type {
+	case 1:
+		c.editPhone(param.Phone)
+	case 2:
+		c.getPhone()
+	default:
+		c.ResponseError(errors.New("参数错误"))
+	}
+	return
+}
+
+func (c *CompanyController) getPhone() {
+	companyid := c.GetUserCompany()
+	srv := companyService.NewCompanyService(nil)
+	data, err := srv.GetCompanyData(companyid)
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	result := map[string]interface{}{
+		"phone": data.Phone,
+	}
+	c.ResponseData(result)
+	return
+}
+
+func (c *CompanyController) editPhone(phone string) {
+	companyid := c.GetUserCompany()
+	srv := companyService.NewCompanyService(nil)
+	err := srv.UpdateCompanyPhone(companyid, phone)
+	if err != nil {
+		c.ResponseError(err)
+		return
+	}
+	c.ResponseData(nil)
+	return
+}

@@ -51,7 +51,7 @@ func (c *OrderDividendController) PageListOrderDividend() {
 	if param.PageSize == 0 {
 	if param.PageSize == 0 {
 		param.PageSize = 20
 		param.PageSize = 20
 	}
 	}
-
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 		PartnerId:    param.Partner,
 		PartnerId:    param.Partner,
@@ -59,6 +59,7 @@ func (c *OrderDividendController) PageListOrderDividend() {
 		OrderType:    domain.OrderReal,
 		OrderType:    domain.OrderReal,
 		Limit:        param.PageSize,
 		Limit:        param.PageSize,
 		Offset:       (param.PageNumber - 1) * param.PageSize,
 		Offset:       (param.PageNumber - 1) * param.PageSize,
+		CompanyId:    companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -106,9 +107,11 @@ func (c *OrderDividendController) OrderDividendDetail() {
 		c.ResponseError(errors.New("参数错误"))
 		c.ResponseError(errors.New("参数错误"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
-		OrderId: orderid,
+		OrderId:   orderid,
+		CompanyId: companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -251,9 +254,11 @@ func (c *OrderDividendController) EditOrderDividend() {
 		}
 		}
 		goodbouns = append(goodbouns, g)
 		goodbouns = append(goodbouns, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	cmd := orderCmd.UpdateGoodBouns{
 	cmd := orderCmd.UpdateGoodBouns{
 		Id:        param.Id,
 		Id:        param.Id,
 		GoodBouns: goodbouns,
 		GoodBouns: goodbouns,
+		CompanyId: companyId,
 	}
 	}
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	err = orderSrv.UpdateGoodBouns(cmd)
 	err = orderSrv.UpdateGoodBouns(cmd)

@@ -24,7 +24,6 @@ type OrderInfoController struct {
 ////Prepare 重写 BaseController 的Prepare方法
 ////Prepare 重写 BaseController 的Prepare方法
 func (c *OrderInfoController) Prepare() {
 func (c *OrderInfoController) Prepare() {
 	c.BaseController.Prepare()
 	c.BaseController.Prepare()
-	return
 	if ok := c.ValidJWTToken(); !ok {
 	if ok := c.ValidJWTToken(); !ok {
 		return
 		return
 	}
 	}
@@ -56,7 +55,7 @@ func (c *OrderInfoController) PageListOrderPurpose() {
 	if param.PageSize == 0 {
 	if param.PageSize == 0 {
 		param.PageSize = 20
 		param.PageSize = 20
 	}
 	}
-
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 		PartnerId: param.Partner,
 		PartnerId: param.Partner,
@@ -64,6 +63,7 @@ func (c *OrderInfoController) PageListOrderPurpose() {
 		OrderType: domain.OrderIntention,
 		OrderType: domain.OrderIntention,
 		Limit:     param.PageSize,
 		Limit:     param.PageSize,
 		Offset:    (param.PageNumber - 1) * param.PageSize,
 		Offset:    (param.PageNumber - 1) * param.PageSize,
+		CompanyId: companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -103,9 +103,11 @@ func (c *OrderInfoController) GetOrderPurpose() {
 		return
 		return
 	}
 	}
 	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
 	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
-		OrderId: orderid,
+		OrderId:   orderid,
+		CompanyId: companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -156,8 +158,9 @@ func (c *OrderInfoController) RemoveOrderPurpose() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
-	err = orderSrv.DeleteOrder(param.Id)
+	err = orderSrv.DeleteOrder(param.Id, companyId)
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
 		return
 		return
@@ -290,6 +293,7 @@ func (c *OrderInfoController) addOrderPurpose(param postPurposeOrderDetail) erro
 		}
 		}
 		newGoods = append(newGoods, g)
 		newGoods = append(newGoods, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	createcmd := orderCmd.CreateOrderCommand{
 	createcmd := orderCmd.CreateOrderCommand{
 		OrderType:            domain.OrderIntention,
 		OrderType:            domain.OrderIntention,
 		OrderCode:            param.OrderId,
 		OrderCode:            param.OrderId,
@@ -299,6 +303,7 @@ func (c *OrderInfoController) addOrderPurpose(param postPurposeOrderDetail) erro
 		PartnerId:            param.PartnerId,
 		PartnerId:            param.PartnerId,
 		SalesmanBonusPercent: param.CommissionProportion,
 		SalesmanBonusPercent: param.CommissionProportion,
 		Goods:                newGoods,
 		Goods:                newGoods,
+		CompanyId:            companyId,
 	}
 	}
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	_, err := orderSrv.CreateNewOrder(createcmd)
 	_, err := orderSrv.CreateNewOrder(createcmd)
@@ -317,6 +322,7 @@ func (c *OrderInfoController) editOrderPurpose(param postPurposeOrderDetail) err
 		}
 		}
 		newGoods = append(newGoods, g)
 		newGoods = append(newGoods, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	updatecmd := orderCmd.UpdateOrderCommand{
 	updatecmd := orderCmd.UpdateOrderCommand{
 		Id:                   param.Id,
 		Id:                   param.Id,
 		OrderType:            domain.OrderIntention,
 		OrderType:            domain.OrderIntention,
@@ -327,6 +333,7 @@ func (c *OrderInfoController) editOrderPurpose(param postPurposeOrderDetail) err
 		PartnerId:            param.PartnerId,
 		PartnerId:            param.PartnerId,
 		SalesmanBonusPercent: param.CommissionProportion,
 		SalesmanBonusPercent: param.CommissionProportion,
 		Goods:                newGoods,
 		Goods:                newGoods,
+		CompanyId:            companyId,
 	}
 	}
 	_, err := orderSrv.UpdateOrderData(updatecmd)
 	_, err := orderSrv.UpdateOrderData(updatecmd)
 	return err
 	return err
@@ -369,7 +376,7 @@ func (c *OrderInfoController) OrderPurposeDelivery() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
-
+	param.ShipmentsId = strings.TrimSpace(param.ShipmentsId)
 	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
 	orderid, _ := strconv.ParseInt(param.Id, 10, 64)
 	if orderid <= 0 {
 	if orderid <= 0 {
 		c.ResponseError(errors.New("参数错误"))
 		c.ResponseError(errors.New("参数错误"))
@@ -387,9 +394,10 @@ func (c *OrderInfoController) OrderPurposeDelivery() {
 		}
 		}
 		goods = append(goods, g)
 		goods = append(goods, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	deliveryCommand := orderCmd.OrderDeliveryCommand{
 	deliveryCommand := orderCmd.OrderDeliveryCommand{
 		OrderId: orderid, DeliveryCode: param.ShipmentsId,
 		OrderId: orderid, DeliveryCode: param.ShipmentsId,
-		DeliveryTime: time.Now(), Goods: goods,
+		DeliveryTime: time.Now(), Goods: goods, CompanyId: companyId,
 	}
 	}
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	err = orderSrv.Delivery(deliveryCommand)
 	err = orderSrv.Delivery(deliveryCommand)
@@ -423,7 +431,7 @@ func (c *OrderInfoController) PageListOrderReal() {
 	if param.PageSize == 0 {
 	if param.PageSize == 0 {
 		param.PageSize = 20
 		param.PageSize = 20
 	}
 	}
-
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 	orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
 		PartnerId:    param.Partner,
 		PartnerId:    param.Partner,
@@ -431,6 +439,7 @@ func (c *OrderInfoController) PageListOrderReal() {
 		OrderType:    domain.OrderReal,
 		OrderType:    domain.OrderReal,
 		Limit:        param.PageSize,
 		Limit:        param.PageSize,
 		Offset:       (param.PageNumber - 1) * param.PageSize,
 		Offset:       (param.PageNumber - 1) * param.PageSize,
+		CompanyId:    companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -485,9 +494,11 @@ func (c *OrderInfoController) GetOrderReal() {
 		c.ResponseError(errors.New("参数错误"))
 		c.ResponseError(errors.New("参数错误"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
 	orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
-		OrderId: orderid,
+		OrderId:   orderid,
+		CompanyId: companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -601,6 +612,7 @@ func (c *OrderInfoController) addOrderReal(param postRealOrderDetail) error {
 		}
 		}
 		newGoods = append(newGoods, g)
 		newGoods = append(newGoods, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	createcmd := orderCmd.CreateOrderCommand{
 	createcmd := orderCmd.CreateOrderCommand{
 		OrderType:            domain.OrderReal,
 		OrderType:            domain.OrderReal,
 		OrderCode:            param.OrderId,
 		OrderCode:            param.OrderId,
@@ -610,6 +622,7 @@ func (c *OrderInfoController) addOrderReal(param postRealOrderDetail) error {
 		PartnerId:            param.PartnerId,
 		PartnerId:            param.PartnerId,
 		SalesmanBonusPercent: param.CommissionProportion,
 		SalesmanBonusPercent: param.CommissionProportion,
 		Goods:                newGoods,
 		Goods:                newGoods,
+		CompanyId:            companyId,
 	}
 	}
 	_, err := orderSrv.CreateNewOrder(createcmd)
 	_, err := orderSrv.CreateNewOrder(createcmd)
 	return err
 	return err
@@ -627,6 +640,7 @@ func (c *OrderInfoController) editOrderReal(param postRealOrderDetail) error {
 		}
 		}
 		newGoods = append(newGoods, g)
 		newGoods = append(newGoods, g)
 	}
 	}
+	companyId := c.GetUserCompany()
 	updatecmd := orderCmd.UpdateOrderCommand{
 	updatecmd := orderCmd.UpdateOrderCommand{
 		Id:                   param.Id,
 		Id:                   param.Id,
 		OrderType:            domain.OrderReal,
 		OrderType:            domain.OrderReal,
@@ -637,6 +651,7 @@ func (c *OrderInfoController) editOrderReal(param postRealOrderDetail) error {
 		PartnerId:            param.PartnerId,
 		PartnerId:            param.PartnerId,
 		SalesmanBonusPercent: param.CommissionProportion,
 		SalesmanBonusPercent: param.CommissionProportion,
 		Goods:                newGoods,
 		Goods:                newGoods,
+		CompanyId:            companyId,
 	}
 	}
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	_, err := orderSrv.UpdateOrderData(updatecmd)
 	_, err := orderSrv.UpdateOrderData(updatecmd)
@@ -668,10 +683,12 @@ func (c *OrderInfoController) OrderDisable() {
 		c.ResponseError(errors.New("参数错误"))
 		c.ResponseError(errors.New("参数错误"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	cmd := orderCmd.DisableOrderCommand{
 	cmd := orderCmd.DisableOrderCommand{
 		OrderId:   orderId,
 		OrderId:   orderId,
 		IsDisable: param.Status,
 		IsDisable: param.Status,
 		OrderType: domain.OrderReal,
 		OrderType: domain.OrderReal,
+		CompanyId: companyId,
 	}
 	}
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
 	err = orderSrv.DisableOrEnable(cmd)
 	err = orderSrv.DisableOrEnable(cmd)
@@ -696,8 +713,9 @@ func (c *OrderInfoController) RemoveOrderReal() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	orderSrv := orderService.NewOrderInfoService(nil)
 	orderSrv := orderService.NewOrderInfoService(nil)
-	err = orderSrv.DeleteOrder(param.Id)
+	err = orderSrv.DeleteOrder(param.Id, companyId)
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
 		return
 		return

@@ -35,14 +35,14 @@ func (c *PartnerInfoController) Prepare() {
 func (c *PartnerInfoController) CreatePartnerInfo() {
 func (c *PartnerInfoController) CreatePartnerInfo() {
 	//用与适配前端定义的数据结构
 	//用与适配前端定义的数据结构
 	type Parameter struct {
 	type Parameter struct {
-		PartnerName     string `json:"partnerName"`
-		PartnerType     int    `json:"partnerType"`
-		Area            string `json:"area"`
-		Account         string `json:"account"`
-		State           int    `json:"state"`
-		CooperationTime string `json:"cooperationTime"`
-		SalesmanName    string `json:"salesmanName"`
-		Phone           string `json:"phone"`
+		PartnerName     string  `json:"partnerName"`
+		PartnerType     []int64 `json:"partnerType"`
+		Area            string  `json:"area"`
+		Account         string  `json:"account"`
+		State           int     `json:"state"`
+		CooperationTime string  `json:"cooperationTime"`
+		SalesmanName    string  `json:"salesmanName"`
+		Phone           string  `json:"phone"`
 	}
 	}
 	var (
 	var (
 		param Parameter
 		param Parameter
@@ -60,6 +60,7 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
 		c.ResponseError(e)
 		c.ResponseError(e)
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	cmd := partnerInfoCmd.CreatePartnerInfoCommand{
 	cmd := partnerInfoCmd.CreatePartnerInfoCommand{
 		PartnerName:     param.PartnerName,
 		PartnerName:     param.PartnerName,
 		Account:         param.Account,
 		Account:         param.Account,
@@ -73,6 +74,7 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
 				Telephone: param.Phone,
 				Telephone: param.Phone,
 			},
 			},
 		},
 		},
+		CompanyId: companyId,
 	}
 	}
 	if len(param.Area) > 0 {
 	if len(param.Area) > 0 {
 		cmd.RegionInfo = &domain.RegionInfo{
 		cmd.RegionInfo = &domain.RegionInfo{
@@ -93,13 +95,13 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
 func (c *PartnerInfoController) UpdatePartnerInfo() {
 func (c *PartnerInfoController) UpdatePartnerInfo() {
 	//用与适配前端定义的数据结构
 	//用与适配前端定义的数据结构
 	type Parameter struct {
 	type Parameter struct {
-		ID              int64  `json:"id"`
-		PartnerType     int    `json:"partnerType"`
-		Area            string `json:"area"`
-		State           int    `json:"state"`
-		CooperationTime string `json:"cooperationTime"`
-		SalesmanName    string `json:"salesmanName"`
-		Phone           string `json:"phone"`
+		ID              int64   `json:"id"`
+		PartnerType     []int64 `json:"partnerType"`
+		Area            string  `json:"area"`
+		State           int     `json:"state"`
+		CooperationTime string  `json:"cooperationTime"`
+		SalesmanName    string  `json:"salesmanName"`
+		Phone           string  `json:"phone"`
 	}
 	}
 	var (
 	var (
 		param Parameter
 		param Parameter
@@ -116,6 +118,7 @@ func (c *PartnerInfoController) UpdatePartnerInfo() {
 		c.ResponseError(e)
 		c.ResponseError(e)
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	cmd := partnerInfoCmd.UpdatePartnerInfoCommand{
 	cmd := partnerInfoCmd.UpdatePartnerInfoCommand{
 		Id:              param.ID,
 		Id:              param.ID,
 		Status:          param.State,
 		Status:          param.State,
@@ -130,6 +133,7 @@ func (c *PartnerInfoController) UpdatePartnerInfo() {
 				Telephone: param.Phone,
 				Telephone: param.Phone,
 			},
 			},
 		},
 		},
+		CompanyId: companyId,
 	}
 	}
 	serve := partnerInfoService.NewPartnerInfoService(nil)
 	serve := partnerInfoService.NewPartnerInfoService(nil)
 	err = serve.UpdatePartnerInfo(&cmd)
 	err = serve.UpdatePartnerInfo(&cmd)
@@ -156,9 +160,11 @@ func (c *PartnerInfoController) GetPartnerInfo() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
+	companyId := c.GetUserCompany()
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	partnerInfo, err := newPartnerService.GetPartnerInfo(partnerQuery.GetPartnerInfoQuery{
 	partnerInfo, err := newPartnerService.GetPartnerInfo(partnerQuery.GetPartnerInfoQuery{
-		Id: param.Id,
+		Id:        param.Id,
+		CompanyId: companyId,
 	})
 	})
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
@@ -166,9 +172,9 @@ func (c *PartnerInfoController) GetPartnerInfo() {
 	}
 	}
 	//数据适配
 	//数据适配
 	rspResult := map[string]interface{}{
 	rspResult := map[string]interface{}{
-		"account":         partnerInfo.Partner.Account,
-		"partnerName":     partnerInfo.Partner.PartnerName,
-		"partnerType":     partnerInfo.PartnerCategory,
+		"account":     partnerInfo.Partner.Account,
+		"partnerName": partnerInfo.Partner.PartnerName,
+		// "partnerType":     []map[string]interface{}{},
 		"area":            partnerInfo.RegionInfo.RegionName,
 		"area":            partnerInfo.RegionInfo.RegionName,
 		"salesmanName":    "",
 		"salesmanName":    "",
 		"phone":           "",
 		"phone":           "",
@@ -181,16 +187,24 @@ func (c *PartnerInfoController) GetPartnerInfo() {
 		rspResult["salesmanName"] = partnerInfo.Salesman[0].Name
 		rspResult["salesmanName"] = partnerInfo.Salesman[0].Name
 		rspResult["phone"] = partnerInfo.Salesman[0].Telephone
 		rspResult["phone"] = partnerInfo.Salesman[0].Telephone
 	}
 	}
+	partnerTypes := []map[string]interface{}{}
+	for _, v := range partnerInfo.PartnerCategoryInfos {
+		m := map[string]interface{}{
+			"id":   v.Id,
+			"name": v.Name,
+		}
+		partnerTypes = append(partnerTypes, m)
+	}
+	rspResult["partnerType"] = partnerTypes
 	c.ResponseData(rspResult)
 	c.ResponseData(rspResult)
 	return
 	return
 }
 }
 
 
-//PartnerInfoSetState 合伙人禁用启用
+//PartnerInfoSetState 合伙人批量禁用
 func (c *PartnerInfoController) PartnerInfoSetState() {
 func (c *PartnerInfoController) PartnerInfoSetState() {
 	//用与适配前端定义的数据结构
 	//用与适配前端定义的数据结构
 	type Parameter struct {
 	type Parameter struct {
-		Id     int64 `json:"id"`
-		Status int   `json:"status"`
+		Id []int64 `json:"id"`
 	}
 	}
 	var (
 	var (
 		param Parameter
 		param Parameter
@@ -201,20 +215,11 @@ func (c *PartnerInfoController) PartnerInfoSetState() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
-
+	comanyId := c.GetUserCompany()
 	cmd := partnerInfoCmd.StatusPartnerInfoCommand{
 	cmd := partnerInfoCmd.StatusPartnerInfoCommand{
-		Id: param.Id,
-	}
-	if param.Status == 1 {
-		//禁用操作
-		cmd.Status = domain.PARTNER_STATUS_NO
-	} else if param.Status == 2 {
-		//启用操作
-		cmd.Status = domain.PARTNER_STATUS_YES
-	} else {
-		//错误
-		c.ResponseError(lib.ThrowError(lib.ARG_ERROR, "状态错误"))
-		return
+		Ids:       param.Id,
+		CompanyId: comanyId,
+		Status:    domain.PARTNER_STATUS_NO,
 	}
 	}
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	err = newPartnerService.UpdateStatus(cmd)
 	err = newPartnerService.UpdateStatus(cmd)
@@ -251,12 +256,14 @@ func (c *PartnerInfoController) ListPartnerInfo() {
 	if param.PageSize == 0 {
 	if param.PageSize == 0 {
 		param.PageSize = 20
 		param.PageSize = 20
 	}
 	}
+	companyId := c.GetUserCompany()
 	query := partnerQuery.ListPartnerInfoQuery{
 	query := partnerQuery.ListPartnerInfoQuery{
 		Partnertype: param.Partnertype,
 		Partnertype: param.Partnertype,
 		PartnerName: param.PartnerName,
 		PartnerName: param.PartnerName,
 		RegionInfo:  param.Area,
 		RegionInfo:  param.Area,
 		Limit:       param.PageSize,
 		Limit:       param.PageSize,
 		Offset:      (param.PageNumber - 1) * param.PageSize,
 		Offset:      (param.PageNumber - 1) * param.PageSize,
+		CompanyId:   companyId,
 	}
 	}
 
 
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
 	newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
@@ -275,7 +282,7 @@ func (c *PartnerInfoController) ListPartnerInfo() {
 			"createTime":      partners[i].CreateAt.Local().Format("2006-01-02 15:04:05"),
 			"createTime":      partners[i].CreateAt.Local().Format("2006-01-02 15:04:05"),
 			"cooperationTime": partners[i].CooperateTime.Local().Format("2006-01-02"),
 			"cooperationTime": partners[i].CooperateTime.Local().Format("2006-01-02"),
 			"state":           partners[i].Status,
 			"state":           partners[i].Status,
-			"partnerType":     partners[i].PartnerCategory,
+			"partnerType":     partners[i].PartnerCategoryInfos,
 			"salesmanName":    "",
 			"salesmanName":    "",
 			"phone":           "",
 			"phone":           "",
 		}
 		}

+package controllers
+
+//用于和企业平台和总后台进行数据通讯
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/astaxie/beego/logs"
+	companyService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/company/service"
+	syncCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/command"
+	syncService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/service"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
+)
+
+type SyncDataController struct {
+	BaseController
+}
+
+////Prepare 重写 BaseController 的Prepare方法
+func (c *SyncDataController) Prepare() {
+	c.BaseController.Prepare()
+}
+
+//SyncData 和企业后台同步数据
+func (c *SyncDataController) SyncData() {
+	var (
+		cmd syncCmd.SyncCallbackCommand
+		err error
+	)
+	if err = c.BindJsonData(&cmd); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	err = syncService.NewSyncAction(cmd)
+	if err != nil {
+		logs.Error("同步数据异常;%s", err)
+	}
+	//不论子系统如何处理以及处理结果成功失败 必须返回 0
+	c.ResponseData(nil)
+	return
+}
+
+//CompanyAdminChance 变更公司主管（超级管理）
+func (c *SyncDataController) CompanyAdminChance() {
+
+	var (
+		param syncCmd.ChanceSuperAdminCommand
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	syncEmployeeSrv := syncService.NewSyncEmployeeService(nil)
+	syncEmployeeSrv.ChangeSuperAdmin(param)
+	if err != nil {
+		logs.Error("变更公司的主管失败;%s", err)
+	}
+	c.ResponseData(nil)
+	return
+}
+
+//AllowForidCompany 总后台调用
+func (c *SyncDataController) AllowForidCompany() {
+	type Paremeter struct {
+		Companyid int64 `json:"company_id"`
+		Status    int   `json:"status"`
+	}
+	var param Paremeter
+	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
+		logs.Error("json 解析失败 err:%s", err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	var (
+		err error
+	)
+	comanySrv := companyService.NewCompanyService(nil)
+	switch param.Status {
+	case 1:
+		err = comanySrv.AllowCompany(param.Companyid)
+	case 2:
+		err = comanySrv.ForbidCompany(param.Companyid)
+	default:
+		c.ResponseError(errors.New("参数错误"))
+		return
+	}
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseData(nil)
+	return
+}
+
+//GetCompanyInfo 总后台调用
+func (c *SyncDataController) GetCompanyInfo() {
+	type Paremeter struct {
+		Companyid int64 `json:"company_id"`
+	}
+	var param Paremeter
+	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
+		logs.Error("json 解析失败 err:%s", err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	var (
+		err         error
+		companyData *domain.Company
+	)
+	comanySrv := companyService.NewCompanyService(nil)
+	companyData, err = comanySrv.GetCompanyData(param.Companyid)
+	rspData := map[string]interface{}{
+		"comopany_id": 0,
+		"exist":       -1, //公司【1：存在；【-1：不存在】
+		"status":      -1, //公司的启用状态【1：启用,-1:禁用】
+	}
+	if err != nil {
+		logs.Error(err)
+		c.ResponseData(rspData)
+		return
+	}
+	if companyData.EnableIsOk() {
+		rspData["status"] = 1
+	}
+	rspData["exist"] = 1
+	c.ResponseData(rspData)
+	return
+}

@@ -6,18 +6,18 @@ import (
 	"github.com/astaxie/beego/logs"
 	"github.com/astaxie/beego/logs"
 	adminPermissionquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/query"
 	adminPermissionquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/query"
 	adminPermissionService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/service"
 	adminPermissionService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/service"
-	adminuserCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/command"
-	adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
-	adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
+	userCommand "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/command"
+	userQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/query"
+	userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
 )
 )
 
 
-type AdminUserController struct {
+type UserController struct {
 	BaseController
 	BaseController
 }
 }
 
 
-////Prepare 重写 BaseController 的Prepare方法
-func (c *AdminUserController) Prepare() {
+//Prepare 重写 BaseController 的Prepare方法
+func (c *UserController) Prepare() {
 	c.BaseController.Prepare()
 	c.BaseController.Prepare()
 	if ok := c.ValidJWTToken(); !ok {
 	if ok := c.ValidJWTToken(); !ok {
 		return
 		return
@@ -27,87 +27,8 @@ func (c *AdminUserController) Prepare() {
 	}
 	}
 }
 }
 
 
-type adminDetailParam struct {
-	Id             int64  `json:"id"`
-	PermissionType []int  `json:"permissionType"`
-	Status         int    `json:"status"`
-	Account        string `json:"account"`
-	IsAdmin        int    `json:"isAdmin"`
-}
-
-func (c *AdminUserController) SaveAdminUser() {
-	//用与适配前端定义的数据结构
-	var (
-		param adminDetailParam
-		err   error
-	)
-	if err = c.BindJsonData(&param); err != nil {
-		logs.Error(err)
-		c.ResponseError(errors.New("json数据解析失败"))
-		return
-	}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	cmd := &adminuserCmd.SaveAdminUserCommand{
-		Id:           param.Id,
-		Name:         param.Account,
-		Account:      param.Account,
-		PermissionId: param.PermissionType,
-		IsUsable:     false,
-	}
-	if param.Status == 1 {
-		cmd.IsUsable = true
-	}
-	_, err = newAdminUserService.SaveAdminUser(cmd)
-	if err != nil {
-		c.ResponseError(err)
-		return
-	}
-	c.ResponseData(nil)
-	return
-}
-
-func (c *AdminUserController) GetAdminUser() {
-	//用与适配前端定义的数据结构
-	type Paramter struct {
-		Id int64 `json:"id"`
-	}
-	var (
-		param Paramter
-		err   error
-	)
-	if err = c.BindJsonData(&param); err != nil {
-		logs.Error(err)
-		c.ResponseError(errors.New("json数据解析失败"))
-		return
-	}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	adminuser, err := newAdminUserService.GetAdminUser(&adminuserquery.GetAdminUserQuery{
-		Id: param.Id,
-	})
-	if err != nil {
-		c.ResponseError(err)
-		return
-	}
-	rspData := adminDetailParam{
-		Id:      adminuser.Id,
-		Account: adminuser.Account,
-		Status:  0,
-		IsAdmin: 0,
-	}
-	for _, v := range adminuser.Permission {
-		rspData.PermissionType = append(rspData.PermissionType, v.Id)
-	}
-	if adminuser.IsUsable {
-		rspData.Status = 1
-	}
-	if adminuser.IsDefault {
-		rspData.IsAdmin = 1
-	}
-	c.ResponseData(rspData)
-	return
-}
-
-func (c *AdminUserController) ListAdminUser() {
+//ListUser 获取用户分页列表
+func (c *UserController) ListUser() {
 	//用与适配前端定义的数据结构
 	//用与适配前端定义的数据结构
 	type Paramter struct {
 	type Paramter struct {
 		SearchText string `json:"searchText"`
 		SearchText string `json:"searchText"`
@@ -129,63 +50,54 @@ func (c *AdminUserController) ListAdminUser() {
 	if param.PageNumber == 0 {
 	if param.PageNumber == 0 {
 		param.PageNumber = 1
 		param.PageNumber = 1
 	}
 	}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	queryOption := &adminuserquery.ListAdminUserQuery{
-		AdminAccountMatch: param.SearchText,
-		Limit:             param.PageSize,
-		Offset:            param.PageSize * (param.PageNumber - 1),
+	newUserService := userService.NewUsersService(nil)
+	queryOption := userQuery.UserListQuery{
+		UserNameMatch: param.SearchText,
+		Limit:         param.PageSize,
+		Offset:        param.PageSize * (param.PageNumber - 1),
+		CompanyId:     c.GetUserCompany(),
 	}
 	}
-	adminusers, cnt, err := newAdminUserService.PageListAdminUser(queryOption)
+	cnt, usersData, err := newUserService.GetUserList(queryOption)
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
 		return
 		return
 	}
 	}
+	c.ResponsePageList(usersData, cnt, param.PageNumber)
+	return
+}
+
+//BeforeEditUser 编辑用户数据的前置接口
+func (c *UserController) BeforeEditUser() {
 	newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
 	newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
 	allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{
 	allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{
 		ParentId: 0,
 		ParentId: 0,
+		NotCode:  []string{domain.PERMINSSION_ADMIN_USER},
 	})
 	})
 	if err != nil {
 	if err != nil {
 		logs.Error("获取权限数据失败：%s", err)
 		logs.Error("获取权限数据失败：%s", err)
 		c.ResponseError(errors.New("服务异常"))
 		c.ResponseError(errors.New("服务异常"))
 		return
 		return
 	}
 	}
-	permissionMap := map[int]domain.AdminPermission{}
+	var rspData []map[string]interface{}
 	for i := range allPermission {
 	for i := range allPermission {
-		permissionMap[allPermission[i].Id] = allPermission[i]
-	}
-	listData := []map[string]interface{}{}
-	//前端数据格式适配
-	for i := range adminusers {
-		permissionTypes := []string{}
-		for _, vv := range adminusers[i].Permission {
-			if pm, ok := permissionMap[vv.Id]; ok {
-				permissionTypes = append(permissionTypes, pm.Name)
-			}
+		if allPermission[i].Code == domain.PERMINSSION_ADMIN_USER {
+			continue
 		}
 		}
 		m := map[string]interface{}{
 		m := map[string]interface{}{
-			"id":         adminusers[i].Id,
-			"account":    adminusers[i].Account,
-			"permission": permissionTypes,
-			"statue":     0,
-			"isAdmin":    0,
-		}
-		if adminusers[i].IsUsable {
-			m["statue"] = 1
-		}
-		if adminusers[i].IsDefault {
-			m["isAdmin"] = 1
+			"id":             allPermission[i].Id,
+			"permissionName": allPermission[i].Name,
 		}
 		}
-		listData = append(listData, m)
+		rspData = append(rspData, m)
 	}
 	}
-	c.ResponsePageList(listData, cnt, param.PageNumber)
+	c.ResponseData(rspData)
 	return
 	return
 }
 }
 
 
-func (c *AdminUserController) ForbiddenAdminUser() {
+//GetUserData 用户详情页数据
+func (c *UserController) GetUserData() {
 	//用与适配前端定义的数据结构
 	//用与适配前端定义的数据结构
 	type Paramter struct {
 	type Paramter struct {
-		Id     int64 `json:"id"`
-		Statue int   `json:"statue"`
+		Id int64 `json:"id"`
 	}
 	}
 	var (
 	var (
 		param Paramter
 		param Paramter
@@ -196,46 +108,45 @@ func (c *AdminUserController) ForbiddenAdminUser() {
 		c.ResponseError(errors.New("json数据解析失败"))
 		c.ResponseError(errors.New("json数据解析失败"))
 		return
 		return
 	}
 	}
-	newAdminUserService := adminuserservice.NewAdminUserService(nil)
-	var isUsable bool
-	if param.Statue == 1 {
-		isUsable = true
-	} else if param.Statue == 0 {
-		isUsable = false
-	} else {
-		c.ResponseError(errors.New("参数错误"))
-		return
-	}
-
-	err = newAdminUserService.UpdateAdminIsUsable(param.Id, isUsable)
+	companyId := c.GetUserCompany()
+	newUserService := userService.NewUsersService(nil)
+	usersData, err := newUserService.GetUserData(param.Id, companyId)
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 		c.ResponseError(err)
 		return
 		return
 	}
 	}
-	c.ResponseData(nil)
+	c.ResponseData(usersData)
 	return
 	return
 }
 }
 
 
-//BeforeEditAdminUser 编辑管理员操作的前置接口
-func (c *AdminUserController) BeforeEditAdminUser() {
-	newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
-	allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{
-		ParentId: 0,
-		NotCode:  []string{domain.PERMINSSION_ADMIN_USER},
+//EditUserPermission 编辑用户的权限数据
+func (c *UserController) EditUserPermission() {
+	type UserDetailParam struct {
+		Id             int64   `json:"id"`
+		PermissionType []int64 `json:"permissionType"`
+		CheckedPartner []int64 `json:"checkedPartner"` //合伙人
+	}
+	var (
+		param UserDetailParam
+		err   error
+	)
+	if err = c.BindJsonData(&param); err != nil {
+		logs.Error(err)
+		c.ResponseError(errors.New("json数据解析失败"))
+		return
+	}
+	companyId := c.GetUserCompany()
+	newUserService := userService.NewUsersService(nil)
+	err = newUserService.EditUserPermission(userCommand.EditUserPermissionCommand{
+		Id:             param.Id,
+		CompanyId:      companyId,
+		PermissionType: param.PermissionType,
+		CheckedPartner: param.CheckedPartner,
 	})
 	})
 	if err != nil {
 	if err != nil {
-		logs.Error("获取权限数据失败：%s", err)
-		c.ResponseError(errors.New("服务异常"))
+		c.ResponseError(err)
 		return
 		return
 	}
 	}
-	var rspData []map[string]interface{}
-	for i := range allPermission {
-		m := map[string]interface{}{
-			"id":             allPermission[i].Id,
-			"permissionName": allPermission[i].Name,
-		}
-		rspData = append(rspData, m)
-	}
-	c.ResponseData(rspData)
+	c.ResponseData(nil)
 	return
 	return
 }
 }

@@ -9,28 +9,30 @@ func init() {
 	adminRouter := beego.NewNamespace("/v1",
 	adminRouter := beego.NewNamespace("/v1",
 		beego.NSNamespace("/auth",
 		beego.NSNamespace("/auth",
 			beego.NSRouter("/login", &controllers.AdminLoginController{}, "POST:Login"),
 			beego.NSRouter("/login", &controllers.AdminLoginController{}, "POST:Login"),
-			beego.NSRouter("/captcha-init", &controllers.AdminLoginController{}, "POST:CaptchaInit"),
 			beego.NSRouter("/profile", &controllers.AdminLoginController{}, "POST:AdminpPofile"),
 			beego.NSRouter("/profile", &controllers.AdminLoginController{}, "POST:AdminpPofile"),
-			beego.NSRouter("/pwd-update", &controllers.AdminLoginController{}, "POST:PwdUpdate"),
 		),
 		),
 		beego.NSNamespace("/admin",
 		beego.NSNamespace("/admin",
-			beego.NSRouter("/update", &controllers.AdminUserController{}, "POST:SaveAdminUser"),
-			beego.NSRouter("/detail", &controllers.AdminUserController{}, "POST:GetAdminUser"),
-			beego.NSRouter("/list", &controllers.AdminUserController{}, "POST:ListAdminUser"),
-			beego.NSRouter("/forbidden", &controllers.AdminUserController{}, "POST:ForbiddenAdminUser"),
-			beego.NSRouter("/permission", &controllers.AdminUserController{}, "POST:BeforeEditAdminUser"),
+			beego.NSRouter("/update", &controllers.UserController{}, "POST:EditUserPermission"),
+			beego.NSRouter("/detail", &controllers.UserController{}, "POST:GetUserData"),
+			beego.NSRouter("/list", &controllers.UserController{}, "POST:ListUser"),
+			beego.NSRouter("/permission", &controllers.UserController{}, "POST:BeforeEditUser"),
 		),
 		),
 		beego.NSNamespace("/partners",
 		beego.NSNamespace("/partners",
 			beego.NSRouter("/list", &controllers.PartnerInfoController{}, "POST:ListPartnerInfo"),
 			beego.NSRouter("/list", &controllers.PartnerInfoController{}, "POST:ListPartnerInfo"),
 			beego.NSRouter("/add", &controllers.PartnerInfoController{}, "POST:CreatePartnerInfo"),
 			beego.NSRouter("/add", &controllers.PartnerInfoController{}, "POST:CreatePartnerInfo"),
 			beego.NSRouter("/edit", &controllers.PartnerInfoController{}, "POST:UpdatePartnerInfo"),
 			beego.NSRouter("/edit", &controllers.PartnerInfoController{}, "POST:UpdatePartnerInfo"),
 			beego.NSRouter("/detail", &controllers.PartnerInfoController{}, "POST:GetPartnerInfo"),
 			beego.NSRouter("/detail", &controllers.PartnerInfoController{}, "POST:GetPartnerInfo"),
-			beego.NSRouter("/set-status", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
+			//beego.NSRouter("/set-status", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
+			beego.NSRouter("/batchDisabled", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
 		),
 		),
 		beego.NSNamespace("/dividends",
 		beego.NSNamespace("/dividends",
 			beego.NSRouter("/list", &controllers.OrderDividendController{}, "POST:PageListOrderDividend"),
 			beego.NSRouter("/list", &controllers.OrderDividendController{}, "POST:PageListOrderDividend"),
 			beego.NSRouter("/edit", &controllers.OrderDividendController{}, "POST:EditOrderDividend"),
 			beego.NSRouter("/edit", &controllers.OrderDividendController{}, "POST:EditOrderDividend"),
 			beego.NSRouter("/detail", &controllers.OrderDividendController{}, "POST:OrderDividendDetail"),
 			beego.NSRouter("/detail", &controllers.OrderDividendController{}, "POST:OrderDividendDetail"),
+
+			beego.NSRouter("/business/detail", &controllers.BusinessBonusController{}, "POST:GetBusinessBonus"),
+			beego.NSRouter("/business/edit", &controllers.BusinessBonusController{}, "POST:UpdateBusinessBonus"),
+			beego.NSRouter("/business/list", &controllers.BusinessBonusController{}, "POST:ListBusinessBonus"),
 		),
 		),
 		beego.NSNamespace("/order",
 		beego.NSNamespace("/order",
 			beego.NSRouter("/purpose/list", &controllers.OrderInfoController{}, "POST:PageListOrderPurpose"),
 			beego.NSRouter("/purpose/list", &controllers.OrderInfoController{}, "POST:PageListOrderPurpose"),
@@ -41,13 +43,17 @@ func init() {
 			beego.NSRouter("/actual/list", &controllers.OrderInfoController{}, "POST:PageListOrderReal"),
 			beego.NSRouter("/actual/list", &controllers.OrderInfoController{}, "POST:PageListOrderReal"),
 			beego.NSRouter("/actual/detail", &controllers.OrderInfoController{}, "POST:GetOrderReal"),
 			beego.NSRouter("/actual/detail", &controllers.OrderInfoController{}, "POST:GetOrderReal"),
 			beego.NSRouter("/actual/del", &controllers.OrderInfoController{}, "POST:RemoveOrderReal"),
 			beego.NSRouter("/actual/del", &controllers.OrderInfoController{}, "POST:RemoveOrderReal"),
-
 			beego.NSRouter("/actual/update", &controllers.OrderInfoController{}, "POST:UpdateOrderReal"),
 			beego.NSRouter("/actual/update", &controllers.OrderInfoController{}, "POST:UpdateOrderReal"),
 			beego.NSRouter("/actual/close", &controllers.OrderInfoController{}, "POST:OrderDisable"),
 			beego.NSRouter("/actual/close", &controllers.OrderInfoController{}, "POST:OrderDisable"),
 		),
 		),
 
 
 		beego.NSNamespace("/common",
 		beego.NSNamespace("/common",
 			beego.NSRouter("/partner", &controllers.CommonController{}, "POST:GetPartnerList"),
 			beego.NSRouter("/partner", &controllers.CommonController{}, "POST:GetPartnerList"),
+			beego.NSRouter("/partnerType", &controllers.CommonController{}, "POST:GetPartnerCategory"),
+		),
+
+		beego.NSNamespace("/enterprises",
+			beego.NSRouter("/setPhone", &controllers.CompanyController{}, "POST:SetPhone"),
 		),
 		),
 	)
 	)
 
 

+package routers
+
+import (
+	"github.com/astaxie/beego"
+	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/port/beego/controllers"
+)
+
+//外部调用,企业平台，总后台调用
+func init() {
+	nsPlatform := beego.NewNamespace("/platform",
+		beego.NSRouter("/action", &controllers.SyncDataController{}, "post:SyncData"),
+		beego.NSRouter("/admins_change", &controllers.SyncDataController{}, "post:CompanyAdminChance"),
+	)
+	nsUcenter := beego.NewNamespace("/ucenter",
+		beego.NSRouter("/company/allow_forbid", &controllers.SyncDataController{}, "post:AllowForidCompany"),
+		//beego.NSRouter("/company/info", &controllers.SyncDataController{}, "post:GetCompanyInfo"),
+	)
+
+	beego.AddNamespace(nsPlatform) //企业平台调用
+	beego.AddNamespace(nsUcenter)  //统一用户中心调用
+}

 package routers
 package routers
 
 
 import (
 import (
+	"net/http"
+
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/context"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
 	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
 )
 )
 
 
 func init() {
 func init() {
-	beego.SetStaticPath("/log", constant.LOG_File)
+	//beego.SetStaticPath("/log", constant.LOG_File)
+	beego.Get("/log", func(ctx *context.Context) {
+		var s string
+		ctx.Input.Bind(&s, "id")
+		if s != "12345" {
+			ctx.Output.SetStatus(http.StatusBadRequest)
+			return
+		}
+		http.ServeFile(ctx.ResponseWriter, ctx.Request, constant.LOG_File)
+		return
+	})
 }
 }