package service

import (
	"fmt"
	"strconv"
	"time"

	"github.com/linmadan/egglib-go/core/application"

	"github.com/astaxie/beego/logs"

	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/application/event/subscriber"
	"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"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"
	domainService "gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain/service"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/models"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/infrastructure/pg/transaction"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/lib"
)

// OrderService 自建订单，意向单，实发订单
type OrderInfoService struct {
}

func NewOrderInfoService(option map[string]interface{}) *OrderInfoService {
	newAdminUserService := new(OrderInfoService)
	return newAdminUserService
}

/**
 * @Author SteveChan
 * @Description // 获取订单列表
 * @Date 22:05 2021/1/10
 * @Param
 * @return
 **/
func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrderBaseQuery) ([]map[string]interface{}, int, error) {
	var err error
	transactionContext, err := factory.CreateTransactionContext(nil)
	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 (
		orderDao *dao.OrderBaseDao
		orders   []models.OrderBase
		cnt      int
	)

	if orderDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	orders, cnt, err = orderDao.OrderListByCondition(
		listOrderQuery.CompanyId,
		listOrderQuery.OrderType,
		listOrderQuery.PartnerName,  // 合伙人姓名
		listOrderQuery.OrderCode,    // 订单号
		listOrderQuery.DeliveryCode, // 发货单号
		[2]string{listOrderQuery.UpdateTimeBegin, listOrderQuery.UpdateTimeEnd}, // 订单创建时间
		[2]string{listOrderQuery.CreateTimeBegin, listOrderQuery.CreateTimeEnd}, // 订单更新时间
		[2]string{listOrderQuery.SaleDateBegin, listOrderQuery.SaleDateEnd},     // 销售日期
		listOrderQuery.PartnerCategory,
		listOrderQuery.PartnerCategoryName,
		listOrderQuery.Limit, listOrderQuery.Offset,
	)
	if err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	orderDataReturn := make([]map[string]interface{}, 0)

	for i := range orders {
		partnerData := &domain.PartnerInfo{}
		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
			UserId: orders[i].PartnerId,
		})
		if err != nil {
			//防崩溃
			partnerData = &domain.PartnerInfo{}
			logs.Error("获取合伙(id=%d)失败%s", orders[i].PartnerId, err)
		}
		listIndex := listOrderQuery.Offset + (1 + i)
		m := map[string]interface{}{
			"index":           listIndex,
			"createTime":      orders[i].CreateTime.Local().Format("2006-01-02 15:04:05"),
			"updateTime":      orders[i].UpdateTime.Local().Format("2006-01-02 15:04:05"),
			"saleDate":        orders[i].SaleDate.Local().Format("2006-01-02 15:04:05"),
			"buyer":           orders[i].Buyer.BuyerName,
			"id":              fmt.Sprint(orders[i].Id),
			"orderId":         orders[i].OrderCode,
			"shipmentsId":     orders[i].DeliveryCode,
			"partner":         partnerData.Partner.PartnerName,
			"orderNum":        orders[i].PlanOrderCount,
			"orderPrice":      orders[i].PlanOrderAmount,
			"orderDist":       orders[i].RegionInfo.RegionName,
			"quantityControl": "",
			"priceControl":    "",
			"status":          orders[i].IsDisable,
			"partnerCategory": orders[i].PartnerCategory.Name,
		}
		if orders[i].UseOrderCount >= 0 {
			m["quantityControl"] = fmt.Sprint(orders[i].UseOrderCount)
		}
		if orders[i].UseOrderAmount >= 0 {
			m["priceControl"] = fmt.Sprint(orders[i].UseOrderAmount)
		}
		orderDataReturn = append(orderDataReturn, m)
	}
	transactionContext.CommitTransaction()
	return orderDataReturn, cnt, nil
}

// GetOrderDetail 获取订单详情
func (service OrderInfoService) GetOrderDetail(getOrderQuery query.GetOrderQuery) (*domain.OrderBase, error) {
	//实际业务
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	var (
		orderBaseRepository   domain.OrderBaseRepository
		partnerInfoRepository domain.PartnerInfoRepository
		orderGoodRepository   domain.OrderGoodRepository
		order                 *domain.OrderBase
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if partnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	order, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId:   getOrderQuery.OrderId,
		CompanyId: getOrderQuery.CompanyId,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单数据失败：%s", err))
	}
	var (
		partnerData *domain.PartnerInfo
		goods       []domain.OrderGood
	)

	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,
		CompanyId: getOrderQuery.CompanyId,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("获取订单中的商品列表失败：%s", err))
	}
	order.Goods = goods
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return order, nil
}

/**
 * @Author SteveChan
 * @Description // 创建订单，增加销售日期
 * @Date 11:57 2021/1/26
 * @Param
 * @return
 **/
func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (*domain.OrderBase, error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = cmd.Valid(); err != nil {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, err.Error())
	}
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var partnerData *domain.PartnerInfo
	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: cmd.PartnerId})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
	}
	var (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
		orderBaseDao        *dao.OrderBaseDao
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	goodNames := []string{}
	for _, v := range cmd.Goods {
		goodNames = append(goodNames, v.GoodName)
	}
	if ok, err := orderBaseDao.CheckOrderExist(cmd.CompanyId, cmd.OrderCode, cmd.DeliveryCode,
		cmd.PartnerCategory, cmd.PartnerId, 0, goodNames); err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	} else if ok {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单已存在")
	}
	//检查货品数据
	var goodMap = map[string]int{}
	for i := range cmd.Goods {
		goodname := cmd.Goods[i].GoodName
		if _, ok := goodMap[goodname]; ok {
			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单中货品重复已存在")
		}
		goodMap[goodname] = 1
	}
	newOrder := &domain.OrderBase{
		OrderType:    cmd.OrderType,
		OrderCode:    cmd.OrderCode,
		DeliveryCode: cmd.DeliveryCode,
		Buyer: domain.Buyer{
			BuyerName: cmd.BuyerName,
		},
		RegionInfo: domain.RegionInfo{
			RegionName: cmd.OrderRegion,
		},
		SaleDate:             cmd.SaleDate,
		PartnerId:            cmd.PartnerId,
		PartnerInfo:          partnerData.Partner,
		SalesmanBonusPercent: cmd.SalesmanBonusPercent,
		CompanyId:            cmd.CompanyId,
	}
	var categoryRepository domain.PartnerCategoryRepository
	if categoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var cmdPartnerCategoryOk bool
	for _, v := range partnerData.PartnerCategoryInfos {
		if v.Id == cmd.PartnerCategory {
			_, categories, err := categoryRepository.Find(domain.PartnerCategoryFindQuery{
				Ids: []int64{v.Id},
			})
			if err != nil {
				e := fmt.Sprintf("获取合伙人分类数据失败：%s", err)
				return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
			}
			if len(categories) > 0 {
				newOrder.PartnerCategory = categories[0]
				cmdPartnerCategoryOk = true
			}
			break
		}
	}
	if !cmdPartnerCategoryOk {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "合伙人类型选择错误")
	}
	var orderGoods []domain.OrderGood
	for _, good := range cmd.Goods {
		m := domain.NewOrderGood()
		m.OrderId = 0
		m.GoodName = good.GoodName
		m.PlanGoodNumber = good.PlanGoodNumber
		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))
		}
		err = m.CurrentBonusStatus.WartPayPartnerBonus(&m)
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
		}
		orderGoods = append(orderGoods, m)
	}
	newOrder.Goods = orderGoods
	err = newOrder.Compute()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(newOrder)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	for i := range newOrder.Goods {
		newOrder.Goods[i].OrderId = newOrder.Id
	}
	err = orderGoodRepository.Save(orderGoods)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err))
	}
	newOrder.Goods = orderGoods
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return newOrder, nil
}

// DeleteOrder 删除订单
func (service OrderInfoService) DeleteOrder(orderId int64, companyId int64) error {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = orderBaseRepository.Remove(orderId, companyId)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单数据失败：%s", err))
	}
	err = orderGoodRepository.Remove(orderId, companyId)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中商品数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// UpdateOrderData 编辑订单
func (service OrderInfoService) UpdateOrderData(cmd command.UpdateOrderCommand) (*domain.OrderBase, error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)

	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	// 获取合伙人类型
	var PartnerCategoryRepository domain.PartnerCategoryRepository
	if PartnerCategoryRepository, err = factory.CreatePartnerCategoryRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var partnerCategories []domain.PartnerCategory
	_, partnerCategories, err = PartnerCategoryRepository.Find(domain.PartnerCategoryFindQuery{
		Ids: []int64{},
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人类型数据失败"))
	}
	partnerCategoryMap := map[int64]interface{}{}
	if len(partnerCategories) > 0 {
		for _, partnerCategory := range partnerCategories {
			partnerCategoryMap[partnerCategory.Id] = partnerCategory.Name
		}
	}

	// 获取合伙人数据
	var PartnerInfoRepository domain.PartnerInfoRepository
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var partnerData *domain.PartnerInfo
	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("检索合伙人数据失败"))
	}
	var (
		orderBaseRepository domain.OrderBaseRepository
		orderGoodRepository domain.OrderGoodRepository
		oldOrderData        *domain.OrderBase
		oldOrderGoods       []domain.OrderGood
		newOrderGoods       []domain.OrderGood
		delGoods            []int64
		orderBaseDao        *dao.OrderBaseDao
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId:   cmd.Id,
		CompanyId: cmd.CompanyId,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	//判定要求的更新的订单类型
	if oldOrderData.OrderType != cmd.OrderType {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, fmt.Sprintf("操作失败，待更新的订单的类型已变更"))
	}
	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	//检查order_code是否重复
	// if oldOrderData.OrderCode != cmd.OrderCode || cmd.PartnerCategory != oldOrderData.PartnerCategory.Id {
	// 	if ok, err := orderBaseDao.OrderCodeExist(cmd.OrderCode, cmd.PartnerCategory, cmd.PartnerId); err != nil {
	// 		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	// 	} else if ok {
	// 		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单号已存在")
	// 	}
	// }
	goodNames := []string{}
	for _, v := range cmd.Goods {
		goodNames = append(goodNames, v.GoodName)
	}
	//检查delivery_code是否重复
	if ok, err := orderBaseDao.CheckOrderExist(cmd.CompanyId, cmd.OrderCode, cmd.DeliveryCode,
		cmd.PartnerCategory, cmd.PartnerId, cmd.Id, goodNames); err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	} else if ok {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单已存在")
	}
	//检查货品数据
	var goodMap = map[string]int{}
	for i := range cmd.Goods {
		goodname := cmd.Goods[i].GoodName
		if _, ok := goodMap[goodname]; ok {
			return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单中货品重复已存在")
		}
		goodMap[goodname] = 1
	}
	//获取旧的订单中的商品
	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
		OrderId:   cmd.Id,
		CompanyId: cmd.CompanyId,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
	}
	for _, good := range cmd.Goods {
		m := domain.NewOrderGood()
		m.OrderId = oldOrderData.Id
		m.GoodName = good.GoodName
		m.PlanGoodNumber = good.PlanGoodNumber
		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))
		}
		err = m.CurrentBonusStatus.WartPayPartnerBonus(&m)
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
		}
		newOrderGoods = append(newOrderGoods, m)
	}
	var cmdPartnerCategoryOk bool
	for _, v := range partnerData.PartnerCategoryInfos {
		if v.Id == cmd.PartnerCategory {
			v.Name = partnerCategoryMap[v.Id].(string)
			oldOrderData.PartnerCategory = v
			cmdPartnerCategoryOk = true
		}
	}
	if !cmdPartnerCategoryOk {
		return nil, lib.ThrowError(lib.BUSINESS_ERROR, "合伙人类型选择错误")
	}
	oldOrderData.OrderCode = cmd.OrderCode
	oldOrderData.DeliveryCode = cmd.DeliveryCode
	oldOrderData.Buyer.BuyerName = cmd.BuyerName
	oldOrderData.RegionInfo.RegionName = cmd.OrderRegion
	oldOrderData.SaleDate = cmd.SaleDate
	oldOrderData.PartnerId = cmd.PartnerId
	oldOrderData.PartnerInfo = partnerData.Partner
	oldOrderData.SalesmanBonusPercent = cmd.SalesmanBonusPercent
	oldOrderData.Goods = newOrderGoods
	err = oldOrderData.Compute()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = orderGoodRepository.Save(newOrderGoods)
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err))
	}
	oldOrderData.Goods = newOrderGoods
	//删不需要的订单总不需要的商品
	delGoods = service.deleteOldOrderGoods(newOrderGoods, oldOrderGoods)
	if len(delGoods) > 0 {
		err = orderGoodRepository.Remove(oldOrderData.Id, cmd.CompanyId, delGoods...)
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("删除订单中的商品数据失败：%s", err))
		}
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return oldOrderData, nil
}

// deleteOldOrderGoods 新旧商品列表对比
func (service OrderInfoService) deleteOldOrderGoods(newGoods []domain.OrderGood, oldGoods []domain.OrderGood) (goodIds []int64) {
	for _, old := range oldGoods {
		var hasIn bool
		for _, new := range newGoods {
			if old.Id == new.Id {
				hasIn = true
				break
			}
		}
		if !hasIn {
			goodIds = append(goodIds, old.Id)
		}
	}
	return
}

// DisableOrEnable 开启关闭订单
func (service OrderInfoService) DisableOrEnable(cmd command.DisableOrderCommand) error {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
	)
	if err = transactionContext.StartTransaction(); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var (
		orderBaseRepository domain.OrderBaseRepository
		oldOrderData        *domain.OrderBase
	)
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId:   cmd.OrderId,
		CompanyId: cmd.CompanyId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	if oldOrderData.OrderType != cmd.OrderType {
		return lib.ThrowError(lib.BUSINESS_ERROR, fmt.Sprintf("操作失败，指定的订单的类型发生变更"))
	}
	oldOrderData.IsDisable = cmd.IsDisable
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// PageListOrderBouns 获取订单的分红列表
func (service OrderInfoService) PageListOrderBonus(listOrderQuery query.ListOrderBonusQuery) ([]map[string]interface{}, int, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	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 (
		ordersM      []models.OrderBase
		orders       []domain.OrderBase
		cnt          int
		orderBaseDao *dao.OrderBaseDao
	)

	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, cnt, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	ordersM, cnt, err = orderBaseDao.OrderBonusListByCondition(
		listOrderQuery.CompanyId,
		listOrderQuery.OrderType,
		listOrderQuery.PartnerOrCode,
		listOrderQuery.PartnerCategory,
		[2]string{listOrderQuery.CreateTimeBegin, listOrderQuery.CreateTimeEnd},
		listOrderQuery.Limit,
		listOrderQuery.Offset,
	)
	for _, orderModel := range ordersM {
		order := domain.OrderBase{
			Id: orderModel.Id, OrderType: orderModel.OrderType, OrderCode: orderModel.OrderCode,
			DeliveryCode: orderModel.DeliveryCode, Buyer: orderModel.Buyer, RegionInfo: orderModel.RegionInfo,
			PartnerId: orderModel.PartnerId, SalesmanBonusPercent: orderModel.SalesmanBonusPercent,
			CreateTime: orderModel.CreateTime, DeliveryTime: orderModel.DeliveryTime, UpdateTime: orderModel.UpdateTime,
			IsDisable: orderModel.IsDisable,
			OrderCompute: domain.OrderCompute{
				PlanPartnerBonus: orderModel.PlanPartnerBonus, UsePartnerBonus: orderModel.UsePartnerBonus,
				PartnerBonusHas: orderModel.PartnerBonusHas, PartnerBonusNot: orderModel.PartnerBonusNot,
				PartnerBonusExpense: orderModel.PartnerBonusExpense, SalesmanBonus: orderModel.SalesmanBonus,
				PlanOrderCount: orderModel.PlanOrderCount, PlanOrderAmount: orderModel.PlanOrderAmount,
				UseOrderCount: orderModel.UseOrderCount, UseOrderAmount: orderModel.UseOrderAmount,
			},
			PartnerInfo: domain.Partner{
				Id: orderModel.PartnerId,
			},
			BonusStatus: orderModel.BonusStatus,
			CompanyId:   orderModel.CompanyId,
		}
		orders = append(orders, order)
	}
	var (
		PartnerInfoRepository domain.PartnerInfoRepository
		orderGoodRepository   domain.OrderGoodRepository
	)
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var resp = []map[string]interface{}{}
	for i := range orders {
		partnerData := &domain.PartnerInfo{}
		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
			UserId: orders[i].PartnerId,
		})
		if err != nil {
			logs.Error("获取合伙(id=%d)失败%s", orders[i].PartnerId, err)
		} else {
			orders[i].PartnerInfo = partnerData.Partner
		}
		var (
			goods           []domain.OrderGood
			hasBonusPercent bool
		)
		goods, _, _ = orderGoodRepository.Find(domain.OrderGoodFindQuery{OrderId: orders[i].Id})
		for ii := range goods {
			if goods[ii].PartnerBonusPercent >= 0 {
				hasBonusPercent = true
				break
			}
		}
		listIndex := listOrderQuery.Offset + (1 + i)
		listItem := map[string]interface{}{
			"index":                listIndex,
			"createTime":           orders[i].CreateTime.Local().Format("2006-01-02 15:04:05"),
			"updateTime":           orders[i].UpdateTime.Local().Format("2006-01-02 15:04:05"),
			"id":                   fmt.Sprint(orders[i].Id),
			"saleDate":             orders[i].SaleDate.Local().Format("2006-01-02"),
			"shipmentsId":          orders[i].DeliveryCode,
			"partner":              orders[i].PartnerInfo.PartnerName,
			"dividendsReceivable":  fmt.Sprint(orders[i].GetCurrentPartnerBonus()),
			"dividendSpending":     fmt.Sprint(orders[i].OrderCompute.PartnerBonusExpense),
			"receiveDividends":     fmt.Sprint(orders[i].OrderCompute.PartnerBonusHas),
			"uncollectedDividends": fmt.Sprint(orders[i].OrderCompute.PartnerBonusNot),
			"stateOfPayment":       orders[i].BonusStatus,
			"orderType":            orders[i].OrderType,
			"orderTypeName":        domain.GetOrderBaseTypeName(orders[i].OrderType),
			"orderNumber":          orders[i].OrderCode,
		}
		if !hasBonusPercent {
			listItem["receiveDividends"] = "-"
			listItem["dividendsReceivable"] = "-"
			listItem["dividendSpending"] = "-"
			listItem["uncollectedDividends"] = "-"
		}
		resp = append(resp, listItem)
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return resp, cnt, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return resp, cnt, nil
}

// PayPartnerBonusWithOrderBestshop 支付分红
func (service OrderInfoService) PayPartnerBonus(orderId int64, goodId int64, adminId int64) 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 (
		orderBonuSrv domainService.OrderBonusService
	)
	orderBonuSrv, err = factory.CreateOrderBonusService(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	orderBonuSrv.Subscribe(&subscriber.OrderLogSubscriber{
		TransactionContext: transactionContext.(*transaction.TransactionContext),
	})
	err = orderBonuSrv.PayOrderGoodBonus(orderId, goodId, adminId)
	if err != nil {
		return err
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// UpdateOrderRemarkBonus 订单分红详情，更新备注
func (service OrderInfoService) UpdateOrderRemarkBonus(orderId int64, adminId int64, remark string) 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 (
		orderBonuSrv domainService.OrderBonusService
	)
	orderBonuSrv, err = factory.CreateOrderBonusService(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	orderBonuSrv.Subscribe(&subscriber.OrderLogSubscriber{
		TransactionContext: transactionContext.(*transaction.TransactionContext),
	})
	err = orderBonuSrv.UpdateOrderRemarkBonus(orderId, adminId, remark)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

func (service OrderInfoService) ListOrderBonusForExcel(listOrderQuery query.ListOrderBonusQuery) ([]map[string]string, [][2]string, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var (
		orderBaseDao *dao.OrderBaseDao
	)

	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	result, err := orderBaseDao.OrderBonusListForExcel(
		listOrderQuery.CompanyId,
		listOrderQuery.OrderType,
		listOrderQuery.PartnerOrCode,
		listOrderQuery.PartnerCategory,
		[2]string{listOrderQuery.CreateTimeBegin, listOrderQuery.CreateTimeEnd},
	)
	if err != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var resultMaps []map[string]string
	for i := range result {
		m := map[string]string{
			"num":                   fmt.Sprint(i + 1),
			"order_type":            domain.GetOrderBaseTypeName(result[i].OrderType),
			"order_code":            result[i].OrderCode,
			"delivery_code":         result[i].DeliveryCode,
			"partner_name":          result[i].PartnerName,
			"bonus_status":          "",
			"update_time":           result[i].UpdateTime,
			"create_time":           result[i].CreateTime,
			"partner_bonus":         fmt.Sprintf("%10.2f", result[i].PartnerBonus),
			"partner_bonus_has":     fmt.Sprintf("%10.2f", result[i].PartnerBonusHas),
			"partner_bonus_not":     fmt.Sprintf("%10.2f", result[i].PartnerBonusNot),
			"partner_bonus_expense": fmt.Sprintf("%10.2f", result[i].PartnerBonusExpense),
		}
		if len(result[i].DeliveryCode) == 0 {
			m["delivery_code"] = "-"
		}
		if result[i].HasBonusPercent == 0 {
			m["partner_bonus"] = "-"
			m["partner_bonus_has"] = "-"
			m["partner_bonus_not"] = "-"
			m["partner_bonus_expense"] = "-"
		}
		switch result[i].BonusStatus {
		case domain.OrderGoodWaitPay:
			m["bonus_status"] = "等待支付分红"
		case domain.OrderGoodHasPay:
			m["bonus_status"] = "已支付分红"
		}
		resultMaps = append(resultMaps, m)
	}
	column := [][2]string{
		[2]string{"num", "序号"},
		[2]string{"order_type", "订单类型"},
		[2]string{"order_code", "订单号"},
		[2]string{"delivery_code", "发货单号"},
		[2]string{"partner_name", "合伙人"},
		[2]string{"bonus_status", "支付状态"},
		[2]string{"create_time", "创建时间"},
		[2]string{"partner_bonus", "应收分红"},
		[2]string{"partner_bonus_has", "已收分红"},
		[2]string{"partner_bonus_not", "未收分红"},
		[2]string{"partner_bonus_expense", "分红支出"},
	}
	return resultMaps, column, nil
}

/**
 * @Author SteveChan
 * @Description //根据栏目设置，导出订单数据
 * @Date 22:05 2021/1/10
 * @Param
 * @return
 **/
func (service OrderInfoService) ListOrderForExcel(listOrderQuery query.ListOrderBaseQuery) ([]map[string]string, [][2]string, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	var (
		orderBaseDao *dao.OrderBaseDao
	)

	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	ordersData, err := orderBaseDao.OrderListForExcel(
		listOrderQuery.CompanyId,
		listOrderQuery.PartnerName,  // 合伙人姓名
		listOrderQuery.OrderCode,    // 订单号
		listOrderQuery.DeliveryCode, // 发货单号
		[2]string{listOrderQuery.UpdateTimeBegin, listOrderQuery.UpdateTimeEnd},
		[2]string{listOrderQuery.CreateTimeBegin, listOrderQuery.CreateTimeEnd},
		[2]string{listOrderQuery.SaleDateBegin, listOrderQuery.SaleDateEnd},
		listOrderQuery.PartnerCategory,
		listOrderQuery.PartnerCategoryName,
	)
	if err != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 获取栏目设置
	var columnSettingRepository domain.ColumnSettingRepository
	if value, errFact := factory.CreateColumnSettingRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); errFact != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		columnSettingRepository = value
	}
	columnSettingFound, err := columnSettingRepository.FindOne(map[string]interface{}{"uid": listOrderQuery.Uid, "companyId": listOrderQuery.CompanyId})
	if err != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if columnSettingFound == nil {
		return nil, nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(listOrderQuery.Uid, 10)))
	}

	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var resultMaps []map[string]string
	for i := range ordersData {
		t, _ := time.ParseInLocation("2006-01-02 15:04:05", ordersData[i].SaleDate, time.Local)
		m := map[string]string{
			//"num":               fmt.Sprint(i + 1),
			//"order_code":        ordersData[i].OrderCode,
			//"delivery_code":     ordersData[i].DeliveryCode,
			//"partner_name":      ordersData[i].PartnerName,
			//"update_time":       ordersData[i].UpdateTime,
			//"create_time":       ordersData[i].CreateTime,
			//"sale_date":         ordersData[i].SaleDate,
			//"plan_order_count":  fmt.Sprint(ordersData[i].PlanOrderCount),
			//"use_order_count":   "",
			//"region_name":       fmt.Sprint(ordersData[i].RegionName),
			//"plan_order_amount": fmt.Sprintf("%10.2f", ordersData[i].PlanOrderAmount),
			//"use_order_amount":  "",
			//"partner_category":  ordersData[i].PartnerCategory,
			//"buyer_name":        ordersData[i].BuyerName,
			"index":           fmt.Sprint(i + 1),
			"orderId":         ordersData[i].OrderCode,
			"shipmentsId":     ordersData[i].DeliveryCode,
			"partner":         ordersData[i].PartnerName,
			"updateTime":      ordersData[i].UpdateTime,
			"createTime":      ordersData[i].CreateTime,
			"saleDate":        t.Format("2006-01-02"),
			"orderNum":        fmt.Sprint(ordersData[i].PlanOrderCount),
			"quantityControl": "",
			"orderDist":       fmt.Sprint(ordersData[i].RegionName),
			"orderPrice":      fmt.Sprintf("%10.2f", ordersData[i].PlanOrderAmount),
			"priceControl":    "",
			"partnerCategory": ordersData[i].PartnerCategory,
			"buyer":           ordersData[i].BuyerName,
		}
		if ordersData[i].UseOrderCount >= 0 {
			m["quantityControl"] = fmt.Sprint(ordersData[i].UseOrderCount)
		}
		if ordersData[i].UseOrderAmount >= 0 {
			m["priceControl"] = fmt.Sprintf("%10.2f", ordersData[i].UseOrderAmount)
		}
		resultMaps = append(resultMaps, m)
	}

	//column := [][2]string{
	//	[2]string{"num", "序号"},
	//	[2]string{"order_code", "订单号"},
	//	[2]string{"delivery_code", "发货单号"},
	//	[2]string{"create_time", "创建时间"},
	//	[2]string{"update_time", "更新时间"},
	//	[2]string{"sale_date", "销售时间"},
	//	[2]string{"plan_order_count", "订单数量"},
	//	[2]string{"use_order_count", "数量调整"},
	//	[2]string{"plan_order_amount", "订单金额"},
	//	[2]string{"use_order_amount", "金额调整"},
	//	[2]string{"region_name", "订单区域"},
	//	[2]string{"partner_category", "合伙人类型"},
	//	[2]string{"buyer_name", "客户"},
	//	[2]string{"partner_name", "合伙人"},
	//}

	var column [][2]string
	for _, columnValue := range columnSettingFound.Value {
		column = append(column, [2]string{columnValue.Id, columnValue.ParamCn})
	}

	return resultMaps, column, nil
}

/**
 * @Author SteveChan
 * @Description // 批量导入创建订单，增加销售时间
 * @Date 11:00 2021/1/7
 * @Param
 * @return
 **/
func (service OrderInfoService) CreateNewOrderByImport(createOrderCommands []*command.CreateOrderCommand) ([]*domain.ImportInfo, error) {
	// 事务初始化
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
		errorDataList         []*domain.ImportInfo // 错误数据返回
	)

	// 循环校验命令
	for _, cmd := range createOrderCommands {
		if err = cmd.Valid(); err != nil {
			// 返回信息 0: 订单号, 1: 发货单号, 2: 客户名称, 3: 订单区域, 4: 编号, 5: 合伙人, 6: 类型, 7: 业务抽成比例, 8: 产品名称, 9: 数量, 10: 单价, 11: 合伙人分红比例
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.BUSINESS_ERROR, err.Error()), // 错误信息
				LineNumbers: cmd.LineNumbers,                                 // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}
	}

	// 开始事务
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	defer func() {
		transactionContext.RollbackTransaction()
	}()

	// 仓储、数据访问对象初始化
	var (
		orderBaseRepository   domain.OrderBaseRepository
		orderGoodRepository   domain.OrderGoodRepository
		PartnerInfoRepository domain.PartnerInfoRepository
		categoryRepository    domain.PartnerCategoryRepository
		orderBaseDao          *dao.OrderBaseDao
	)

	// 合伙人信息仓储初始化
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 订单仓储初始化
	if orderBaseRepository, err = factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 订单产品仓储初始化
	if orderGoodRepository, err = factory.CreateOrderGoodRepository(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())
	}

	// 订单数据访问对象初始化
	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}

	// 批量创建订单
	for _, cmd := range createOrderCommands {
		// 批量校验合伙人信息
		var partnerData *domain.PartnerInfo
		partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{UserId: cmd.PartnerId})
		if err != nil {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败")),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}
		goodNames := []string{}
		for _, v := range cmd.Goods {
			goodNames = append(goodNames, v.GoodName)
		}
		// 批量校验订单
		if ok, err := orderBaseDao.CheckOrderExist(cmd.CompanyId, cmd.OrderCode, cmd.DeliveryCode,
			cmd.PartnerCategory, cmd.PartnerId, 0, goodNames); err != nil {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.TRANSACTION_ERROR, err.Error()),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		} else if ok {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.BUSINESS_ERROR, "订单已存在"),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		// 批量校验产品
		var goodMap = map[string]int{}
		goodErrMap := make(map[int]interface{}, 0)
		for i := range cmd.Goods {
			goodName := cmd.Goods[i].GoodName
			if _, ok := goodMap[goodName]; ok {
				goodErrMap[cmd.Goods[i].LineNumber] = lib.ThrowError(lib.BUSINESS_ERROR, "订单中货品重复已存在")
				continue
			}
			goodMap[goodName] = 1
		}
		if len(goodErrMap) > 0 {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.BUSINESS_ERROR, "订单中货品重复已存在"),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    goodErrMap,      // 错误产品行号记录
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		newOrder := &domain.OrderBase{
			OrderType: cmd.OrderType, OrderCode: cmd.OrderCode,
			DeliveryCode: cmd.DeliveryCode,
			Buyer: domain.Buyer{
				BuyerName: cmd.BuyerName,
			},
			RegionInfo: domain.RegionInfo{
				RegionName: cmd.OrderRegion,
			},
			PartnerId:            cmd.PartnerId,
			PartnerInfo:          partnerData.Partner,
			SalesmanBonusPercent: cmd.SalesmanBonusPercent,
			CompanyId:            cmd.CompanyId,
			SaleDate:             cmd.SaleDate,
		}

		// 批量校验合伙人分类数据
		var cmdPartnerCategoryOk bool
		for _, v := range partnerData.PartnerCategoryInfos {
			if v.Id == cmd.PartnerCategory {
				_, categories, err := categoryRepository.Find(domain.PartnerCategoryFindQuery{
					Ids: []int64{v.Id},
				})
				if err != nil {
					e := fmt.Sprintf("获取合伙人分类数据失败：%s", err)
					return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
				}
				if len(categories) > 0 {
					newOrder.PartnerCategory = categories[0]
					cmdPartnerCategoryOk = true
				}
				break
			}
		}
		if !cmdPartnerCategoryOk {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.BUSINESS_ERROR, "合伙人类型选择错误"),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		// 订单产品分红核算
		var orderGoods []domain.OrderGood
		orderGoodErrMap := make(map[int]interface{}, 0)
		for i, good := range cmd.Goods {
			m := domain.NewOrderGood()
			m.OrderId = 0
			m.GoodName = good.GoodName
			m.PlanGoodNumber = good.PlanGoodNumber
			m.Price = good.Price
			m.PartnerBonusPercent = good.PartnerBonusPercent
			m.Remark = good.Remark
			m.CompanyId = cmd.CompanyId

			err = m.Compute()
			if err != nil {
				orderGoodErrMap[cmd.Goods[i].LineNumber] = lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
				continue
			}

			err = m.CurrentBonusStatus.WartPayPartnerBonus(&m)
			if err != nil {
				orderGoodErrMap[cmd.Goods[i].LineNumber] = lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
				continue
			}

			orderGoods = append(orderGoods, m)
		}
		if len(orderGoodErrMap) > 0 {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.BUSINESS_ERROR, "核算订单中商品错误"),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    orderGoodErrMap, // 错误产品行号记录
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		newOrder.Goods = orderGoods

		err = newOrder.Compute()
		if err != nil {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err)),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		// 保存订单数据
		err = orderBaseRepository.Save(newOrder)
		if err != nil {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err)),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}

		for i := range newOrder.Goods {
			newOrder.Goods[i].OrderId = newOrder.Id
		}

		// 保存订单产品
		err = orderGoodRepository.Save(orderGoods)
		if err != nil {
			row := &domain.ImportInfo{
				Error:       lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单中的商品数据失败：%s", err)),
				LineNumbers: cmd.LineNumbers, // 错误影响的行
				GoodLine:    map[int]interface{}{},
			}
			errorDataList = append(errorDataList, row)
			continue
		}
		newOrder.Goods = orderGoods
	}

	if len(errorDataList) == 0 {
		// 完成事务
		err = transactionContext.CommitTransaction()
		if err != nil {
			return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
		}
		return errorDataList, nil
	}

	return errorDataList, nil
}

/**
 * @Author SteveChan
 * @Description // 根据合伙人编号和合伙人类型获取合伙人id
 * @Date 23:15 2021/1/6
 * @Param
 * @return
 **/
func (service OrderInfoService) GetPartnerIdByCodeAndCategory(getPartnerIdQuery query.GetPartnerIdQuery) (*domain.PartnerInfo, error) {
	// 事务初始化
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
		err                   error
		partnerData           *domain.PartnerInfo
	)

	// 开始事务
	if err = transactionContext.StartTransaction(); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 收尾
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	// 仓储、数据访问对象初始化
	var (
		PartnerInfoRepository domain.PartnerInfoRepository
	)
	// 合伙人信息仓储初始化
	if PartnerInfoRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}

	//var partnerData *domain.PartnerInfo
	partnerData, err = PartnerInfoRepository.FindOne(domain.PartnerFindOneQuery{
		CompanyId:       getPartnerIdQuery.CompanyId,
		Code:            getPartnerIdQuery.Code,
		PartnerCategory: getPartnerIdQuery.PartnerCategory,
	})
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("检索合伙人数据失败"))
	}

	// 完成事务
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return partnerData, nil
}