package service

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"
	"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"
)

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

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

// PageListOrderBase 获取订单列表
func (service OrderInfoService) PageListOrderBase(listOrderQuery query.ListOrderBaseQuery) ([]domain.OrderBase, 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 (
		orderRepository domain.OrderBaseRepository
		orders          []domain.OrderBase
		cnt             int
	)

	if value, err := factory.CreateOrderBaseRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, 0, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		orderRepository = value
	}
	query := domain.OrderBaseFindQuery{
		PartnerId:    listOrderQuery.PartnerId,
		OrderCode:    listOrderQuery.OrderCode,
		Offset:       listOrderQuery.Offset,
		Limit:        listOrderQuery.Limit,
		OrderType:    listOrderQuery.OrderType,
		DeliveryCode: listOrderQuery.DeliveryCode,
		CompanyId:    listOrderQuery.CompanyId,
	}
	orders, cnt, err = orderRepository.Find(query)
	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())
	}
	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
		}
	}
	transactionContext.CommitTransaction()
	return orders, 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
}

//CreateNewOrder 创建订单
func (service OrderInfoService) CreateNewOrder(cmd command.CreateOrderCommand) (*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 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())
	}
	//检查order_code是否重复
	// if ok, err := orderBaseDao.OrderCodeExist(cmd.OrderCode); err != nil {
	// 	return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	// } else if ok {
	// 	return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单号已存在")
	// }
	//检查delivery_code是否重复
	if len(cmd.DeliveryCode) > 0 {
		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, "发货号已存在")
		}
	}
	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,
	}
	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 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 ok, err := orderBaseDao.OrderCodeExist(cmd.OrderCode, cmd.Id); err != nil {
	// 	return nil, lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	// } else if ok {
	// 	return nil, lib.ThrowError(lib.BUSINESS_ERROR, "订单号已存在")
	// }
	//检查delivery_code是否重复
	if len(cmd.DeliveryCode) > 0 {
		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, "发货号已存在")
		}
	}
	//获取旧的订单中的商品
	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)
	}
	oldOrderData.OrderCode = cmd.OrderCode
	oldOrderData.DeliveryCode = cmd.DeliveryCode
	oldOrderData.Buyer.BuyerName = cmd.BuyerName
	oldOrderData.RegionInfo.RegionName = cmd.OrderRegion
	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
}

//Delivery 发货
func (service OrderInfoService) Delivery(cmd command.OrderDeliveryCommand) 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
		oldOrderData        *domain.OrderBase
		oldOrderGoods       []domain.OrderGood
		orderBaseDao        *dao.OrderBaseDao
	)

	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())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		CompanyId: cmd.CompanyId,
		OrderId:   cmd.OrderId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	if oldOrderData.OrderType != domain.OrderIntention {
		return lib.ThrowError(lib.BUSINESS_ERROR, "订单类型已发生变更")
	}
	if orderBaseDao, err = factory.CreateOrderBaseDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return lib.ThrowError(lib.TRANSACTION_ERROR, err.Error())
	}
	//检查delivery_code是否重复
	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,
		CompanyId: cmd.CompanyId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
	}
	for _, newGood := range cmd.Goods {
		for i := range oldOrderGoods {
			if newGood.Id != oldOrderGoods[i].Id {
				continue
			}
			oldOrderGoods[i].GoodName = newGood.GoodName
			oldOrderGoods[i].PlanGoodNumber = newGood.PlanGoodNumber
			oldOrderGoods[i].Price = newGood.Price
			oldOrderGoods[i].PartnerBonusPercent = newGood.PartnerBonusPercent
			oldOrderGoods[i].Remark = newGood.Remark
			err = oldOrderGoods[i].Compute()
			if err != nil {
				return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
			}
			err = oldOrderGoods[i].CurrentBonusStatus.WartPayPartnerBonus(&oldOrderGoods[i])
			if err != nil {
				return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
			}
		}
	}
	oldOrderData.DeliveryCode = cmd.DeliveryCode
	oldOrderData.DeliveryTime = time.Now()
	oldOrderData.Goods = oldOrderGoods
	//变更订单类型
	oldOrderData.OrderType = domain.OrderReal
	err = oldOrderData.Compute()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = orderGoodRepository.Save(oldOrderGoods)
	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
}

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

//UpdateGoodBouns 分红时，更新货品的分红相关的数值
func (service OrderInfoService) UpdateGoodBouns(cmd command.UpdateGoodBouns) 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
		oldOrderData        *domain.OrderBase
		oldOrderGoods       []domain.OrderGood
	)
	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())
	}
	//获取旧的订单
	oldOrderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId:   cmd.Id,
		CompanyId: cmd.CompanyId,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单:%s", err))
	}
	if oldOrderData.OrderType != domain.OrderReal {
		return lib.ThrowError(lib.BUSINESS_ERROR, fmt.Sprintf("指定的订单的订单类型发生变更"))
	}
	//获取旧的订单中的商品
	oldOrderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{
		OrderId: cmd.Id,
	})
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("未找到指定的订单中的商品列表失败:%s", err))
	}
	for _, newGood := range cmd.GoodBouns {
		for i := range oldOrderGoods {
			if newGood.GoodId != oldOrderGoods[i].Id {
				continue
			}
			oldOrderGoods[i].UseGoodNumber = newGood.UseGoodNumber
			oldOrderGoods[i].Remark = newGood.Remark
			oldOrderGoods[i].BonusStatus = newGood.BounsStatus
			err = oldOrderGoods[i].Compute()
			if err != nil {
				return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的数值失败：%s", err))
			}
			switch newGood.BounsStatus {
			case domain.OrderGoodWaitPay:
				err = oldOrderGoods[i].CurrentBonusStatus.WartPayPartnerBonus(&oldOrderGoods[i])
				if err != nil {
					return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
				}
			case domain.OrderGoodHasPay:
				err = oldOrderGoods[i].CurrentBonusStatus.PayPartnerBonus(&oldOrderGoods[i])
				if err != nil {
					return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中商品的分红数值失败：%s", err))
				}
			default:
				return lib.ThrowError(lib.ARG_ERROR, fmt.Sprintf("货品的支付状态错误"))
			}
		}
	}
	oldOrderData.Goods = oldOrderGoods

	err = oldOrderData.Compute()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("核算订单中合计的数值失败：%s", err))
	}
	err = orderBaseRepository.Save(oldOrderData)
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, fmt.Sprintf("保存订单数据失败：%s", err))
	}
	err = orderGoodRepository.Save(oldOrderGoods)
	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

}

//UpdateBounsWithGoodNumber 分红时，因修改订单中商品的数量发生分红变动
func (service OrderInfoService) UpdateBounsByGoodNumber() 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()
	}()
	//TODO
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

//UpdateBounsByPartnerBonusPercent 分红时，因修改订单中商品的合伙人分行比例发生分红变动
func (service OrderInfoService) UpdateBounsByPartnerBonusPercent() 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()
	}()
	//TODO
	err = transactionContext.CommitTransaction()
	if err != nil {
		return lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}