mmm-go / partnermg · 提交

转到一个项目

作者 唐旭辉
提交 ad505cda6c7e593936ab08e3aaa69e91ccaf0253 2 个父辈 e59a452f 6942e9fa

Merge branch 'test'

内嵌 并排对比
正在显示 72 个修改的文件 包含 3054 行增加 和 904 行删除

要显示太多修改。
重新载入完整差异 差异文件 邮件补丁

为保证性能只显示 72 of 72+ 个文件。

... ... @@ -68,6 +68,16 @@ spec:
value: "1"
- name: ERROR_BASE_CODE_MULTIPLE
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:
- name: accesslogs
emptyDir: {}
... ...
... ... @@ -65,10 +65,16 @@ spec:
value: "1"
- name: ERROR_BASE_CODE_MULTIPLE
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:
- name: accesslogs
emptyDir: {}
\ No newline at end of file
... ...
... ... @@ -65,6 +65,16 @@ spec:
value: "1"
- name: ERROR_BASE_CODE_MULTIPLE
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:
- name: accesslogs
emptyDir: {}
... ...
... ... @@ -7,7 +7,7 @@ import (
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
)
//AdminUserService 管理员相关服务
//AdminPermissionService 管理员权限
type AdminPermissionService struct {
}
... ... @@ -39,12 +39,10 @@ func (adminPermissionSrv AdminPermissionService) ListAdminPermission(queryOption
} else {
permissionRepository = value
}
permissions, err = permissionRepository.Find(domain.AdminPermissionFindQuery{
NotCode: queryOption.NotCode,
ParentId: queryOption.ParentId,
})
permissions, err = permissionRepository.Find(domain.PermissionFindOption{})
if err != nil {
return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
}
err = transactionContext.CommitTransaction()
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"
)
func CreateAdminUserkDao(options map[string]interface{}) (*dao.AdminUserDao, error) {
func CreatePartnerInfoDao(options map[string]interface{}) (*dao.PartnerInfoDao, error) {
var transactionContext *transaction.TransactionContext
if value, ok := options["transactionContext"]; ok {
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
if value, ok := options["transactionContext"]; ok {
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
if value, ok := options["transactionContext"]; ok {
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)
}
//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 管理员权限信息
func CreateAdminPermissionRepository(options map[string]interface{}) (domain.AdminPermissionRepository, error) {
var transactionContext *transaction.TransactionContext
... ... @@ -50,3 +41,39 @@ func CreateOrderGoodRepository(options map[string]interface{}) (domain.OrderGood
}
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"`
//货品
Goods []OrderGoodData `json:"goods"`
Goods []OrderGoodData `json:"goods"`
CompanyId int64 `json:"companyId"`
}
... ...
... ... @@ -5,4 +5,5 @@ type DisableOrderCommand struct {
OrderId int64 `json:"orderId"`
IsDisable int `json:"isDisable"`
OrderType int `json:"orderType"`
CompanyId int64 `json:"companyId"`
}
... ...
... ... @@ -7,4 +7,5 @@ type OrderDeliveryCommand struct {
DeliveryTime time.Time `json:"deliveryTime"`
DeliveryCode string `json:"deliveryCode"`
Goods []OrderGoodData `json:"goods"`
CompanyId int64
}
... ...
... ... @@ -4,6 +4,7 @@ package command
type UpdateGoodBouns struct {
Id int64 `json:"id"` //订单id
GoodBouns []GoodBouns `json:"goodBouns"`
CompanyId int64 `json:"companyId"`
}
//GoodBoun 商品数量调整
... ...
... ... @@ -18,5 +18,6 @@ type UpdateOrderCommand struct {
//订单类型
OrderType int `json:"orderType"`
//货品
Goods []OrderGoodData `json:"goods"`
Goods []OrderGoodData `json:"goods"`
CompanyId int64 `json:"companyId"`
}
... ...
... ... @@ -2,5 +2,6 @@ package query
//GetOrderQuery 获取订单详情
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"`
//发货单号
DeliveryCode string `json:"deliveryCode"`
CompanyId int64 `json:"companyId"`
}
... ...
... ... @@ -4,6 +4,8 @@ import (
"fmt"
"time"
"github.com/astaxie/beego/logs"
"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/query"
... ... @@ -27,11 +29,18 @@ func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrder
if err != nil {
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 (
orderRepository domain.OrderBaseRepository
orders []domain.OrderBase
cnt int
)
if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
"transactionContext": transactionContext,
}); err != nil {
... ... @@ -46,6 +55,7 @@ func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrder
Limit: listOrderQuery.Limit,
OrderType: listOrderQuery.OrderType,
DeliveryCode: listOrderQuery.DeliveryCode,
CompanyId: listOrderQuery.CompanyId,
}
orders, cnt, err = orderRepository.Find(query)
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())
}
for i := range orders {
var partnerData *domain.PartnerInfo
partnerData := &domain.PartnerInfo{}
partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
UserId: orders[i].PartnerId,
})
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
}
... ... @@ -79,7 +91,7 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
}
var (
orderBaseRepository domain.OrderBaseRepository
PartnerInfoRepository domain.PartnerInfoRepository
partnerInfoRepository domain.PartnerInfoRepository
orderGoodRepository domain.OrderGoodRepository
order *domain.OrderBase
)
... ... @@ -89,14 +101,12 @@ func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery
defer func() {
transactionContext.RollbackTransaction()
}()
if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
"transactionContext": transactionContext,
}); err != nil {
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,
}); err != nil {
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())
}
order, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
OrderId: getOrderQuery.OrderId,
OrderId: getOrderQuery.OrderId,
CompanyId: getOrderQuery.CompanyId,
})
if err != nil {
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
)
partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: order.PartnerId})
partnerData, err = partnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
UserId: order.PartnerId,
CompanyId: getOrderQuery.CompanyId,
})
if err != nil {
return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败：%s", err))
}
order.PartnerInfo = partnerData.Partner
goods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
OrderId: order.Id,
OrderId: order.Id,
CompanyId: getOrderQuery.CompanyId,
})
if err != nil {
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是否重复
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())
} else if ok {
return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
... ... @@ -197,15 +212,16 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
newOrder := &domain.OrderBase{
OrderType: cmd.OrderType, OrderCode: cmd.OrderCode,
DeliveryCode: cmd.DeliveryCode,
Buyer: &domain.Buyer{
Buyer: domain.Buyer{
BuyerName: cmd.BuyerName,
},
RegionInfo: &domain.RegionInfo{
RegionInfo: domain.RegionInfo{
RegionName: cmd.OrderRegion,
},
PartnerId: cmd.PartnerId,
PartnerInfo: partnerData.Partner,
SalesmanBonusPercent: cmd.SalesmanBonusPercent,
CompanyId: cmd.CompanyId,
}
var orderGoods []domain.OrderGood
for _, good := range cmd.Goods {
... ... @@ -216,6 +232,7 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
m.Price = good.Price
m.PartnerBonusPercent = good.PartnerBonusPercent
m.Remark = good.Remark
m.CompanyId = cmd.CompanyId
err = m.Compute()
if err != nil {
return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
... ... @@ -251,7 +268,7 @@ func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (
}
//DeleteOrder 删除订单
func (service OrderInfoService) DeleteOrder(orderId int64) error {
func (service OrderInfoService) DeleteOrder(orderId int64, companyId int64) error {
var (
transactionContext, _ = factory.CreateTransactionContext(nil)
err error
... ... @@ -276,11 +293,11 @@ func (service OrderInfoService) DeleteOrder(orderId int64) error {
}); err != nil {
return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
}
err = orderBaseRepository.Remove(orderId)
err = orderBaseRepository.Remove(orderId, companyId)
if err != nil {
return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单数据失败：%s", err))
}
err = orderGoodRepository.Remove(orderId)
err = orderGoodRepository.Remove(orderId, companyId)
if err != nil {
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())
}
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 {
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{
OrderId: cmd.Id,
OrderId: cmd.Id,
CompanyId: cmd.CompanyId,
})
if err != nil {
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是否重复
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())
} else if ok {
return nil, lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
... ... @@ -367,7 +387,8 @@ func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand)
}
//获取旧的订单中的商品
oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
OrderId: cmd.Id,
OrderId: cmd.Id,
CompanyId: cmd.CompanyId,
})
if err != nil {
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.PartnerBonusPercent = good.PartnerBonusPercent
m.Remark = good.Remark
m.CompanyId = cmd.CompanyId
err = m.Compute()
if err != nil {
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
//删不需要的订单总不需要的商品
delGoods = service.deleteOldOrderGoods(newOrderGoods, oldOrderGoods)
err = orderGoodRepository.Remove(oldOrderData.Id, delGoods...)
err = orderGoodRepository.Remove(oldOrderData.Id, cmd.CompanyId, delGoods...)
if err != nil {
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{
OrderId: cmd.OrderId,
CompanyId: cmd.CompanyId,
OrderId: cmd.OrderId,
})
if err != nil {
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())
}
//检查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())
} else if ok {
return lib.ThrowError(lib.BUSINESS_ERROR, "发货号已存在")
}
//获取旧的订单中的商品
oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
OrderId: cmd.OrderId,
OrderId: cmd.OrderId,
CompanyId: cmd.CompanyId,
})
if err != nil {
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{
OrderId: cmd.OrderId,
OrderId: cmd.OrderId,
CompanyId: cmd.CompanyId,
})
if err != nil {
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{
OrderId: cmd.Id,
OrderId: cmd.Id,
CompanyId: cmd.CompanyId,
})
if err != nil {
return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
... ...
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"`
// 状态（1：启用或者0：禁用）
Status int `json:"status"`
// 合伙类别 （1.研发合伙人 2.业务合伙人 3.事业）
PartnerCategory int `json:"partnerCategory,omitempty"`
// 合伙类别
PartnerCategory []int64 `json:"partnerCategory,omitempty"`
//合作时间
CooperateTime time.Time `json:"cooperateTime"`
// 区域
RegionInfo *domain.RegionInfo `json:"regionInfo"`
//关联业务员
Salesman []domain.Salesman `json:"salesman,omitempty"`
//公司id
CompanyId int64 `json:"companyId"`
}
func (command CreatePartnerInfoCommand) ValidateCommand() error {
if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
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 {
return lib.ThrowError(lib.ARG_ERROR, "合伙人名称必填")
... ...
... ... @@ -7,16 +7,14 @@ import (
type StatusPartnerInfoCommand struct {
// 合伙人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 {
if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
return lib.ThrowError(lib.ARG_ERROR, "合伙人状态错误")
}
if command.Id == 0 {
return lib.ThrowError(lib.ARG_ERROR, "合伙人id错误")
}
return nil
}
... ...
... ... @@ -13,25 +13,21 @@ type UpdatePartnerInfoCommand struct {
// 状态（1：启用或者0：禁用）
Status int `json:"status"`
// 合伙类别 （1.研发合伙人 2.业务合伙人 3.事业）
PartnerCategory int `json:"partnerCategory,omitempty"`
PartnerCategory []int64 `json:"partnerCategory,omitempty"`
// 区域
RegionInfo *domain.RegionInfo `json:"regionInfo"`
//关联业务员
Salesman []domain.Salesman `json:"salesman,omitempty"`
//合作时间
CooperateTime time.Time `json:"cooperateTime"`
//公司id
CompanyId int64 `json:"companyId"`
}
func (command *UpdatePartnerInfoCommand) ValidateCommand() error {
if !(command.Status == domain.PARTNER_STATUS_NO || command.Status == domain.PARTNER_STATUS_YES) {
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 {
return lib.ThrowError(lib.ARG_ERROR, "区域必填")
}
... ...
... ... @@ -2,7 +2,8 @@ package query
type GetPartnerInfoQuery struct {
// 合伙人ID
Id int64 `json:"id" `
Id int64 `json:"id" `
CompanyId int64 `json:"companyId"`
}
func (q *GetPartnerInfoQuery) ValidateQuery() error {
... ...
... ... @@ -7,6 +7,7 @@ type ListPartnerInfoQuery struct {
RegionInfo string `json:"regionInfo"`
// 合伙人姓名
PartnerName string `json:"partnerName"`
CompanyId int64 `json:"companyId"`
// 查询偏离量
Offset int `json:"offset"`
// 查询限制
... ...
package service
import (
"fmt"
"github.com/linmadan/egglib-go/core/application"
"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/query"
"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/lib"
)
... ... @@ -19,12 +22,12 @@ func NewPartnerInfoService(options map[string]interface{}) *PartnerInfoService {
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 (
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())
}
if err = transactionContext.StartTransaction(); err != nil {
... ... @@ -37,14 +40,12 @@ func (PartnerInfoService *PartnerInfoService) CreatePartnerInfo(command *command
var (
partnerinfoDao *dao.PartnerInfoDao
)
if v, err := factory.CreatePartnerInfoDao(map[string]interface{}{
if partnerinfoDao, err = factory.CreatePartnerInfoDao(map[string]interface{}{
"transactionContext": transactionContext,
}); err != nil {
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 {
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, "账号已存在")
}
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,
}); err != nil {
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{
Partner: domain.Partner{
Account: command.Account,
PartnerName: command.PartnerName,
Account: cmd.Account,
PartnerName: cmd.PartnerName,
},
PartnerCategory: command.PartnerCategory,
Password: command.Password,
Status: command.Status,
RegionInfo: command.RegionInfo,
Salesman: command.Salesman,
CooperateTime: command.CooperateTime,
}
if data, err = PartnerInfoRepository.Save(newPartnerInfo); err != nil {
PartnerCategory: 0,
Password: cmd.Password,
Status: cmd.Status,
RegionInfo: *cmd.RegionInfo,
Salesman: cmd.Salesman,
CooperateTime: cmd.CooperateTime,
CompanyId: cmd.CompanyId,
PartnerCategoryInfos: categorys,
}
if err = partnerInfoRepository.Save(&newPartnerInfo); err != nil {
return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
}
var businessBonusSrv service.BusinessBonusService
if businessBonusSrv, err = factory.CreateBusinessBonusService(map[string]interface{}{
"transactionContext": transactionContext,
}); err != nil {
return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
}
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()
return
return newPartnerInfo, nil
}
// 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 (
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())
}
if err := transactionContext.StartTransaction(); err != nil {
... ... @@ -91,26 +121,54 @@ func (PartnerInfoService *PartnerInfoService) GetPartnerInfo(command query.GetPa
defer func() {
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{}{
"transactionContext": transactionContext,
}); err != nil {
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 {
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()
return
return partnerData, nil
}
//UpdatePartnerInfo 更新合伙人
func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(updatePartnerInfoCommand *command.UpdatePartnerInfoCommand) (err error) {
func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(cmd *command.UpdatePartnerInfoCommand) (err error) {
var (
transactionContext, _ = factory.CreateTransactionContext(nil)
)
if err = updatePartnerInfoCommand.ValidateCommand(); err != nil {
if err = cmd.ValidateCommand(); err != nil {
return application.ThrowError(application.ARG_ERROR, err.Error())
}
if err := transactionContext.StartTransaction(); err != nil {
... ... @@ -119,31 +177,61 @@ func (PartnerInfoService *PartnerInfoService) UpdatePartnerInfo(updatePartnerInf
defer func() {
transactionContext.RollbackTransaction()
}()
var partnerInfoRepository domain.PartnerInfoRepository
var (
partnerInfoRepository domain.PartnerInfoRepository
categoryRepository domain.PartnerCategoryRepository
categorys []domain.PartnerCategory
)
if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
"transactionContext": transactionContext,
}); err != nil {
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{
UserId: updatePartnerInfoCommand.Id,
UserId: cmd.Id, CompanyId: cmd.CompanyId,
})
if err != nil {
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())
}
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()
return
}
// 返回客户价值列表
// ListPartnerInfo 合伙人列表
func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQuery *query.ListPartnerInfoQuery) (int, []domain.PartnerInfo, error) {
var (
transactionContext, _ = factory.CreateTransactionContext(nil)
... ... @@ -158,21 +246,30 @@ func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQue
return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
}
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{}{
"transactionContext": transactionContext,
}); err != nil {
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{
Offset: listPartnerInfoQuery.Offset,
Limit: listPartnerInfoQuery.Limit,
Offset: listPartnerInfoQuery.Offset,
Limit: listPartnerInfoQuery.Limit,
PartnerName: listPartnerInfoQuery.PartnerName,
CompanyId: listPartnerInfoQuery.CompanyId,
}
if listPartnerInfoQuery.Partnertype > 0 {
queryOption.PartnerCategory = []int{listPartnerInfoQuery.Partnertype}
... ... @@ -187,17 +284,37 @@ func (PartnerInfoService *PartnerInfoService) ListPartnerInfo(listPartnerInfoQue
if count, err = partnerInfoRepository.CountAll(queryOption); err != nil {
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 {
return 0, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
}
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 (
transactionContext, _ = factory.CreateTransactionContext(nil)
)
if err = command.ValidateCommand(); err != nil {
if err = cmd.ValidateCommand(); err != nil {
return application.ThrowError(application.ARG_ERROR, err.Error())
}
if err := transactionContext.StartTransaction(); err != nil {
... ... @@ -206,21 +323,18 @@ func (PartnerInfoService *PartnerInfoService) UpdateStatus(command command.Statu
defer func() {
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,
}); err != nil {
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 {
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()
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
//ListAdminUserQuery 获取用户列表
type ListAdminUserQuery struct {
//账号匹配
AdminAccountMatch string `json:"adminAccountMatch" `
type UserListQuery struct {
//用户名称匹配
UserNameMatch string `json:"userNameMatch" `
// 查询偏离量
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 (
UCENTER_HOST = "http://suplus-ucenter-dev.fjmaimaimai.com" //统一用户中心地址
UCENTER_HOST = "https://suplus-ucenter-dev.fjmaimaimai.com" //统一用户中心地址
UCENTER_SECRET = "cykbjnfqgctn"
UCENTER_APP_KEY = "39aefef9e22744a3b2d2d3791824ae7b"
UCENTER_CHECK_ALT = "rsF0pL!6DwjBO735"
)
var (
BUSINESS_ADMIN_HOST = "http://suplus-business-admin-dev.fjmaimaimai.com" //企业平台的地址
)
func init() {
if os.Getenv("LOG_LEVEL") != "" {
LOG_LEVEL = os.Getenv("LOG_LEVEL")
}
if os.Getenv("UCENTER_HOST") != "" {
LOG_LEVEL = os.Getenv("UCENTER_HOST")
UCENTER_HOST = os.Getenv("UCENTER_HOST")
}
if os.Getenv("UCENTER_SECRET") != "" {
LOG_LEVEL = os.Getenv("UCENTER_SECRET")
UCENTER_SECRET = os.Getenv("UCENTER_SECRET")
}
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") != "" {
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_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_SQL_GENERATE_PRINT = false
... ...
package domain
//权限代码
//权限配置 1合作管理人 2订单管理 3分红管理 4管理员管理
//权限配置 ：admin_permission表中对应的权限编码
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 {
Id int `json:"id"`
Id int64 `json:"id"`
Code string `json:"code"`
}
// 权限结构
type AdminPermission struct {
Id int `json:"id"`
ParentId int `json:"parentId"`
Id int64 `json:"id"`
ParentId int64 `json:"parentId"`
Code string `json:"code"`
Name string `json:"name"`
Sort int `json:"sort"`
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 {
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"`
//买家
Buyer *Buyer `json:"buyer"`
Buyer Buyer `json:"buyer"`
//订单区域信息
RegionInfo *RegionInfo `json:"regionInfo"`
RegionInfo RegionInfo `json:"regionInfo"`
//订单对应的合伙人
PartnerId int64 `json:"partnerId"`
PartnerInfo Partner `json:"partnerInfo"`
... ... @@ -59,6 +59,8 @@ type OrderBase struct {
IsDisable int `json:"isDisable"`
//分红支付状态
BonusStatus int `json:"bonusStatus"`
//公司
CompanyId int64 `json:"companyId"`
}
type OrderCompute struct {
... ... @@ -178,7 +180,8 @@ func (order *OrderBase) Compute() error {
}
type OrderBaseFindOneQuery struct {
OrderId int64
OrderId int64
CompanyId int64
}
type OrderBaseFindQuery struct {
... ... @@ -188,11 +191,12 @@ type OrderBaseFindQuery struct {
Offset int
Limit int
OrderType int
CompanyId int64
}
type OrderBaseRepository interface {
Save(order *OrderBase) error
FindOne(qureyOptions OrderBaseFindOneQuery) (*OrderBase, 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:"-"`
///核算订单相关数据
GoodCompute GoodCompute `json:"goodCompute"`
//公司
CompanyId int64
}
type GoodCompute struct {
... ... @@ -170,13 +172,14 @@ func (good *OrderGood) Compute() error {
}
type OrderGoodFindQuery struct {
OrderId int64
Offset int
Limit int
OrderId int64
Offset int
Limit int
CompanyId int64
}
type OrderGoodRepository interface {
Save(order []OrderGood) 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
import (
"fmt"
"time"
)
... ... @@ -12,25 +11,23 @@ const (
)
//合伙类别 （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 {
Partner Partner `json:"partner"`
//合伙类别
PartnerCategory int `json:"partnerCategory"`
// 登录密码
Password string `json:"password"`
// 状态（1：启用或者0：禁用）
... ... @@ -41,38 +38,30 @@ type PartnerInfo struct {
UpdateAt time.Time `json:"updateAt"`
//合作时间
CooperateTime time.Time `json:"cooperateTime"`
//关联业务员//所属区域信息
RegionInfo *RegionInfo `json:"regionInfo"`
//所属区域信息
RegionInfo RegionInfo `json:"regionInfo"`
//关联业务员
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 {
UserId int64
AccountEqual string
CompanyId int64
}
type PartnerFindQuery struct {
... ... @@ -81,10 +70,12 @@ type PartnerFindQuery struct {
PartnerCategory []int //合伙人类型
RegionInfo *RegionInfo //区域
PartnerName string //合伙人姓名
CompanyId int64
Ids []int64
}
type PartnerInfoRepository interface {
Save(dm PartnerInfo) (*PartnerInfo, error)
Save(dm *PartnerInfo) error
FindOne(queryOptions PartnerFindOneQuery) (*PartnerInfo, error)
Find(queryOptions PartnerFindQuery) ([]PartnerInfo, 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
}
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
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 {
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
m := &models.PartnerInfo{}
ok, err := tx.Model(m).
Where("account=?", account).
Where("company_id=?", companyId).
Exists()
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 {
tableName struct{} `pg:"admin_permission,alias:admin_permission"`
//id
Id int `pg:",pk"`
Id int64 `pg:",pk"`
//权限名称、菜单名称
Name string
//权限编码
Code string
//父级id
ParentId int
ParentId int64
//排序编号
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
//买家
Buyer *domain.Buyer
Buyer domain.Buyer
//订单区域信息
RegionInfo *domain.RegionInfo
RegionInfo domain.RegionInfo
//订单对应的合伙人
PartnerId int64
//业务员抽成比例
... ... @@ -62,6 +62,7 @@ type OrderBase struct {
IsDisable int `pg:",use_zero"`
//分红支付状态
BonusStatus int
CompanyId int64
}
var _ pg.BeforeUpdateHook = (*OrderBase)(nil)
... ...
... ... @@ -36,5 +36,6 @@ type OrderGood struct {
//分红状态
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 {
tableName struct{} `pg:"partner_info,alias:partner_info"`
tableName struct{} `pg:"partner_info"`
// 合伙人ID
Id int64 `pg:",pk"`
// 合伙人姓名
... ... @@ -20,10 +20,8 @@ type PartnerInfo struct {
Password string
// 状态（1：启用或者0：禁用）
Status int `pg:",use_zero"`
// 合伙类别 （1.研发合伙人 2.业务合伙人 3.事业）
PartnerCategory int `pg:",default:1"` //partner_category
//所属区域信息
RegionInfo *domain.RegionInfo
RegionInfo domain.RegionInfo
//创建时间
CreateAt time.Time
//更新时间
... ... @@ -32,6 +30,12 @@ type PartnerInfo struct {
CooperateTime time.Time
//关联业务员
Salesman []domain.Salesman
// 合伙类别 （1.研发合伙人 2.业务合伙人 3.事业）
PartnerCategory int `pg:",default:1"` //partner_category
//合伙类别
PartnerCategoryInfos []domain.PartnerCategory
//公司id
CompanyId int64
}
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
import "github.com/go-pg/pg/v10"
import (
"github.com/go-pg/pg/v10"
"github.com/go-pg/pg/v10/orm"
)
type TransactionContext struct {
PgDd *pg.DB
... ... @@ -26,6 +29,13 @@ func (transactionContext *TransactionContext) RollbackTransaction() error {
return err
}
func (transactionContext *TransactionContext) GetDB() orm.DB {
if transactionContext.PgTx != nil {
return transactionContext.PgTx
}
return transactionContext.PgDd
}
func NewPGTransactionContext(pgDd *pg.DB) *TransactionContext {
return &TransactionContext{
PgDd: pgDd,
... ...
package repository
import (
"errors"
"fmt"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
... ... @@ -29,23 +30,19 @@ func (reponsitory AdminPermissionRepository) transformPgModelToDomainModel(permi
Name: permissionModel.Name,
Icon: permissionModel.Icon,
Code: permissionModel.Code,
Sort: permissionModel.Sort,
}
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
permissionModels := make([]models.AdminPermission, 0)
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 {
return nil, err
}
... ... @@ -56,3 +53,29 @@ func (reponsitory AdminPermissionRepository) Find(queryOptions domain.AdminPermi
}
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
}