mmm-go / partnermg · 提交

转到一个项目

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

Merge branch 'test'

内嵌 并排对比
正在显示 95 个修改的文件 包含 4406 行增加 和 1306 行删除
... ... @@ -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
}
package repository
import (
"errors"
"fmt"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
)
type BusinessBonusRepository struct {
transactionContext *transaction.TransactionContext
}
func (repository *BusinessBonusRepository) transformPgModelToDomainModel(m *models.BusinessBonus) (domain.BusinessBonus, error) {
dm := domain.BusinessBonus{
Id: m.Id,
CompanyId: m.CompanyId,
PartnerInfoId: m.PartnerInfoId,
Bonus: m.Bonus,
BonusNot: m.BonusNot,
BonusHas: m.BonusHas,
BonusExpense: m.BonusExpense,
IsDisable: m.IsDisable,
BonusStatus: m.BonusStatus,
CreateAt: m.CreateAt,
UpdateAt: m.UpdateAt,
}
switch m.BonusStatus {
case domain.BUSINESS_BONUS_WAIT_PAY:
dm.BusinessBonusPayStatus = domain.BusinessBonusWaitPay{}
case domain.BUSINESS_BONUS_HAS_PAY:
dm.BusinessBonusPayStatus = domain.BusinessBonusHasPay{}
default:
dm.BusinessBonusPayStatus = domain.BusinessBonusNullPay{}
}
return dm, nil
}
func NewBusinessBonusRepository(transactionContext *transaction.TransactionContext) (*BusinessBonusRepository, error) {
if transactionContext == nil {
return nil, fmt.Errorf("transactionContext参数不能为nil")
}
return &BusinessBonusRepository{transactionContext: transactionContext}, nil
}
func (repository *BusinessBonusRepository) Add(dm *domain.BusinessBonus) error {
tx := repository.transactionContext.PgTx
bonusModel := models.BusinessBonus{
Id: dm.Id,
CompanyId: dm.CompanyId,
PartnerInfoId: dm.PartnerInfoId,
Bonus: dm.Bonus,
BonusNot: dm.Bonus,
BonusHas: dm.BonusHas,
BonusExpense: dm.BonusExpense,
IsDisable: dm.IsDisable,
BonusStatus: dm.BonusStatus,
}
_, err := tx.Model(&bonusModel).
Insert()
dm.CreateAt = bonusModel.CreateAt
dm.UpdateAt = bonusModel.UpdateAt
dm.Id = bonusModel.Id
return err
}
func (repository *BusinessBonusRepository) Edit(dm *domain.BusinessBonus) error {
tx := repository.transactionContext.PgTx
bonusModel := models.BusinessBonus{
Id: dm.Id,
CompanyId: dm.CompanyId,
PartnerInfoId: dm.PartnerInfoId,
Bonus: dm.Bonus,
BonusNot: dm.BonusNot,
BonusExpense: dm.BonusExpense,
BonusHas: dm.BonusHas,
IsDisable: dm.IsDisable,
BonusStatus: dm.BonusStatus,
CreateAt: dm.CreateAt,
UpdateAt: dm.UpdateAt,
}
_, err := tx.Model(&bonusModel).WherePK().Update()
return err
}
func (repository *BusinessBonusRepository) FindOne(queryOptions domain.BusinessBonusFindOneQuery) (*domain.BusinessBonus, error) {
tx := repository.transactionContext.PgTx
BusinessBonusModel := new(models.BusinessBonus)
var hasCondition bool
query := tx.Model(BusinessBonusModel).Where("delete_at ISNULL")
if queryOptions.Id > 0 {
hasCondition = true
query = query.Where("id=?", queryOptions.Id)
}
if queryOptions.PartnerId > 0 {
hasCondition = true
query = query.Where("partner_info_id=?", queryOptions.PartnerId)
}
if queryOptions.CompanyId > 0 {
hasCondition = true
query = query.Where("company_id=?", queryOptions.CompanyId)
}
if !hasCondition {
return nil, errors.New("没有查询条件")
}
if err := query.First(); err != nil {
return nil, err
}
data, err := repository.transformPgModelToDomainModel(BusinessBonusModel)
return &data, err
}
func (repository *BusinessBonusRepository) Find(queryOptions domain.BusinessBonusFindQuery) (int, []domain.BusinessBonus, error) {
tx := repository.transactionContext.PgTx
var (
err error
cnt int
businessBonuss []domain.BusinessBonus
businessBonusModels []models.BusinessBonus
)
query := tx.Model(&businessBonusModels)
if queryOptions.Offset > -1 {
query = query.Offset(queryOptions.Offset)
}
if queryOptions.Limit > 0 {
query = query.Limit(queryOptions.Limit)
} else {
query = query.Limit(1000)
}
query = query.Order("business_bonus.id DESC")
if cnt, err = query.SelectAndCount(); err != nil {
return 0, businessBonuss, err
}
for i := range businessBonusModels {
businessBonus, err := repository.transformPgModelToDomainModel(&businessBonusModels[i])
if err != nil {
return 0, businessBonuss, err
}
businessBonuss = append(businessBonuss, businessBonus)
}
return cnt, businessBonuss, nil
}
... ...
package repository
import (
"errors"
"fmt"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
)
type CompanyRepository struct {
transactionContext *transaction.TransactionContext
}
var (
_ domain.CompanyRepository = (*CompanyRepository)(nil)
)
func NewCompanyRepository(transactionContext *transaction.TransactionContext) (*CompanyRepository, error) {
if transactionContext == nil {
return nil, fmt.Errorf("transactionContext参数不能为nil")
}
return &CompanyRepository{transactionContext: transactionContext}, nil
}
func (repository CompanyRepository) transformPgModelToDomainModel(m *models.Company) (domain.Company, error) {
return domain.Company{
Id: m.Id,
Name: m.Name,
Phone: m.Phone,
Logo: m.Logo,
Remarks: m.Remarks,
AdminCompanyId: m.AdminCompanyId,
Enable: m.Enable,
CreateAt: m.CreateAt,
UpdateAt: m.UpdateAt,
Abbreviation: m.Abbreviation,
}, nil
}
func (reponsitory CompanyRepository) Add(m *domain.Company) error {
var (
err error
tx = reponsitory.transactionContext.PgTx
)
companyModel := models.Company{
Id: m.Id,
Name: m.Name,
Phone: m.Phone,
Logo: m.Logo,
Remarks: m.Remarks,
AdminCompanyId: m.AdminCompanyId,
Enable: m.Enable,
CreateAt: m.CreateAt,
UpdateAt: m.UpdateAt,
Abbreviation: m.Abbreviation,
}
_, err = tx.Model(&companyModel).Insert()
return err
}
func (reponsitory CompanyRepository) Edit(m *domain.Company) error {
var (
err error
tx = reponsitory.transactionContext.PgTx
)
companyModel := models.Company{
Id: m.Id,
Name: m.Name,
Phone: m.Phone,
Logo: m.Logo,
Remarks: m.Remarks,
AdminCompanyId: m.AdminCompanyId,
Enable: m.Enable,
CreateAt: m.CreateAt,
DeleteAt: m.DeleteAt,
UpdateAt: m.UpdateAt,
Abbreviation: m.Abbreviation,
}
_, err = tx.Model(&companyModel).WherePK().Update()
return err
}
func (reponsitory CompanyRepository) FindOne(queryOptions domain.CompanyFindOneOptions) (domain.Company, error) {
var (
err error
tx = reponsitory.transactionContext.PgTx
m models.Company
hasCondition bool
)
query := tx.Model(&m)
if queryOptions.Id > 0 {
hasCondition = true
query = query.Where("id=?", queryOptions.Id)
}
if queryOptions.AdminCompanyId > 0 {
hasCondition = true
query = query.Where("admin_company_id=?", queryOptions.AdminCompanyId)
}
if !hasCondition {
return domain.Company{}, errors.New("findOne 必须要有查询条件")
}
err = query.First()
if err != nil {
return domain.Company{}, err
}
return reponsitory.transformPgModelToDomainModel(&m)
}
func (reponsitory CompanyRepository) Find(queryOptions domain.CompanyFindOptions) (int64, []domain.Company, error) {
return 0, nil, nil
}
... ...
... ... @@ -41,6 +41,7 @@ func (reponsitory OrderBaseRepository) transformPgModelToDomainModel(orderModel
Id: orderModel.PartnerId,
},
BonusStatus: orderModel.BonusStatus,
CompanyId: orderModel.CompanyId,
}
return order, nil
}
... ... @@ -61,6 +62,7 @@ func (repository OrderBaseRepository) Save(orderInfo *domain.OrderBase) error {
PartnerBonusHas: orderInfo.OrderCompute.PartnerBonusHas, PartnerBonusNot: orderInfo.OrderCompute.PartnerBonusNot,
PartnerBonusExpense: orderInfo.OrderCompute.PartnerBonusExpense, IsDisable: orderInfo.IsDisable,
CreateTime: orderInfo.CreateTime, BonusStatus: orderInfo.BonusStatus,
CompanyId: orderInfo.CompanyId,
}
if m.Id == 0 {
_, err = tx.Model(m).
... ... @@ -95,6 +97,9 @@ func (repository OrderBaseRepository) Find(queryOption domain.OrderBaseFindQuery
if queryOption.OrderType > 0 {
query = query.Where("order_type=?", queryOption.OrderType)
}
if queryOption.CompanyId > 0 {
query = query.Where("company_id=?", queryOption.CompanyId)
}
if queryOption.Offset > -1 {
query = query.Offset(queryOption.Offset)
}
... ... @@ -128,9 +133,12 @@ func (repository OrderBaseRepository) FindOne(qureyOptions domain.OrderBaseFindO
tx = repository.transactionContext.PgDd
)
m := new(models.OrderBase)
err = tx.Model(m).
Where("id=?", qureyOptions.OrderId).
First()
query := tx.Model(m).
Where("id=?", qureyOptions.OrderId)
if qureyOptions.CompanyId > 0 {
query = query.Where("company_id=?", qureyOptions.CompanyId)
}
err = query.First()
if err != nil {
return nil, err
}
... ... @@ -138,7 +146,7 @@ func (repository OrderBaseRepository) FindOne(qureyOptions domain.OrderBaseFindO
return &result, err
}
func (repository OrderBaseRepository) Remove(id int64) error {
func (repository OrderBaseRepository) Remove(id int64, companyId int64) error {
var (
err error
tx = repository.transactionContext.PgTx
... ... @@ -146,6 +154,9 @@ func (repository OrderBaseRepository) Remove(id int64) error {
m := &models.OrderBase{
Id: id,
}
_, err = tx.Model(m).WherePK().Delete()
_, err = tx.Model(m).
Where("id=?", id).
Where("company_id=?", companyId).
Delete()
return err
}
... ...
... ... @@ -38,6 +38,7 @@ func (reponsitory OrderGoodRepository) transformPgModelToDomainModel(orderModel
PartnerBonusNot: orderModel.PartnerBonusNot,
PartnerBonusExpense: orderModel.PartnerBonusExpense,
},
CompanyId: orderModel.CompanyId,
}
switch orderModel.BonusStatus {
case domain.OrderGoodWaitPay:
... ... @@ -62,7 +63,8 @@ func (repository OrderGoodRepository) Save(data []domain.OrderGood) error {
PlanPartnerBonus: v.GoodCompute.PlanPartnerBonus, UsePartnerBonus: v.GoodCompute.UsePartnerBonus,
PartnerBonusHas: v.GoodCompute.PartnerBonusHas, PartnerBonusNot: v.GoodCompute.PartnerBonusNot,
PartnerBonusExpense: v.GoodCompute.PartnerBonusExpense, BonusStatus: v.BonusStatus,
Remark: v.Remark,
Remark: v.Remark,
CompanyId: v.CompanyId,
}
if v.Id == 0 {
_, err = tx.Model(m).
... ... @@ -91,6 +93,9 @@ func (repository OrderGoodRepository) Find(queryOption domain.OrderGoodFindQuery
if queryOption.OrderId > 0 {
query = query.Where("order_id=?", queryOption.OrderId)
}
if queryOption.CompanyId > 0 {
query = query.Where("company_id=?", queryOption.CompanyId)
}
if queryOption.Offset > -1 {
query = query.Offset(queryOption.Offset)
}
... ... @@ -118,13 +123,15 @@ func (repository OrderGoodRepository) Find(queryOption domain.OrderGoodFindQuery
return orderGoods, count, nil
}
func (repository OrderGoodRepository) Remove(orderId int64, goodids ...int64) error {
func (repository OrderGoodRepository) Remove(orderId int64, companyId int64, goodids ...int64) error {
var (
err error
tx = repository.transactionContext.PgTx
)
m := &models.OrderGood{}
query := tx.Model(m).Where("order_id=?", orderId)
query := tx.Model(m).
Where("order_id=?", orderId).
Where("company_id=?", companyId)
if len(goodids) > 0 {
query = query.WhereIn("id in(?)", goodids)
}
... ...
package repository
import (
"fmt"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
)
type PartnerCategoryRepository struct {
transactionContext *transaction.TransactionContext
}
func (repository PartnerCategoryRepository) transformPgModelToDomainModel(m *models.PartnerCategoryInfo) (domain.PartnerCategory, error) {
pc := domain.PartnerCategory{
Id: m.Id,
Name: m.Name,
}
return pc, nil
}
func NewPartnerCategoryRepository(transactionContext *transaction.TransactionContext) (*PartnerCategoryRepository, error) {
if transactionContext == nil {
return nil, fmt.Errorf("transactionContext参数不能为nil")
}
return &PartnerCategoryRepository{transactionContext: transactionContext}, nil
}
func (repository PartnerCategoryRepository) Find(queryOptions domain.PartnerCategoryFindQuery) (int, []domain.PartnerCategory, error) {
tx := repository.transactionContext.PgTx
var (
PartnerCategoryInfoModels []models.PartnerCategoryInfo
cnt int
err error
)
query := tx.Model(&PartnerCategoryInfoModels)
if len(queryOptions.Ids) > 0 {
query = query.WhereIn("id in(?)", queryOptions.Ids)
}
if cnt, err = query.SelectAndCount(); err != nil {
return 0, nil, err
}
partnerCategoryInfos := make([]domain.PartnerCategory, 0, len(PartnerCategoryInfoModels))
for i := range PartnerCategoryInfoModels {
m, _ := repository.transformPgModelToDomainModel(&PartnerCategoryInfoModels[i])
partnerCategoryInfos = append(partnerCategoryInfos, m)
}
return cnt, partnerCategoryInfos, nil
}
... ...
package repository
import (
"errors"
"fmt"
"github.com/go-pg/pg/v10/orm"
"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"
... ... @@ -30,7 +32,16 @@ func (repository *PartnerInfoRepository) transformPgModelToDomainModel(partnerIn
Salesman: partnerInfoModel.Salesman,
RegionInfo: partnerInfoModel.RegionInfo,
CooperateTime: partnerInfoModel.CooperateTime,
CompanyId: partnerInfoModel.CompanyId,
}
p := []domain.PartnerCategory{}
for _, v := range partnerInfoModel.PartnerCategoryInfos {
catagory := domain.PartnerCategory{
Id: v.Id,
}
p = append(p, catagory)
}
m.PartnerCategoryInfos = p
return m, nil
}
... ... @@ -41,50 +52,69 @@ func NewPartnerInfoRepository(transactionContext *transaction.TransactionContext
return &PartnerInfoRepository{transactionContext: transactionContext}, nil
}
func (repository *PartnerInfoRepository) Save(dm domain.PartnerInfo) (*domain.PartnerInfo, error) {
func (repository *PartnerInfoRepository) Save(dm *domain.PartnerInfo) error {
var (
err error
tx = repository.transactionContext.PgTx
)
categorys := []domain.PartnerCategory{}
for _, v := range dm.PartnerCategoryInfos {
categorys = append(categorys, domain.PartnerCategory{
Id: v.Id,
})
}
m := &models.PartnerInfo{
Id: dm.Partner.Id,
PartnerName: dm.Partner.PartnerName,
Account: dm.Partner.Account,
Password: dm.Password,
Status: dm.Status,
PartnerCategory: dm.PartnerCategory,
Salesman: dm.Salesman,
RegionInfo: dm.RegionInfo,
CooperateTime: dm.CooperateTime,
Id: dm.Partner.Id,
PartnerName: dm.Partner.PartnerName,
Account: dm.Partner.Account,
Password: dm.Password,
Status: dm.Status,
PartnerCategory: dm.PartnerCategory,
Salesman: dm.Salesman,
RegionInfo: dm.RegionInfo,
CooperateTime: dm.CooperateTime,
CompanyId: dm.CompanyId,
PartnerCategoryInfos: categorys,
}
if m.Id == 0 {
err = tx.Insert(m)
dm.Partner.Id = m.Id
if err != nil {
return nil, err
return err
}
} else {
_, err = tx.Model(m).WherePK().
Column("partner_name", "account", "password", "status", "partner_category", "salesman",
"region_info", "cooperate_time", "update_at").
"region_info", "cooperate_time", "update_at", "partner_category_infos").
Update()
if err != nil {
return nil, err
return err
}
}
return &dm, nil
return nil
}
func (repository *PartnerInfoRepository) FindOne(queryOptions domain.PartnerFindOneQuery) (*domain.PartnerInfo, error) {
tx := repository.transactionContext.PgDd
tx := repository.transactionContext.PgTx
PartnerInfoModel := new(models.PartnerInfo)
var hasCondition bool
query := tx.Model(PartnerInfoModel)
if len(queryOptions.AccountEqual) > 0 {
hasCondition = true
query = query.Where("account=?", queryOptions.AccountEqual)
}
if queryOptions.UserId > 0 {
hasCondition = true
query = query.Where("id=?", queryOptions.UserId)
}
if queryOptions.CompanyId > 0 {
hasCondition = true
query = query.Where("company_id=?", queryOptions.CompanyId)
}
if !hasCondition {
return nil, errors.New("FindOne 必须要有查询条件")
}
if err := query.First(); err != nil {
return nil, err
}
... ... @@ -93,7 +123,7 @@ func (repository *PartnerInfoRepository) FindOne(queryOptions domain.PartnerFind
}
func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuery) ([]domain.PartnerInfo, error) {
db := repository.transactionContext.PgDd
db := repository.transactionContext.PgTx
partnerModels := []models.PartnerInfo{}
query := db.Model(&partnerModels)
if len(queryOption.PartnerName) > 0 {
... ... @@ -102,8 +132,20 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
if queryOption.RegionInfo != nil {
query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
}
//合伙人类型
if len(queryOption.PartnerCategory) > 0 {
query = query.WhereIn("partner_category in(?)", queryOption.PartnerCategory)
query = query.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
for _, value := range queryOption.PartnerCategory {
q = q.WhereOr(`partner_category_infos@> '[{"id":?}]'`, value)
}
return q, nil
})
}
if queryOption.CompanyId > 0 {
query = query.Where("company_id=?", queryOption.CompanyId)
}
if len(queryOption.Ids) > 0 {
query = query.WhereIn("id in(?)", queryOption.Ids)
}
if queryOption.Offset > -1 {
query = query.Offset(queryOption.Offset)
... ... @@ -111,7 +153,7 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
if queryOption.Limit > 0 {
query = query.Limit(queryOption.Limit)
} else {
query = query.Limit(20)
query = query.Limit(1000)
}
var (
err error
... ... @@ -133,7 +175,7 @@ func (repository *PartnerInfoRepository) Find(queryOption domain.PartnerFindQuer
}
func (repository PartnerInfoRepository) CountAll(queryOption domain.PartnerFindQuery) (int, error) {
db := repository.transactionContext.PgDd
db := repository.transactionContext.PgTx
partnerModels := models.PartnerInfo{}
query := db.Model(&partnerModels)
if len(queryOption.PartnerName) > 0 {
... ... @@ -142,8 +184,20 @@ func (repository PartnerInfoRepository) CountAll(queryOption domain.PartnerFindQ
if queryOption.RegionInfo != nil {
query = query.Where("region_info::jsonb->>'regionName' like ?", "%"+queryOption.RegionInfo.RegionName+"%")
}
//合伙人类型
if len(queryOption.PartnerCategory) > 0 {
query = query.WhereIn("partner_category in(?)", queryOption.PartnerCategory)
query = query.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
for _, value := range queryOption.PartnerCategory {
q = q.WhereOr(`partner_category_infos@> '[{"id":?}]'`, value)
}
return q, nil
})
}
if queryOption.CompanyId > 0 {
query = query.Where("company_id=?", queryOption.CompanyId)
}
if len(queryOption.Ids) > 0 {
query = query.WhereIn("id in(?)", queryOption.Ids)
}
cnt, err := query.Count()
return cnt, err
... ...
package repository
import (
"errors"
"fmt"
"time"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
)
type UsersRepository struct {
transactionContext *transaction.TransactionContext
}
var (
_ domain.UsersRepository = (*UsersRepository)(nil)
)
func NewUsersRepository(transactionContext *transaction.TransactionContext) (*UsersRepository, error) {
if transactionContext == nil {
return nil, fmt.Errorf("transactionContext参数不能为nil")
}
return &UsersRepository{transactionContext: transactionContext}, nil
}
func (repository UsersRepository) transformPgModelToDomainModel(m *models.Users) (domain.Users, error) {
return domain.Users{
Id: m.Id,
CompanyId: m.CompanyId,
OpenId: m.OpenId,
Name: m.Name,
Sex: m.Sex,
JobNum: m.JobNum,
Phone: m.Phone,
PrivatePhone: m.PrivatePhone,
Email: m.Email,
ExtensionNum: m.ExtensionNum,
EntryTime: m.EntryTime,
Workspace: m.Workspace,
Status: m.Status,
Avatar: m.Avatar,
Remarks: m.Remarks,
ChargeStatus: m.ChargeStatus,
CreateAt: m.CreateAt,
UpdateAt: m.UpdateAt,
Permission: m.Permission,
AccessPartners: m.AccessPartners,
AdminType: m.AdminType,
}, nil
}
func (reponsitory UsersRepository) Add(u *domain.Users) error {
var (
err error
tx = reponsitory.transactionContext.PgTx
)
m := &models.Users{
Id: u.Id,
CompanyId: u.CompanyId,
OpenId: u.OpenId,
Name: u.Name,
Sex: u.Sex,
JobNum: u.JobNum,
Phone: u.Phone,
PrivatePhone: u.PrivatePhone,
Email: u.Email,
ExtensionNum: u.ExtensionNum,
EntryTime: u.EntryTime,
Workspace: u.Workspace,
Status: u.Status,
Avatar: u.Avatar,
Remarks: u.Remarks,
ChargeStatus: u.ChargeStatus,
CreateAt: u.CreateAt,
UpdateAt: u.UpdateAt,
Permission: u.Permission,
AccessPartners: u.AccessPartners,
AdminType: u.AdminType,
}
_, err = tx.Model(m).Insert()
return err
}
func (reponsitory UsersRepository) Edit(u *domain.Users) error {
var (
err error
tx = reponsitory.transactionContext.PgTx
)
m := &models.Users{
Id: u.Id,
CompanyId: u.CompanyId,
OpenId: u.OpenId,
Name: u.Name,
Sex: u.Sex,
JobNum: u.JobNum,
Phone: u.Phone,
PrivatePhone: u.PrivatePhone,
Email: u.Email,
ExtensionNum: u.ExtensionNum,
EntryTime: u.EntryTime,
Workspace: u.Workspace,
Status: u.Status,
Avatar: u.Avatar,
Remarks: u.Remarks,
ChargeStatus: u.ChargeStatus,
CreateAt: u.CreateAt,
UpdateAt: u.UpdateAt,
Permission: u.Permission,
AccessPartners: u.AccessPartners,
AdminType: u.AdminType,
}
_, err = tx.Model(m).WherePK().Update()
return err
}
func (reponsitory UsersRepository) FindOne(queryOptions domain.UsersFindOneQuery) (domain.Users, error) {
var (
err error
tx = reponsitory.transactionContext.PgTx
m models.Users
hasCondition bool
)
query := tx.Model(&m)
query.Where("delete_at ISNULL")
if queryOptions.Id > 0 {
hasCondition = true
query = query.Where("id=?", queryOptions.Id)
}
if len(queryOptions.Phone) > 0 {
hasCondition = true
query = query.Where("phone=?", queryOptions.Phone)
}
if queryOptions.CompanyId > 0 {
hasCondition = true
query = query.Where("company_id=?", queryOptions.CompanyId)
}
if queryOptions.OpenId > 0 {
hasCondition = true
query = query.Where("open_id=?", queryOptions.OpenId)
}
if !hasCondition {
return domain.Users{}, errors.New("FindOne 必须要有查询条件")
}
err = query.First()
if err != nil {
return domain.Users{}, err
}
return reponsitory.transformPgModelToDomainModel(&m)
}
func (reponsitory UsersRepository) Find(queryOption domain.UsersFindQuery) (int, []domain.Users, error) {
db := reponsitory.transactionContext.PgTx
usersModels := []models.Users{}
query := db.Model(&usersModels)
query.Where("delete_at ISNULL")
if queryOption.CompanyId > 0 {
query = query.Where("company_id=?", queryOption.CompanyId)
}
if queryOption.ChargeStatus > 0 {
query = query.Where("charge_status=?", queryOption.ChargeStatus)
}
if queryOption.AdminType > 0 {
query = query.Where("admin_type=?", queryOption.AdminType)
}
if len(queryOption.UserNameMatch) > 0 {
query = query.Where("name like ?", "%"+queryOption.UserNameMatch+"%")
}
if queryOption.Offset >= 0 {
query = query.Offset(queryOption.Offset)
}
if queryOption.Limit > 0 {
query = query.Limit(queryOption.Limit)
} else {
query = query.Limit(1000)
}
var (
err error
usersReturn = make([]domain.Users, 0)
cnt int
)
query = query.Order("id DESC")
cnt, err = query.SelectAndCount()
if err != nil {
return 0, usersReturn, err
}
for i := range usersModels {
domainUsers, err := reponsitory.transformPgModelToDomainModel(&usersModels[i])
if err != nil {
return 0, usersReturn, err
}
usersReturn = append(usersReturn, domainUsers)
}
return cnt, usersReturn, nil
}
func (reponsitory UsersRepository) Remove(ids []int64) error {
if len(ids) == 0 {
return nil
}
var (
err error
tx = reponsitory.transactionContext.PgTx
)
_, err = tx.Model(&models.Users{}).
Set("delete_at=?", time.Now()).
WhereIn("id in(?)", ids).
Update()
return err
}
... ...
package serviceGateway
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"time"
"github.com/astaxie/beego/logs"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
)
type MmmBusinessAdminServiceGateway struct {
baseURL string
}
func NewMmmBusinessAdminServiceGateway() *MmmBusinessAdminServiceGateway {
return &MmmBusinessAdminServiceGateway{
baseURL: constant.BUSINESS_ADMIN_HOST,
}
}
func (client MmmBusinessAdminServiceGateway) buildHeader() http.Header {
var h = http.Header{}
h.Set("Content-Type", "application/json")
h.Set("Accept", "application/json")
return h
}
type ResponseGetUserAuth struct {
UCenterCommonMsg
Data struct {
UserAuth bool `json:"userAuth"`
} `json:"data"`
}
func (gateway MmmBusinessAdminServiceGateway) httpDo(reqURL string, mathod string, bodyData interface{}) ([]byte, error) {
httpclient := http.Client{
Timeout: 60 * time.Second, //请求超时时间60秒
}
bt := &bytes.Buffer{}
if bodyData != nil {
enc := json.NewEncoder(bt)
enc.Encode(bodyData)
}
logs.Info("====>Send To URL:%s", reqURL)
logs.Info("====>Send To BusinessAdmin:%s", bt.String())
req, err := http.NewRequest(mathod, reqURL, bt)
req.Header = gateway.buildHeader()
if err != nil {
return nil, err
}
resp, err := httpclient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
logs.Info("<====BusinessAdmin Return:%s", string(body))
return body, nil
}
func (gateway MmmBusinessAdminServiceGateway) GetUserAuth(userId int64) (*ResponseGetUserAuth, error) {
param := map[string]interface{}{
"userId": fmt.Sprint(userId),
"platformId": "25", //天联共创固定值：25
}
url := gateway.baseURL + "/auth/get-user-auth"
byteData, err := gateway.httpDo(url, "POST", param)
if err != nil {
return nil, err
}
respData := &ResponseGetUserAuth{}
err = json.Unmarshal(byteData, respData)
if err != nil {
return nil, fmt.Errorf("body data %s; err:%s", string(byteData), err)
}
return respData, nil
}
... ...
package service_gateway
package serviceGateway
import (
"bytes"
"crypto/sha1"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"time"
"github.com/astaxie/beego/logs"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
)
type UCenterCommonMsg struct {
Code int `json:"code"`
Msg string `json:"msg"`
}
func (msg UCenterCommonMsg) IsOK() error {
if msg.Code != 0 {
return fmt.Errorf("统一用户中心响应数据异常,code：%d,msg:%s", msg.Code, msg.Msg)
}
return nil
}
type MmmUserCenterServiceGateway struct {
httplibBaseServiceGateway
baseURL string
}
func NewMmmUserCenterServiceGateway() *MmmUserCenterServiceGateway {
return &MmmUserCenterServiceGateway{
httplibBaseServiceGateway{
baseURL: constant.UCENTER_HOST,
connectTimeout: 100 * time.Second,
readWriteTimeout: 30 * time.Second,
}}
baseURL: constant.UCENTER_HOST,
}
}
func (gateway MmmUserCenterServiceGateway) buildHeader() http.Header {
... ... @@ -37,12 +51,40 @@ func (gateway MmmUserCenterServiceGateway) buildHeader() http.Header {
return h
}
func (gateway MmmUserCenterServiceGateway) httpDo(reqURL string, mathod string, bodyData interface{}) ([]byte, error) {
httpclient := http.Client{
Timeout: 60 * time.Second, //请求超时时间60秒
}
bt := &bytes.Buffer{}
if bodyData != nil {
enc := json.NewEncoder(bt)
enc.Encode(bodyData)
}
logs.Info("====>Send To URL:%s", reqURL)
logs.Info("====>Send To BusinessAdmin:%s", bt.String())
req, err := http.NewRequest(mathod, reqURL, bt)
if err != nil {
return nil, err
}
req.Header = gateway.buildHeader()
resp, err := httpclient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
logs.Info("<====BusinessAdmin Return:%s", string(body))
return body, nil
}
type ResponseLogin struct {
Code int `json:"code"`
Msg string `json:"msg"`
UCenterCommonMsg
Data struct {
Id int64 `json:"id"` //统一用户中心的id,对应本系统中users表的open_id
Phone string `json:"phone"`
Id int64 `json:"id"` //统一用户中心的id,对应本系统中users表的open_id
Phone string `json:"phone"` //手机号 ，账号
NickName string `json:"nickname"` //昵称
Avatar string `json:"avatar"` //头像
Imtoken string `json:"imtoken"` //网易云imtoken
... ... @@ -53,13 +95,23 @@ type ResponseLogin struct {
} `json:"data"`
}
//RequestUCenterLoginBySecret 使用密钥方式登录统一用户中心
func (gateway MmmUserCenterServiceGateway) RequestUCenterLoginBySecret(secret string) (*ResponseLogin, error) {
// param := map[string]interface{}{
// "type": 3, //登录方式 固定值
// "secret": url.QueryEscape(secret), //必要的转换
// }
// url := "/auth/serverLogin"
// httpRequest := gateway.createRequest(url, "post")
// httpRequest.
return nil, nil
param := map[string]interface{}{
"type": 3, //登录方式 固定值
"secret": url.QueryEscape(secret), //必要的转换
}
url := gateway.baseURL + "/auth/serverLogin"
byteData, err := gateway.httpDo(url, "POST", param)
if err != nil {
return nil, err
}
respData := &ResponseLogin{}
err = json.Unmarshal(byteData, respData)
if err != nil {
return nil, fmt.Errorf("body data %s; err:%s", string(byteData), err)
}
return respData, nil
}
//企业鉴权 接口
... ...
package service_gateway
import (
"time"
)
type httplibBaseServiceGateway struct {
baseURL string
connectTimeout time.Duration
readWriteTimeout time.Duration
}
... ... @@ -6,15 +6,10 @@ import (
"fmt"
"time"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
"github.com/GeeTeam/gt3-golang-sdk/geetest"
"github.com/astaxie/beego/logs"
adminPermissionquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/query"
adminPermissionService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/service"
adminuserCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/command"
adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
userCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/command"
userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
)
type AdminLoginController struct {
... ... @@ -29,6 +24,7 @@ func (c *AdminLoginController) Prepare() {
"/v1/auth/captcha-init": 1,
"/v1/auth/login": 1,
}
nowUrl := c.Ctx.Input.URL()
if _, ok := urlIn[nowUrl]; ok {
//跳过校验
... ... @@ -39,50 +35,21 @@ func (c *AdminLoginController) Prepare() {
}
}
//Login 用户登录
func (c *AdminLoginController) Login() {
type Paramter struct {
Username string `json:"username"`
Password string `json:"password"`
}
var (
param Paramter
err error
param userCmd.LoginBySecretKeyCommand
)
if err = c.BindJsonData(&param); err != nil {
if err := c.BindJsonData(&param); err != nil {
c.ResponseError(fmt.Errorf("json解析失败：%s", err))
return
}
newAdminuserquery := adminuserquery.GetAdminUserQuery{AdminAccount: param.Username}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
newUserService := userService.NewUsersService(nil)
resp, err := newUserService.UserLoginBySecretKey(param)
if err != nil {
logs.Error("获取用户数据失败：%s", err)
c.ResponseError(errors.New("用户不存在"))
return
}
if adminuser.Password != param.Password {
c.ResponseError(errors.New("账号或密码错误"))
return
}
if !adminuser.IsUsable {
c.ResponseError(errors.New("用户被禁用"))
}
//TODO
newJwt := lib.NewMyToken(adminuser.Id, 0)
newToken, err := newJwt.CreateJWTToken()
if err != nil {
logs.Error("生成jwt数据失败：%s", err)
c.ResponseError(errors.New("服务异常"))
c.ResponseError(err)
return
}
rspdata := map[string]interface{}{
"access": map[string]interface{}{
"accessToken": newToken,
"expiresIn": lib.JWtExpiresSecond,
},
}
c.ResponseData(rspdata)
c.ResponseData(resp)
return
}
... ... @@ -112,86 +79,13 @@ func (c *AdminLoginController) CaptchaInit() {
//AdminpPofile 获取登录用户的权限配置
func (c *AdminLoginController) AdminpPofile() {
adminId := c.GetUserId()
newAdminuserquery := adminuserquery.GetAdminUserQuery{Id: adminId}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
newUserService := userService.NewUsersService(nil)
respData, err := newUserService.GetUserPofile(adminId)
if err != nil {
logs.Error("获取用户数据失败：%s", err)
c.ResponseError(errors.New("用户不存在"))
return
}
newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{})
if err != nil {
logs.Error("获取权限数据失败：%s", err)
c.ResponseError(errors.New("服务异常"))
return
}
//适配前端的数据格式
permissionSlice := make([]map[string]interface{}, 0)
for _, v := range allPermission {
m := map[string]interface{}{
"code": v.Code,
"icon": v.Icon,
"parentId": v.ParentId,
"sort": v.Sort,
"name": v.Name,
"id": v.Id,
"status": 0, //状态 1-启用 0-禁用，前端需要
}
for _, p := range adminuser.Permission {
if p.Id == v.Id {
m["status"] = 1
break
}
if p.Id == v.ParentId {
m["status"] = 1
break
}
}
permissionSlice = append(permissionSlice, m)
}
userData := map[string]string{
"id": fmt.Sprint(adminuser.Id),
"name": adminuser.AdminName,
"adminType": "2", // 管理员类型 1-超级管理员 2-子管理员
}
if adminuser.IsDefault {
userData["adminType"] = "1"
}
respData := map[string]interface{}{
"user": userData,
"menus": permissionSlice,
}
c.ResponseData(respData)
}
func (c *AdminLoginController) PwdUpdate() {
//用与适配前端定义的数据结构
type Paramater struct {
Pwd string `json:"pwd"`
}
var (
param Paramater
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
uid := c.GetUserId()
newAdminUserService := adminuserservice.NewAdminUserService(nil)
cmd := adminuserCmd.UpdateAdminUserPwdCommand{
Id: uid,
Password: param.Pwd,
}
err = newAdminUserService.UpdateAdminPassword(cmd)
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(nil)
return
}
... ...
... ... @@ -11,8 +11,8 @@ import (
"github.com/astaxie/beego"
"github.com/astaxie/beego/logs"
adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
userQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/query"
userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/port/beego/protocol"
)
... ... @@ -33,7 +33,7 @@ func (controller BaseController) ResponseError(err error) {
if !(e.Code == lib.ARG_ERROR || e.Code == lib.BUSINESS_ERROR) {
controller.Data["json"] = protocol.ResponseData{
Code: -1,
Msg: "服务异常",
Msg: "操作失败",
Data: struct{}{},
}
controller.ServeJSON()
... ... @@ -144,6 +144,7 @@ func (controller *BaseController) ValidJWTToken() bool {
return false
}
controller.setUserId(tokenData.UID)
controller.setUserCompanyId(tokenData.CompanyId)
return true
}
... ... @@ -161,27 +162,22 @@ func (controller *BaseController) ValidAdminPermission(permissionCode string, ex
controller.ResponseError(errors.New("无操作权限"))
return false
}
newAdminuserquery := adminuserquery.GetAdminUserQuery{Id: userId}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
adminuser, err := newAdminUserService.GetAdminUser(&newAdminuserquery)
comanyId := controller.GetUserCompany()
newQuery := userQuery.ValidatePermissionQuery{
UserId: userId,
PermissionCode: permissionCode,
CompanyId: comanyId,
}
newUserService := userService.NewUsersService(nil)
ok, err := newUserService.ValidateAdminpPermission(newQuery)
if err != nil {
logs.Error("获取用户数据失败：%s", err)
logs.Error("用户鉴权失败：%s", err)
controller.ResponseError(errors.New("无操作权限"))
return false
}
if adminuser.IsDefault {
logs.Debug("用户是超级管理员")
if ok {
return true
}
if !adminuser.IsUsable {
controller.ResponseError(errors.New("用户被禁用"))
return false
}
for _, v := range adminuser.Permission {
if v.Code == permissionCode {
return true
}
}
controller.ResponseError(errors.New("无操作权限"))
return false
}
... ... @@ -196,3 +192,17 @@ func (controller *BaseController) setUserId(id int64) {
logs.Info("token:admin_user_id = ", id)
controller.Ctx.Input.SetData("token:admin_user_id", id)
}
func (controller *BaseController) setUserCompanyId(id int64) {
logs.Info("token:company_id = ", id)
controller.Ctx.Input.SetData("token:company_id", id)
}
func (controller *BaseController) GetUserCompany() int64 {
idV := controller.Ctx.Input.GetData("token:company_id")
uid, err := strconv.ParseInt(fmt.Sprint(idV), 10, 64)
if err != nil {
logs.Error(err)
}
return uid
}
... ...
package controllers
import (
"errors"
"github.com/astaxie/beego/logs"
businessCommand "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/command"
businessQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/query"
businessService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/businessBonus/service"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
)
type BusinessBonusController struct {
BaseController
}
func (c *BusinessBonusController) Prepare() {
c.BaseController.Prepare()
if ok := c.ValidJWTToken(); !ok {
return
}
if ok := c.ValidAdminPermission(domain.PERMISSION_DIVIDEND); !ok {
return
}
}
func (c *BusinessBonusController) ListBusinessBonus() {
type Parameter struct {
PageNumber int `json:"pageNumber"`
Partner int64 `json:"partner"`
PageSize int `json:"pageSize"`
SearchText string `json:"searchText"`
}
var (
param Parameter
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
if param.PageSize == 0 {
param.PageSize = 20
}
if param.PageNumber == 0 {
param.PageNumber = 1
}
companyId := c.GetUserCompany()
srv := businessService.NewBusinessBonusService(nil)
cnt, result, err := srv.ListBusinessBonus(businessQuery.ListBusinessBonusQuery{
CompanyId: companyId,
Limit: param.PageSize,
Offset: param.PageSize * (param.PageNumber - 1),
PartnerId: param.Partner,
})
if err != nil {
c.ResponseError(err)
return
}
c.ResponsePageList(result, cnt, param.PageNumber)
}
func (c *BusinessBonusController) UpdateBusinessBonus() {
type Parameter struct {
Id int64 `json:"id"`
DividendsReceivable float64 `json:"dividendsReceivable"`
StateOfPayment int8 `json:"stateOfPayment"`
}
var (
param Parameter
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
srv := businessService.NewBusinessBonusService(nil)
err = srv.UpdateBusinessBonus(businessCommand.UpdateBusinessBonusCommand{
CompanyId: companyId,
Id: param.Id,
Bonus: param.DividendsReceivable,
BonusStatus: param.StateOfPayment,
})
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(nil)
}
func (c *BusinessBonusController) GetBusinessBonus() {
type Parameter struct {
Id int64 `json:"id"`
}
var (
param Parameter
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
srv := businessService.NewBusinessBonusService(nil)
data, err := srv.GetBusinessBonus(businessQuery.GetBusinessBonusQuery{
Id: param.Id,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(data)
}
... ...
package controllers
import (
categoryQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerCategory/query"
categoryService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerCategory/service"
partnerQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/query"
partnerInfoService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/partnerInfo/service"
)
... ... @@ -19,9 +21,11 @@ func (c *CommonController) Prepare() {
// GetPartnerList 下拉选项数据通用接口，获取合伙人列表
func (c *CommonController) GetPartnerList() {
companyId := c.GetUserCompany()
query := partnerQuery.ListPartnerInfoQuery{
Limit: 5000,
Offset: 0,
Limit: 1000,
Offset: 0,
CompanyId: companyId,
}
newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
_, partners, err := newPartnerService.ListPartnerInfo(&query)
... ... @@ -41,3 +45,22 @@ func (c *CommonController) GetPartnerList() {
}
c.ResponseData(resp)
}
// GetPartnerCategory 下拉选项数据通用接口，获取合伙人分类列表
func (c *CommonController) GetPartnerCategory() {
newService := categoryService.NewPartnerCategoryService(nil)
_, categorys, err := newService.ListPartnerCategory(categoryQuery.ListPartnerCategoryCommand{})
if err != nil {
c.ResponseError(err)
return
}
resp := []map[string]interface{}{}
for i := range categorys {
m := map[string]interface{}{
"id": categorys[i].Id,
"name": categorys[i].Name,
}
resp = append(resp, m)
}
c.ResponseData(resp)
}
... ...
package controllers
import (
"errors"
"github.com/astaxie/beego/logs"
companyService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/company/service"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
)
type CompanyController struct {
BaseController
}
//Prepare 重写 BaseController 的Prepare方法
func (c *CompanyController) Prepare() {
c.BaseController.Prepare()
if ok := c.ValidJWTToken(); !ok {
return
}
if ok := c.ValidAdminPermission(domain.PERMISSION_ENTERPRISE_SET); !ok {
return
}
}
func (c *CompanyController) SetPhone() {
//用与适配前端定义的数据结构
type Paramter struct {
Type int `json:"type"`
Phone string `json:"phone"`
}
var (
param Paramter
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
switch param.Type {
case 1:
c.editPhone(param.Phone)
case 2:
c.getPhone()
default:
c.ResponseError(errors.New("参数错误"))
}
return
}
func (c *CompanyController) getPhone() {
companyid := c.GetUserCompany()
srv := companyService.NewCompanyService(nil)
data, err := srv.GetCompanyData(companyid)
if err != nil {
c.ResponseError(err)
return
}
result := map[string]interface{}{
"phone": data.Phone,
}
c.ResponseData(result)
return
}
func (c *CompanyController) editPhone(phone string) {
companyid := c.GetUserCompany()
srv := companyService.NewCompanyService(nil)
err := srv.UpdateCompanyPhone(companyid, phone)
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(nil)
return
}
... ...
... ... @@ -51,7 +51,7 @@ func (c *OrderDividendController) PageListOrderDividend() {
if param.PageSize == 0 {
param.PageSize = 20
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
PartnerId: param.Partner,
... ... @@ -59,6 +59,7 @@ func (c *OrderDividendController) PageListOrderDividend() {
OrderType: domain.OrderReal,
Limit: param.PageSize,
Offset: (param.PageNumber - 1) * param.PageSize,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -106,9 +107,11 @@ func (c *OrderDividendController) OrderDividendDetail() {
c.ResponseError(errors.New("参数错误"))
return
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
OrderId: orderid,
OrderId: orderid,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -251,9 +254,11 @@ func (c *OrderDividendController) EditOrderDividend() {
}
goodbouns = append(goodbouns, g)
}
companyId := c.GetUserCompany()
cmd := orderCmd.UpdateGoodBouns{
Id: param.Id,
GoodBouns: goodbouns,
CompanyId: companyId,
}
orderSrv := orderService.NewOrderInfoService(nil)
err = orderSrv.UpdateGoodBouns(cmd)
... ...
... ... @@ -24,7 +24,6 @@ type OrderInfoController struct {
////Prepare 重写 BaseController 的Prepare方法
func (c *OrderInfoController) Prepare() {
c.BaseController.Prepare()
return
if ok := c.ValidJWTToken(); !ok {
return
}
... ... @@ -56,7 +55,7 @@ func (c *OrderInfoController) PageListOrderPurpose() {
if param.PageSize == 0 {
param.PageSize = 20
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
PartnerId: param.Partner,
... ... @@ -64,6 +63,7 @@ func (c *OrderInfoController) PageListOrderPurpose() {
OrderType: domain.OrderIntention,
Limit: param.PageSize,
Offset: (param.PageNumber - 1) * param.PageSize,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -103,9 +103,11 @@ func (c *OrderInfoController) GetOrderPurpose() {
return
}
orderid, _ := strconv.ParseInt(param.Id, 10, 64)
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
OrderId: orderid,
OrderId: orderid,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -156,8 +158,9 @@ func (c *OrderInfoController) RemoveOrderPurpose() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
err = orderSrv.DeleteOrder(param.Id)
err = orderSrv.DeleteOrder(param.Id, companyId)
if err != nil {
c.ResponseError(err)
return
... ... @@ -290,6 +293,7 @@ func (c *OrderInfoController) addOrderPurpose(param postPurposeOrderDetail) erro
}
newGoods = append(newGoods, g)
}
companyId := c.GetUserCompany()
createcmd := orderCmd.CreateOrderCommand{
OrderType: domain.OrderIntention,
OrderCode: param.OrderId,
... ... @@ -299,6 +303,7 @@ func (c *OrderInfoController) addOrderPurpose(param postPurposeOrderDetail) erro
PartnerId: param.PartnerId,
SalesmanBonusPercent: param.CommissionProportion,
Goods: newGoods,
CompanyId: companyId,
}
orderSrv := orderService.NewOrderInfoService(nil)
_, err := orderSrv.CreateNewOrder(createcmd)
... ... @@ -317,6 +322,7 @@ func (c *OrderInfoController) editOrderPurpose(param postPurposeOrderDetail) err
}
newGoods = append(newGoods, g)
}
companyId := c.GetUserCompany()
updatecmd := orderCmd.UpdateOrderCommand{
Id: param.Id,
OrderType: domain.OrderIntention,
... ... @@ -327,6 +333,7 @@ func (c *OrderInfoController) editOrderPurpose(param postPurposeOrderDetail) err
PartnerId: param.PartnerId,
SalesmanBonusPercent: param.CommissionProportion,
Goods: newGoods,
CompanyId: companyId,
}
_, err := orderSrv.UpdateOrderData(updatecmd)
return err
... ... @@ -369,7 +376,7 @@ func (c *OrderInfoController) OrderPurposeDelivery() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
param.ShipmentsId = strings.TrimSpace(param.ShipmentsId)
orderid, _ := strconv.ParseInt(param.Id, 10, 64)
if orderid <= 0 {
c.ResponseError(errors.New("参数错误"))
... ... @@ -387,9 +394,10 @@ func (c *OrderInfoController) OrderPurposeDelivery() {
}
goods = append(goods, g)
}
companyId := c.GetUserCompany()
deliveryCommand := orderCmd.OrderDeliveryCommand{
OrderId: orderid, DeliveryCode: param.ShipmentsId,
DeliveryTime: time.Now(), Goods: goods,
DeliveryTime: time.Now(), Goods: goods, CompanyId: companyId,
}
orderSrv := orderService.NewOrderInfoService(nil)
err = orderSrv.Delivery(deliveryCommand)
... ... @@ -423,7 +431,7 @@ func (c *OrderInfoController) PageListOrderReal() {
if param.PageSize == 0 {
param.PageSize = 20
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfos, cnt, err := orderSrv.PageListOrderBase(orderQuery.ListOrderBaseQuery{
PartnerId: param.Partner,
... ... @@ -431,6 +439,7 @@ func (c *OrderInfoController) PageListOrderReal() {
OrderType: domain.OrderReal,
Limit: param.PageSize,
Offset: (param.PageNumber - 1) * param.PageSize,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -485,9 +494,11 @@ func (c *OrderInfoController) GetOrderReal() {
c.ResponseError(errors.New("参数错误"))
return
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
orderinfo, err := orderSrv.GetOrderDetail(orderQuery.GetOrderQuery{
OrderId: orderid,
OrderId: orderid,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -601,6 +612,7 @@ func (c *OrderInfoController) addOrderReal(param postRealOrderDetail) error {
}
newGoods = append(newGoods, g)
}
companyId := c.GetUserCompany()
createcmd := orderCmd.CreateOrderCommand{
OrderType: domain.OrderReal,
OrderCode: param.OrderId,
... ... @@ -610,6 +622,7 @@ func (c *OrderInfoController) addOrderReal(param postRealOrderDetail) error {
PartnerId: param.PartnerId,
SalesmanBonusPercent: param.CommissionProportion,
Goods: newGoods,
CompanyId: companyId,
}
_, err := orderSrv.CreateNewOrder(createcmd)
return err
... ... @@ -627,6 +640,7 @@ func (c *OrderInfoController) editOrderReal(param postRealOrderDetail) error {
}
newGoods = append(newGoods, g)
}
companyId := c.GetUserCompany()
updatecmd := orderCmd.UpdateOrderCommand{
Id: param.Id,
OrderType: domain.OrderReal,
... ... @@ -637,6 +651,7 @@ func (c *OrderInfoController) editOrderReal(param postRealOrderDetail) error {
PartnerId: param.PartnerId,
SalesmanBonusPercent: param.CommissionProportion,
Goods: newGoods,
CompanyId: companyId,
}
orderSrv := orderService.NewOrderInfoService(nil)
_, err := orderSrv.UpdateOrderData(updatecmd)
... ... @@ -668,10 +683,12 @@ func (c *OrderInfoController) OrderDisable() {
c.ResponseError(errors.New("参数错误"))
return
}
companyId := c.GetUserCompany()
cmd := orderCmd.DisableOrderCommand{
OrderId: orderId,
IsDisable: param.Status,
OrderType: domain.OrderReal,
CompanyId: companyId,
}
orderSrv := orderService.NewOrderInfoService(nil)
err = orderSrv.DisableOrEnable(cmd)
... ... @@ -696,8 +713,9 @@ func (c *OrderInfoController) RemoveOrderReal() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
orderSrv := orderService.NewOrderInfoService(nil)
err = orderSrv.DeleteOrder(param.Id)
err = orderSrv.DeleteOrder(param.Id, companyId)
if err != nil {
c.ResponseError(err)
return
... ...
... ... @@ -35,14 +35,14 @@ func (c *PartnerInfoController) Prepare() {
func (c *PartnerInfoController) CreatePartnerInfo() {
//用与适配前端定义的数据结构
type Parameter struct {
PartnerName string `json:"partnerName"`
PartnerType int `json:"partnerType"`
Area string `json:"area"`
Account string `json:"account"`
State int `json:"state"`
CooperationTime string `json:"cooperationTime"`
SalesmanName string `json:"salesmanName"`
Phone string `json:"phone"`
PartnerName string `json:"partnerName"`
PartnerType []int64 `json:"partnerType"`
Area string `json:"area"`
Account string `json:"account"`
State int `json:"state"`
CooperationTime string `json:"cooperationTime"`
SalesmanName string `json:"salesmanName"`
Phone string `json:"phone"`
}
var (
param Parameter
... ... @@ -60,6 +60,7 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
c.ResponseError(e)
return
}
companyId := c.GetUserCompany()
cmd := partnerInfoCmd.CreatePartnerInfoCommand{
PartnerName: param.PartnerName,
Account: param.Account,
... ... @@ -73,6 +74,7 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
Telephone: param.Phone,
},
},
CompanyId: companyId,
}
if len(param.Area) > 0 {
cmd.RegionInfo = &domain.RegionInfo{
... ... @@ -93,13 +95,13 @@ func (c *PartnerInfoController) CreatePartnerInfo() {
func (c *PartnerInfoController) UpdatePartnerInfo() {
//用与适配前端定义的数据结构
type Parameter struct {
ID int64 `json:"id"`
PartnerType int `json:"partnerType"`
Area string `json:"area"`
State int `json:"state"`
CooperationTime string `json:"cooperationTime"`
SalesmanName string `json:"salesmanName"`
Phone string `json:"phone"`
ID int64 `json:"id"`
PartnerType []int64 `json:"partnerType"`
Area string `json:"area"`
State int `json:"state"`
CooperationTime string `json:"cooperationTime"`
SalesmanName string `json:"salesmanName"`
Phone string `json:"phone"`
}
var (
param Parameter
... ... @@ -116,6 +118,7 @@ func (c *PartnerInfoController) UpdatePartnerInfo() {
c.ResponseError(e)
return
}
companyId := c.GetUserCompany()
cmd := partnerInfoCmd.UpdatePartnerInfoCommand{
Id: param.ID,
Status: param.State,
... ... @@ -130,6 +133,7 @@ func (c *PartnerInfoController) UpdatePartnerInfo() {
Telephone: param.Phone,
},
},
CompanyId: companyId,
}
serve := partnerInfoService.NewPartnerInfoService(nil)
err = serve.UpdatePartnerInfo(&cmd)
... ... @@ -156,9 +160,11 @@ func (c *PartnerInfoController) GetPartnerInfo() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
partnerInfo, err := newPartnerService.GetPartnerInfo(partnerQuery.GetPartnerInfoQuery{
Id: param.Id,
Id: param.Id,
CompanyId: companyId,
})
if err != nil {
c.ResponseError(err)
... ... @@ -166,9 +172,9 @@ func (c *PartnerInfoController) GetPartnerInfo() {
}
//数据适配
rspResult := map[string]interface{}{
"account": partnerInfo.Partner.Account,
"partnerName": partnerInfo.Partner.PartnerName,
"partnerType": partnerInfo.PartnerCategory,
"account": partnerInfo.Partner.Account,
"partnerName": partnerInfo.Partner.PartnerName,
// "partnerType": []map[string]interface{}{},
"area": partnerInfo.RegionInfo.RegionName,
"salesmanName": "",
"phone": "",
... ... @@ -181,16 +187,24 @@ func (c *PartnerInfoController) GetPartnerInfo() {
rspResult["salesmanName"] = partnerInfo.Salesman[0].Name
rspResult["phone"] = partnerInfo.Salesman[0].Telephone
}
partnerTypes := []map[string]interface{}{}
for _, v := range partnerInfo.PartnerCategoryInfos {
m := map[string]interface{}{
"id": v.Id,
"name": v.Name,
}
partnerTypes = append(partnerTypes, m)
}
rspResult["partnerType"] = partnerTypes
c.ResponseData(rspResult)
return
}
//PartnerInfoSetState 合伙人禁用启用
//PartnerInfoSetState 合伙人批量禁用
func (c *PartnerInfoController) PartnerInfoSetState() {
//用与适配前端定义的数据结构
type Parameter struct {
Id int64 `json:"id"`
Status int `json:"status"`
Id []int64 `json:"id"`
}
var (
param Parameter
... ... @@ -201,20 +215,11 @@ func (c *PartnerInfoController) PartnerInfoSetState() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
comanyId := c.GetUserCompany()
cmd := partnerInfoCmd.StatusPartnerInfoCommand{
Id: param.Id,
}
if param.Status == 1 {
//禁用操作
cmd.Status = domain.PARTNER_STATUS_NO
} else if param.Status == 2 {
//启用操作
cmd.Status = domain.PARTNER_STATUS_YES
} else {
//错误
c.ResponseError(lib.ThrowError(lib.ARG_ERROR, "状态错误"))
return
Ids: param.Id,
CompanyId: comanyId,
Status: domain.PARTNER_STATUS_NO,
}
newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
err = newPartnerService.UpdateStatus(cmd)
... ... @@ -251,12 +256,14 @@ func (c *PartnerInfoController) ListPartnerInfo() {
if param.PageSize == 0 {
param.PageSize = 20
}
companyId := c.GetUserCompany()
query := partnerQuery.ListPartnerInfoQuery{
Partnertype: param.Partnertype,
PartnerName: param.PartnerName,
RegionInfo: param.Area,
Limit: param.PageSize,
Offset: (param.PageNumber - 1) * param.PageSize,
CompanyId: companyId,
}
newPartnerService := partnerInfoService.NewPartnerInfoService(nil)
... ... @@ -275,7 +282,7 @@ func (c *PartnerInfoController) ListPartnerInfo() {
"createTime": partners[i].CreateAt.Local().Format("2006-01-02 15:04:05"),
"cooperationTime": partners[i].CooperateTime.Local().Format("2006-01-02"),
"state": partners[i].Status,
"partnerType": partners[i].PartnerCategory,
"partnerType": partners[i].PartnerCategoryInfos,
"salesmanName": "",
"phone": "",
}
... ...
package controllers
//用于和企业平台和总后台进行数据通讯
import (
"encoding/json"
"errors"
"github.com/astaxie/beego/logs"
companyService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/company/service"
syncCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/command"
syncService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/unifiedUserCenter/service"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
)
type SyncDataController struct {
BaseController
}
////Prepare 重写 BaseController 的Prepare方法
func (c *SyncDataController) Prepare() {
c.BaseController.Prepare()
}
//SyncData 和企业后台同步数据
func (c *SyncDataController) SyncData() {
var (
cmd syncCmd.SyncCallbackCommand
err error
)
if err = c.BindJsonData(&cmd); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
err = syncService.NewSyncAction(cmd)
if err != nil {
logs.Error("同步数据异常;%s", err)
}
//不论子系统如何处理以及处理结果成功失败 必须返回 0
c.ResponseData(nil)
return
}
//CompanyAdminChance 变更公司主管（超级管理）
func (c *SyncDataController) CompanyAdminChance() {
var (
param syncCmd.ChanceSuperAdminCommand
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
syncEmployeeSrv := syncService.NewSyncEmployeeService(nil)
syncEmployeeSrv.ChangeSuperAdmin(param)
if err != nil {
logs.Error("变更公司的主管失败;%s", err)
}
c.ResponseData(nil)
return
}
//AllowForidCompany 总后台调用
func (c *SyncDataController) AllowForidCompany() {
type Paremeter struct {
Companyid int64 `json:"company_id"`
Status int `json:"status"`
}
var param Paremeter
if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
logs.Error("json 解析失败 err:%s", err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
var (
err error
)
comanySrv := companyService.NewCompanyService(nil)
switch param.Status {
case 1:
err = comanySrv.AllowCompany(param.Companyid)
case 2:
err = comanySrv.ForbidCompany(param.Companyid)
default:
c.ResponseError(errors.New("参数错误"))
return
}
if err != nil {
c.ResponseError(err)
}
c.ResponseData(nil)
return
}
//GetCompanyInfo 总后台调用
func (c *SyncDataController) GetCompanyInfo() {
type Paremeter struct {
Companyid int64 `json:"company_id"`
}
var param Paremeter
if err := json.Unmarshal(c.Ctx.Input.RequestBody, &param); err != nil {
logs.Error("json 解析失败 err:%s", err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
var (
err error
companyData *domain.Company
)
comanySrv := companyService.NewCompanyService(nil)
companyData, err = comanySrv.GetCompanyData(param.Companyid)
rspData := map[string]interface{}{
"comopany_id": 0,
"exist": -1, //公司【1：存在；【-1：不存在】
"status": -1, //公司的启用状态【1：启用,-1:禁用】
}
if err != nil {
logs.Error(err)
c.ResponseData(rspData)
return
}
if companyData.EnableIsOk() {
rspData["status"] = 1
}
rspData["exist"] = 1
c.ResponseData(rspData)
return
}
... ...
... ... @@ -6,18 +6,18 @@ import (
"github.com/astaxie/beego/logs"
adminPermissionquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/query"
adminPermissionService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminPermission/service"
adminuserCmd "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/command"
adminuserquery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/query"
adminuserservice "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/adminUser/service"
userCommand "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/command"
userQuery "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/query"
userService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/users/service"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
)
type AdminUserController struct {
type UserController struct {
BaseController
}
////Prepare 重写 BaseController 的Prepare方法
func (c *AdminUserController) Prepare() {
//Prepare 重写 BaseController 的Prepare方法
func (c *UserController) Prepare() {
c.BaseController.Prepare()
if ok := c.ValidJWTToken(); !ok {
return
... ... @@ -27,87 +27,8 @@ func (c *AdminUserController) Prepare() {
}
}
type adminDetailParam struct {
Id int64 `json:"id"`
PermissionType []int `json:"permissionType"`
Status int `json:"status"`
Account string `json:"account"`
IsAdmin int `json:"isAdmin"`
}
func (c *AdminUserController) SaveAdminUser() {
//用与适配前端定义的数据结构
var (
param adminDetailParam
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
cmd := &adminuserCmd.SaveAdminUserCommand{
Id: param.Id,
Name: param.Account,
Account: param.Account,
PermissionId: param.PermissionType,
IsUsable: false,
}
if param.Status == 1 {
cmd.IsUsable = true
}
_, err = newAdminUserService.SaveAdminUser(cmd)
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(nil)
return
}
func (c *AdminUserController) GetAdminUser() {
//用与适配前端定义的数据结构
type Paramter struct {
Id int64 `json:"id"`
}
var (
param Paramter
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
adminuser, err := newAdminUserService.GetAdminUser(&adminuserquery.GetAdminUserQuery{
Id: param.Id,
})
if err != nil {
c.ResponseError(err)
return
}
rspData := adminDetailParam{
Id: adminuser.Id,
Account: adminuser.Account,
Status: 0,
IsAdmin: 0,
}
for _, v := range adminuser.Permission {
rspData.PermissionType = append(rspData.PermissionType, v.Id)
}
if adminuser.IsUsable {
rspData.Status = 1
}
if adminuser.IsDefault {
rspData.IsAdmin = 1
}
c.ResponseData(rspData)
return
}
func (c *AdminUserController) ListAdminUser() {
//ListUser 获取用户分页列表
func (c *UserController) ListUser() {
//用与适配前端定义的数据结构
type Paramter struct {
SearchText string `json:"searchText"`
... ... @@ -129,63 +50,54 @@ func (c *AdminUserController) ListAdminUser() {
if param.PageNumber == 0 {
param.PageNumber = 1
}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
queryOption := &adminuserquery.ListAdminUserQuery{
AdminAccountMatch: param.SearchText,
Limit: param.PageSize,
Offset: param.PageSize * (param.PageNumber - 1),
newUserService := userService.NewUsersService(nil)
queryOption := userQuery.UserListQuery{
UserNameMatch: param.SearchText,
Limit: param.PageSize,
Offset: param.PageSize * (param.PageNumber - 1),
CompanyId: c.GetUserCompany(),
}
adminusers, cnt, err := newAdminUserService.PageListAdminUser(queryOption)
cnt, usersData, err := newUserService.GetUserList(queryOption)
if err != nil {
c.ResponseError(err)
return
}
c.ResponsePageList(usersData, cnt, param.PageNumber)
return
}
//BeforeEditUser 编辑用户数据的前置接口
func (c *UserController) BeforeEditUser() {
newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{
ParentId: 0,
NotCode: []string{domain.PERMINSSION_ADMIN_USER},
})
if err != nil {
logs.Error("获取权限数据失败：%s", err)
c.ResponseError(errors.New("服务异常"))
return
}
permissionMap := map[int]domain.AdminPermission{}
var rspData []map[string]interface{}
for i := range allPermission {
permissionMap[allPermission[i].Id] = allPermission[i]
}
listData := []map[string]interface{}{}
//前端数据格式适配
for i := range adminusers {
permissionTypes := []string{}
for _, vv := range adminusers[i].Permission {
if pm, ok := permissionMap[vv.Id]; ok {
permissionTypes = append(permissionTypes, pm.Name)
}
if allPermission[i].Code == domain.PERMINSSION_ADMIN_USER {
continue
}
m := map[string]interface{}{
"id": adminusers[i].Id,
"account": adminusers[i].Account,
"permission": permissionTypes,
"statue": 0,
"isAdmin": 0,
}
if adminusers[i].IsUsable {
m["statue"] = 1
}
if adminusers[i].IsDefault {
m["isAdmin"] = 1
"id": allPermission[i].Id,
"permissionName": allPermission[i].Name,
}
listData = append(listData, m)
rspData = append(rspData, m)
}
c.ResponsePageList(listData, cnt, param.PageNumber)
c.ResponseData(rspData)
return
}
func (c *AdminUserController) ForbiddenAdminUser() {
//GetUserData 用户详情页数据
func (c *UserController) GetUserData() {
//用与适配前端定义的数据结构
type Paramter struct {
Id int64 `json:"id"`
Statue int `json:"statue"`
Id int64 `json:"id"`
}
var (
param Paramter
... ... @@ -196,46 +108,45 @@ func (c *AdminUserController) ForbiddenAdminUser() {
c.ResponseError(errors.New("json数据解析失败"))
return
}
newAdminUserService := adminuserservice.NewAdminUserService(nil)
var isUsable bool
if param.Statue == 1 {
isUsable = true
} else if param.Statue == 0 {
isUsable = false
} else {
c.ResponseError(errors.New("参数错误"))
return
}
err = newAdminUserService.UpdateAdminIsUsable(param.Id, isUsable)
companyId := c.GetUserCompany()
newUserService := userService.NewUsersService(nil)
usersData, err := newUserService.GetUserData(param.Id, companyId)
if err != nil {
c.ResponseError(err)
return
}
c.ResponseData(nil)
c.ResponseData(usersData)
return
}
//BeforeEditAdminUser 编辑管理员操作的前置接口
func (c *AdminUserController) BeforeEditAdminUser() {
newPermissionSrv := adminPermissionService.NewAdminPermissionService(nil)
allPermission, err := newPermissionSrv.ListAdminPermission(adminPermissionquery.ListAdminPermissionQuery{
ParentId: 0,
NotCode: []string{domain.PERMINSSION_ADMIN_USER},
//EditUserPermission 编辑用户的权限数据
func (c *UserController) EditUserPermission() {
type UserDetailParam struct {
Id int64 `json:"id"`
PermissionType []int64 `json:"permissionType"`
CheckedPartner []int64 `json:"checkedPartner"` //合伙人
}
var (
param UserDetailParam
err error
)
if err = c.BindJsonData(&param); err != nil {
logs.Error(err)
c.ResponseError(errors.New("json数据解析失败"))
return
}
companyId := c.GetUserCompany()
newUserService := userService.NewUsersService(nil)
err = newUserService.EditUserPermission(userCommand.EditUserPermissionCommand{
Id: param.Id,
CompanyId: companyId,
PermissionType: param.PermissionType,
CheckedPartner: param.CheckedPartner,
})
if err != nil {
logs.Error("获取权限数据失败：%s", err)
c.ResponseError(errors.New("服务异常"))
c.ResponseError(err)
return
}
var rspData []map[string]interface{}
for i := range allPermission {
m := map[string]interface{}{
"id": allPermission[i].Id,
"permissionName": allPermission[i].Name,
}
rspData = append(rspData, m)
}
c.ResponseData(rspData)
c.ResponseData(nil)
return
}
... ...
... ... @@ -9,28 +9,30 @@ func init() {
adminRouter := beego.NewNamespace("/v1",
beego.NSNamespace("/auth",
beego.NSRouter("/login", &controllers.AdminLoginController{}, "POST:Login"),
beego.NSRouter("/captcha-init", &controllers.AdminLoginController{}, "POST:CaptchaInit"),
beego.NSRouter("/profile", &controllers.AdminLoginController{}, "POST:AdminpPofile"),
beego.NSRouter("/pwd-update", &controllers.AdminLoginController{}, "POST:PwdUpdate"),
),
beego.NSNamespace("/admin",
beego.NSRouter("/update", &controllers.AdminUserController{}, "POST:SaveAdminUser"),
beego.NSRouter("/detail", &controllers.AdminUserController{}, "POST:GetAdminUser"),
beego.NSRouter("/list", &controllers.AdminUserController{}, "POST:ListAdminUser"),
beego.NSRouter("/forbidden", &controllers.AdminUserController{}, "POST:ForbiddenAdminUser"),
beego.NSRouter("/permission", &controllers.AdminUserController{}, "POST:BeforeEditAdminUser"),
beego.NSRouter("/update", &controllers.UserController{}, "POST:EditUserPermission"),
beego.NSRouter("/detail", &controllers.UserController{}, "POST:GetUserData"),
beego.NSRouter("/list", &controllers.UserController{}, "POST:ListUser"),
beego.NSRouter("/permission", &controllers.UserController{}, "POST:BeforeEditUser"),
),
beego.NSNamespace("/partners",
beego.NSRouter("/list", &controllers.PartnerInfoController{}, "POST:ListPartnerInfo"),
beego.NSRouter("/add", &controllers.PartnerInfoController{}, "POST:CreatePartnerInfo"),
beego.NSRouter("/edit", &controllers.PartnerInfoController{}, "POST:UpdatePartnerInfo"),
beego.NSRouter("/detail", &controllers.PartnerInfoController{}, "POST:GetPartnerInfo"),
beego.NSRouter("/set-status", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
//beego.NSRouter("/set-status", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
beego.NSRouter("/batchDisabled", &controllers.PartnerInfoController{}, "POST:PartnerInfoSetState"),
),
beego.NSNamespace("/dividends",
beego.NSRouter("/list", &controllers.OrderDividendController{}, "POST:PageListOrderDividend"),
beego.NSRouter("/edit", &controllers.OrderDividendController{}, "POST:EditOrderDividend"),
beego.NSRouter("/detail", &controllers.OrderDividendController{}, "POST:OrderDividendDetail"),
beego.NSRouter("/business/detail", &controllers.BusinessBonusController{}, "POST:GetBusinessBonus"),
beego.NSRouter("/business/edit", &controllers.BusinessBonusController{}, "POST:UpdateBusinessBonus"),
beego.NSRouter("/business/list", &controllers.BusinessBonusController{}, "POST:ListBusinessBonus"),
),
beego.NSNamespace("/order",
beego.NSRouter("/purpose/list", &controllers.OrderInfoController{}, "POST:PageListOrderPurpose"),
... ... @@ -41,13 +43,17 @@ func init() {
beego.NSRouter("/actual/list", &controllers.OrderInfoController{}, "POST:PageListOrderReal"),
beego.NSRouter("/actual/detail", &controllers.OrderInfoController{}, "POST:GetOrderReal"),
beego.NSRouter("/actual/del", &controllers.OrderInfoController{}, "POST:RemoveOrderReal"),
beego.NSRouter("/actual/update", &controllers.OrderInfoController{}, "POST:UpdateOrderReal"),
beego.NSRouter("/actual/close", &controllers.OrderInfoController{}, "POST:OrderDisable"),
),
beego.NSNamespace("/common",
beego.NSRouter("/partner", &controllers.CommonController{}, "POST:GetPartnerList"),
beego.NSRouter("/partnerType", &controllers.CommonController{}, "POST:GetPartnerCategory"),
),
beego.NSNamespace("/enterprises",
beego.NSRouter("/setPhone", &controllers.CompanyController{}, "POST:SetPhone"),
),
)
... ...
package routers
import (
"github.com/astaxie/beego"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/port/beego/controllers"
)
//外部调用,企业平台，总后台调用
func init() {
nsPlatform := beego.NewNamespace("/platform",
beego.NSRouter("/action", &controllers.SyncDataController{}, "post:SyncData"),
beego.NSRouter("/admins_change", &controllers.SyncDataController{}, "post:CompanyAdminChance"),
)
nsUcenter := beego.NewNamespace("/ucenter",
beego.NSRouter("/company/allow_forbid", &controllers.SyncDataController{}, "post:AllowForidCompany"),
//beego.NSRouter("/company/info", &controllers.SyncDataController{}, "post:GetCompanyInfo"),
)
beego.AddNamespace(nsPlatform) //企业平台调用
beego.AddNamespace(nsUcenter) //统一用户中心调用
}
... ...
package routers
import (
"net/http"
"github.com/astaxie/beego"
"github.com/astaxie/beego/context"
"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/constant"
)
func init() {
beego.SetStaticPath("/log", constant.LOG_File)
//beego.SetStaticPath("/log", constant.LOG_File)
beego.Get("/log", func(ctx *context.Context) {
var s string
ctx.Input.Bind(&s, "id")
if s != "12345" {
ctx.Output.SetStatus(http.StatusBadRequest)
return
}
http.ServeFile(ctx.ResponseWriter, ctx.Request, constant.LOG_File)
return
})
}
... ...