ZLJ_API_V6.0/代码/TVShoppingCa.../Controllers/Order/OrderControl...

/* =============================================
-- Author:		<Author,,zhangkun>
-- Create date: <Create Date,,20200618>
-- Description:	<Description,,订单相关操作）>
-- ============================================*/

using System;
using System.Collections.Generic;
using System.Common;
using System.Common.Helpers;
using System.Data;
using System.IRepositories;
using System.IRepositories.Bus;
using System.IRepositories.Cus;
using System.Linq;
using System.Linq.Expressions;
using System.Model;
using System.Model.Bus;
using System.Model.Cus;
using System.Repositories;
using System.Security.Claims;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Utility.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
using Microsoft.Extensions.Configuration;
using SqlSugar;
using TVShoppingCallCenter_ZLJ.Models.Inputs;

namespace TVShoppingCallCenter_ZLJ.Controllers.Order
{
    [Produces("application/json")]
    [Route("api/[controller]")]
    public class OrderController : BaseController
    {
        private readonly IBus_OrderDetailRepository bus_OrderDetailRepository;
        private readonly IBus_OrderRepository bus_OrderRepository;
        private readonly ISys_MarketingRepository bus_MarketingRepository;
        private readonly IBus_ProductRepository bus_productRepository;
        private readonly ICus_VipInfoRepository cus_vip_infoRepository;
        private readonly IBus_StockLogRepository bus_StockLogRepository;
        private readonly ICus_ScoreSetRepository cus_score_setRepository;
        private readonly IBus_OrderMoneyRepository busOrderMoneyRepository;
        private readonly IConfiguration config;
        private readonly IBus_AfterSaleRepository busAfterSaleRepository;
        private readonly IBus_OrderlogsRepository busOrderlogsRepository;
        private readonly IBus_ChatLogRepository bus_ChatLogRepository;
        private readonly ICus_MembershipRepository _cus_membershiprepository;
        private readonly ISys_UserAccountRepository _sys_useraccountRepository;
        private readonly OrderFunctionController busOrderFunctionController;

        public OrderController(IBus_OrderMoneyRepository _busOrderMoneyRepository,OrderFunctionController _OrderFunctionController,ICus_ScoreSetRepository _cus_score_setRepository, IBus_StockLogRepository _bus_StockLogRepository, IBus_OrderRepository _bus_OrderRepository, IBus_OrderDetailRepository _bus_OrderDetailRepository, ISys_MarketingRepository _bus_MarketingRepository, IBus_ProductRepository _productRepository, ICus_VipInfoRepository _cus_vip_infoRepository, IConfiguration _configuration, IBus_AfterSaleRepository _busAfterSaleRepository, IBus_OrderlogsRepository _busOrderlogsRepository, IBus_ChatLogRepository _bus_ChatLogRepository, ICus_MembershipRepository cus_membershiprepository
            , ISys_UserAccountRepository sys_useraccountRepository)
        {
            bus_OrderDetailRepository = _bus_OrderDetailRepository;
            bus_OrderRepository = _bus_OrderRepository;
            bus_MarketingRepository = _bus_MarketingRepository;
            bus_productRepository = _productRepository;
            cus_vip_infoRepository = _cus_vip_infoRepository;
            bus_StockLogRepository = _bus_StockLogRepository;
            cus_score_setRepository = _cus_score_setRepository;
            config = _configuration;
            busOrderFunctionController = _OrderFunctionController;
            busOrderMoneyRepository = _busOrderMoneyRepository;
            busAfterSaleRepository = _busAfterSaleRepository;
            busOrderlogsRepository = _busOrderlogsRepository;
            bus_ChatLogRepository = _bus_ChatLogRepository;
            _cus_membershiprepository = cus_membershiprepository;
            _sys_useraccountRepository = sys_useraccountRepository;
        }



        #region 
        /// <summary>
        /// 创建订单 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        //  [HttpPost("addorder")]
        /**public async Task<IActionResult> AddOrder([FromBody]OrderInput input)
        {
            try {
                T_Cus_VipInfo modelvip = new T_Cus_VipInfo();
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_ADFrom))
                    return Error("请输入选择广告来源");
                if (string.IsNullOrEmpty(input.F_Type))
                    return Error("请输入选择订单类型");
                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("请输入订单编号");
                if (string.IsNullOrEmpty(input.F_Customer))
                    return Error("请输入客户姓名");
                if (string.IsNullOrEmpty(input.F_CustomerPhone))
                    return Error("请输入客户电话");
                if (input.F_Type=="售后订单")
                    return Error("售后订单只能根据售后单自动创建");
                #endregion


                int exist = await bus_OrderRepository.GetCount(q => q.F_Id == input.F_Id);
                if (exist > 0)
                {
                    return Error("此订单号已存在");
                }

                T_Bus_Order modelOrder = new T_Bus_Order();
                #region 订单属性
                //必填
                modelOrder.F_ADFrom = input.F_ADFrom;
                modelOrder.F_Type = input.F_Type;
                modelOrder.F_Id = input.F_Id;

                modelOrder.F_Customer = input.F_Customer;
                modelOrder.F_CustomerPhone = input.F_CustomerPhone;

                if (input.F_RecommendId>0)
                {
                    modelOrder.F_RecommendId = input.F_RecommendId;
                    modelOrder.F_RecommendName = input.F_RecommendName;
                }
                if (input.F_CustomerType > 0)
                { modelOrder.F_CustomerType = input.F_CustomerType; }
                if (!string.IsNullOrEmpty(input.F_CustomerTel))
                { modelOrder.F_CustomerTel = input.F_CustomerTel; }
                //选填 快递属性
                 modelOrder.F_TrackingNo = ""; 
                if (!string.IsNullOrEmpty(input.F_Addressee))
                { modelOrder.F_Addressee = input.F_Addressee; }
                if (!string.IsNullOrEmpty(input.F_AddPhone))
                { modelOrder.F_AddPhone = input.F_AddPhone; }

                if (!string.IsNullOrEmpty(input.F_AddProvince))
                { modelOrder.F_AddProvince = input.F_AddProvince; }
                if (!string.IsNullOrEmpty(input.F_AddCity))
                { modelOrder.F_AddCity = input.F_AddCity; }
                if (!string.IsNullOrEmpty(input.F_AddArea))
                { modelOrder.F_AddArea = input.F_AddArea; }
                if (!string.IsNullOrEmpty(input.F_AddTown))
                { modelOrder.F_AddTown = input.F_AddTown; }

                if (!string.IsNullOrEmpty(input.F_AddDes))
                { modelOrder.F_AddDes = input.F_AddDes; }
                if (!string.IsNullOrEmpty(input.F_Address))
                { modelOrder.F_Address = input.F_Address; }
                if (!string.IsNullOrEmpty(input.F_PostalCode))
                { modelOrder.F_PostalCode = input.F_PostalCode; }
                if (!string.IsNullOrEmpty(input.F_Express))
                { modelOrder.F_Express = input.F_Express; }
                if (!string.IsNullOrEmpty(input.F_Remark))
                { modelOrder.F_Remark = input.F_Remark; }
                if (!string.IsNullOrEmpty(input.F_PayType))
                { modelOrder.F_PayType = input.F_PayType; }
                if 
                    (input.F_VipId > 0)
                { modelOrder.F_VipId = input.F_VipId; }
                else
                {
                    var vip = await cus_vip_infoRepository.GetListALL(x => x.F_Phone == input.F_CustomerPhone
                    && x.F_State == 1);
                    if (vip != null && vip.Count > 0)
                        modelOrder.F_VipId = vip.FirstOrDefault().F_ID;
                    else
                        modelOrder.F_VipId = 0;
                }
                if (input.F_Belong > 0)
                { 
                    modelOrder.F_Belong = input.F_Belong;
                    modelOrder.F_BelongName = input.F_BelongName;
                }
                else 
                { 
                    modelOrder.F_Belong = UserLogin.UserId.ObjToInt();
                    modelOrder.F_BelongName = UserLogin.UserName;
                }


                modelOrder.F_ExpressFee = input.F_ExpressFee;
                modelOrder.F_Stock = input.F_Stock;
                

                modelOrder.F_RealPrice = input.F_RealPrice;
                modelOrder.F_UseScore = input.F_UseScore;
                //选填 关联属性
                modelOrder.F_State = input.F_State;
                modelOrder.F_Status = 0;


                //必须属性 系统生成
                modelOrder.F_AddTime = DateTime.Now;
                modelOrder.F_AddUser = UserLogin.UserId.ObjToInt();
                modelOrder.F_AddUserName = UserLogin.UserName;


                #endregion

                if (input.F_State == 1)
                {
                    if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                    { }
                    else
                    { return Error("请选择订购商品"); }
                        if (string.IsNullOrEmpty(input.F_Stock))
                    {
                        return Error("请选择出库货仓");
                    }
                    if (string.IsNullOrEmpty(modelOrder.F_Express))
                    {
                        return Error("快递不能为空");
                    }
                    if (string.IsNullOrEmpty(modelOrder.F_AddPhone))
                    {
                        return Error("收件人电话不能为空");
                    }
                    if (string.IsNullOrEmpty(modelOrder.F_AddTown))
                    {
                        return Error("收件人地址不能为空");
                    }
                    if (string.IsNullOrEmpty(modelOrder.F_Address))
                    {
                        return Error("收件人详细地址不能为空");
                    }
                }

                decimal totle = 0.00M;
                decimal ActivityMoney = 0.00M;
                string UseActivity = "";
                string UseActivity4 = ",";
                string UseActivity2 = ",";
                List<T_Bus_OrderDetail> modelDetailList = new List<T_Bus_OrderDetail>();

                #region 订单详情列表核算
                if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                {
                    int n = 1;
                    int n2 = input.OrderDetailList.Count + 1;
                    #region 活动核算
                    if (input.UseActList != null && input.UseActList.Count > 0)
                    {
                        //遍历所有选中的活动
                        foreach (UseActInput act in input.UseActList)
                        {
                            UseActivity += act.id + ",";
                            //满赠
                            if (act.type == 1)
                            {
                                string[] productidlist = act.gift.Split(',');
                                foreach (string giftid in productidlist)
                                {
                                    T_Bus_Product m = await bus_productRepository.GetSingle(b => ("," + giftid + ",").Contains("," + b.F_ProductId + ",") && b.F_IsSale == 0);
                                    if (m != null)
                                    {
                                        T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                                        modelDetail.F_ProductName = m.F_ProductName;
                                        modelDetail.F_ProductId = m.F_ProductId;
                                        modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                                        modelDetail.F_OrderId = input.F_Id;
                                        modelDetail.F_Count = 1;
                                        modelDetail.F_Price = 0.00M;
                                        modelDetail.F_DealPrice = 0.00M;
                                        modelDetail.F_Sort = n2;
                                        modelDetail.F_Remark = "赠品-活动：" + act.id;
                                        modelDetail.F_AddUser = modelOrder.F_AddUser;
                                        modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                                        modelDetail.F_TotlePrice = 0.00M;
                                        modelDetail.F_Activity = act.id;
                                        modelDetail.F_AddTime = DateTime.Now;
                                        modelDetailList.Add(modelDetail);
                                        n2++;
                                    }
                                }

                            }
                            //生日赠
                            else if (act.type == 2)
                            {
                                UseActivity2 += act.gift + ",";
                            }
                            //满减
                            else if (act.type == 3)
                            {
                                ActivityMoney += act.money;
                            }
                            else if (act.type == 4)
                            {
                                UseActivity4 += act.gift + ",";
                            }
                        }
                        UseActivity = UseActivity.Trim(',');
                    }
                    #endregion

                    #region 商品核算
                    foreach (OrderDetailInput m in input.OrderDetailList)
                    {
                        T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                        if (modelProduct == null)
                            return Error("商品不存在:" + m.F_ProductId);
                        T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                        modelDetail.F_ProductName = modelProduct.F_ProductName;
                        modelDetail.F_ProductId = modelProduct.F_ProductId;
                        modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        modelDetail.F_OrderId = input.F_Id;
                        modelDetail.F_Count = m.F_Count;
                        modelDetail.F_Price = modelProduct.F_MemberPrice;
                        //参加活动特价
                        if (UseActivity4.Contains("," + modelProduct.F_ProductId + ","))
                            modelDetail.F_DealPrice = modelProduct.F_SpecialPrice;
                        else
                            modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                        //参加生日
                        if (UseActivity2.Contains("," + modelProduct.F_ProductId + ","))
                        {
                            modelDetail.F_DealPrice = 0.00M;
                            modelDetail.F_Remark = "生日赠品-活动：";
                        }

                        modelDetail.F_Sort = n;
                        modelDetail.F_AddTime = DateTime.Now;

                        modelDetail.F_AddUser = modelOrder.F_AddUser;
                        modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                        modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                        modelDetail.F_Activity = 0;
                        if (modelProduct.F_Tag.IndexOf(".") > -1&& !string.IsNullOrEmpty(UseActivity))
                        {
                            string[] tagarry = modelProduct.F_Tag.Split(',');
                            string[] actlist = UseActivity.Split(',');
                            string tag = tagarry.First(a => a.StartsWith(".")).ToString();
                            T_Sys_Marketing modelactive = await bus_MarketingRepository.GetFirst(b => actlist.Contains(b.F_ID.ToString())&& b.F_EndTime >= DateTime.Now && b.F_StartTime <= DateTime.Now && b.F_IsDelete == 0 && ("," + b.F_Commodity + ",").Contains(("," + tag + ",")));


                            //此商品参加活动
                            if (modelactive != null)
                            {
                                modelDetail.F_Activity = modelactive.F_ID;
                            }
                        }
                        else { modelDetail.F_Activity = 0; }

                        totle += modelDetail.F_TotlePrice;
                        modelDetailList.Add(modelDetail);

                        n++;
                    }
                    #endregion

                    modelOrder.F_TotlePrice = totle;
                    modelOrder.F_ActivityMoney = ActivityMoney;
                    modelOrder.F_UseActivity = UseActivity;
                }
                else
                {
                    //不改变订单
                }
                #endregion

                //订单完成后也不计算积分
                modelOrder.F_Score = 0.00M;
                T_Cus_ScoreSet modelscore = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                if (modelscore == null)
                {
                    modelscore = new T_Cus_ScoreSet();
                    modelscore.F_Start = 0;
                    modelscore.F_StartDebit = 1;
                    modelscore.F_DebitPercent = 1000;
                }


                #region 直接提交  锁库存log  锁积分log

                if (input.F_State == 1)
                {

                    if (modelscore.F_StartDebit == 0 || modelOrder.F_VipId == 0)
                    {
                        modelOrder.F_UseScore = 0;
                    }
                    modelOrder.F_FlowNum =  DateTime.Now.ToString("yyMMddHHmmss")+"U" + UserLogin.UserId +"R"+ new Random().Next(9);
                    string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 1, modelDetailList);
                    if (strStock != "1")
                    { return Error(strStock); }
                    if (modelscore.F_Start == 1)
                    {
                        //订单完成后计算积分
                        modelOrder.F_Score = -0.01M;
                    }

                    modelOrder.F_SubmitTime = DateTime.Now;
                }

                #endregion
                //计算结果  积分有规则            
                modelOrder.F_ShouldPrice = modelOrder.F_TotlePrice - ActivityMoney + modelOrder.F_ExpressFee- modelOrder.F_UseScore / modelscore.F_DebitPercent;


                    modelOrder.F_PayState = 0;
                



                if (await bus_OrderRepository.AddReturnCount(modelOrder))
                {
                    if (modelDetailList != null && modelDetailList.Count > 0)
                    {
                        if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                            return Success("订单添加成功2");
                        else
                            return Error("订单添加失败,请重试！1");
                    }
                    return Success("订单添加成功1");
                }
                else
                {
                    return Error("订单添加失败,请重试！2");
                }
            }
            catch (Exception ex)
            { return Error(ex.Message); }
        }**/
        #endregion
        /// <summary>
        /// 创建订单 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("addorder")]
        public async Task<IActionResult> AddOrder([FromBody]OrderInput input)
        {
            try
            {
                #region 验证参数 必填项  
                if (string.IsNullOrEmpty(input.F_ADFrom))
                    return Error("请输入选择广告来源");
                if (string.IsNullOrEmpty(input.F_Type))
                    return Error("请输入选择订单类型");
                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("请输入订单编号");
                if (string.IsNullOrEmpty(input.F_Customer))
                    return Error("请输入客户姓名");
                if (string.IsNullOrEmpty(input.F_AddPhone))
                {
                    return Error("收件人电话不能为空");
                }
                if (string.IsNullOrEmpty(input.F_AddProvince ))
                {
                    return Error("收件人省份不能为空");
                }
                if (string.IsNullOrEmpty(input.F_AddCity ))
                {
                    return Error("收件人城市不能为空");
                }
                if (string.IsNullOrEmpty(input.F_AddArea ))
                {
                    return Error("收件人区/县不能为空");
                }
                if (string.IsNullOrEmpty(input.F_Address ))
                {
                    return Error("收件人详细地址不能为空");
                }
                if (string.IsNullOrEmpty(input.F_CustomerPhone))
                    return Error("请输入客户电话");
                if (input.F_Type == "售后订单")
                    return Error("售后订单只能根据售后单自动创建");
                #endregion
                int exist = await bus_OrderRepository.GetCount(q => q.F_Id == input.F_Id);
                if (exist > 0)
                {
                    return Error("此订单号已存在");
                }
                T_Bus_Order modelOrder = new T_Bus_Order();
                #region 订单属性
                //必填
                modelOrder.F_ADFrom = input.F_ADFrom;
                modelOrder.F_Type = input.F_Type;
                modelOrder.F_Id = input.F_Id;
                modelOrder.F_Customer = input.F_Customer;
                modelOrder.F_CustomerPhone = input.F_CustomerPhone;
                if (input.F_RecommendId > 0)
                {
                    modelOrder.F_RecommendId = input.F_RecommendId;
                    modelOrder.F_RecommendName = input.F_RecommendName;
                }
                if (input.F_CustomerType > 0)
                { modelOrder.F_CustomerType = input.F_CustomerType; }
                if (!string.IsNullOrEmpty(input.F_CustomerTel))
                { modelOrder.F_CustomerTel = input.F_CustomerTel; }
                //选填 快递属性
                modelOrder.F_TrackingNo = "";
                if (!string.IsNullOrEmpty(input.F_Addressee))
                { modelOrder.F_Addressee = input.F_Addressee; }
                if (!string.IsNullOrEmpty(input.F_AddPhone))
                { modelOrder.F_AddPhone = input.F_AddPhone; }

                if (!string.IsNullOrEmpty(input.F_AddProvince))
                { modelOrder.F_AddProvince = input.F_AddProvince; }
                if (!string.IsNullOrEmpty(input.F_AddCity))
                { modelOrder.F_AddCity = input.F_AddCity; }
                if (!string.IsNullOrEmpty(input.F_AddArea))
                { modelOrder.F_AddArea = input.F_AddArea; }
                if (!string.IsNullOrEmpty(input.F_AddTown))
                { modelOrder.F_AddTown = input.F_AddTown; }
                if (!string.IsNullOrEmpty(input.F_AddDes))
                { modelOrder.F_AddDes = input.F_AddDes; }
                if (!string.IsNullOrEmpty(input.F_Address))
                { modelOrder.F_Address = input.F_Address; }
                if (!string.IsNullOrEmpty(input.F_PostalCode))
                { modelOrder.F_PostalCode = input.F_PostalCode; }
                // if (!string.IsNullOrEmpty(input.F_Express))
                //   { modelOrder.F_Express = input.F_Express; }
              
                if (!string.IsNullOrEmpty(input.F_Remark))
                { modelOrder.F_Remark = input.F_Remark; }
                if (!string.IsNullOrEmpty(input.F_PayType))
                { modelOrder.F_PayType = input.F_PayType; }
                if
                    (input.F_VipId > 0)
                { modelOrder.F_VipId = input.F_VipId; }
                else
                {
                    var vip = await cus_vip_infoRepository.GetListALL(x => x.F_Phone == input.F_CustomerPhone
                    && x.F_State == 1);
                    if (vip != null && vip.Count > 0)
                        modelOrder.F_VipId = vip.FirstOrDefault().F_ID;
                    else
                        modelOrder.F_VipId = 0;
                }
                var modelvip= await cus_vip_infoRepository.GetSingle (x => x.F_ID  == modelOrder.F_VipId);
                if (modelvip!=null )
                {
                    modelOrder.F_Belong = modelvip.F_Saleperson.ObjToInt();
                    var user = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_Belong);
                    modelOrder.F_BelongName = user.F_UserName ;
                    if (modelOrder.F_AddTime!=null )
                    {
                      TimeSpan time = modelOrder.F_AddTime - DateTime.Now;
                        if (time.Days >3)
                        {
                            modelOrder.F_Type = "回访";
                        }
                        else
                        {
                            modelOrder.F_Type = "热线";
                        }
                    }
                       
                }
                else if (input.F_Belong > 0)
                {
                    modelOrder.F_Belong = UserLogin.UserId .ObjToInt();
                    modelOrder.F_BelongName = UserLogin.UserName;
                }
                
                if (input .F_Media>0)
                {
                    modelOrder.F_Media = input.F_Media;
                    modelOrder.F_MediaName  = input.F_MediaName;
                }
                var useraccount = await _sys_useraccountRepository.GetSingle(x => x.F_UserId  == modelvip.F_Saleperson.ObjToInt());

                if (useraccount != null )
                {
                  modelOrder.F_Department = useraccount.F_DeptId;
                  modelOrder.F_Core = useraccount.F_DeptTeamId ;
                  modelOrder.F_Group = useraccount.F_GroupId;
                }
                
              modelOrder.F_ExpressFee = input.F_ExpressFee;
                //  modelOrder.F_Stock = input.F_Stock;
                modelOrder.F_IsExpress = 0;
                modelOrder.F_RealPrice = input.F_RealPrice;
                modelOrder.F_MemberNotes = input.F_MemberNotes;//会员备注
                modelOrder.F_UseScore = input.F_UseScore;


              
             
               
                    modelOrder.F_State = 0;
                //选填 关联属性
               
                modelOrder.F_Status = 0;
               
                modelOrder.F_IsPayment = input.F_IsPayment;
               
                //必须属性 系统生成
                modelOrder.F_AddTime = DateTime.Now;
                modelOrder.F_AddUser = UserLogin.UserId.ObjToInt();
                modelOrder.F_AddUserName = UserLogin.UserName;


                #endregion
                   
                decimal totle = 0.00M;
                decimal ActivityMoney = 0.00M;
                string UseActivity = "";
                string UseActivity4 = ",";
                string UseActivity2 = ",";
                string Eventprice = "";
                Dictionary<string, decimal> innerCompute = new Dictionary<string, decimal>();
                List<T_Bus_OrderDetail> modelDetailList = new List<T_Bus_OrderDetail>();
                Dictionary<string, int> innerEventprice = new Dictionary<string, int >();
                #region 订单详情列表核算
                if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                {
                    int n = 1;
                    int n2 = input.OrderDetailList.Count + 1;
                    #region 活动核算
                    if (input.UseActList != null && input.UseActList.Count > 0)
                    {
                        //遍历所有选中的活动
                        foreach (UseActInput act in input.UseActList)
                        {
                            UseActivity += act.id + ",";
                            //满赠
                            //if (act.type == 1)
                            //{
                            //    string[] productidlist = act.gift.Split(',');
                            //    foreach (string giftid in productidlist)
                            //    {
                            //        T_Bus_Product m = await bus_productRepository.GetSingle(b => ("," + giftid + ",").Contains("," + b.F_ProductId + ",") && b.F_IsSale == 0);
                            //        if (m != null)
                            //        {
                            //            T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                            //            modelDetail.F_ProductName = m.F_ProductName;
                            //            modelDetail.F_ProductId = m.F_ProductId;
                            //            modelDetail.F_Specifications = m.F_Specifications;
                            //            modelDetail.F_ProductShortName = m.F_ProductShortName;
                            //            modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                            //            modelDetail.F_OrderId = input.F_Id;
                            //            modelDetail.F_Count = 1;
                            //            modelDetail.F_Price = 0.00M;
                            //            modelDetail.F_DealPrice = 0.00M;
                            //            modelDetail.F_Sort = n2;
                            //            modelDetail.F_Remark = "赠品-活动：" + act.id;
                            //            modelDetail.F_AddUser = modelOrder.F_AddUser;
                            //            modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                            //            modelDetail.F_TotlePrice = 0.00M;
                            //            modelDetail.F_Activity = act.id;
                            //            modelDetail.F_AddTime = DateTime.Now;
                                       
                            //            modelDetailList.Add(modelDetail);
                            //            n2++;
                            //        }
                            //    }

                            //}
                            ////生日赠
                            //else 
                            if (act.type == 2)
                            {
                                UseActivity2 += act.gift + ",";
                            }
                            //满减
                            else if (act.type == 3)
                            {
                                ActivityMoney += act.money;
                                if (string.IsNullOrEmpty(Eventprice))
                                    Eventprice = "" + act.id + "," + act.money;
                                else
                                    Eventprice += "|" + act.id + "," + act.money;
                            }
                            else if (act.type == 4)
                            {
                                UseActivity4 += act.gift + ",";
                                innerCompute.Add(act.gift, act.money);
                                innerEventprice.Add(act.gift, act.id );
                            }
                        }
                        UseActivity = UseActivity.Trim(',');
                    }
                    #endregion
                    modelOrder.F_IsZeroCommodity = 0;
                    #region 商品核算
                    foreach (OrderDetailInput m in input.OrderDetailList)
                    {
                        T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                        if (modelProduct == null)
                            return Error("商品不存在:" + m.F_ProductName );
                       if (modelProduct.F_OnSaleEnd<DateTime .Now &&UserLogin.RoleCode != "SH")
                        {
                            return Error ("商品已下架:" + m.F_ProductName);
                        }
                       
                        if (!modelOrder.F_Type.Contains("售后"))
                        {
                           // List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(modelProduct.F_ProductId, "新乡仓");
                            if (modelProduct.F_MinimumStock+ m.F_Count > modelProduct.F_Stock1 )
                            {
                                return Error(m.F_ProductName + "数量库存低于" + modelProduct.F_MinimumStock + "不能添加");
                            }
                        }
                        T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                        modelDetail.F_ProductName = modelProduct.F_ProductName;
                        modelDetail.F_ProductId = modelProduct.F_ProductId;
                        modelDetail.F_Specifications = modelProduct.F_Specifications;
                        modelDetail.F_ProductShortName = modelProduct.F_ProductShortName;
                        modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        modelDetail.F_OrderId = input.F_Id;
                        modelDetail.F_Count = m.F_Count;
                        modelDetail.F_Price = modelProduct.F_MemberPrice;
                        //参加活动特价
                        if (UseActivity4.Contains("," + modelProduct.F_ProductId + ","))
                        {
                            
                            if (innerCompute.ContainsKey (modelProduct.F_ProductId))
                            {
                                ActivityMoney += innerCompute[modelProduct.F_ProductId] * m.F_Count;
                                if (!string .IsNullOrEmpty (Eventprice))
                                Eventprice += "|" + innerEventprice[modelProduct.F_ProductId] + "," + innerCompute[modelProduct.F_ProductId] * m.F_Count;
                                else
                                    Eventprice += "" + innerEventprice[modelProduct.F_ProductId] + "," + innerCompute[modelProduct.F_ProductId] * m.F_Count;
                            }
                          
                        }
                            modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                        //参加生日
                        if (UseActivity2.Contains("," + modelProduct.F_ProductId + ","))
                        {
                            modelDetail.F_DealPrice = 0.00M;
                            modelDetail.F_Remark = "生日赠品-活动：";
                        }
                        if (modelProduct.F_ClassName =="袜子" && modelDetail.F_DealPrice == 0)
                        {
                            modelOrder.F_IsZeroCommodity = 1;
                        }
                        modelDetail.F_Sort = n;
                        modelDetail.F_AddTime = DateTime.Now;

                        modelDetail.F_AddUser = modelOrder.F_AddUser;
                        modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                        modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                        modelDetail.F_Activity = 0;
                        if (modelProduct.F_Tag.IndexOf(".") > -1 && !string.IsNullOrEmpty(UseActivity))
                        {
                            string[] tagarry = modelProduct.F_Tag.Split(',');
                            string[] actlist = UseActivity.Split(',');
                            string tag = tagarry.First(a => a.StartsWith(".")).ToString();
                            T_Sys_Marketing modelactive = await bus_MarketingRepository.GetFirst(b => actlist.Contains(b.F_ID.ToString()) && b.F_EndTime >= DateTime.Now && b.F_StartTime <= DateTime.Now && b.F_IsDelete == 0 && ("," + b.F_Commodity + ",").Contains(("," + tag + ",")));


                            //此商品参加活动
                            if (modelactive != null)
                            {
                                modelDetail.F_Activity = modelactive.F_ID;
                            }
                        }
                        else { modelDetail.F_Activity = 0; }

                        totle += modelDetail.F_TotlePrice;
                        modelDetailList.Add(modelDetail);

                        n++;
                    }
                    #endregion

                    modelOrder.F_TotlePrice = totle;
                    modelOrder.F_ActivityMoney = ActivityMoney;
                    modelOrder.F_Eventprice = Eventprice;
                    modelOrder.F_UseActivity = UseActivity;
                }
                else
                {
                    //不改变订单
                }
                #endregion
               
              

                    //  modelOrder.F_TotlePrice += input.F_ExpressFee;//订单总额（包括快递费）
                    modelOrder.F_RecommenderTel = input.F_RecommenderTel;
                modelOrder.F_PayState = 0;
                if (input .F_State ==1)
                {
                    if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                    { }
                    else
                    { return Error("请选择订购商品"); }
                 
                    //List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                    //    if (modelDetailList != null && modelDetailList.Count > 0)
                    //    {
                    //        foreach (var it in modelDetailList)
                    //        {
                    //            T_Bus_Product t_Bus_Product = await bus_productRepository.GetSingle(x => x.F_ProductId == it.F_ProductId);

                    //            if (t_Bus_Product != null)
                    //            {
                                  
                    //                List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(it.F_ProductId, "新乡仓");
                               
                    //              t_Bus_Product.F_UseNumber += it.F_Count;
                    //              if (listStock1!=null && listStock1.Count > 0)
                    //              {
                    //                if (t_Bus_Product.F_UseNumber > listStock1[0].qty)
                    //                {
                    //                    return Error("提交失败,可配量不足.");
                    //                }
                    //                else
                    //                {
                    //                    Productlist.Add(t_Bus_Product);
                    //                }
                    //              }
                    //              else
                    //                return Error("提交失败,可配量不足.");


                    //        }
                    //            else
                    //            {
                    //            return Error("提交失败,商品不存在");
                    //            }
                               
                    //        }
                    //    await bus_productRepository.UpdateList(Productlist);
                    //   }
                        modelOrder.F_SubmitTime = DateTime.Now;
                        if (modelOrder.F_IsPayment > 0|| modelOrder.F_PayType != "货到付款")
                            modelOrder.F_State = 7;
                        else
                            modelOrder.F_State = 0;

                        modelOrder.F_FlowNum = DateTime.Now.ToString("yyMMddHHmmss") + "U" + UserLogin.UserId + "R" + new Random().Next(9);
                }
                T_Cus_ScoreSet modelscore = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                if (modelscore == null)
                {
                    modelscore = new T_Cus_ScoreSet();
                    modelscore.F_Start = 0;
                    modelscore.F_StartDebit = 1;
                    modelscore.F_DebitPercent = 1000;
                }
                string count = UserLogin.UserName + "创建订单";
                if (!modelOrder.F_Type.Contains("售后"))
                {
                   
                    
                    string a = string.Format("{0:f0}", Math.Floor(modelOrder.F_UseScore / modelscore.F_DebitPercent));
                    modelOrder.F_ShouldPrice = modelOrder.F_TotlePrice - modelOrder.F_ActivityMoney - int.Parse(a) + input.F_ExpressFee; if (input.OrderUserGift != null && input.OrderUserGift.Count > 0)
                    {
                        decimal moneys = 0.00M;
                        if (modelvip.F_Money != null)
                        {
                            moneys= (decimal)modelvip.F_Money + modelOrder.F_ShouldPrice;
                        }
                        else
                            moneys = modelOrder.F_ShouldPrice;

                        int b = 0;
                        if (moneys > 3000)
                        {
                            decimal fund = moneys - 3000;
                            string c = string.Format("{0:f0}", Math.Floor(fund / 2000));
                             b = int.Parse(c) + 1 - modelvip.F_UseGift;
                        }
                        int n2 = 0;
                        foreach (var m in input.OrderUserGift)
                        {
                            T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                            modelDetail.F_ProductName = m.F_ProductName;
                            modelDetail.F_ProductId = m.F_ProductId;
                            modelDetail.F_Specifications = m.F_Specifications;
                            modelDetail.F_ProductShortName = m.F_ProductShortName;
                            modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                            modelDetail.F_OrderId = input.F_Id;
                            modelDetail.F_Count = 1;
                            modelDetail.F_Price = 0.00M;
                            modelDetail.F_DealPrice = 0.00M;
                            modelDetail.F_Sort = n2;
                            modelDetail.F_Remark = "满赠营销" ;
                            modelDetail.F_AddUser = modelOrder.F_AddUser;
                            modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                            modelDetail.F_TotlePrice = 0.00M;
                            modelDetail.F_Activity =0;
                            modelDetail.F_AddTime = DateTime.Now;
                            modelDetailList.Add(modelDetail);
                            n2++;
                        }
                        if (n2> b)
                        {
                            return Error("该会员最多可赠送"+ b+"件赠品");
                        }
                        else
                        {
                            modelvip.F_UseGift += n2;
                            modelOrder.F_UseGift = n2;
                        }
                    }
                    if (modelvip != null)
                    {
                        modelvip.F_Score -= modelOrder.F_UseScore;
                      //  modelvip.F_TotalScore  -= modelOrder.F_UseScore;
                        await cus_vip_infoRepository.Update(modelvip);
                    }
                    //订单完成后也不计算积分

                    if (input.F_State == 1)
                    {
                        if (modelOrder.F_State == 1)
                           count += "进入客服待分仓";
                        else if (modelOrder.F_State == 7)
                            count += "进入客服待付款待审核";
                    }
                    else
                        count += "进入销售待提交";
                }

                if (input.F_IsPayment > 0 || input.F_PayType != "货到付款")
                {
                    try
                    {
                        #region 验证参数 必填项  

                        if (string.IsNullOrEmpty(input.F_Id))
                            return Error("请输入订单号");
                        if (string.IsNullOrEmpty(input.F_PayType))
                            return Error("请选择付款方式");
                        //  if (string.IsNullOrEmpty(input.OrderMoney.F_RemarkKF))
                        //  input.OrderMoney.F_RemarkKF = "";
                        if (string.IsNullOrEmpty(input.OrderMoney.F_RemarkXS))
                            input.OrderMoney.F_RemarkXS = "";

                        // if (input.OrderMoney.F_PayTime == null)
                        // return Error("请选择打款时间");
                        if (input.OrderMoney.F_Money <= 0)
                            return Error("请输入付款金额");
                      
                        #endregion
                        modelOrder.F_RealPrice = input.OrderMoney.F_Money;
                        T_Bus_OrderMoney modelOrderMoeny = new T_Bus_OrderMoney();
                        ModelConvertHelper<T_Bus_OrderMoney, OrderMoneyInput>.ModeToModelDefault(modelOrderMoeny, input.OrderMoney);
                        modelOrderMoeny.F_AddUserId = UserLogin.UserId.ObjToInt();
                        modelOrderMoeny.F_UserName = UserLogin.UserName;
                        modelOrderMoeny.F_MoneyBak = modelOrderMoeny.F_Money;
                        modelOrderMoeny.F_State = 0;
                        modelOrderMoeny.F_Type = 1;
                        modelOrderMoeny.F_OrderId = input.F_Id;
                        modelOrderMoeny.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        if (!await busOrderMoneyRepository.AddReturnCount(modelOrderMoeny))
                            return Error("付款失败");
                    }
                    catch (Exception ex)
                    { return Error(ex.Message); }
                }
                int t = await AddLog(modelOrder.F_Id, count, UserLogin.UserCode , modelOrder.F_State);
                if (t >0)
                {
                    if (await bus_OrderRepository.AddReturnCount(modelOrder))
                    {
                        if (modelDetailList != null && modelDetailList.Count > 0)
                        {
                            if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                            {

                                return Success("订单添加成功2");

                            }

                            else
                                return Error("订单添加失败,请重试！1");
                        }
                        return Success("订单添加成功1");
                    }
                }
                    return Error("订单添加失败,请重试！2");
                
            }
            catch (Exception ex)
            { return Error(ex.Message); }
        }
        /// <summary>
        /// 获取总金额
        /// </summary>
        /// <param name="OrderDetailList"></param>
        /// <param name="UseActList"></param>
        /// <returns></returns>
        [HttpPost("getPrice")]
        public async Task<IActionResult> GetPrice(List<OrderDetailInput> OrderDetailList
            , List<UseActInput> UseActList, decimal F_ExpressFee =0, decimal UseScore =0)
        {
            decimal totle = 0.00M;
            decimal ActivityMoney = 0.00M;
            string UseActivity = "";
            string UseActivity4 = ",";
            string UseActivity2 = ",";
            decimal TotlePrice = 0.00M;
            Dictionary<string, decimal> innerCompute = new Dictionary<string, decimal>();
            List<T_Bus_OrderDetail> orderDetails = new List<T_Bus_OrderDetail>();
            if (OrderDetailList != null && OrderDetailList.Count > 0)
            {
                int n = 1;
                int n2 = OrderDetailList.Count + 1;
                #region 活动核算
                if (UseActList != null && UseActList.Count > 0)
                {
                    //遍历所有选中的活动
                    foreach (UseActInput act in UseActList)
                    {
                        UseActivity += act.id + ",";
                        
                        if (act.type == 2)
                        {
                            UseActivity2 += act.gift + ",";
                        }
                        //满减
                        else if (act.type == 3)
                        {
                           
                            ActivityMoney += act.money;
                        }
                        else if (act.type == 4)
                        {
                            UseActivity4 += act.gift + ",";
                            innerCompute.Add(act.gift, act.money);
                           
                        }
                    }
                    UseActivity = UseActivity.Trim(',');
                }
                #endregion

                #region 商品核算
              
                foreach (OrderDetailInput m in OrderDetailList)
                {
                    T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                    if (modelProduct == null)
                        return Error("商品不存在:" + m.F_ProductName );
                    if (modelProduct.F_OnSaleEnd < DateTime.Now && UserLogin.RoleCode != "SH")
                    {
                        return Error("商品已下架:" + m.F_ProductName);
                    }
                //  List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(modelProduct.F_ProductId, "新乡仓");
                    if (modelProduct.F_MinimumStock + m.F_Count > modelProduct.F_Stock1 )
                    {
                        return Error(m.F_ProductName + "数量库存低于" + modelProduct.F_MinimumStock + "不能添加");
                    }
                    T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                    //参加活动特价
                    if (UseActivity4.Contains("," + modelProduct.F_ProductId + ","))
                    {if (innerCompute.ContainsKey (modelProduct.F_ProductId))
                        {
                            ActivityMoney += innerCompute[modelProduct.F_ProductId] * m.F_Count;
                        }
                   
                    }
                   
                        modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                    //参加生日
                    if (UseActivity2.Contains("," + modelProduct.F_ProductId + ","))
                    {
                        modelDetail.F_DealPrice = 0.00M;
                        modelDetail.F_Remark = "生日赠品-活动：";
                    }
                    modelDetail.F_ProductId = modelProduct.F_ProductId;
                    modelDetail.F_ProductName  = modelProduct.F_ProductName;
                    modelDetail.F_Count = m.F_Count;
                    modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                    orderDetails.Add(modelDetail);
                    totle += modelDetail.F_TotlePrice;
                    TotlePrice += modelDetail.F_TotlePrice; ;

                    n++;
                }
                #endregion
               
            }
            else
            {
                //不改变订单
            }
            T_Cus_ScoreSet modelscore = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
            
            string a = string.Format("{0:f0}", Math.Floor(UseScore / modelscore.F_DebitPercent));


            totle += F_ExpressFee - ActivityMoney-int .Parse ( a);
            var obj = new
            {
                orderDetails,
                TotlePrice,
                totle
            };
            return Content(obj.ToJson()); ;
        }


        /// <returns></returns>
        [HttpGet("UseGift")]
        public async Task<IActionResult> UseGift(int vip = 0, decimal money = 0)
        {
            if (vip <= 0)
                return Error("请选择会员");
            var model = await cus_vip_infoRepository.GetSingleV(x => x.F_ID == vip && x.F_State == (int)EnumDelState.Enabled);
            if (model == null)
                return Error("该会员不存在");
            decimal moneys = 0.00M;
            if (model.F_Money != null)
            {
                moneys = (decimal)model.F_Money + money;
            }
            else
                moneys = money;
            if (moneys > 3000)
            {
                decimal fund = moneys - 3000;
                string a = string.Format("{0:f0}", Math.Floor(fund / 2000));
                int b = int.Parse(a) + 1- model.F_UseGift  ;
                return Success("获取成功", b);
            }
            else
                return Success("获取成功", 0);
        }
        /// <summary>
        /// 获取最大可使用积分
        /// </summary>
        /// <param name="OrderDetailList"></param>
        /// <param name="UseActList"></param>
        /// <returns></returns>
        [HttpGet("deductible")]
        public async Task<IActionResult> Deductible(int vip=0,decimal   money=0)
        {
            if (vip <= 0)
                return Error("请选择会员");
            var model = await cus_vip_infoRepository .GetSingleV(x => x.F_ID == vip && x.F_State == (int)EnumDelState.Enabled);
            if (model==null )
                return Error("该会员不存在");
            var score = await cus_score_setRepository .GetSingle(x => x.F_State == 1);
           if (model.F_Score>0)
            {
                string a = string.Format("{0:f0}", Math.Floor((decimal)model.F_Score / score.F_DebitPercent));
                string Score = "";  int moneys = 0;
                if (money <= int.Parse(a))
                {
                    moneys = (int)money;
                    Score = string.Format("{0:f0}", (int)money * score.F_DebitPercent);
                }
                else
                {
                    moneys = int.Parse(a);
                    Score = string.Format("{0:f0}", int.Parse(a) * score.F_DebitPercent);
                }
                  
                var obj = new
                {
                    Score,
                    moneys
                };
                return Content(obj.ToJson());

            }
           else
                return Success("获取成功", 0);
        }
        
        /// <summary>
        /// 提交订单 Audit payment
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("submit")]
        public async Task<IActionResult> Submit(string orderids)
        {
            string msg = "";
            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            string[] ids = orderids.Split(',');

         //   List<EBossStock> listStock = await busOrderFunctionController.GetStock("", "山西仓",1,10000);
          //  List<EBossStock> listStock1 = await busOrderFunctionController.GetStock("", "新乡仓",1,10000);


            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
          //  List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
            foreach (var item in ids)
                {
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == item);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                if (detaillist != null && detaillist.Count > 0)
                { }
                else
                { msg += "订单" + modelOrder.F_Id + "请选择订购商品"; continue; }
                if (string.IsNullOrEmpty(modelOrder.F_AddPhone))
                {
                        msg += "订单" + modelOrder.F_Id + "收件人电话不能为空";

                        continue;
                }
               
                if (string.IsNullOrEmpty(modelOrder.F_Address))
                {
                        msg += "订单" + modelOrder.F_Id + "收件人详细地址不能为空";
                        continue;
                }
                if (modelOrder.F_IsZeroCommodity ==1&& !modelOrder.F_Type.Contains ("回访")&& !modelOrder.F_Type.Contains("售后") )
                {
                    msg += "订单" + modelOrder.F_Id + "非回访单不能添加0金额袜子";
                    continue;
                }
               
                    if (detaillist!=null && detaillist.Count >0)
                    {
                        foreach (var it in detaillist)
                        {
                            T_Bus_Product t_Bus_Product = await bus_productRepository.GetSingle(x => x.F_ProductId == it.F_ProductId);
                        if (t_Bus_Product==null )
                        {
                            msg += "订单" + modelOrder.F_Id + "商品不存在";
                            continue;
                        }
                          
                        if (t_Bus_Product.F_OnSaleEnd < DateTime.Now && UserLogin.RoleCode != "SH")
                        {
                            msg += "订单" + modelOrder.F_Id + "商品已下架:" + t_Bus_Product.F_ProductName;
                            continue;
                        }
                        //if (t_Bus_Product!=null )
                        //    {
                        // //   var listStock2 = listStock.Where(x => x.sku == t_Bus_Product.F_ProductId).ToList(); ;
                        //    var listStock3 = listStock1.Where(x => x.sku == t_Bus_Product.F_ProductId).ToList(); ;
                        //    //  List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(it.F_ProductId, "新乡仓");
                           
                          
                        //    if (listStock3!=null&& listStock3.Count > 0)
                        //    {
                        //        if (t_Bus_Product.F_UseNumber > listStock3[0].qty)
                        //        {
                        //            msg += "订单" + modelOrder.F_Id + "提交失败,可配量不足.";
                        //            continue;
                                   
                        //        }
                        //        else
                        //        {
                        //            t_Bus_Product.F_UseNumber += it.F_Count;
                        //            Productlist.Add(t_Bus_Product);
                        //        }

                        //    }
                        //   else  
                        //    {
                        //        msg += "订单" + modelOrder.F_Id + "提交失败,可配量不足.";
                        //        continue;
                        //    }
                        //  }
                        //    else
                        //    {
                        //        msg += "订单" + modelOrder.F_Id + "提交失败,商品不存在.";
                        //     continue;
                        //   }
                       
                        }
                    }
                    
                  
                  
                    if (modelOrder.F_IsPayment > 0|| modelOrder.F_PayType != "货到付款")
                   {
                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "提交订单"+","+ modelOrder.F_PayType+"流转客服付款待审核";
                    modelOrder.F_State = 7;
                    }
                        
                    else
                   {
                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "提交订单"+",流转客服待分仓";
                    modelOrder.F_State = 1;
                       }
                     
                    modelOrder.F_FlowNum = DateTime.Now.ToString("yyMMddHHmmss") + "U" + UserLogin.UserId + "R" + new Random().Next(9);
                modelOrder.F_SubmitTime = DateTime.Now;
                modelOrder.F_SubmitUser    = UserLogin .UserName ;
                modelOrder.F_SubmitUserId  = UserLogin.UserId.ObjToInt () ;
                orderLIst.Add(modelOrder);
                  t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                
                  t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                  t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                  t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                   logs.Add(t_Bus_Orderlogs);
                }
            if (msg == "")
            {
              //  if (await bus_productRepository.UpdateList(Productlist))
              //  {
                    if (bus_OrderRepository.UpdateList(orderLIst).Result)
                    {
                        await busOrderlogsRepository.AddAndUpdateList(logs);
                        return Success("提交成功");
                    }

              //  }
            }
            else
            {
                return Error(msg);
            }
            return Error("提交失败");
            }
        /// <summary>
        /// 上传文件并导入数据库批量
        /// </summary>审核订单金额
        /// <returns></returns>
        [HttpPost("importcheckordermoney")]
        public async Task<IActionResult> importcheckordermoney(int headrow = 0)
        {
            Microsoft.AspNetCore.Http.IFormFile _upfile = Request.Form.Files[0];
            if (!_upfile.ContentType.Equals("application/vnd.ms-excel") && !_upfile.ContentType.Equals("application/x-xls") && !_upfile.ContentType.Equals("application/x-xlsx") && !_upfile.ContentType.Equals("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") && !_upfile.ContentType.Equals("application/octet-stream"))
                return Error($"请正确上传Excel文件：file.ContentType={_upfile.ContentType}");
            NPOIHelper npoi = new NPOIHelper();
            var dtExcel = npoi.ExcelToTable1(_upfile, headrow);
            int num = dtExcel.Rows.Count;
            var cols = dtExcel.Columns;
            int colnum = cols.Count;
            string errmsg = string.Empty;
            string user = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value;
            List<T_Bus_Order> _Orders = new List<T_Bus_Order>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            if (num > 0)
            {
                int index = 1;
                foreach (DataRow dr in dtExcel.Rows)
                {
                    index++;
                    T_Bus_Order modelOrder = new T_Bus_Order();
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    if (dr.Table.Columns.Contains("订单号"))
                    {
                        if (!string.IsNullOrEmpty(dr["订单号"].ToString()))
                        {
                            modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == dr["订单号"].ToString());
                            if (modelOrder == null)
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！订单不存在";
                                continue;
                            }
                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + index + "行导入失败！订单不存在";
                            continue;
                        }
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    if (dr.Table.Columns.Contains("打款金额"))
                    {
                        if (!string.IsNullOrEmpty(dr["打款金额"].ToString()))
                        {
                            try
                            {
                                if (modelOrder.F_RealPrice==decimal  .Parse (dr["打款金额"].ToString()))
                                {
                                    if (modelOrder.F_PayState == 0)
                                    {
                                        if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                                        {
                                            //0待回款1已支付 2待退款3已退款
                                            modelOrder.F_PayState = 1;
                                        }
                                    }
                                    else if (modelOrder.F_PayState == 2)
                                    {
                                        if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                                        {
                                            //0待回款1已支付 2待退款3已退款
                                            modelOrder.F_PayState = 3;
                                        }
                                    }
                                    var membership = await _cus_membershiprepository.GetListALL(x => x.F_State != 2);
                                    if (membership != null && membership.Count > 0)
                                    {
                                        T_Cus_VipInfo vip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
                                        if (vip != null)
                                        {
                                            vip.F_Money += modelOrder.F_RealPrice;
                                            T_Cus_Membership t_Cus_Membership = membership.Where(x => x.F_MinMoney <= vip.F_Money
                                            ).OrderByDescending(a => a.F_MaxMoney).FirstOrDefault();
                                            if (t_Cus_Membership != null)
                                            {
                                                vip.F_MembershipId = t_Cus_Membership.F_ID;
                                                vip.F_Membership = t_Cus_Membership.F_Name;
                                            }
                                            await cus_vip_infoRepository.Update(vip);
                                        }
                                    }
                                    modelOrder.F_State = 1;
                                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "审核付款金额，审核通过流转客服待分仓";
                                }
                                else
                                {
                                    errmsg = errmsg + "\r\n第" + index + "行导入失败！打款金额不匹配";
                                    continue;
                                }
                                
                            }
                            catch
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！打款金额格式错误";
                                continue;
                            }
                            
                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + index + "行导入失败！请选择打款金额";
                            continue;
                        }
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                    t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                    logs.Add(t_Bus_Orderlogs);
                    _Orders.Add(modelOrder);


                   
                }
                if (_Orders.Count >0)
                {
                    await busOrderlogsRepository.AddAndUpdateList(logs);
                    if (!await bus_OrderRepository.UpdateList(_Orders))
                    {
                        if (!string.IsNullOrEmpty(errmsg))
                        {
                            errmsg = errmsg + "导入失败！";
                        }
                        else
                        {
                            errmsg = "导入失败！";
                        }
                    }
                }
             
            }
            else
            {
                return Error("文件中无数据");
            }

            if (!string.IsNullOrEmpty(errmsg))
            {
                return Error(errmsg);
            }

            return Success("导入成功");
        }
        /// <summary>
        /// 销售选择未发原因
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("notissued")]
        public async Task<IActionResult> Notissued(string orderids,string remarks)
        {
            string msg = "";
            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(remarks))
                return Error("请选择未发原因");
            string[] ids = orderids.Split(',');
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            foreach (var item in ids)
            {
                T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == item);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                modelOrder.F_Notissued = remarks;
                modelOrder.F_NotissuedID = 1; 
                orderLIst.Add(modelOrder);
                t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "填写未发原因:" + remarks;
                t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                logs.Add(t_Bus_Orderlogs);
            }
            if (msg == "")
            {
                if (bus_OrderRepository.UpdateList(orderLIst).Result)
                {
                    await busOrderlogsRepository.AddMany (logs);
                    return Success("提交成功");
                }
            }
            else
            {
                return Error(msg);
            }
            return Error("提交失败");
        }
        /// <summary>
        /// 审核订单金额
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("checkordermoney")]
        public async Task<IActionResult> CheckOrderMoney(string orderids,int state)
        {
            try
            {
                #region 验证参数 必填项  
                if (string.IsNullOrEmpty(orderids))
                    return Error("请选择订单号");
                string[] ids = orderids.Split(',');
                List<T_Bus_Order> _Orders = new List<T_Bus_Order>();
                List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
                string msg = "";
                foreach (var it  in ids)
                {
                    #endregion
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    Expression<Func<T_Bus_OrderMoney, bool>> eq = a => a.F_OrderId == it;
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                   
                    if (state == 1)
                    {
                        if (modelOrder.F_PayState == 0)
                        {
                            if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                            {
                                //0待回款1已支付 2待退款3已退款
                                modelOrder.F_PayState = 1;
                            }
                        }
                        else if (modelOrder.F_PayState == 2)
                        {
                            if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                            {
                                //0待回款1已支付 2待退款3已退款
                                modelOrder.F_PayState = 3;
                            }
                        }
                        var membership = await _cus_membershiprepository.GetListALL(x => x.F_State != 2);
                        if (membership != null && membership.Count > 0)
                        {
                            T_Cus_VipInfo vip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
                            if (vip != null)
                            {
                                vip.F_Money += modelOrder.F_RealPrice;
                                T_Cus_Membership t_Cus_Membership = membership.Where(x => x.F_MinMoney <= vip.F_Money
                                ).OrderByDescending(a => a.F_MaxMoney).FirstOrDefault();
                                if (t_Cus_Membership != null)
                                {
                                    vip.F_MembershipId = t_Cus_Membership.F_ID ;
                                    vip.F_Membership = t_Cus_Membership.F_Name;
                                }
                                await cus_vip_infoRepository.Update(vip);
                            }
                        }
                        modelOrder.F_State = 1;
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "审核付款金额，审核通过流转客服待分仓";
                        _Orders.Add(modelOrder);
                    }
                    else
                    {
                        List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                     //   List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        if (detaillist != null && detaillist.Count > 0)
                        {
                            foreach (var iv in detaillist)
                            {
                                T_Bus_Product t_Bus_Product = await bus_productRepository.GetSingle(x => x.F_ProductId == iv.F_ProductId);
                                if (t_Bus_Product != null)
                                {
                                    if (t_Bus_Product.F_OnSaleEnd < DateTime.Now && UserLogin.RoleCode != "SH")
                                    {
                                        return Error("商品已下架:" + t_Bus_Product.F_ProductId);
                                    }
                                  //  t_Bus_Product.F_UseNumber -= iv.F_Count;
                                  //  Productlist.Add(t_Bus_Product);
                                }
                                else
                                {
                                    msg += "订单" + modelOrder.F_Id + "提交失败,商品不存在.";
                                    continue;
                                }
                            }
                        }
                        //if (msg == "")
                        //{
                        //    if (Productlist != null && Productlist.Count > 0)
                        //    {
                        //        if (!await bus_productRepository.UpdateList(Productlist))
                        //        {
                        //            msg += "订单" + modelOrder.F_Id + "提交失败";
                        //            continue;
                        //        }
                                   
                        //    }
                        //    else
                        //    {
                        //        msg += "订单" + modelOrder.F_Id + "提交失败,请选择商品";
                        //        continue;
                        //    }
                        //}
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "审核付款金额，审核不通过，退回销售待提交";
                        modelOrder.F_State = 0;
                        _Orders.Add(modelOrder);
                    }
                   
                  
                    t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                 
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                    t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                    logs.Add(t_Bus_Orderlogs);
                }
                if (msg == "")
                {
                    await busOrderlogsRepository.AddAndUpdateList(logs);
                    if (await bus_OrderRepository.UpdateList(_Orders))
                        return Success("成功");
                }
                else
                    return Error(msg);

                return Error("失败！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }
        /// <summary>
        /// 上传文件并导入数据库批量导入快递信息
        /// </summary>
        /// <returns></returns>
        [HttpPost("importorderexpressexcel")]
        public async Task<IActionResult> importorderexpressexcel(int headrow = 0)
        {
            Microsoft.AspNetCore.Http.IFormFile _upfile = Request.Form.Files[0];
            if (!_upfile.ContentType.Equals("application/vnd.ms-excel") && !_upfile.ContentType.Equals("application/x-xls") && !_upfile.ContentType.Equals("application/x-xlsx") && !_upfile.ContentType.Equals("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") && !_upfile.ContentType.Equals("application/octet-stream"))
                return Error($"请正确上传Excel文件：file.ContentType={_upfile.ContentType}");
            NPOIHelper npoi = new NPOIHelper();
            var dtExcel = npoi.ExcelToTable1(_upfile, headrow);
            int num = dtExcel.Rows.Count;
            var cols = dtExcel.Columns;
            int colnum = cols.Count;
            string errmsg = string.Empty;
            string user = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value;
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            List<T_Bus_AfterSale> afterList  = new List<T_Bus_AfterSale>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            if (num > 0)
            {
                int index = 1;
                foreach (DataRow dr in dtExcel.Rows)
                {
                    index++;
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    T_Bus_Order modelOrder = new T_Bus_Order();
                    List<T_Bus_AfterSale > after = new List<T_Bus_AfterSale>();
                    if (dr.Table.Columns.Contains("订单号"))
                    {
                        if (!string.IsNullOrEmpty(dr["订单号"].ToString()))
                        {
                            modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == dr["订单号"].ToString());
                             after =await  busAfterSaleRepository.GetListALL(x => x.F_OrderId == dr["订单号"].ToString()&&x .F_Type  ==9 && x.F_WoState == 0);
                            if (after==null|| after.Count <=0)
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！订单不存在售后改代收";
                                continue;
                            }
                            if (modelOrder == null)
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！订单不存在";
                                continue;
                            }

                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + index + "行导入失败！订单不存在";
                            continue;
                        }
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    if (dr.Table.Columns.Contains("运单号"))
                    {
                        if (!string.IsNullOrEmpty(dr["运单号"].ToString()))
                        {
                            if (IsRegex(dr["运单号"].ToString()))
                            {
                                    modelOrder.F_NewTrackingNo = dr["运单号"].ToString();
                                    after[0].F_TrackingNo = dr["运单号"].ToString();
                            }
                            else
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！运单号格式错误";
                                continue;
                            }
                        }
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName +"改代收导入运单号"+ modelOrder.F_NewTrackingNo;
                    t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                    t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                    logs.Add(t_Bus_Orderlogs);
                    orderLIst.Add(modelOrder);
                    afterList.Add(after[0]);
                  
                }
                if (errmsg == "")
                {
                    if (await bus_OrderRepository.UpdateList(orderLIst))
                    {
                        await busOrderlogsRepository.AddAndUpdateList(logs);
                        if (!await busAfterSaleRepository .UpdateList(afterList))
                        {
                            errmsg = errmsg + "导入失败！";
                        }
                    }
                    else 
                    errmsg = errmsg + "导入失败！";
                }
            }
            else
            {
                return Error("文件中无数据");
            }

            if (!string.IsNullOrEmpty(errmsg))
            {
                return Error(errmsg);
            }

            return Success("导入成功");
        }

        private bool IsRegex(string accountStr)
        {
            Regex reg = new Regex(@"^[A-Za-z0-9]+$");
            return reg.IsMatch(accountStr);
        }
        /// <summary>
        /// 更新改代收运单号
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="status">
        /// <returns></returns>
        [HttpPost("updateexpres")]
        public async Task<IActionResult> UpdateTrackingNo(string orderids, string trackingNo="")
        {

            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(trackingNo))
                return Error("请输入运单号");
            #endregion
            //  string[] ids = orderids.Split(',');
            var    after = await busAfterSaleRepository.GetSingle    (x => x.F_Id  == orderids );
            if (after == null )
            {
                return Error("售后不存在");
            }
            int t = await AddLog(orderids, UserLogin.UserName + "改代收更新运单号", UserLogin.UserCode,-1);
            if (await bus_OrderRepository.Update(s => new T_Bus_Order() { F_NewTrackingNo  = trackingNo }, q => q .F_Id ==after .F_OrderId ))

            {
                after.F_TrackingNo = trackingNo;
                if (await busAfterSaleRepository .Update(after))
                {
                    return Success("成功");
                }
            }
            return Error("失败,请重试！");

        }


        #region 
        /// <summary>
        /// 修改订单 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /**
        [HttpPost("editorder")]
        public async Task<IActionResult> EditOrder([FromBody]OrderInput input)
        {
            T_Cus_VipInfo modelvip = new T_Cus_VipInfo();
            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(input.F_ADFrom))
                return Error("请输入选择广告来源");
            if (string.IsNullOrEmpty(input.F_Type))
                return Error("请输入选择订单类型");
            if (string.IsNullOrEmpty(input.F_Id))
                return Error("请输入订单编号");
            if (string.IsNullOrEmpty(input.F_Customer))
                return Error("请输入客户姓名");
            if (string.IsNullOrEmpty(input.F_CustomerPhone))
                return Error("请输入客户电话");
            if (input.F_Type == "售后订单")
                return Error("售后订单销售不能修改");
            #endregion


            T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_Id);
            if (modelOrder == null)
            {
                return Error("此订单号不存在");
            }
            //保存 审退回 仓退回
            if (!(new int[] { 0, 2 }.Contains(modelOrder.F_State)))
            {
                return Error("已提交订单不允许修改，先撤回订单");
            }
            #region 数据绑定
            //必填
            modelOrder.F_ADFrom = input.F_ADFrom;
            modelOrder.F_Type = input.F_Type;
            modelOrder.F_Customer = input.F_Customer;
            modelOrder.F_CustomerPhone = input.F_CustomerPhone;
            if (input.F_RecommendId > 0)
            {
                modelOrder.F_RecommendId = input.F_RecommendId;
                modelOrder.F_RecommendName = input.F_RecommendName;
            }
            if (input.F_CustomerType > 0)
            { modelOrder.F_CustomerType = input.F_CustomerType; }
            if (!string.IsNullOrEmpty(input.F_CustomerTel))
            { modelOrder.F_CustomerTel = input.F_CustomerTel; }
            //选填 快递属性
            modelOrder.F_TrackingNo = "";
            if (!string.IsNullOrEmpty(input.F_Addressee))
            { modelOrder.F_Addressee = input.F_Addressee; }
            if (!string.IsNullOrEmpty(input.F_AddPhone))
            { modelOrder.F_AddPhone = input.F_AddPhone; }

            if (!string.IsNullOrEmpty(input.F_AddProvince))
            { modelOrder.F_AddProvince = input.F_AddProvince; }
            if (!string.IsNullOrEmpty(input.F_AddCity))
            { modelOrder.F_AddCity = input.F_AddCity; }
            if (!string.IsNullOrEmpty(input.F_AddArea))
            { modelOrder.F_AddArea = input.F_AddArea; }
            if (!string.IsNullOrEmpty(input.F_AddTown))
            { modelOrder.F_AddTown = input.F_AddTown; }

            if (!string.IsNullOrEmpty(input.F_AddDes))
            { modelOrder.F_AddDes = input.F_AddDes; }
            if (!string.IsNullOrEmpty(input.F_Address))
            { modelOrder.F_Address = input.F_Address; }
            if (!string.IsNullOrEmpty(input.F_PostalCode))
            { modelOrder.F_PostalCode = input.F_PostalCode; }
            if (!string.IsNullOrEmpty(input.F_Express))
            { modelOrder.F_Express = input.F_Express; }
            if (!string.IsNullOrEmpty(input.F_Remark))
            { modelOrder.F_Remark = input.F_Remark; }
            if (!string.IsNullOrEmpty(input.F_PayType))
            { modelOrder.F_PayType = input.F_PayType; }

            if (input.F_Belong > 0)
            {
                modelOrder.F_Belong = input.F_Belong;
                modelOrder.F_BelongName = input.F_BelongName;
            }
            else
            {
                modelOrder.F_Belong = UserLogin.UserId.ObjToInt();
                modelOrder.F_BelongName = UserLogin.UserName;
            }

            modelOrder.F_ExpressFee = input.F_ExpressFee;
            modelOrder.F_Stock = input.F_Stock;

            modelOrder.F_RealPrice = input.F_RealPrice;
            modelOrder.F_UseScore = input.F_UseScore;
            //选填 关联属性
            if (input.F_VipId>0)
            modelOrder.F_VipId = input.F_VipId;
            else
            {
                var vip = await cus_vip_infoRepository.GetListALL(x => x.F_Phone == input.F_CustomerPhone
                    && x.F_State == 1);
                if (vip != null && vip.Count > 0)
                    modelOrder.F_VipId = vip.FirstOrDefault().F_ID;
                else
                    modelOrder.F_VipId = 0;
            }



            modelOrder.F_State = input.F_State;
            modelOrder.F_Status = 0;
            modelOrder.F_IsPayment = input.F_IsPayment;
            if (input.F_IsPayment > 0 && input.F_PaymentMoney <= 0)
                return Error("付款金额不能小于0");
           
            //必须属性 系统生成
            modelOrder.F_AddTime = DateTime.Now;
            modelOrder.F_AddUser = UserLogin.UserId.ObjToInt();
            modelOrder.F_AddUserName = UserLogin.UserName;

            #endregion

            //计算属性  商品计算

            decimal totle = 0.00M;
            decimal ActivityMoney = 0.00M;
            string UseActivity = "";
            string UseActivity4 = ",";
            string UseActivity2 = ",";
            List<T_Bus_OrderDetail> modelDetailList = new List<T_Bus_OrderDetail>();

            if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
            {
                #region 核算活动

                int n2 = input.OrderDetailList.Count + 1;
                if (input.UseActList != null && input.UseActList.Count > 0)
                {
                    //遍历所有选中的活动
                    foreach (UseActInput act in input.UseActList)
                    {
                        UseActivity += act.id + ",";
                        //满赠
                        if (act.type == 1)
                        {
                            string[] productidlist = act.gift.Split(',');
                            foreach (string giftid in productidlist)
                            {
                                T_Bus_Product m = await bus_productRepository.GetSingle(b => ("," + giftid + ",").Contains("," + b.F_ProductId + ",") && b.F_IsSale == 0);
                                if (m != null)
                                {
                                    T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                                    modelDetail.F_ProductName = m.F_ProductName;
                                    modelDetail.F_ProductId = m.F_ProductId;
                                    modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                                    modelDetail.F_OrderId = input.F_Id;
                                    modelDetail.F_Count = 1;
                                    modelDetail.F_Price = 0.00M;
                                    modelDetail.F_DealPrice = 0.00M;
                                    modelDetail.F_Sort = n2;
                                    modelDetail.F_Remark = "赠品-活动：" + act.id;
                                    modelDetail.F_AddUser = modelOrder.F_AddUser;
                                    modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                                    modelDetail.F_TotlePrice = 0.00M;
                                    modelDetail.F_Activity = act.id;
                                    modelDetail.F_AddTime = DateTime.Now.AddSeconds(30);
                                    modelDetailList.Add(modelDetail);
                                    n2++;
                                }
                            }

                        }
                        //生日赠
                        else if (act.type == 2)
                        {
                            UseActivity2 += act.gift + ",";
                        }
                        //满减
                        else if (act.type == 3)
                        {
                            ActivityMoney += act.money;
                        }
                        else if (act.type == 4)
                        {
                            UseActivity4 += act.gift + ",";
                        }
                    }
                    UseActivity = UseActivity.Trim(',');
                }

                #endregion

                #region  核算商品

                int n = 1;
                foreach (OrderDetailInput m in input.OrderDetailList)
                {
                    T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                    if (modelProduct == null) return Error("在售商品不存在");
                    T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                    modelDetail.F_ProductName = modelProduct.F_ProductName;
                    modelDetail.F_ProductId = modelProduct.F_ProductId;
                    modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                    modelDetail.F_OrderId = input.F_Id;
                    modelDetail.F_Count = m.F_Count;
                    modelDetail.F_Price = modelProduct.F_MemberPrice;
                    //参加活动特价
                    if (UseActivity4.Contains("," + modelProduct.F_ProductId + ","))
                        modelDetail.F_DealPrice = modelProduct.F_SpecialPrice;
                    else
                        modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                    //参加生日
                    if (UseActivity2.Contains("," + modelProduct.F_ProductId + ","))
                    {
                        modelDetail.F_DealPrice = 0.00M;
                        modelDetail.F_Remark = "生日赠品-活动：";
                    }

                    modelDetail.F_Sort = n;
                    modelDetail.F_AddTime = DateTime.Now;

                    modelDetail.F_AddUser = modelOrder.F_AddUser;
                    modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                    modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                    modelDetail.F_Activity = 0;
                    if (modelProduct.F_Tag.IndexOf(".") > -1 && !string.IsNullOrEmpty(UseActivity))
                    {
                        string[] tagarry = modelProduct.F_Tag.Split(',');
                        string[] actlist = UseActivity.Split(',');
                        string tag = tagarry.First(a => a.StartsWith(".")).ToString();
                        T_Sys_Marketing modelactive = await bus_MarketingRepository.GetFirst(b => actlist.Contains(b.F_ID.ToString()) && b.F_EndTime >= DateTime.Now && b.F_StartTime<=DateTime.Now && b.F_IsDelete==0&&("," + b.F_Commodity + ",").Contains(("," + tag + ",")));

                        //此商品参加活动
                        if (modelactive != null)
                        {
                            modelDetail.F_Activity = modelactive.F_ID;
                        }
                    }

                    totle += modelDetail.F_TotlePrice;
                    modelDetailList.Add(modelDetail);

                    n++;
                }

                #endregion
                modelOrder.F_TotlePrice = totle;
                modelOrder.F_ActivityMoney = ActivityMoney;
                modelOrder.F_UseActivity = UseActivity;
            }
            else
            {
                //不传商品 表明不修改商品信息 不重新计算商品
            }


            //直接提交  锁库存
            T_Cus_ScoreSet modelscore = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
            if (modelscore == null)
            {
                modelscore = new T_Cus_ScoreSet();
                modelscore.F_Start = 0;
                modelscore.F_StartDebit = 1;
                modelscore.F_DebitPercent = 1000;
            }
            #region 提交 更改状态   库存  积分

             
            if (input.F_State == 1)
            {
                if (string.IsNullOrEmpty(input.F_Stock))
                {
                    return Error("请选择出库货仓");
                }
                if (string.IsNullOrEmpty(modelOrder.F_Express))
                {
                    return Error("快递不能为空"); 
                }
                if (string.IsNullOrEmpty(modelOrder.F_AddPhone))
                {
                    return Error("收件人电话不能为空");
                }
                if (string.IsNullOrEmpty(modelOrder.F_AddTown))
                {
                    return Error("收件人地址不能为空");
                }
                if (string.IsNullOrEmpty(modelOrder.F_Address))
                {
                    return Error("收件人详细地址不能为空");
                }
                modelOrder.F_FlowNum = DateTime.Now.ToString("yyMMddHHmmss") + "U" + UserLogin.UserId + "R" + new Random().Next(9);

                if (modelscore.F_Start == 1)
                {
                    //订单完成后计算积分
                    modelOrder.F_Score = -0.01M;
                }
                else
                {  //订单完成后也不计算积分
                    modelOrder.F_Score = 0.00M;
                }
                if (modelscore.F_StartDebit == 0 || modelOrder.F_VipId == 0)
                {
                    modelOrder.F_UseScore = 0;
                }

                string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 1, modelDetailList);
                if (strStock != "1")
                { return Error(strStock); }
                modelOrder.F_SubmitTime = DateTime.Now;
            }
            #endregion

            if (!modelOrder.F_Type.Contains("售后"))
            { modelOrder.F_ShouldPrice = modelOrder.F_TotlePrice - modelOrder.F_ActivityMoney + modelOrder.F_ExpressFee - modelOrder.F_UseScore / modelscore.F_DebitPercent;
        }
            DataTable dt=await busOrderMoneyRepository.GetTableSugar(string.Format("SELECT IFNULL(SUM(F_Money),0) FROM T_Bus_OrderMoney WHERE F_OrderId='{0}' AND F_State=1", modelOrder.F_Id));
            modelOrder.F_RealPrice = dt.Rows[0][0].ObjToDecimal() ;
            if (modelOrder.F_ShouldPrice > 0)
            {
                if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                     modelOrder.F_PayState = 1;
                else
                     modelOrder.F_PayState = 0;
            }
            else
            {
                if (modelOrder.F_ShouldPrice >= modelOrder.F_RealPrice)
                    modelOrder.F_PayState = 3;
                else 
                    modelOrder.F_PayState = 2;                 

            }
            //待付款 客服审核付款情况后改为已付款


            if (await bus_OrderRepository.Update(modelOrder))
            {
                if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                {
                    //删除之前订单商品，重新添加
                    if (await bus_OrderDetailRepository.Delete(q => q.F_OrderId == modelOrder.F_Id))
                    {
                        
                        if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                            return Success("订单生成成功");
                        else
                            return Error("订单操作失败,请重试1！");
                    }
                    else {
                        if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                            return Success("订单生成成功2");
                        else
                            return Error("订单操作失败,请重试2！");
                       }
                }
                else { return Success("成功"); }
            }

            return Error("订单添加失败,请重试！");


        }
    **/
        #endregion
        #region 
        /// <summary>
        /// 修改订单 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>

        [HttpPost("editorder")]
        public async Task<IActionResult> EditOrder([FromBody]OrderInput input)
        {
          //  T_Cus_VipInfo modelvip = new T_Cus_VipInfo();
            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(input.F_ADFrom))
                return Error("请输入选择广告来源");
            if (string.IsNullOrEmpty(input.F_Type))
                return Error("请输入选择订单类型");
            if (string.IsNullOrEmpty(input.F_Id))
                return Error("请输入订单编号");
            if (string.IsNullOrEmpty(input.F_Customer))
                return Error("请输入客户姓名");
            if (string.IsNullOrEmpty(input.F_CustomerPhone))
                return Error("请输入客户电话");
            if (string.IsNullOrEmpty(input.F_AddProvince))
            {
                return Error("收件人省份不能为空");
            }
            if (string.IsNullOrEmpty(input.F_AddCity))
            {
                return Error("收件人城市不能为空");
            }
            if (string.IsNullOrEmpty(input.F_AddArea))
            {
                return Error("收件人区/县不能为空");
            }
            if (string.IsNullOrEmpty(input.F_Address))
            {
                return Error("收件人详细地址不能为空");
            }
             if (input.F_Type == "售后订单")
           {
                if (UserLogin .RoleCode !="SH")
                return Error("售后订单只能售后修改");
            }
           
            #endregion


            T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_Id);
            if (modelOrder == null)
            {
                return Error("此订单号不存在");
            }
            //保存 审退回 仓退回
            if (!(new int[] { 0, 2 }.Contains(modelOrder.F_State)))
            {
                return Error("已提交订单不允许修改，先撤回订单");
            }
            #region 数据绑定
            //必填
            modelOrder.F_ADFrom = input.F_ADFrom;
            modelOrder.F_Type = input.F_Type;
            modelOrder.F_Customer = input.F_Customer;
            modelOrder.F_CustomerPhone = input.F_CustomerPhone;
            if (input.F_RecommendId > 0)
            {
                modelOrder.F_RecommendId = input.F_RecommendId;
                modelOrder.F_RecommendName = input.F_RecommendName;
            }
            if (input.F_CustomerType > 0)
            { modelOrder.F_CustomerType = input.F_CustomerType; }
            if (!string.IsNullOrEmpty(input.F_CustomerTel))
            { modelOrder.F_CustomerTel = input.F_CustomerTel; }
            //选填 快递属性
            modelOrder.F_TrackingNo = "";
            if (!string.IsNullOrEmpty(input.F_Addressee))
            { modelOrder.F_Addressee = input.F_Addressee; }
            if (!string.IsNullOrEmpty(input.F_AddPhone))
            { modelOrder.F_AddPhone = input.F_AddPhone; }

            if (!string.IsNullOrEmpty(input.F_AddProvince))
            { modelOrder.F_AddProvince = input.F_AddProvince; }
            if (!string.IsNullOrEmpty(input.F_AddCity))
            { modelOrder.F_AddCity = input.F_AddCity; }
            if (!string.IsNullOrEmpty(input.F_AddArea))
            { modelOrder.F_AddArea = input.F_AddArea; }
            if (!string.IsNullOrEmpty(input.F_AddTown))
            { modelOrder.F_AddTown = input.F_AddTown; }

            if (!string.IsNullOrEmpty(input.F_AddDes))
            { modelOrder.F_AddDes = input.F_AddDes; }
            if (!string.IsNullOrEmpty(input.F_Address))
            { modelOrder.F_Address = input.F_Address; }
          //  if (!string.IsNullOrEmpty(input.F_PostalCode))//快递
          //  { modelOrder.F_PostalCode = input.F_PostalCode; }
            if (!string.IsNullOrEmpty(input.F_Express))
            { modelOrder.F_Express = input.F_Express; }
            if (!string.IsNullOrEmpty(input.F_Remark))
            { modelOrder.F_Remark = input.F_Remark; }
            if (!string.IsNullOrEmpty(input.F_PayType))
            { modelOrder.F_PayType = input.F_PayType; }

            var modelvip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
            if (modelvip != null)
            {
                modelOrder.F_Belong = modelvip.F_Saleperson.ObjToInt();
                var user = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_Belong);
                modelOrder.F_BelongName = user.F_UserName ;
            }
            else if (input.F_Belong > 0)
            {
                modelOrder.F_Belong = UserLogin.UserId.ObjToInt();
                modelOrder.F_BelongName = UserLogin.UserName;
            }
            var useraccount = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelvip.F_Saleperson.ObjToInt());

            if (useraccount != null)
            {
                modelOrder.F_Department = useraccount.F_DeptId;
                modelOrder.F_Core = useraccount.F_DeptTeamId;
                modelOrder.F_Group = useraccount.F_GroupId;
            }
            if (input.F_Media > 0)
            {
                modelOrder.F_Media = input.F_Media;
                modelOrder.F_MediaName = input.F_MediaName;
            }
           
            //    modelOrder.F_Stock = input.F_Stock;//仓库
            modelOrder.F_IsExpress = 0;
            modelOrder.F_MemberNotes = input.F_MemberNotes;//会员备注

            if (modelvip != null)
            {
                modelvip.F_Score += modelOrder.F_UseScore;

            }
            modelOrder.F_RealPrice = input.F_RealPrice;
            modelOrder.F_UseScore = input.F_UseScore;
            //选填 关联属性
            if (input.F_VipId>0)
            modelOrder.F_VipId = input.F_VipId;
            else
            {
                var vip = await cus_vip_infoRepository.GetListALL(x => x.F_Phone == input.F_CustomerPhone
                    && x.F_State == 1);
                if (vip != null && vip.Count > 0)
                    modelOrder.F_VipId = vip.FirstOrDefault().F_ID;
                else
                    modelOrder.F_VipId = 0;
            }
          
         
            modelOrder.F_State = input.F_State;
            modelOrder.F_Status = 0;
            modelOrder.F_IsPayment = input.F_IsPayment;
         

            //必须属性 系统生成
            modelOrder.F_AddTime = DateTime.Now;
            modelOrder.F_AddUser = UserLogin.UserId.ObjToInt();
            modelOrder.F_AddUserName = UserLogin.UserName;

            #endregion

            //计算属性  商品计算

            decimal totle = 0.00M;
            decimal ActivityMoney = 0.00M;
            string UseActivity = "";
            string UseActivity4 = ",";
            string UseActivity2 = ",";
            string Eventprice = "";
            Dictionary<string , decimal> innerCompute = new Dictionary<string, decimal>();
          
            List<T_Bus_OrderDetail> modelDetailList = new List<T_Bus_OrderDetail>();
            Dictionary<string, int> innerEventprice = new Dictionary<string, int>();
            if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
            {
                #region 核算活动

                int n2 = input.OrderDetailList.Count + 1;
                if (input.UseActList != null && input.UseActList.Count > 0)
                {
                    //遍历所有选中的活动
                    foreach (UseActInput act in input.UseActList)
                    {
                        UseActivity += act.id + ",";
                        //满赠
                        //if (act.type == 1)
                        //{
                        //    string[] productidlist = act.gift.Split(',');
                        //    foreach (string giftid in productidlist)
                        //    {
                        //        T_Bus_Product m = await bus_productRepository.GetSingle(b => ("," + giftid + ",").Contains("," + b.F_ProductId + ",") && b.F_IsSale == 0);
                        //        if (m != null)
                        //        {
                        //            T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                        //            modelDetail.F_ProductName = m.F_ProductName;
                        //            modelDetail.F_ProductId = m.F_ProductId;
                        //            modelDetail.F_Specifications = m.F_Specifications;
                        //            modelDetail.F_ProductShortName = m.F_ProductShortName;
                        //            modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        //            modelDetail.F_OrderId = input.F_Id;
                        //            modelDetail.F_Count = 1;
                        //            modelDetail.F_Price = 0.00M;
                        //            modelDetail.F_DealPrice = 0.00M;
                        //            modelDetail.F_Sort = n2;
                        //            modelDetail.F_Remark = "赠品-活动：" + act.id;
                        //            modelDetail.F_AddUser = modelOrder.F_AddUser;
                        //            modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                        //            modelDetail.F_TotlePrice = 0.00M;
                        //            modelDetail.F_Activity = act.id;
                        //            modelDetail.F_AddTime = DateTime.Now.AddSeconds(30);
                        //            modelDetailList.Add(modelDetail);
                        //            n2++;
                        //        }
                        //    }

                        //}
                        ////生日赠
                        //else 
                        if (act.type == 2)
                        {
                            UseActivity2 += act.gift + ",";
                        }
                        //满减
                        else if (act.type == 3)
                        {
                            ActivityMoney += act.money;
                            if (string .IsNullOrEmpty (Eventprice))
                            Eventprice= "" + act.id + "," + act.money;
                            else
                                Eventprice+= "|" + act.id + "," + act.money;
                        }
                        else if (act.type == 4)
                        {
                            UseActivity4 += act.gift + ",";
                            innerCompute.Add(act.gift, act.money);
                            innerEventprice.Add(act.gift, act.id);
                        }
                    }
                    UseActivity = UseActivity.Trim(',');
                }

                #endregion

                #region  核算商品
                modelOrder.F_IsZeroCommodity = 0;
                int n = 1;
                foreach (OrderDetailInput m in input.OrderDetailList)
                {
                    T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                    if (modelProduct == null) return Error("在售商品不存在");
                    if (modelProduct.F_OnSaleEnd < DateTime.Now && UserLogin.RoleCode != "SH")
                    {
                        return Error("商品已下架:" + m.F_ProductName);
                    }
                    if (!modelOrder.F_Type.Contains("售后"))
                    {
                     //   List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(modelProduct.F_ProductId, "新乡仓");
                        if (modelProduct.F_MinimumStock + m.F_Count > modelProduct.F_Stock1 )
                        {
                            return Error(m.F_ProductName + "数量库存低于" + modelProduct.F_MinimumStock + "不能添加");
                        }
                    }
                    T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                    modelDetail.F_ProductName = modelProduct.F_ProductName;
                    modelDetail.F_ProductId = modelProduct.F_ProductId;
                    modelDetail.F_Specifications = modelProduct.F_Specifications;
                    modelDetail.F_ProductShortName = modelProduct.F_ProductShortName;
                    modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                    modelDetail.F_OrderId = input.F_Id;
                    modelDetail.F_Count = m.F_Count;
                    modelDetail.F_Price = modelProduct.F_MemberPrice;
                    //参加活动特价
                    if (UseActivity4.Contains("," + modelProduct.F_ProductId + ","))
                    {
                        if (innerCompute.ContainsKey(modelProduct.F_ProductId))
                        {
                            ActivityMoney += innerCompute[modelProduct.F_ProductId] * m.F_Count;
                            if (!string .IsNullOrEmpty (Eventprice))
                            Eventprice += "|" + innerEventprice[modelProduct.F_ProductId] + "," + innerCompute[modelProduct.F_ProductId] * m.F_Count;
                            else
                                Eventprice += "" + innerEventprice[modelProduct.F_ProductId] + "," + innerCompute[modelProduct.F_ProductId] * m.F_Count;
                        }
                    }
                        modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                    //参加生日
                    if (UseActivity2.Contains("," + modelProduct.F_ProductId + ","))
                    {
                        modelDetail.F_DealPrice = 0.00M;
                        modelDetail.F_Remark = "生日赠品-活动：";
                    }
                    if (modelProduct.F_ClassName == "袜子" && modelDetail.F_DealPrice == 0)
                    {
                        modelOrder.F_IsZeroCommodity = 1;
                    }
                    modelDetail.F_Sort = n;
                    modelDetail.F_AddTime = DateTime.Now;

                    modelDetail.F_AddUser = modelOrder.F_AddUser;
                    modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                    modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                    modelDetail.F_Activity = 0;
                    if (modelProduct.F_Tag.IndexOf(".") > -1 && !string.IsNullOrEmpty(UseActivity))
                    {
                        string[] tagarry = modelProduct.F_Tag.Split(',');
                        string[] actlist = UseActivity.Split(',');
                        string tag = tagarry.First(a => a.StartsWith(".")).ToString();
                        T_Sys_Marketing modelactive = await bus_MarketingRepository.GetFirst(b => actlist.Contains(b.F_ID.ToString()) && b.F_EndTime >= DateTime.Now && b.F_StartTime<=DateTime.Now && b.F_IsDelete==0&&("," + b.F_Commodity + ",").Contains(("," + tag + ",")));

                        //此商品参加活动
                        if (modelactive != null)
                        {
                            modelDetail.F_Activity = modelactive.F_ID;
                        }
                    }

                    totle += modelDetail.F_TotlePrice;
                    modelDetailList.Add(modelDetail);

                    n++;
                }

                #endregion
                modelOrder.F_TotlePrice = totle;
                modelOrder.F_ActivityMoney = ActivityMoney;
                modelOrder.F_Eventprice  = Eventprice;
                
                modelOrder.F_UseActivity = UseActivity;
               
            }
            else
            {
                //不传商品 表明不修改商品信息 不重新计算商品
            }
           
            modelOrder.F_ExpressFee = input.F_ExpressFee;
            //直接提交  锁库存
            T_Cus_ScoreSet modelscore = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
            if (modelscore == null)
            {
                modelscore = new T_Cus_ScoreSet();
                modelscore.F_Start = 0;
                modelscore.F_StartDebit = 1;
                modelscore.F_DebitPercent = 1000;
            }
            #region 提交 更改状态   库存  积分

            
            if (input.F_State == 1)
            {
                if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                { }
                else
                { return Error("请选择订购商品"); }
                if (string.IsNullOrEmpty(modelOrder.F_AddPhone))
                {
                    return Error("收件人电话不能为空");
                }
                if (string.IsNullOrEmpty(modelOrder.F_AddTown))
                {
                    return Error("收件人地址不能为空");
                }
                if (string.IsNullOrEmpty(modelOrder.F_Address))
                {
                    return Error("收件人详细地址不能为空");
                }
             //   List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                if (modelDetailList != null && modelDetailList.Count > 0)
                {
                    foreach (var it in modelDetailList)
                    {
                        T_Bus_Product t_Bus_Product = await bus_productRepository.GetSingle(x => x.F_ProductId == it.F_ProductId);

                        if (t_Bus_Product != null)
                        {
                          //  List<EBossStock> listStock = await busOrderFunctionController.GetStock(it.F_ProductId, "山西仓");
                            //List<EBossStock> listStock1 = await busOrderFunctionController.GetStock(it.F_ProductId, "新乡仓");

                            //t_Bus_Product.F_UseNumber += it.F_Count;
                            //if (listStock1!=null && listStock1.Count >0)
                            //{
                            //    if (t_Bus_Product.F_UseNumber > listStock1[0].qty)
                            //    {
                            //        return Error("提交失败,可配量不足.");
                            //    }
                            //    else
                            //    {
                            //        Productlist.Add(t_Bus_Product);
                            //    }
                            //}
                            //else
                            //    return Error("提交失败,可配量不足.");

                        }
                        else
                        {
                            return Error("提交失败,商品不存在");
                        }
                    }
                 //   await bus_productRepository.UpdateList(Productlist);
                }
                modelOrder.F_SubmitTime = DateTime.Now;
                if (modelOrder.F_IsPayment > 0 || modelOrder.F_PayType != "货到付款")
                    modelOrder.F_State = 7;
                else
                    modelOrder.F_State = 1;

                modelOrder.F_FlowNum = DateTime.Now.ToString("yyMMddHHmmss") + "U" + UserLogin.UserId + "R" + new Random().Next(9);
            }
            //  if (modelscore.F_Start == 1)
            //   {
            //订单完成后计算积分
            //   modelOrder.F_Score = -0.01M;
            //  }
            //    else
            //   {  //订单完成后也不计算积分
            //      modelOrder.F_Score = 0.00M;
            //  }
            //   if (modelscore.F_StartDebit == 0 || modelOrder.F_VipId == 0)
            //  {
            //     modelOrder.F_UseScore = 0;
            //   }

            //  string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 1, modelDetailList);
            //  if (strStock != "1")
            //  { return Error(strStock); }
            //   modelOrder.F_SubmitTime = DateTime.Now;
            //  }
            #endregion
            string count = UserLogin.UserName + "修改订单";
            if (!modelOrder.F_Type.Contains("售后"))
            {
                
                string a = string.Format("{0:f0}", Math.Floor(modelOrder.F_UseScore / modelscore.F_DebitPercent));
                modelOrder.F_Discount = int.Parse(a);
                modelOrder.F_ShouldPrice = modelOrder.F_TotlePrice - modelOrder.F_ActivityMoney  -int .Parse (a) + input.F_ExpressFee;
                modelvip.F_UseGift -= modelOrder.F_UseGift;
                if (input.OrderUserGift != null && input.OrderUserGift.Count > 0)
                {
                    decimal moneys = 0.00M;
                    if (modelvip.F_Money != null)
                    {
                        moneys = (decimal)modelvip.F_Money + modelOrder.F_ShouldPrice;
                    }
                    else
                        moneys = modelOrder.F_ShouldPrice;

                    int b = 0;
                    if (moneys > 3000)
                    {
                        decimal fund = moneys - 3000;
                        string c = string.Format("{0:f0}", Math.Floor(fund / 2000));
                        b = int.Parse(c) + 1 - modelvip.F_UseGift;
                    }
                    int n2 = 0;
                    foreach (var m in input.OrderUserGift)
                    {
                        T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                        modelDetail.F_ProductName = m.F_ProductName;
                        modelDetail.F_ProductId = m.F_ProductId;
                        modelDetail.F_Specifications = m.F_Specifications;
                        modelDetail.F_ProductShortName = m.F_ProductShortName;
                        modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        modelDetail.F_OrderId = input.F_Id;
                        modelDetail.F_Count = 1;
                        modelDetail.F_Price = 0.00M;
                        modelDetail.F_DealPrice = 0.00M;
                        modelDetail.F_Sort = n2;
                        modelDetail.F_Remark = "满赠营销";
                        modelDetail.F_AddUser = modelOrder.F_AddUser;
                        modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                        modelDetail.F_TotlePrice = 0.00M;
                        modelDetail.F_Activity = 0;
                        modelDetail.F_AddTime = DateTime.Now;
                        modelDetailList.Add(modelDetail);
                        n2++;
                    }
                    if (n2 > b)
                    {
                        return Error("该会员最多可赠送" + b + "件赠品");
                    }
                    else
                    {
                        modelvip.F_UseGift += n2;
                        modelOrder.F_UseGift = n2;
                    }
                }
                if (modelvip != null)
                {
                    modelvip.F_Score -= modelOrder.F_UseScore;
                    await cus_vip_infoRepository.Update(modelvip);
                }
                if (input.F_State == 1)
                {

                    if (modelOrder.F_State == 1)
                        count += "进入客服待分仓";
                    else if (modelOrder.F_State == 7)
                        count += "进入客服待付款待审核";
                }
                else
                    count += "进入销售待提交";
            }
            if (input.F_IsPayment > 0 || input.F_PayType != "货到付款")
            {
                try
                {

                    if (string.IsNullOrEmpty(input.F_PayType))
                        return Error("请输入打款方式");
                    if (string.IsNullOrEmpty(input.OrderMoney.F_RemarkKF))
                        input.OrderMoney.F_RemarkKF = "";
                    if (string.IsNullOrEmpty(input.OrderMoney.F_RemarkXS))
                        input.OrderMoney.F_RemarkXS = "";
                    if (input.OrderMoney.F_PayTime == null)
                        return Error("请输入打款时间");
                    if (input.OrderMoney.F_Money <= 0)
                        return Error("请输入付款金额");
                   
                    #region 验证参数 必填项  
                    Expression<Func<T_Bus_OrderMoney, bool>> eq = a => a.F_OrderId == input.F_Id;
                    //var  modelOrderMoen = await busOrderMoneyRepository.GetListALL(eq, o => o.F_AddTime, OrderByType.Asc);
                    var modelOrderMoen = await busOrderMoneyRepository.GetListALL(x => x.F_OrderId == modelOrder.F_Id && x.F_Type == 1);
                    T_Bus_OrderMoney modelOrderMoeny = new T_Bus_OrderMoney();
                    if (modelOrderMoen != null && modelOrderMoen.Count > 0)
                    {
                        modelOrderMoeny = modelOrderMoen.FirstOrDefault();
                    }
                    modelOrder.F_RealPrice = input.OrderMoney.F_Money;
                    #endregion
                    ModelConvertHelper<T_Bus_OrderMoney, OrderMoneyInput>.ModeToModelDefault(modelOrderMoeny, input.OrderMoney);
                    modelOrderMoeny.F_AddUserId = UserLogin.UserId.ObjToInt();
                    modelOrderMoeny.F_UserName = UserLogin.UserName;
                    modelOrderMoeny.F_OrderId = input.F_Id;
                    modelOrderMoeny.F_MoneyBak = modelOrderMoeny.F_Money;
                    modelOrderMoeny.F_State = 0;
                    modelOrderMoeny.F_Type = 1;
                    if (modelOrderMoen != null && modelOrderMoen.Count > 0)
                    {
                        if (!await busOrderMoneyRepository.Update(modelOrderMoeny))
                            return Error("付款失败");
                    }
                    else
                    {
                        modelOrderMoeny.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        if (!await busOrderMoneyRepository.AddReturnCount(modelOrderMoeny))
                            return Error("付款失败");
                    }

                }
                catch (Exception ex)
                { return Error(ex.Message); }
            }
            //DataTable dt=await busOrderMoneyRepository.GetTableSugar(string.Format("SELECT IFNULL(SUM(F_Money),0) FROM T_Bus_OrderMoney WHERE F_OrderId='{0}' AND F_State=1", modelOrder.F_Id));
            //modelOrder.F_RealPrice = dt.Rows[0][0].ObjToDecimal() ;
            //if (modelOrder.F_ShouldPrice > 0)
            //{
            //    if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
            //         modelOrder.F_PayState = 1;
            //    else
            //         modelOrder.F_PayState = 0;
            //}
            //else
            //{
            //    if (modelOrder.F_ShouldPrice >= modelOrder.F_RealPrice)
            //        modelOrder.F_PayState = 3;
            //    else 
            //        modelOrder.F_PayState = 2;                 

            //}
            //待付款 客服审核付款情况后改为已付款

            int t = await AddLog(modelOrder.F_Id, count, UserLogin.UserCode , modelOrder.F_State);
            if (t >0)
            {
                if (await bus_OrderRepository.Update(modelOrder))
                {
                    if (input.OrderDetailList != null && input.OrderDetailList.Count > 0)
                    {
                        //删除之前订单商品，重新添加
                        if (await bus_OrderDetailRepository.Delete(q => q.F_OrderId == modelOrder.F_Id))
                        {

                            if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                                return Success("订单生成成功");
                            else
                                return Error("订单操作失败,请重试1！");
                        }
                        else
                        {
                            if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                                return Success("订单生成成功2");
                            else
                                return Error("订单操作失败,请重试2！");
                        }
                    }
                    else if (input.OrderUserGift != null && input.OrderUserGift.Count > 0)
                    {
                        //删除之前订单商品，重新添加
                        if (await bus_OrderDetailRepository.Delete(q => q.F_OrderId == modelOrder.F_Id
                        &&q .F_Remark == "满赠营销"))
                        {

                            if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                                return Success("订单生成成功");
                            else
                                return Error("订单操作失败,请重试1！");
                        }
                        else
                        {
                            if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                                return Success("订单生成成功2");
                            else
                                return Error("订单操作失败,请重试2！");
                        }
                    }
                    else { return Success("成功"); }
                }

            }

            return Error("订单添加失败,请重试！");


        }
    
        #endregion



        /// <summary>
        /// 根据商品组合 获取符合的所有活动
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getact")]
        public async Task<IActionResult> GetAct([FromBody]List<OrderDetailInput> input)
        {
            decimal def = 0.00M;
            if (input==null&& input.Count<=0)
                return Error("请选择商品/数量");

            //统计活动金额是否符合条件 满减
            Dictionary<int, decimal> acttype3 = new Dictionary<int, decimal>();
            //内部计算
            Dictionary<int, decimal> innerCompute = new Dictionary<int, decimal>();

            //选择活动
            Dictionary<int, string> chooseact = new Dictionary<int, string>();
            List<UseActInput> actlist = new List<UseActInput>();

            Dictionary<string , string> MarketingDic = new Dictionary<string, string>();
            List<T_Sys_Marketing> t_Sys_Marketings = new List<T_Sys_Marketing>();
            foreach (var m in input)
            {
                T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == m.F_ProductId);
                if (modelProduct != null)
                {
                    if (modelProduct.F_OnSaleEnd < DateTime.Now && UserLogin.RoleCode != "SH")
                    {
                        return Error("商品已下架:" + modelProduct.F_ProductName);
                    }
                    if (modelProduct.F_Tag.IndexOf(".") > -1)
                    {
                        string[] tagarry = modelProduct.F_Tag.Split(',');
                        foreach (var it in tagarry)
                        {
                            var Marketing = await bus_MarketingRepository.GetListALL(q => q.F_IsDelete == 0 && q.F_Commodity==
                           it && q.F_StartTime <= DateTime.Now && q.F_EndTime >= DateTime.Now && q.F_IsDelete == 0);
                            if (Marketing!=null&& Marketing.Count >0)
                            {
                                T_Sys_Marketing modelactive = Marketing.FirstOrDefault();
                                //if (modelactive.F_Type == 1)
                                //{
                                //    //满赠
                                //    //判断此人是否有参与活动的资格  默认暂不筛选
                                //    if (chooseact.ContainsKey(modelactive.F_ID))
                                //        continue;
                                //    if (innerCompute.ContainsKey(modelactive.F_ID))
                                //    {
                                //        innerCompute[modelactive.F_ID] = (decimal)modelProduct.F_MemberPrice * m.F_Count + innerCompute[modelactive.F_ID].ObjToDecimal();
                                //    }
                                //    else
                                //    {
                                //        innerCompute.Add(modelactive.F_ID, (decimal)modelProduct.F_MemberPrice * m.F_Count);
                                //    }

                                //    if (modelactive.F_Money.ObjToDecimal() <= (decimal)innerCompute[modelactive.F_ID])
                                //    {
                                //        chooseact.Add(modelactive.F_ID, "1_" + modelactive.F_Gift);
                                //        actlist.Add(new UseActInput { id = modelactive.F_ID, type = 1, gift = modelactive.F_Gift, money = def, actname = modelactive.F_Name, actdes = modelactive.F_PromotionRules });
                                //    }
                                //}
                                //else 
                                if (modelactive.F_Type == 2)
                                {
                                    //  生日
                                    //TODO 判断此人是否有参与活动的资格  默认暂不筛选  
                                    if (chooseact.ContainsKey(modelactive.F_ID))
                                        continue;
                                    chooseact.Add(modelactive.F_ID, "2_" + modelactive.F_Commodity);
                                    actlist.Add(new UseActInput { id = modelactive.F_ID, type = 2, gift = modelactive.F_Gift, money = def, actname = modelactive.F_Name, actdes = modelactive.F_PromotionRules });
                                }
                                else if (modelactive.F_Type == 3)
                                {

                                    //满减
                                    //判断此人是否有参与活动的资格  默认暂不筛选
                                    string[] AmountRange = modelactive.F_AmountRange.Split(',');
                                    if (modelactive.F_Describe == "按总件数")
                                    {
                                        if (innerCompute.ContainsKey(modelactive.F_ID))
                                        {
                                            innerCompute[modelactive.F_ID] = m.F_Count + innerCompute[modelactive.F_ID];
                                        }
                                        else
                                        {
                                            innerCompute.Add(modelactive.F_ID, m.F_Count);
                                        }
                                        for (int i = 0; i < AmountRange.Length; i++)
                                        {
                                            //符合满减某个条件
                                            if (innerCompute[modelactive.F_ID] >= AmountRange[i].ObjToDecimal())
                                            {
                                                if (acttype3.ContainsKey(modelactive.F_ID))
                                                {
                                                    string a = string.Format("{0:f0}", Math.Floor(innerCompute[modelactive.F_ID] / AmountRange[i].ObjToDecimal()));
                                                    acttype3[modelactive.F_ID] = modelactive.F_Money.Split(',')[i].ObjToDecimal() * int.Parse(a);
                                                    actlist.ForEach(q => { if (q.id == modelactive.F_ID) { q.money = modelactive.F_Money.Split(',')[i].ObjToDecimal() * int.Parse(a); } });
                                                }
                                                else
                                                {
                                                    string a = string.Format("{0:f0}", Math.Floor(innerCompute[modelactive.F_ID] / AmountRange[i].ObjToDecimal()));

                                                    acttype3.Add(modelactive.F_ID, modelactive.F_Money.Split(',')[i].ObjToDecimal() * int.Parse(a));
                                                    actlist.Add(new UseActInput { id = modelactive.F_ID, type = 3, gift = "", money = modelactive.F_Money.Split(',')[i].ObjToDecimal() * int.Parse(a), actname = modelactive.F_Name, actdes = modelactive.F_PromotionRules });

                                                }
                                                   
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (innerCompute.ContainsKey(modelactive.F_ID))
                                        {
                                            innerCompute[modelactive.F_ID] = (decimal)modelProduct.F_MemberPrice * m.F_Count + innerCompute[modelactive.F_ID];
                                        }
                                        else
                                        {
                                            innerCompute.Add(modelactive.F_ID, (decimal)modelProduct.F_MemberPrice * m.F_Count);
                                        }
                                        for (int i = 0; i < AmountRange.Length; i++)
                                        {
                                            //符合满减某个条件
                                            if (innerCompute[modelactive.F_ID] >= AmountRange[i].ObjToDecimal())
                                            {
                                                if (acttype3.ContainsKey(modelactive.F_ID))
                                                {
                                                    //当前减免金额大于之前发赋值，替换掉
                                                    if (modelactive.F_Money.Split(',')[i].ObjToDecimal() > acttype3[modelactive.F_ID])
                                                    {
                                                        acttype3[modelactive.F_ID] = modelactive.F_Money.Split(',')[i].ObjToDecimal();
                                                        actlist.ForEach(q => { if (q.id == modelactive.F_ID) { q.money = modelactive.F_Money.Split(',')[i].ObjToDecimal(); } });
                                                    }
                                                }
                                                else
                                                {
                                                    //满足条件，赋值满减金额 减的金额
                                                    acttype3.Add(modelactive.F_ID, modelactive.F_Money.Split(',')[i].ObjToDecimal());
                                                    actlist.Add(new UseActInput { id = modelactive.F_ID, type = 3, gift = "", money = modelactive.F_Money.Split(',')[i].ObjToDecimal(), actname = modelactive.F_Name, actdes = modelactive.F_PromotionRules });
                                                }
                                            }
                                        }
                                    }


                                }
                                else if (modelactive.F_Type == 4)
                                {
                                    //限时特惠
                                    //判断此人是否有参与活动的资格  默认暂不筛选
                                    if (chooseact.ContainsKey(modelactive.F_ID))
                                    {
                                        chooseact[modelactive.F_ID] = chooseact[modelactive.F_ID] + "," + m.F_ProductId.ToString();
                                        actlist.ForEach(q => { if (q.id == modelactive.F_ID) { q.gift = q.gift + m.F_ProductId.ToString(); } });
                                    }
                                    else
                                    {
                                        chooseact.Add(modelactive.F_ID, "4_" + m.F_ProductId.ToString());
                                        actlist.Add(new UseActInput { id = modelactive.F_ID, type = 4, gift = m.F_ProductId.ToString(), money = modelactive.F_Money.ObjToDecimal(), actname = modelactive.F_Name, actdes = modelactive.F_PromotionRules });
                                    }


                                }
                            }
                        }
                    }

                }
                else
                {
                    return Error("商品不存在" + modelProduct.F_ProductName);
                }
            }




         

            return Success("参与活动", actlist);


        }

        /// <summary>
        /// 获取订单详情
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getorderdetail")]
        public async Task<IActionResult> GetOrderDetail(string orderid)
        {
            if (string.IsNullOrEmpty(orderid))
                return Error("请输入订单号");
            T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == orderid);
            OrderInput modelreturn = new OrderInput();
            if (modelOrder != null)
            {
                ModelConvertHelper<OrderInput, T_Bus_Order>.ModeToModel(modelreturn, modelOrder);

                List<OrderDetailInput> modeldetailreturn = new List<OrderDetailInput>();
                List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id
                &&q .F_Remark!="满赠营销", o => o.F_Sort, OrderByType.Asc);
                if (detaillist != null)
                {
                    foreach (T_Bus_OrderDetail m in detaillist)
                    {
                        OrderDetailInput model = new OrderDetailInput();
                        model.F_ProductName = m.F_ProductName;
                        model.F_ProductId = m.F_ProductId;
                        model.F_Specifications = m.F_Specifications;
                        model.F_ProductShortName = m.F_ProductShortName;
                        model.F_Id = m.F_Id;
                        model.F_OrderId = m.F_OrderId;
                        model.F_Count = m.F_Count;
                        model.F_Price = m.F_Price;

                        model.F_DealPrice = m.F_DealPrice;
                        model.F_Sort = m.F_Sort;
                        model.F_AddTime = m.F_AddTime;
                        model.F_Remark = m.F_Remark;
                        model.F_AddUser = m.F_AddUser;
                        model.F_AddUserName = m.F_ProductName;
                        model.F_TotlePrice = m.F_TotlePrice;
                        model.F_Activity = m.F_Activity;
                        modeldetailreturn.Add(model);
                    }
                }
                modelreturn.OrderDetailList = modeldetailreturn;
                List<OrderDetailInput> modelUserGift = new List<OrderDetailInput>();
                List<T_Bus_OrderDetail> detaillistgife = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id
             && q.F_Remark == "满赠营销", o => o.F_Sort, OrderByType.Asc);
                if (detaillist != null)
                {
                    foreach (T_Bus_OrderDetail m in detaillistgife)
                    {
                        OrderDetailInput model = new OrderDetailInput();
                        model.F_ProductName = m.F_ProductName;
                        model.F_ProductId = m.F_ProductId;
                        model.F_Specifications = m.F_Specifications;
                        model.F_ProductShortName = m.F_ProductShortName;
                        model.F_Id = m.F_Id;
                        model.F_OrderId = m.F_OrderId;
                        model.F_Count = m.F_Count;
                        model.F_Price = m.F_Price;

                        model.F_DealPrice = m.F_DealPrice;
                        model.F_Sort = m.F_Sort;
                        model.F_AddTime = m.F_AddTime;
                        model.F_Remark = m.F_Remark;
                        model.F_AddUser = m.F_AddUser;
                        model.F_AddUserName = m.F_ProductName;
                        model.F_TotlePrice = m.F_TotlePrice;
                        model.F_Activity = m.F_Activity;
                        modelUserGift.Add(model);
                    }
                }
                modelreturn.OrderUserGift  = modelUserGift;
                var useraccount =await  _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_Belong);
                if (useraccount!=null )
                {
                    modelreturn.F_BelongName = useraccount.F_UserName;
                    modelreturn.F_GroupName  = useraccount.F_Group ;
                    modelreturn.F_CoreName  = useraccount.F_Team ;
                }
                modelreturn.UseActList = new List<UseActInput>();
                List<IConditionalModel> conModels = new List<IConditionalModel>();
                conModels.Add(new ConditionalModel() { FieldName = "F_ID", ConditionalType = ConditionalType.In , FieldValue = modelOrder.F_UseActivity });
                List<T_Sys_Marketing> modelactiveList = await bus_MarketingRepository.GetListALL(conModels, "F_ID DESC");
                Dictionary<string, string> innerEventprice = new Dictionary<string, string >();
                if (modelactiveList != null && modelactiveList.Count > 0)
                {
                    if (!string.IsNullOrEmpty(modelOrder.F_Eventprice))
                    {
                        string[] Eventprice = modelOrder.F_Eventprice.Split('|');
                        foreach (var it in Eventprice)
                        {
                            try
                            {
                                string[] sprit = it.Split(',');
                                innerEventprice.Add(sprit[0], sprit[1]);
                            }
                            catch
                            {
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(modelOrder.F_Eventprice))
                    {
                        foreach (T_Sys_Marketing modelactive in modelactiveList)
                        {
                            modelreturn.UseActList.Add(new UseActInput
                            {
                                id = modelactive.F_ID,
                                type = modelactive.F_Type,
                                gift = modelactive.F_Gift,
                                money = decimal.Parse(innerEventprice[modelactive.F_ID.ToString()]),
                                actname = modelactive.F_Name,
                                actdes = modelactive.F_PromotionRules
                            });
                        }
                    }
                    else 
                    {
                        foreach (T_Sys_Marketing modelactive in modelactiveList)
                        {
                            modelreturn.UseActList.Add(new UseActInput
                            {
                                id = modelactive.F_ID,
                                type = modelactive.F_Type,
                                gift = modelactive.F_Gift,
                                money = modelOrder.F_ActivityMoney,
                                actname = modelactive.F_Name,
                                actdes = modelactive.F_PromotionRules
                            });
                        }
                    }
                }
              //  modelreturn.UseActList = actlist;
            }
            else
                return Error("订单不存在");
            Expression<Func<T_Bus_Orderlogs , bool>> eq = a => a.F_WoID == orderid;
            var ItemList = await busOrderlogsRepository.GetListALL(eq, o => o.F_CreateTime , OrderByType.Desc );
            Expression<Func<T_Bus_ChatLog, bool>> aq = a => a.F_WoID == orderid;
            aq = aq.And(a => a.F_IsDelete == 0);

            var modelOrderMoen = await busOrderMoneyRepository.GetListALL(x => x.F_OrderId == modelOrder.F_Id && x.F_Type == 1);
            modelreturn.OrderMoney = new OrderMoneyInput();
            if (modelOrderMoen!=null && modelOrderMoen.Count >0)
            {
                ModelConvertHelper<OrderMoneyInput, T_Bus_OrderMoney>.ModeToModel(modelreturn.OrderMoney, modelOrderMoen.FirstOrDefault());
            }
            V_Cus_VipInfo vip = new V_Cus_VipInfo();
            if (modelOrder.F_VipId >0)
            {
                vip = await cus_vip_infoRepository .GetSingleV(x => x.F_ID == modelOrder.F_VipId && x.F_State == (int)EnumDelState.Enabled);
            }
            if (UserLogin.RoleCode == "XS")
            {
                aq = aq.And(a => a.F_IsSo  ==1);
            }
            aq = aq.And(a => a.F_State  == 0);
            var ChatList = await bus_ChatLogRepository.GetListALL(aq, o => o.F_AddTime , OrderByType.Asc);
            var obj = new
            {
                modelreturn,
                ItemList,
                ChatList,
                vip
            };
            return Content(obj.ToJson());
        }
        /// <summary>
        /// 获取订单分页列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getorderlistbypage")]
        public async Task<IActionResult> GetXSOrderListByPage(OrderInput input,string keywords,int State = -1)
        {

            List<IConditionalModel> conModels = new List<IConditionalModel>();
            #region 条件筛选

            if (State > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_State", ConditionalType = ConditionalType.NotIn, FieldValue = "0,2" });
            }
            if (input.F_State > -2)
            {
                if (input.F_State == 14)
                    conModels.Add(new ConditionalModel() { FieldName = "F_State", ConditionalType = ConditionalType.In, FieldValue = "1,4,7" });
                else
                    conModels.Add(new ConditionalModel() { FieldName = "F_State", ConditionalType = ConditionalType.Equal, FieldValue = input.F_State.ToString() });
            }
            if (!string.IsNullOrEmpty(input .F_SubmitUser ))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_SubmitUser", ConditionalType = ConditionalType.Like , FieldValue = input.F_SubmitUser });
            }
           
            //根据角色展示列表
            if (UserLogin.RoleCode == "XS")
            {
                conModels.Add(new ConditionalCollections()
                {
                    ConditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>()
                    {
                        new  KeyValuePair<WhereType, ConditionalModel>( WhereType.And , new ConditionalModel() { FieldName = "F_AddUser", ConditionalType = ConditionalType.Equal, FieldValue = UserLogin.UserId }),
                        new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or, new ConditionalModel() { FieldName = "F_Belong", ConditionalType = ConditionalType.Equal, FieldValue = UserLogin.UserId })
                     }
                } );

            }
            else if (UserLogin.RoleCode == "KF" && input.F_State != 1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_CheckUser", ConditionalType = ConditionalType.Equal, FieldValue = UserLogin.UserId });
            }
            else if (UserLogin.RoleCode == "KG" && input.F_State != 3)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_StockUser", ConditionalType = ConditionalType.Equal, FieldValue = UserLogin.UserId });
                //OR  conModels.Add(new ConditionalModel() { FieldName = "F_SendUser", ConditionalType = ConditionalType.Equal, FieldValue = UserLogin.UserId });
            }
            else if (UserLogin .RoleCode == "ZXFZR")
            {
                var useraccount = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == UserLogin.UserId .ObjToInt());
                conModels.Add(new ConditionalModel() { FieldName = "F_Core", ConditionalType = ConditionalType.Equal, FieldValue = useraccount.F_DeptTeamId.ToString() });
            }
            else if (UserLogin.RoleCode == "XZFZR")
            {
                var useraccount = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == UserLogin.UserId.ObjToInt());
                conModels.Add(new ConditionalModel() { FieldName = "F_Group", ConditionalType = ConditionalType.Equal, FieldValue = useraccount.F_GroupId .ToString() });
            }


            if (input.F_Core > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Core", ConditionalType = ConditionalType.Like, FieldValue = input.F_Core.ToString() });
            }
            if (input.F_Group > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Group", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Group.ToString () });
            }
            if (!string .IsNullOrEmpty (input.F_BelongName))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_BelongName", ConditionalType = ConditionalType.Equal, FieldValue = input.F_BelongName });
            }







            if (!string.IsNullOrEmpty(input.F_ADFrom))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_ADFrom", ConditionalType = ConditionalType.Like, FieldValue = input.F_ADFrom });
            }
            if (!string.IsNullOrEmpty(input.F_Type))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Type", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Type });
            }
            if (!string.IsNullOrEmpty(input.F_Id))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Id", ConditionalType = ConditionalType.Like, FieldValue = input.F_Id });
            }
            if (input .F_IsZeroCommodity>-1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_IsZeroCommodity", ConditionalType = ConditionalType.Equal, FieldValue = input.F_IsZeroCommodity.ToString () });
            }
            if (!string.IsNullOrEmpty(input.F_Customer))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Customer", ConditionalType = ConditionalType.Like, FieldValue = input.F_Customer });
            }
            if (input.F_Media > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Media", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Media.ToString () });
            }
            if (input.F_Status  > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Status", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Status.ToString() });
            }
            if (!string.IsNullOrEmpty(keywords))
            {
                conModels.Add(new ConditionalCollections()
                {
                    ConditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>()
                    {
                                new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_Id", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                   new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_TrackingNo", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                           new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_Addressee", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                                       new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_AddPhone", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                                       new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_CustomerTel", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                                         new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_CustomerPhone", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                                             new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_Customer", ConditionalType = ConditionalType.Like, FieldValue = keywords }),
                                                              new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_ADFrom", ConditionalType = ConditionalType.Like, FieldValue = keywords })

                    }
                });
            }
            if (input.F_VipId>0)
            {
                var model = await cus_vip_infoRepository.GetSingleV(x => x.F_ID == input.F_VipId && x.F_State == (int)EnumDelState.Enabled);
                if (model == null)
                    return Error("会员不存在");
                var modellist = await cus_vip_infoRepository.GetListALL(x => x.F_ParentID == input.F_VipId && x.F_State == (int)EnumDelState.Delete);

                if (modellist != null || modellist.Count> 0)
                {
                    string msgvip = input.F_VipId.ToString();
                    foreach (var it in modellist)
                    {
                        msgvip+=","+ it.F_ID ;
                    }
                    conModels.Add(new ConditionalModel() { FieldName = "F_VipId", ConditionalType = ConditionalType.In, FieldValue = msgvip });
                }
                else 
                    conModels.Add(new ConditionalModel() { FieldName = "F_VipId", ConditionalType = ConditionalType.Equal, FieldValue = input.F_VipId.ToString() });

            }
            if (!string.IsNullOrEmpty(input.F_CustomerPhone))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_CustomerPhone", ConditionalType = ConditionalType.Like , FieldValue = input.F_CustomerPhone });
            }
            if (!string.IsNullOrEmpty(input.F_TrackingNo))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_TrackingNo", ConditionalType = ConditionalType.Like, FieldValue = input.F_TrackingNo });
            }
            if (!string.IsNullOrEmpty(input.F_AddProvince))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddProvince", ConditionalType = ConditionalType.Equal, FieldValue = input.F_AddProvince });
            }
            if (!string.IsNullOrEmpty(input.F_AddCity))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddCity", ConditionalType = ConditionalType.Equal, FieldValue = input.F_AddCity });
            }
            if (!string.IsNullOrEmpty(input.F_AddArea))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddArea", ConditionalType = ConditionalType.Equal, FieldValue = input.F_AddArea });
            }
            if (!string.IsNullOrEmpty(input.F_AddTown))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddTown", ConditionalType = ConditionalType.Equal, FieldValue = input.F_AddTown });
            }
            if (!string.IsNullOrEmpty(input.F_Express))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Express", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Express });
            }
            if (!string.IsNullOrEmpty(input.F_PayType))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_PayType", ConditionalType = ConditionalType.Equal, FieldValue = input.F_PayType });
            }
            if (!string.IsNullOrEmpty(input.F_Stock))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Stock", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Stock });
            }
            if (input.F_PayState > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_PayState", ConditionalType = ConditionalType.Equal, FieldValue = input.F_PayState.ToString() });
            }
            if (input.SearchEndTime != null)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddTime", ConditionalType = ConditionalType.LessThan, FieldValue = input.SearchEndTime.GetValueOrDefault().ToString("yyyy-MM-dd 23:59:59") });
            }
            if (input.SearchStartTime != null)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddTime", ConditionalType = ConditionalType.GreaterThan, FieldValue = input.SearchStartTime.GetValueOrDefault().ToString("yyyy-MM-dd 00:00:01") });
            }




            #endregion
            RefAsync<int> recordCount = 0;
            PageData<T_Bus_Order> list = await bus_OrderRepository.GetListByPage(conModels, new MyPageModel() { PageIndex = input.pageindex, PageSize = input.pagesize, PageCount = recordCount }, " F_AddTime DESC");
            PageData<OrderInput> returnobj = new PageData<OrderInput>() { Totals = list.Totals };
            List<OrderInput> returnlist = new List<OrderInput>();
            foreach (T_Bus_Order t in list.Rows)
            {
                OrderInput m = new OrderInput();
                ModelConvertHelper<OrderInput, T_Bus_Order>.ModeToModel(m, t);

                List<OrderDetailInput> orderDetailInputs = new List<OrderDetailInput>();
                #region 遍历订单商品
                List<T_Bus_OrderDetail> orderDetails = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == t.F_Id);
                if (orderDetails != null)
                {
                    foreach (T_Bus_OrderDetail t1 in orderDetails)
                    {
                        OrderDetailInput m1 = new OrderDetailInput();
                        ModelConvertHelper<OrderDetailInput, T_Bus_OrderDetail>.ModeToModel(m1, t1);
                        orderDetailInputs.Add(m1);
                    }
                }
                #endregion
                m.OrderDetailList = orderDetailInputs;
                m.IsSale  = busAfterSaleRepository.GetListALL(x => x.F_OrderId == t.F_Id).Result!=null
                    ? busAfterSaleRepository.GetListALL(x => x.F_OrderId == t.F_Id).Result.Count :0;
               
                returnlist.Add(m);
            }
            returnobj.Rows = returnlist;

            return Success("成功", returnobj);


        }



        /// <summary>
        /// 撤回未审核订单
        /// </summary>
        /// <param name="orderid">订单号</param>
        /// <param name="state">订单状态 -1无效 0暂存 1提交  2KF退回  3通过 4KG退回 5已分拣 6已发货</param>
        /// <param name="remark">客服备注</param>
        /// <returns></returns>
        [HttpPost("cancelorder")]
        public async Task<IActionResult> CancelOrder(string orderids, int state = 0)
        {
            try
            {
                //状态变化  积分变化  处理时间人变化  库存变化  备注
                T_Cus_VipInfo modelvip = new T_Cus_VipInfo();
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(orderids))
                    return Error("请选择订单号");
                if (state != 0)
                    return Error("请选择操作类型");
                string[] orderid = orderids.Split(',');
                string msg = "";
                #endregion
                List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
                List<T_Bus_Order> orders = new List<T_Bus_Order>();
                foreach (var it in orderid)
                {
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it && new int[] {1, 3,  7 }.Contains(q.F_State));
                    if (modelOrder == null)
                    {
                       msg +="订单"+ it + "已审核";
                        continue;
                    }
                    else
                    {
                        if (modelOrder.F_State ==1)
                        {
                            List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                         //   List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                            if (detaillist != null && detaillist.Count > 0)
                            {
                                foreach (var iv in detaillist)
                                {
                                    T_Bus_Product t_Bus_Product = await bus_productRepository.GetSingle(x => x.F_ProductId == iv.F_ProductId);
                                    if (t_Bus_Product != null)
                                    {
                                      //  t_Bus_Product.F_UseNumber -= iv.F_Count;
                                      //  Productlist.Add(t_Bus_Product);
                                    }
                                    else
                                    {
                                        msg += "订单" + modelOrder.F_Id + "退回失败,商品不存在.";
                                        continue;
                                    }
                                }
                                //if (Productlist != null && Productlist.Count > 0)
                                //{
                                //    if (!await bus_productRepository.UpdateList(Productlist))
                                //    {
                                //        msg += "订单" + modelOrder.F_Id + "退回失败";
                                //        continue;
                                //    }
                                // }
                                //else
                                //{
                                //    msg += "订单" + modelOrder.F_Id + "退回失败,请选择商品";
                                //    continue;

                                //}
                            }
                        }
                        modelOrder.F_TrackingNo = "";
                        modelOrder.F_Express = "";
                        modelOrder.F_IsExpress = 0;
                        modelOrder.F_Stock = "";
                        modelOrder.F_State = state;
                        t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                        t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                        t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "撤回订单,流转销售待提交";
                        t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                        logs.Add(t_Bus_Orderlogs);
                        orders.Add(modelOrder);
                    }
                  
                }
            //    string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, null);
             //   if (strStock != "1")
                 //   return Error(strStock);
             //   modelOrder.F_State = 0;
           //     modelOrder.F_Score = 0.00M;
                if (msg =="")
                {
                    if (await bus_OrderRepository.UpdateList(orders))
                    {
                        await busOrderlogsRepository.AddMany (logs);
                        return Success("订单成功审核！");
                    }
                }
                else
                    return Error(msg);

                return Error("订单审核失败,请汇报技术支持！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }


        [HttpPost("ordermoney")]
        public async Task<IActionResult> OrderMoney(OrderMoneyInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_OrderId))
                    return Error("请输入订单号");
                if (string.IsNullOrEmpty(input.F_PayUser))
                    return Error("请输入打款人");
                if (string.IsNullOrEmpty(input.F_PayType))
                    return Error("请输入打款方式");
                if (string.IsNullOrEmpty(input.F_RemarkKF))
                    input.F_RemarkKF = "";
                if (string.IsNullOrEmpty(input.F_RemarkXS))
                    input.F_RemarkXS = "";
                if (input.F_PayTime==null)
                    return Error("请输入打款时间");
                if (input.F_Money <= 0)
                    return Error("请输入金额");

                #endregion

                T_Bus_OrderMoney modelOrderMoeny = new T_Bus_OrderMoney();
                ModelConvertHelper<T_Bus_OrderMoney, OrderMoneyInput>.ModeToModelDefault(modelOrderMoeny, input);
                modelOrderMoeny.F_AddUserId =UserLogin.UserId.ObjToInt();
                modelOrderMoeny.F_UserName = UserLogin.UserName;
                modelOrderMoeny.F_MoneyBak= modelOrderMoeny.F_Money;
                modelOrderMoeny.F_State= 0;
                modelOrderMoeny.F_Id = Guid.NewGuid().ToString().Replace("-","");
                if (await busOrderMoneyRepository.AddReturnCount(modelOrderMoeny))
                    return Success("成功！");
                return Error("失败！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }


       private async Task<int> AddLog(string WoID,string count,string user,int state)
        {
            T_Bus_Orderlogs logs = new T_Bus_Orderlogs();
            logs.F_WoID = WoID;
            logs.F_WoState = state;
            logs.F_OptContent  = count;
            logs.F_CreateUser  = user;
            logs.F_CreateTime  = DateTime .Now ;
            var res =await  busOrderlogsRepository.Add(logs);
            return res;
        }

    }
}