package service

import (
	"fmt"
	"strings"
	"time"

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

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

}

//PageListOrderBouns 获取订单的分红列表
func (service OrderInfoService) PageListOrderBonus(listOrderQuery query.ListOrderBonusQuery) ([]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 (
		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.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
	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
		}
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return orders, cnt, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	return orders, cnt, nil
}

//GetOrderBestshopInfo 获取来源于xiangmi订单的详情以及分红数据
func (service OrderInfoService) GetOrderBestshopInfoWithBonus(orderBaseId int64, companyId int64) (interface{}, 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 (
		orderBaseRepository         domain.OrderBaseRepository
		orderGoodRepository         domain.OrderGoodRepository
		orderBestshopRepository     domain.OrderBestshopRepository
		orderGoodBestshopRepository domain.OrderGoodBestshopRepository
		orderLogRepository          domain.OrderLogRepository
		partnerRepository           domain.PartnerInfoRepository
	)
	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 orderBestshopRepository, err = factory.CreateOrderBestshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderGoodBestshopRepository, err = factory.CreateOrderGoodBestshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if orderLogRepository, err = factory.CreateOrderLogRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	if partnerRepository, err = factory.CreatePartnerInfoRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	var (
		orderData         *domain.OrderBase
		orderGoods        []domain.OrderGood
		orderBestshopData *domain.OrderBestShop
		orderGoodBestshop []domain.OrderGoodBestShop
		orderLogs         []domain.OrderLog
		partnerInfo       *domain.PartnerInfo
	)

	orderData, err = orderBaseRepository.FindOne(domain.OrderBaseFindOneQuery{
		OrderId:   orderBaseId,
		CompanyId: companyId,
	})
	if err != nil {
		e := fmt.Sprintf("获取订单(order_base)数据失败,id=%d,company_id=%d,err=%s", orderBaseId, companyId, err)
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	if orderData.OrderType != domain.OrderTypeBestShop {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, "获取的订单数据失败,OrderType err")
	}
	orderGoods, _, err = orderGoodRepository.Find(domain.OrderGoodFindQuery{OrderId: orderData.Id})
	if err != nil {
		e := fmt.Sprintf("获取订单的商品(order_good)数据失败,order_id=%d,err=%s", orderData.Id, err)
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	orderData.Goods = orderGoods
	partnerInfo, err = partnerRepository.FindOne(domain.PartnerFindOneQuery{UserId: orderData.PartnerId})
	if err != nil {
		e := fmt.Sprintf("获取订单中的合伙人(partner)数据失败,id=%d,order_id=%d,err=%s", orderData.PartnerId, orderData.Id, err)
		logs.Error(e)
	}
	orderData.PartnerInfo = partnerInfo.Partner
	orderBestshopData, err = orderBestshopRepository.FindOne(domain.OrderBestshopFindOneQuery{OrderId: orderData.DataFrom.DataId})
	if err != nil {
		e := fmt.Sprintf("获取xiangmi订单(order_bestshop)数据失败,id=%d,err=%s", orderData.DataFrom.DataId, err)
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	orderGoodBestshop, err = orderGoodBestshopRepository.Find(domain.OrderGoodBestshopFindQuery{OrderId: orderBestshopData.Id})
	if err != nil {
		e := fmt.Sprintf("获取xiangmi订单货品(order_good_bestshop)数据失败,order_id=%d,err=%s", orderBestshopData.Id, err)
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, e)
	}
	orderBestshopData.Goods = orderGoodBestshop
	orderLogs, err = orderLogRepository.Find(domain.OrderLogFindQuery{OrderId: orderData.Id})
	if err != nil {
		e := fmt.Sprintf("获取订单的修改记录（order_log）失败,err=%s", err)
		logs.Error(e)
	}
	err = transactionContext.CommitTransaction()
	if err != nil {
		return nil, lib.ThrowError(lib.INTERNAL_SERVER_ERROR, err.Error())
	}
	result := service.buildOrderBestshopInfoData(orderData, orderBestshopData, orderLogs)
	return result, nil
}

//BuildOrderBestshopInfoData 构建前端需要的数据结构
func (service OrderInfoService) buildOrderBestshopInfoData(orderBase *domain.OrderBase,
	orderBestshop *domain.OrderBestShop, orderLogs []domain.OrderLog) interface{} {
	orderGoodBestshopMap := map[int64]*domain.OrderGoodBestShop{}
	for i := range orderBestshop.Goods {
		goodid := orderBestshop.Goods[i].Id
		orderGoodBestshopMap[goodid] = &orderBestshop.Goods[i]
	}
	//订单描述
	order := map[string]interface{}{
		"orderId":             orderBase.Id,
		"orderState":          orderBestshop.OrderState,
		"customers":           orderBestshop.BuyerName,
		"address":             orderBestshop.BuyerAddress,
		"remarks":             orderBestshop.BuyerRemark,
		"partner":             orderBase.PartnerInfo.PartnerName,
		"phone":               orderBestshop.BuyerPhone,
		"orderTime":           orderBestshop.OrderTime,
		"shippingStatus":      orderBestshop.DeliveryState,
		"partnerDividends":    orderBase.GetCurrentPartnerBonus(),
		"receivedDividends":   orderBase.OrderCompute.PartnerBonusHas,
		"notReceivedDividend": orderBase.OrderCompute.PartnerBonusNot,
		"dividendSpending":    orderBase.OrderCompute.PartnerBonusExpense,
		"orderNumber":         orderBase.OrderCode,
	}
	//订单中的商品
	product := map[string]interface{}{
		"orderNumCount":              orderBase.GetCurrentOrderCount(),
		"partnerDividendsCount":      orderBase.GetCurrentPartnerBonus(),
		"orderAmountAdjustmentCount": orderBase.GetCurrentOrderAmount(),
	}
	productDetail := []map[string]interface{}{}
	for i := range orderBase.Goods {
		detail := map[string]interface{}{
			"commodityName":    orderBase.Goods[i].GoodName,
			"productCodes":     "",
			"commodityCode":    "",
			"univalence":       orderBase.Goods[i].Price,
			"orderNum":         orderBase.Goods[i].GetCurrentGoodNumber(),
			"commodityPrice":   orderBase.Goods[i].GetCurrentAmount(),
			"partnerDividends": orderBase.Goods[i].GetCurrentPartnerBonus(),
			"productId":        orderBase.Goods[i].Id,
			"paymentStatus":    orderBase.Goods[i].BonusStatus,
			"partnerRatio":     orderBase.Goods[i].PartnerBonusPercent,
		}
		goodBestshopId := orderBase.Goods[i].DataFrom.DataId
		if v, ok := orderGoodBestshopMap[goodBestshopId]; ok {
			detail["productCodes"] = v.Sn
			detail["commodityCode"] = v.Bn
		}
		productDetail = append(productDetail, detail)
	}
	product["detail"] = productDetail
	modifyLog := []map[string]interface{}{}
	for i := range orderLogs {
		m := map[string]interface{}{
			"title":    orderLogs[i].LogAction,
			"time":     orderLogs[i].AlterTime.Local().Format("2006-01-02 15:04:05"),
			"userName": orderLogs[i].Operator,
			"id":       orderLogs[i].Id,
		}
		detail := []map[string]string{}
		for ii, vv := range orderLogs[i].Descript {
			d := map[string]string{
				"updateTitle": vv.Title,
				"id":          fmt.Sprint(ii),
				"content":     vv.Item,
			}
			if len(vv.Action) > 0 {
				d["content"] = vv.Item + ":" + strings.Join(vv.Action, ";")
			}
			detail = append(detail, d)
		}
		m["updateList"] = detail
		modifyLog = append(modifyLog, m)
	}

	result := map[string]interface{}{
		"order":   order,
		"product": product,
		"modify":  modifyLog,
		"remark":  orderBase.Remark.RemarkBonus,
	}
	return result
}

//UpdateBounsWithGoodNumber 分红时，因修改订单中商品的数量发生分红变动
func (service OrderInfoService) UpdateBonusByGoodNumber(orderId int64, goodId int64, adminId int64, goodNumber int, reason 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.UpdateBounsByGoodNumber(orderId, adminId, goodId, goodNumber, reason)
	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
}

//UpdateBounsByPartnerBonusPercent 分红时，因修改订单中商品的合伙人分行比例发生分红变动
func (service OrderInfoService) UpdateBonusByPartnerBonusPercent(orderId int64, goodId int64, adminId int64, percent float64, reason 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.UpdateBounsByPartnerBonusPercent(orderId, adminId, goodId, percent, reason)
	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
}

//PayPartnerBonusWithOrderBestshop 支付分红，海鲜干货的订单 （orderType=domain.OrderTypeBestShop）
func (service OrderInfoService) PayPartnerBonusWithOrderBestshop(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 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
}

//PayPartnerBonusWithOrderBestshop 支付分红，海鲜干货的订单 （orderType=domain.OrderTypeBestShop）
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
}