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

/* =============================================
-- 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.Threading.Tasks;
using System.Utility.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
using Microsoft.Extensions.Configuration;
using SqlSugar;
using System.Text.RegularExpressions;
using TVShoppingCallCenter_ZLJ.Models.Inputs;

namespace TVShoppingCallCenter_ZLJ.Controllers.Order
{
    [Route("api/[controller]")]
    public class KFOrderController : BaseController
    {
        #region 
        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 OrderFunctionController busOrderFunctionController;
        private readonly IBus_OrderlogsRepository busOrderlogsRepository;
        private readonly IBus_AfterSaleRepository busAfterSaleRepository;
        private readonly ISys_DictionaryValueRepository _sys_dictionaryRepository;
        private readonly ISMS_InternalMessagesReposytory _sys_internalMessagesrepository;
        private readonly ISys_UserAccountRepository _sys_useraccountRepository;
        private readonly ISys_RoleInfoRepository sys_RoleInfoRepository  ;
        private readonly ICus_MembershipRepository _cus_membershiprepository;
        private readonly ISys_TaskManagementRepository _sys_taskmanagement_Repository;
        public KFOrderController(IBus_AfterSaleRepository _busAfterSaleRepository, 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_OrderlogsRepository _busOrderlogsRepository
            ,ISys_DictionaryValueRepository sys_dictionaryRepository, ISMS_InternalMessagesReposytory sys_internalMessagesrepository,
           ISys_UserAccountRepository sys_useraccountRepository, ISys_RoleInfoRepository _sys_RoleInfoRepository
            , IConfiguration configuration, ICus_MembershipRepository cus_membershiprepository,
           ISys_TaskManagementRepository sys_taskmanagement_Repository
        
            )
        {
            _sys_taskmanagement_Repository = sys_taskmanagement_Repository;
            busAfterSaleRepository = _busAfterSaleRepository;
            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;
            busOrderMoneyRepository = _busOrderMoneyRepository;
            config = _configuration;
            busOrderFunctionController = _OrderFunctionController;
            busOrderlogsRepository = _busOrderlogsRepository;
            _sys_dictionaryRepository = sys_dictionaryRepository;
            sys_RoleInfoRepository = _sys_RoleInfoRepository;
            _sys_useraccountRepository = sys_useraccountRepository;
            _sys_internalMessagesrepository = sys_internalMessagesrepository;
            _cus_membershiprepository = cus_membershiprepository;
            _cus_score_setRepository = cus_score_setRepository;
        }
        #endregion
        /// <summary>
        /// 导入订单跟踪
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("importordertrack")]
        public async Task<IActionResult> ImportOrderTrack(int type=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}");
            
            //将数据导入数据库
            int headrow = 0;
            NPOIHelper npoi = new NPOIHelper();
            DataTable dtExcel = npoi.ExcelToTable1(_upfile, headrow);
            string errmsg = "";
            if (dtExcel.Rows.Count > 0)
            {
                if (type == 1)
                {
                    Dictionary<string, string> dirList = new Dictionary<string, string>();
                    string[] arrykey = config["Import:ordertrackkey"].ToString().ToLower().Split(',');
                    string[] arryvalue = config["Import:ordertracktvalue"].ToString().Split(',');
                    for (int i = 0; i < arrykey.Length; i++)
                    {
                        dirList.Add(arrykey[i], arryvalue[i]);
                    }
                    IList<T_Bus_AfterSale> IModels = ModelConvertHelper<T_Bus_AfterSale>.ConvertToModelByColumns(dtExcel, dirList);

                    List<T_Bus_AfterSale> models = new List<T_Bus_AfterSale>();
                    
                    int num = 0;
                    foreach (var it  in IModels)
                    {
                        num++;
                        if (IsRegex(it .F_TrackingNo))
                        {
                            T_Bus_AfterSale t_Bus_AfterSale = await busAfterSaleRepository.GetSingle (x=>x .F_Id ==it .F_Id );
                            if (t_Bus_AfterSale!=null )
                            {
                                t_Bus_AfterSale.F_TrackingNo = it.F_TrackingNo;
                                models.Add(t_Bus_AfterSale);
                            }
                            else
                            {
                                errmsg = errmsg + "\r\n第" + num + "行导入失败！订单不存在";
                                continue;
                            } 
                           
                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + num + "行导入失败！运单号格式错误";
                            continue;
                        }
                    }
                 //   List<T_Bus_AfterSale> models = ModelConvertHelper<T_Bus_AfterSale>.ConvertIListToList(IModels);
                    

                    if (models != null && models.Count > 0)
                    {
                        //foreach (T_Bus_Order model in models)
                        //{
                        //状态如果需要更新 下面加F_State  如果需要验证之前状态，这里要循环查询
                        //}

                        if (await busAfterSaleRepository.UpdateListToColumns(models, s => new { s.F_TrackingNo }))
                        {
                            if (errmsg == "")
                                return Success("成功");
                            else
                                return Error(errmsg);
                        }
                    }
                }
                else
                {
                    Dictionary<string, string> dirList = new Dictionary<string, string>();
                    string[] arrykey = config["Import:ordertrackkey"].ToString().ToLower().Split(',');
                    string[] arryvalue = config["Import:ordertracktvalue"].ToString().Split(',');
                    for (int i = 0; i < arrykey.Length; i++)
                    {
                        dirList.Add(arrykey[i], arryvalue[i]);
                    }
                    IList<T_Bus_Order> IModels = ModelConvertHelper<T_Bus_Order>.ConvertToModelByColumns(dtExcel, dirList);

                    List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
                    List<T_Bus_Order> models = new List<T_Bus_Order>();
                    int num = 0;
                    foreach (var it in IModels)
                    {
                        num++;
                        if (IsRegex(it.F_TrackingNo))
                        {
                            T_Bus_Order _Order  = await bus_OrderRepository .GetSingle(x => x.F_Id == it.F_Id);
                            T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                            if (_Order != null)
                            {
                                if (await bus_OrderRepository.GetCount(q => (q.F_TrackingNo == it.F_TrackingNo)) > 0)
                                {
                                    errmsg = errmsg + "\r\n第" + num + "行导入失败！运单号重复" + it.F_TrackingNo;
                                    continue;
                                }
                                else
                                {
                                    _Order.F_TrackingNo = it.F_TrackingNo;
                                    t_Bus_Orderlogs.F_WoID = _Order.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 = _Order.F_State;
                                    logs.Add(t_Bus_Orderlogs);
                                    models.Add(_Order);
                                }
                                    
                            }
                            else
                            {
                                errmsg = errmsg + "\r\n第" + num + "行导入失败！订单不存在";
                                continue;
                            }

                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + num + "行导入失败！运单号格式错误";
                            continue;
                        }
                       
                    }


                    if (models != null && models.Count > 0)
                    {
                        foreach (var it in models)
                        {
                            it.F_Waybill = DateTime.Now;
                        }
                        //foreach (T_Bus_Order model in models)
                        //{
                        //状态如果需要更新 下面加F_State  如果需要验证之前状态，这里要循环查询
                        //}

                        if (await bus_OrderRepository.UpdateListToColumns(models, s => new { s.F_TrackingNo, s.F_Status, s.F_Waybill }))
                        {
                            if (errmsg == "")
                            {
                                await busOrderlogsRepository.AddMany (logs);
                                return Success("成功");
                            }
                            else
                                return Error(errmsg);
                        }
                    }

                }
               

            }
            else
            {
                return Success("内容为空");

              
            }
            if (errmsg != "")
                return Error(errmsg);
            return Error("请选择要导入的文件");
        }
        /// <summary>
        /// 上传文件并导入数据库批量退回
        /// </summary>
        /// <returns></returns>
        [HttpPost("importorderbackexcel")]
        public async Task<IActionResult> ImportorderbackExcel(int headrow = 0,int state=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 colnu5m = cols.Count;
            string errmsg = "";
            string user = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value;
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            List<T_SMS_InternalMessages> internalMessages = new List<T_SMS_InternalMessages>();
            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("退回说明"))
                    {
                        modelOrder.F_CheckRemark = dr["退回说明"].ToString();
                       
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    if (modelOrder .F_State ==1|| modelOrder.F_State == 7)
                    {
                        modelOrder.F_State = 2;
                        modelOrder.F_Status = 0;
                        modelOrder.F_TrackingNo = "";
                        modelOrder.F_Express = "";
                        modelOrder.F_IsExpress = 0;
                        modelOrder.F_Stock = "";
                        T_SMS_InternalMessages model = new T_SMS_InternalMessages();
                        model.F_ID = modelOrder.F_Id;
                        model.SMS_Title = "订单退回提醒";
                        model.SMS_Content = "订单" + modelOrder.F_Id + "退回,请注意查收.";
                        var users = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_AddUser);
                        if (users != null)
                        {
                            model.SMS_ReceiveUserCode = users.F_UserCode;
                            model.SMS_Deptid = users.F_DeptId;
                        }
                        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>();
                        //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);
                        //    }
                        //}
                    //    if (Productlist != null && Productlist.Count > 0)
                       // {
                         //   await bus_productRepository.UpdateList(Productlist);
                      //  }
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。";
                        model.SMS_SendUserCode = UserLogin.UserCode;
                        model.SMS_IsRead = 0;
                        model.SMS_SendTime = DateTime.Now;
                        model.SMS_Remindertime = DateTime.Now;
                        model.SMS_IsDelete = 0;
                        model.SMS_Order = 0;
                        model.SMS_IsTop = 1;
                        model.SMS_Type = 1;
                        model.SMS_ReceivingType = 1;
                        internalMessages.Add(model);
                    }
                    else if (state==1)
                    {
                       
                        T_SMS_InternalMessages model = new T_SMS_InternalMessages();
                        model.F_ID = modelOrder.F_Id;
                        modelOrder.F_Status = 0;
                        modelOrder.F_TrackingNo = "";
                        modelOrder.F_Express = "";
                        modelOrder.F_IsExpress = 0;
                        modelOrder.F_Stock = "";
                        model.SMS_Title = "订单退回提醒";
                        if (modelOrder.F_State == 5)
                        {

                            modelOrder.F_State =9;
                            model.SMS_Content = "订单" + modelOrder.F_Id + "退回物流未通过,请注意查收";
                            if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售物流未通过列表。" + "( " + modelOrder.F_CheckRemark + ")";
                            else
                                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售物流未通过列表。";
                        }
                        else
                        {
                            modelOrder.F_State = 2;
                            model.SMS_Content = "订单" + modelOrder.F_Id + "退回客服退回,请注意查收";
                            if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。" + "( " + modelOrder.F_CheckRemark + ")";
                            else
                                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。";
                          
                        }
                       
                      
                        var users = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_AddUser);
                        if (users != null)
                        {
                            model.SMS_ReceiveUserCode = users.F_UserCode;
                            model.SMS_Deptid = users.F_DeptId;
                        }
                        model.SMS_SendUserCode = UserLogin.UserCode;
                        model.SMS_IsRead = 0;
                        model.SMS_SendTime = DateTime.Now;
                        model.SMS_Remindertime = DateTime.Now;
                        model.SMS_IsDelete = 0;
                        model.SMS_Order = 0;
                        model.SMS_IsTop = 1;
                        model.SMS_Type = 1;
                        model.SMS_ReceivingType = 1;
                        internalMessages.Add(model);
                        List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                        string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                      //  if (modelOrder .F_State ==4)
                      //  {
                           // List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                            //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);
                            //    }
                            //}
                            //if (Productlist != null && Productlist.Count > 0)
                            //{
                            //    await bus_productRepository.UpdateList(Productlist);
                            //}
                    //    }
                        modelOrder.F_Status = 0;
                        modelOrder.F_Stock = "";
                       

                    }
                    else if (modelOrder.F_State == 3)
                    {
                        modelOrder.F_Express = "";
                        modelOrder.F_IsExpress  = 0;
                        modelOrder.F_State =8;
                        modelOrder.F_Status = 0;
                        modelOrder.F_TrackingNo = "";
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分物流列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分物流列表。";
                       
                    }
                    else if (modelOrder.F_State == 6)
                    {
                      
                        modelOrder.F_State = 5;
                        modelOrder.F_Status = 0;
                     //   modelOrder.F_TrackingNo = "";
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转仓库待审核列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转仓库待审核列表。";

                    }
                    else if ( modelOrder.F_State == 4|| modelOrder.F_State == 8)
                    {
                        List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                        if (modelOrder.F_State == 8)
                        {
                            string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                        }
                      //  List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        //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);
                        //    }
                        //}
                        //if (Productlist != null && Productlist.Count > 0)
                        //{
                        //    await bus_productRepository.UpdateList(Productlist);
                        //}
                        modelOrder.F_Stock = "";
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。";
                      
                        modelOrder.F_State =1;
                    }
                    else if (modelOrder.F_State == 5)
                    {
                        modelOrder.F_TrackingNo = "";
                        modelOrder.F_State = 3;
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转" + modelOrder.F_Express + "列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转" + modelOrder.F_Express + "列表。";
                      
                    }
                    else
                    {
                        if (modelOrder.F_State>2)
                        {
                            List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                            string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                         //   List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                            //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);
                            //    }
                            //}
                            //if (Productlist != null && Productlist.Count > 0)
                            //{
                            //    await bus_productRepository.UpdateList(Productlist);
                            //}

                        }
                        modelOrder.F_Stock = "";
                        modelOrder.F_TrackingNo = "";
                        modelOrder.F_Express = "";
                        modelOrder.F_IsExpress = 0;
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。";
                       
                        modelOrder.F_State = 1;
                    }
                    
                  
                      
                   
                    modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                    modelOrder.F_CheckUserName = UserLogin.UserName;
                    modelOrder.F_CheckTime = DateTime.Now;
                    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 (errmsg=="")
                {
                    if (!await bus_OrderRepository.UpdateList(orderLIst))
                    {
                        await busOrderlogsRepository.AddAndUpdateList(logs);
                        if (internalMessages.Count > 0)
                            await _sys_internalMessagesrepository.AddAndUpdateList(internalMessages);
                        if (!string.IsNullOrEmpty(errmsg))
                        {
                            errmsg = errmsg + "导入失败！";
                        }
                        else
                        {
                            errmsg = "导入失败！";
                        }
                    }
                } 
                
            }
            else
            {
                return Error("文件中无数据");
            }

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

            return Success("导入成功");
        }
        /// <summary>
        /// 批量退回
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="stock"></param>
        /// <returns></returns>
        [HttpPost("orderback")]
        public async Task<IActionResult> OrderBack(string orderids,string remark,int state=0)
        {

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            string msg = "";
            string[] ids = orderids.Split(',');
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            List<T_SMS_InternalMessages> internalMessages = new List<T_SMS_InternalMessages>();
            foreach (var it in ids)
            {

                T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                modelOrder.F_CheckUserName = UserLogin.UserName;
                modelOrder.F_CheckTime = DateTime.Now;
                modelOrder.F_CheckRemark = remark;
                if (modelOrder.F_State == 1 || modelOrder.F_State == 7)
                {
                    
                   modelOrder.F_State = 2;
                    modelOrder.F_Status = 0;
                    modelOrder.F_TrackingNo = "";
                    modelOrder.F_Express = "";
                    modelOrder.F_IsExpress = 0;
                    modelOrder.F_Stock = "";
                    T_SMS_InternalMessages model = new T_SMS_InternalMessages();
                    model.F_ID = modelOrder.F_Id;
                    model.SMS_Title = "订单退回提醒";
                    model.SMS_Content = "订单" + modelOrder.F_Id + "退回,请注意查收";
                    if (!string .IsNullOrEmpty (modelOrder.F_CheckRemark))
                    {
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。" + "(" + modelOrder.F_CheckRemark+")";
                    }
                    else
                    {
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。";
                    }
                   
                    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>();
                    //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);
                    //    }
                    //}
                    //if (Productlist != null && Productlist.Count > 0)
                    //{
                    //    await bus_productRepository.UpdateList(Productlist);
                    //}
                    var user = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_AddUser);
                    if (user != null)
                    {
                        model.SMS_ReceiveUserCode = user.F_UserCode;
                        model.SMS_Deptid = user.F_DeptId;
                    }
                    model.SMS_SendUserCode = UserLogin.UserCode;
                    model.SMS_IsRead = 0;
                    model.SMS_SendTime = DateTime.Now;
                    model.SMS_Remindertime = DateTime.Now;
                    model.SMS_IsDelete = 0;
                    model.SMS_Order = 0;
                    model.SMS_IsTop = 1;
                    model.SMS_Type = 1;
                    model.SMS_ReceivingType = 1;
                    internalMessages.Add(model);
                }
                else if (state == 1)
                {
                    modelOrder.F_CheckRemark = remark;
                   
                    T_SMS_InternalMessages model = new T_SMS_InternalMessages();
                    model.F_ID = modelOrder.F_Id;
                    model.SMS_Title = "订单退回提醒";
                    if (modelOrder.F_State == 5)
                    {
                        modelOrder.F_State = 9;
                        model.SMS_Content = "订单" + modelOrder.F_Id + "退回物流未通过,请注意查收";
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售物流未通过列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售物流未通过列表。";
                       
                    }
                    else
                    {
                        modelOrder.F_State = 2;
                        model.SMS_Content = "订单" + modelOrder.F_Id + "退回客服退回,请注意查收";
                        if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。" + "( " + modelOrder.F_CheckRemark + ")";
                        else
                            t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转销售客服退回列表。";
                       
                    }
                    var user = await _sys_useraccountRepository.GetSingle(x => x.F_UserId == modelOrder.F_AddUser);
                    if (user != null)
                    {
                        model.SMS_ReceiveUserCode = user.F_UserCode;
                        model.SMS_Deptid = user.F_DeptId;
                    }
                    model.SMS_SendUserCode = UserLogin.UserCode;
                    model.SMS_IsRead = 0;
                    model.SMS_SendTime = DateTime.Now;
                    model.SMS_Remindertime = DateTime.Now;
                    model.SMS_IsDelete = 0;
                    model.SMS_Order = 0;
                    model.SMS_IsTop = 1;
                    model.SMS_Type = 1;
                    model.SMS_ReceivingType = 1;
                    internalMessages.Add(model);
                    List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                    string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                    if (modelOrder .F_State ==4)
                    {
                      //  List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        //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);
                        //    }
                        //}
                        //if (Productlist != null && Productlist.Count > 0)
                        //{
                        //    await bus_productRepository.UpdateList(Productlist);
                        //}
                    }
                    modelOrder.F_Status = 0;
                    modelOrder.F_TrackingNo = "";
                    modelOrder.F_Express = "";
                    modelOrder.F_IsExpress = 0;
                    modelOrder.F_Stock = "";


                }
                else if (modelOrder.F_State == 3 )
                {
                    modelOrder.F_Status = 0;
                    modelOrder.F_Express = "";
                    modelOrder.F_State = 8;
                    modelOrder.F_IsExpress =0;
                    modelOrder.F_TrackingNo  = "";
                    if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分物流列表。" + "( " + modelOrder.F_CheckRemark + ")";
                    else
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分物流列表。";
                   
                }
                else if (modelOrder.F_State == 6)
                {

                    modelOrder.F_State = 5;
                    modelOrder.F_Status = 0;
                    //   modelOrder.F_TrackingNo = "";
                    if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转仓库待审核列表。" + "( " + modelOrder.F_CheckRemark + ")";
                    else
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转仓库待审核列表。";

                }
                else if ( modelOrder.F_State == 4 || modelOrder.F_State == 8)
                {
                    //退回恢复库存
                    if (modelOrder.F_State == 8)
                    {
                        List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                        string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                      //  List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        //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);
                        //    }
                        //}
                        //if (Productlist != null && Productlist.Count > 0)
                        //{
                        //    await bus_productRepository.UpdateList(Productlist);
                        //}
                    }
                    if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。" + "( " + modelOrder.F_CheckRemark + ")";
                    else
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表。";
                  
                    modelOrder.F_Stock = "";
                    modelOrder.F_State = 1;
                }
                else if (modelOrder.F_State == 5)
                {
                    modelOrder.F_State =3;
                    modelOrder.F_TrackingNo = "";
                    if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转" + modelOrder.F_Express+ "列表" + "( " + modelOrder.F_CheckRemark + ")";
                    else
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转" + modelOrder.F_Express+ "列表";

                  
                }
                else
                {
                    if (modelOrder.F_State > 2)
                    {
                        List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                        string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                       // List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        //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);
                        //    }
                        //}
                        //if (Productlist != null && Productlist.Count > 0)
                        //{
                        //    await bus_productRepository.UpdateList(Productlist);
                        //}
                    }
                    modelOrder.F_Status = 0;
                    modelOrder.F_TrackingNo = "";
                    modelOrder.F_Express = "";
                    modelOrder.F_IsExpress = 0;
                    modelOrder.F_Stock = "";
                    modelOrder.F_State = 1;
                    if (!string.IsNullOrEmpty(modelOrder.F_CheckRemark))
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表"+ "( " + modelOrder.F_CheckRemark + ")";
                    else
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单,流转待分仓列表";
                   
                }
                
                
               
                t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
             //   t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "退回订单";
                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);
            }
            
            if (await bus_OrderRepository.UpdateList(orderLIst))
            {
                await busOrderlogsRepository.AddAndUpdateList(logs);
                {
                    if (internalMessages.Count >0)
                    await _sys_internalMessagesrepository .AddAndUpdateList(internalMessages);
                     return Success("退回成功");
                }
                
            }
            else
                return Error("退回失败");

        }

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

                if (string.IsNullOrEmpty(orderid))
                    return Error("请输入订单号");
                if (state <= 0)
                    return Error("请选择操作类型");

                #endregion


                T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == orderid && q.F_State == 1);

                if (modelOrder == null)
                {
                    return Error("只有提交订单才可以审核");
                }
                if (state == 3)
                {
                    if (string.IsNullOrEmpty(modelOrder.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_CheckTime = DateTime.Now;
                modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                modelOrder.F_CheckUserName = UserLogin.UserName;
                if (!string.IsNullOrEmpty(remark))
                    modelOrder.F_CheckRemark = remark;
                if (state == 2)
                {
                    string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 2, null);
                    modelOrder.F_State = 2;
                    modelOrder.F_Score = 0.00M;
                }
                else if (state == 3)
                {
                    #region 判断积分
                    bool blScore = false;
                    if (modelOrder.F_UseScore > 0)
                    {
                        //退回积分  查询批次号核算积分是否已经解冻
                        modelvip = await cus_vip_infoRepository.GetSingle(q => q.F_ID == modelOrder.F_VipId);
                        modelvip.F_Score = modelvip.F_Score + modelOrder.F_UseScore;
                        if (await cus_vip_infoRepository.Update(modelvip))
                        {
                            //log 或者解冻积分
                            blScore = true;
                        }
                    }
                    else
                    {
                        blScore = true;
                    }
                    if (!blScore)
                    {
                        return Error("积分处理失败");
                    }
                    #endregion
                    //库存不做处理
                    modelOrder.F_State = 3;
                }
                if (await bus_OrderRepository.Update(modelOrder))
                    return Success("订单成功审核！");
                return Error("订单审核失败,请汇报技术支持！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }

        /// <summary>
        /// 批量提交
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="stock"></param>
        /// <returns></returns>
        [HttpPost("submitAfter")]
        public async Task<IActionResult> SubmitAfter(string orderids,string id)
        {

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(id))
                return Error("请选择售后单");
            string msg = "";
            string[] order = orderids.Split(',');
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            foreach (var it in order)
            {
                T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                if (modelOrder == null)
                    return Error("订单不存在");
                if (string .IsNullOrEmpty (modelOrder.F_NewTrackingNo) )
                    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_OptContent = UserLogin.UserName + "提交改代收订单";
                t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                logs.Add(t_Bus_Orderlogs);
            }

            string[] ids = id.Split(',');

            if (await busAfterSaleRepository .Update(s => new T_Bus_AfterSale () { F_WoState  = 1 }, q => ids.Contains(q.F_Id)))
            {
                await busOrderlogsRepository.AddMany (logs);
                return Success("成功");
            }
            else
                return Error ("失败");
        }
        /// <summary>
        /// 客服同意改代收
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="stock"></param>
        /// <returns></returns>
        [HttpPost("Agree")]
        public async Task<IActionResult> Agree( string orderids, int state=0)
        {
           
            if (string.IsNullOrEmpty(orderids))
                return Error("请选择售后单");

            string[] ids = orderids.Split(',');
            if (state == 1)
                state =3;
            if (await busAfterSaleRepository.Update(s => new T_Bus_AfterSale() { F_WoState = state }, q => ids.Contains(q.F_Id)))
            {

                return Success("成功");
            }
            else
                return Error("失败");
        }
        /// <summary>
        /// 获取订单分页列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("/api/order/getorderlistbykfpage")]
        public async Task<IActionResult> GetOrderListByKFPage(OrderInput input,string Product,string keywords,
            string startWaybill, string endWaybill, string startexpress,string endexpress,int sort=-1,
              decimal minprice=-1, decimal maxprice=-1,int PayState =0,int state=0,int isdc=0,string usercode="",string username="",int Warehousing=-1,int isWaybill=-1,
              string  Orderstatus="",string Status="")
        {
            
            List<IConditionalModel> conModels = new List<IConditionalModel>();
            #region 条件筛选

          
            if (!string.IsNullOrEmpty(input.F_SubmitUser))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_SubmitUser", ConditionalType = ConditionalType.Like, FieldValue = input.F_SubmitUser });
            }
            if (Warehousing > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Warehousing", ConditionalType = ConditionalType.Equal , FieldValue = Warehousing.ToString() });
            }
            if (!string .IsNullOrEmpty (Orderstatus))
            {

                conModels.Add(new ConditionalModel() { FieldName = "F_State", ConditionalType = ConditionalType.In , FieldValue = Orderstatus });

            }
            else
            {
                if (state > 0)
                {

                    conModels.Add(new ConditionalModel() { FieldName = "F_State", ConditionalType = ConditionalType.NotIn, FieldValue = "0,2" });
                }
                else
                {
                    //状态
                    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 (Status))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Status", ConditionalType = ConditionalType.In , FieldValue = Status });
            }
            //根据角色展示列表
            if (isdc<=0)
            {
                if (UserLogin.RoleCode == "XS")
                {
                    conModels.Add(new ConditionalModel() { FieldName = "F_AddUser", 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_Media > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Media", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Media.ToString() });
            }
            if (minprice > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_TotlePrice", ConditionalType = ConditionalType.GreaterThanOrEqual, FieldValue = minprice.ToString() });
            }

            if (maxprice > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_TotlePrice", ConditionalType = ConditionalType.LessThanOrEqual, FieldValue = maxprice.ToString() });
            }
            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_AddDes))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_AddDes", ConditionalType = ConditionalType.Equal, FieldValue = input.F_AddDes });
            }
            
            if (!string.IsNullOrEmpty(input.F_Type))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Type", ConditionalType = ConditionalType.Equal, FieldValue = input.F_Type });
            }
            if (input.F_IsZeroCommodity >-1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_IsZeroCommodity", ConditionalType = ConditionalType.Equal, FieldValue = input.F_IsZeroCommodity.ToString() });
            }
            if (input.F_VipId > 0)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_VipId", ConditionalType = ConditionalType.Equal, FieldValue = input.F_VipId.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.And  , 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 (!string.IsNullOrEmpty(input.F_Id))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Id", ConditionalType = ConditionalType.Like , FieldValue = input.F_Id });
            }
            if (!string.IsNullOrEmpty(input.F_Customer))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Customer", ConditionalType = ConditionalType.Like, FieldValue = input.F_Customer });
            }
            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 });
            }
             else   if (isWaybill>-1)
            {
                if (isWaybill==0)
                {
                    conModels.Add(new ConditionalModel() { FieldName = "F_TrackingNo", ConditionalType = ConditionalType.Equal  , FieldValue = "" });
                }
                else
                {
                    conModels.Add(new ConditionalModel() { FieldName = "F_TrackingNo", ConditionalType = ConditionalType.NoEqual, FieldValue = "" });
                }
            }
            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 (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_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_IsExpress>-1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_IsExpress", ConditionalType = ConditionalType.Equal, FieldValue = input.F_IsExpress.ToString () });
            }
            
            if (input.F_PayState > -1)
            {
                if (PayState>0)
                {
                    conModels.Add(new ConditionalModel() { FieldName = "F_PayState", ConditionalType = ConditionalType.Equal, FieldValue = input.F_PayState.ToString() });
                }
                else
                {
                    if (input.F_PayState == 1 || input.F_PayState == 3)
                    {
                        conModels.Add(new ConditionalCollections()
                        {
                            ConditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>()
                    {
                        new  KeyValuePair<WhereType, ConditionalModel>( WhereType.And , new ConditionalModel() { FieldName = "F_PayState", ConditionalType = ConditionalType.Equal, FieldValue = "1" }),
                        new  KeyValuePair<WhereType, ConditionalModel>( WhereType.Or , new ConditionalModel() { FieldName = "F_PayState", ConditionalType = ConditionalType.Equal, FieldValue ="3" })
                     }
                        });
                    }
                    else
                    {
                        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") });
            }
            if (input. F_IsExpress > -1)
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_IsExpress", ConditionalType = ConditionalType.Equal, FieldValue = input.F_IsExpress.ToString() });
            }


            if (!string .IsNullOrEmpty (endWaybill ) )
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Waybill", ConditionalType = ConditionalType.LessThan, FieldValue = endWaybill });
            }
            if (!string.IsNullOrEmpty(startWaybill  ))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_Waybill", ConditionalType = ConditionalType.GreaterThan, FieldValue = startWaybill });
            }
            if (!string.IsNullOrEmpty(endexpress))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_ExpressTime", ConditionalType = ConditionalType.LessThan, FieldValue = endexpress });
            }
            if (!string.IsNullOrEmpty(startexpress))
            {
                conModels.Add(new ConditionalModel() { FieldName = "F_ExpressTime", ConditionalType = ConditionalType.GreaterThan, FieldValue = startexpress });
            }
            string sorting = "F_AddTime ASC";
            if (sort > -1)
            {
                if (sort==0)
                {
                    sorting = "F_RealPrice ASC";
                }
                else
                {
                    sorting = "F_RealPrice Desc";
                }
            }
            
            #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 }, sorting);
           
            PageData<OrderInput> returnobj = new PageData<OrderInput>() { Totals = list.Totals };
            List<OrderInput> returnlist = new List<OrderInput>();
            if (isdc ==1)
            {
                var zzroleid =await  sys_RoleInfoRepository.GetListALL (x => x.F_RoleCode == "XZFZR" && x .F_State ==1);
                var jlroleid = await sys_RoleInfoRepository.GetListALL(x => x.F_RoleCode == "ZXFZR" && x.F_State == 1);
                foreach (T_Bus_Order t in list.Rows)
                {
                    OrderInput m = new OrderInput();
                    ModelConvertHelper<OrderInput, T_Bus_Order>.ModeToModel(m, t);
            
                    #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)
                        {
                            m.F_ProductName += ","+t1.F_ProductName+"("+t1 .F_Count +")";
                            m.Count += t1.F_Count;
                        }
                    }
                    if (!string.IsNullOrEmpty(m.F_ProductName))
                        m.F_ProductName = m.F_ProductName.TrimStart(',');
                    var model =await  _sys_useraccountRepository.GetSingle(x => x.F_UserId == t.F_Belong);
                    if (model !=null )
                    {
                        if (zzroleid!=null && zzroleid.Count > 0)
                        {
                            var zz = await _sys_useraccountRepository.GetListALL(x => x.F_GroupId == model.F_GroupId && x.F_RoleId == zzroleid.FirstOrDefault().F_RoleId&&x .F_DeleteFlag ==0);
                            if (zz != null&&zz .Count >0)
                                m.XSZZ = zz.FirstOrDefault().F_UserName;
                        }
                        m.DeptName = model.F_Team;
                        if (jlroleid!=null && jlroleid.Count > 0)
                        {
                            var zz = await _sys_useraccountRepository.GetListALL(x => x.F_DeptTeamId  == model.F_DeptTeamId && x.F_RoleId == jlroleid.FirstOrDefault().F_RoleId && x.F_DeleteFlag == 0);
                            if (zz != null && zz.Count > 0)
                                m.Manager = zz.FirstOrDefault().F_UserName;
                        }
                    }
                    m.F_Ress = t.F_AddProvince + t.F_AddCity + t.F_AddArea + t.F_AddTown + t.F_Address;
                    List<T_Sys_Marketing> modelactiveList = await bus_MarketingRepository.GetListALL(b => ("," + t.F_UseActivity + ",").Contains(("," + b.F_ID.ToString() + ",")));
                    if (modelactiveList != null && modelactiveList.Count > 0)
                    {
                        foreach (T_Sys_Marketing modelactive in modelactiveList)
                        {
                            m.Preferential += ","+modelactive.F_Name;
                        }
                    }
                    if (!string .IsNullOrEmpty (m.Preferential))
                    m.Preferential = m.Preferential.TrimStart(',');
                    #endregion
                    returnlist.Add(m);
                }
            }
            else if (isdc ==2)
            {
               
                    var model = _sys_dictionaryRepository.GetListALL(x => x.F_ValueCode == "EXPRESS" && x.F_State == 1 && x.F_IsLeaf == true).Result;
                    if (model != null && model.Count > 0)
                    {
                        List<Billoflading> Billofladings = new List<Billoflading>();
                        int n = 1;
                        foreach (var it in model)
                        {
                            Billoflading billoflading = new Billoflading();
                            List<T_Bus_OrderDetail> Details = new List<T_Bus_OrderDetail>();
                            var order = list.Rows.Where(x => x.F_Express == it.F_Value);
                            billoflading.express = it.F_Value;

                            if (order != null && order.Count() > 0)
                            {
                                Random random = new Random();
                                billoflading.code = "TH-K" + random.Next(100, 999) + "-" + usercode + "-" + DateTime.Now.ToString("yyMMdd") + n++;
                                // billoflading.code = "TH-K" + random.Next(100, 999) + "-" +"8000" + "-" + DateTime.Now.ToString("yyMMdd") + n++;
                                foreach (var iv in order)
                                {
                                    List<T_Bus_OrderDetail> orderDetails = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == iv.F_Id);
                                    if (orderDetails != null)
                                    {
                                        Details.AddRange(orderDetails);
                                    }
                                    billoflading.user = iv.F_CheckUserName;
                                    //  billoflading.user = "8000";
                                    billoflading.maketime = (DateTime)iv.F_CheckTime;
                                    // billoflading.maketime = DateTime.Now ;
                                }
                                var query = Details.GroupBy(x => new { x.F_ProductName, x.F_ProductShortName, x.F_Specifications }).Select(x => new { F_Count = x.Select(y => y.F_Count).Sum(), x.Key.F_ProductShortName, x.Key.F_Specifications, x.Key.F_ProductName });
                                billoflading.checkuser = username ;
                                //  billoflading.checkuser = "8000";
                                billoflading.commodities = new List<Commodity>();
                                int res = 1; int count = 0;
                                foreach (var im in query)
                                {
                                    Commodity commodity = new Commodity();
                                    commodity.serialnumber = res++;
                                    commodity.F_ProductName = im.F_ProductName;
                                    commodity.F_Specifications = im.F_Specifications;
                                    commodity.F_ProductShortName = im.F_ProductShortName;
                                    commodity.F_Count = im.F_Count;
                                    count += im.F_Count;
                                    billoflading.commodities.Add(commodity);
                                }
                                billoflading.count = count;
                                Billofladings.Add(billoflading);

                            }
                        }
                        NPOIHelper npoi = new NPOIHelper();
                        byte[] sm = npoi.BillofladingExportToExcel(Billofladings);
                        if (sm != null)
                        {
                            return File(sm, "application/vnd.ms-excel", "提货单.xlsx");
                        }
                        else
                        {
                            return Error("导出失败");
                        }

                    }
                    else
                        return Error("暂无快递");

                
            }
            else if (isdc ==3)
            {
                var tb = ModelConvertHelper<T_Bus_Order>.ConvertListToDataTable(list .Rows);
                NPOIHelper npoi = new NPOIHelper();
                string dbkeys = config["Import:ordertrackkey"].ToString();
                string title = config["Import:ordertracktvalue"].ToString();
                string[] colname = dbkeys.Split(",");
                string[] cols = title.Split(",");
                byte[] sm = npoi.ExportToExcel1(tb, cols, colname);
                if (sm != null)
                {
                    return File(sm, "application/vnd.ms-excel", "运单号导入模板.xlsx");
                }
                else
                {
                    return Error("导出失败");
                }


            }
            else
            {
                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;
                    if (!string.IsNullOrEmpty(Product))
                    {
                        if (orderDetailInputs.Select(x => x.F_ProductId == Product).Count() > 0)
                            returnlist.Add(m);
                    }
                    else
                        returnlist.Add(m);
                }
            }
            
            returnobj.Rows = returnlist;
            if (input.F_State == 6)
            {
                returnobj.Rows = returnlist.OrderBy(x => x.F_Status ).ThenByDescending(x => x.F_AddTime ).ToList();//排序
              
            }
            if (isdc >0)
            {
                var tb = ModelConvertHelper<OrderInput>.ConvertListToDataTable(returnobj.Rows );
                NPOIHelper npoi = new NPOIHelper();
                string dbkeys = config["Import:orderkey"].ToString();
                string title = config["Import:ordervalue"].ToString();
                string[] colname = dbkeys.Split(",");
                string[] cols = title.Split(",");
                byte[] sm = npoi.ExportToExcel1(tb, cols, colname);
                if (sm != null)
                {
                    return File(sm, "application/vnd.ms-excel", "订单列表.xlsx");
                }
                else
                {
                    return Error("导出失败");
                }
            }
            return Success("成功", returnobj);

        }
     

        /// <summary>
        /// 修改订单 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("/api/order/editorderkf")]
        public async Task<IActionResult> EditOrderKF([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("请输入客户电话");
            #endregion


            T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_Id);
            if (modelOrder == null)
            {
                return Error("此订单号不存在");
            }
            //保存 审退回 仓退回
            if (!(new int[] { 1, 3 ,4}.Contains(modelOrder.F_State)))
            {
                return Error("此状态订单不允许修改，先撤回订单");
            }

                #region 数据绑定
                //必填
                modelOrder.F_ADFrom = input.F_ADFrom;
            modelOrder.F_Type = input.F_Type;
            modelOrder.F_Id = input.F_Id;


            if (input.F_CustomerType > 0)
            { modelOrder.F_CustomerType = input.F_CustomerType; }
            if (!string.IsNullOrEmpty(input.F_CustomerTel))
            { modelOrder.F_CustomerTel = input.F_CustomerTel; }
            //选填 快递属性
            if (!string.IsNullOrEmpty(input.F_TrackingNo))
            { modelOrder.F_TrackingNo = input.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; }
            if (!string.IsNullOrEmpty(modelOrder.F_Express))
                modelOrder.F_IsExpress = 1;
            //选填 关联属性
            modelOrder.F_ExpressFee = input.F_ExpressFee;
            modelOrder.F_State = input.F_State;
            modelOrder.F_Status = 0;
            //必须属性 系统生成
            modelOrder.F_CheckTime = DateTime.Now;
            modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
            modelOrder.F_CheckUserName = UserLogin.UserName;

            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("收件人详细地址不能为空");
            }
            #endregion

            modelOrder.F_ShouldPrice = modelOrder.F_TotlePrice - modelOrder.F_ActivityMoney + modelOrder.F_ExpressFee + modelOrder.F_MergeMoney;

            if (await bus_OrderRepository.Update(modelOrder))
            {
                return Success("成功");
            }

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


        }
        /// <summary>
        /// 订单打标签 
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="tags"></param>
        /// <returns></returns>
        [HttpPost("addordertag")]
        public async Task<IActionResult> AddOrderTag(string orderids, string tags)
        {

            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(tags))
                return Error("请选择标签");
            #endregion
            string[] ids = orderids.Split(',');
            if (await bus_OrderRepository.Update(s => new T_Bus_Order() { F_Tag = tags }, q => ids.Contains(q.F_Id)))
            {
                return Success("成功");
            }

            return Error("失败,请重试！");

        }
        /// <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_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();
                    string F_TrackingNo = "";

                    if (dr.Table.Columns.Contains("运单号"))
                    {
                        if (IsRegex(dr["运单号"].ToString()))
                        {
                            F_TrackingNo = dr["运单号"].ToString();
                        }
                        else
                        {
                            errmsg = errmsg + "\r\n第" + index + "行导入失败！运单号格式错误";
                            continue;
                        }
                    }
                    else
                    {
                        return Error("模板错误，请选择正确的模板");
                    }
                    if (dr.Table.Columns.Contains("订单号"))
                    {
                        if (!string.IsNullOrEmpty(dr["订单号"].ToString()))
                        {
                            modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == dr["订单号"].ToString().Trim ()
                            && q .F_TrackingNo == F_TrackingNo);
                            if (modelOrder == null)
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！订单号或运单号错误";
                                continue;
                            }
                            else if (modelOrder .F_State !=6)
                            {
                                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
                            {
                                var model = _sys_dictionaryRepository.GetListALL (x => x.F_Remark == dr["快递状态"].ToString() && x.F_State == 1&&x.F_ValueCode == "OrderF_State").Result ;
                                if (model!=null &&model .Count >0)
                                {
                                    modelOrder.F_Status =int .Parse ( model[0].F_Value) ;
                                }
                                else
                                {
                                    errmsg = errmsg + "\r\n第" + index + "行导入失败！快递状态错误";
                                    continue;
                                }
                            }
                            catch
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！快递状态错误";
                                continue;
                            }
                        }
                        else
                        {
                            return Error("模板错误，请选择正确的模板");
                        }
                    if (dr.Table.Columns.Contains("实付金额"))
                    {
                        if (!string.IsNullOrEmpty(dr["实付金额"].ToString()))

                            try
                            {
                                modelOrder.F_RealPrice = 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;
                                        //更新最终消费金额
                                        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)
                                            {
                                                int multiple = 1;
                                                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_Membership = t_Cus_Membership.F_Name;
                                                    vip.F_MembershipId = t_Cus_Membership.F_ID;
                                                    if (vip.F_Membership.Contains  ("VIP钻石会员"))
                                                    {
                                                        multiple = 2;
                                                    }
                                                }
                                                if (modelOrder.F_Status == 2&& modelOrder.VipCount<1
                                                    && decimal .Parse(dr["实付金额"].ToString())>0)
                                                {
                                                    modelOrder.VipCount = 1;
                                                    vip.F_Count  += 1;
                                                    if (vip.F_Birthday!=null )
                                                    {
                                                        if (((DateTime)vip.F_Birthday).ToString("yyyy-MM-dd") ==                                 DateTime.Now.ToString("yyyy-MM-dd"))
                                                            multiple = 2;
                                                    }
                                                    var model = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                                                    vip.F_Score += decimal.Parse(dr["实付金额"].ToString()) * model.F_GetPercent* multiple;
                                                    if (vip.F_TotalScore == null)
                                                        vip.F_TotalScore = 0.00M;
                                                    vip.F_TotalScore  += decimal.Parse(dr["实付金额"].ToString()) * model.F_GetPercent* multiple;
                                                    if (vip .F_RecommenderID>0 )
                                                    {
                                                        T_Cus_VipInfo vipinfo = await cus_vip_infoRepository.GetSingle(x => x.F_ID == vip.F_RecommenderID);
                                                        if (vipinfo!=null )
                                                        {
                                                            vipinfo.F_Score+= decimal.Parse(dr["实付金额"].ToString()) * model.F_GetPercent * multiple;
                                                            if (vipinfo.F_TotalScore == null)
                                                                vipinfo.F_TotalScore = 0.00M;
                                                            vipinfo.F_TotalScore += decimal.Parse(dr["实付金额"].ToString()) * model.F_GetPercent * multiple;
                                                            await cus_vip_infoRepository.Update(vipinfo);
                                                        }
                                                    }
                                                    UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                                                }
                                                await cus_vip_infoRepository.Update(vip);
                                            }
                                        }
                                    }
                                }
                                else if (modelOrder.F_PayState == 2)
                                {
                                    if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                                    {
                                        //0待回款1已支付 2待退款3已退款
                                        modelOrder.F_PayState = 3;
                                    }
                                }
                              
                            }
                            catch
                            {
                                errmsg = errmsg + "\r\n第" + index + "行导入失败！实付金额错误";
                                continue;
                            }
                    }
                    string msg = "";
                    if (modelOrder.F_Status == 2)
                        msg = "签收";
                    else if (modelOrder.F_Status == 4)
                        msg = "拒收";
                    modelOrder.F_Waybill = DateTime.Now;
                    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 + "更新物流状态"+ msg;
                    t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                    logs.Add(t_Bus_Orderlogs);
                    orderLIst.Add(modelOrder);
                   
                }
                if (orderLIst.Count >0)
                {
                    if (!await bus_OrderRepository.UpdateList(orderLIst))
                    {
                        await busOrderlogsRepository.AddMany(logs);
                        if (!string.IsNullOrEmpty(errmsg))
                        {
                            errmsg = errmsg + "导入失败！";
                        }
                        else
                        {
                            errmsg = "导入失败！";
                        }
                    }
                }
                
               
            }
            else
            {
                return Error("文件中无数据");
            }

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

            return Success("导入成功");
        }
        /// <summary>
        /// 更新物流状态 
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="status">0 未发出 1未签收2签收3改代收4拒收</param>
        /// <returns></returns>
        [HttpPost("updatestatus")]
        public async Task<IActionResult> UpdateStatus(string orderids, int status=-1)
        {

            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (status <0)
                return Error("请选择状态");
            #endregion
            string[] ids = orderids.Split(',');
            List<T_Bus_Order> orders = new List<T_Bus_Order>();
            List<T_Cus_VipInfo > vips = new List<T_Cus_VipInfo>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            foreach (var it in ids)
            {
                var modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                if (modelOrder == null)
                    return Error("订单" + it + "不存在");
                modelOrder.F_Status = status;
                modelOrder.F_Waybill = DateTime.Now;
                if (modelOrder.F_RealPrice >0&& status==2&&modelOrder .VipCount < 1)
                {
                    var vip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
             
                
                    if (vip != null)
                    {
                        int multiple = 1;
                        vip.F_Money += modelOrder.F_RealPrice;
                        var membership = await _cus_membershiprepository.GetListALL(x => x.F_State != 2);
                        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_Membership = t_Cus_Membership.F_Name;
                            vip.F_MembershipId = t_Cus_Membership.F_ID;
                            if (vip.F_Membership.Contains("VIP钻石会员"))
                            {
                                multiple = 2;
                            }
                        }
                        if (modelOrder.F_Status == 2 && modelOrder.VipCount < 1
                            && modelOrder.F_ShouldPrice > 0)
                        {
                            modelOrder.VipCount = 1;
                            vip.F_Count += 1;
                            if (vip.F_Birthday != null)
                            {
                                if (((DateTime)vip.F_Birthday).ToString("yyyy-MM-dd") == DateTime.Now.ToString("yyyy-MM-dd"))
                                    multiple = 2;
                            }
                            var model = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                            vip.F_Score += modelOrder.F_ShouldPrice * model.F_GetPercent * multiple;
                            if (vip.F_TotalScore == null)
                                vip.F_TotalScore = 0.00M;
                            vip.F_TotalScore += modelOrder.F_ShouldPrice * model.F_GetPercent * multiple;
                            if (vip.F_RecommenderID > 0)
                            {
                                T_Cus_VipInfo vipinfo = await cus_vip_infoRepository.GetSingle(x => x.F_ID == vip.F_RecommenderID);
                                if (vipinfo != null)
                                {
                                    vipinfo.F_Score += modelOrder.F_ShouldPrice * model.F_GetPercent * multiple;
                                    if (vipinfo.F_TotalScore == null)
                                        vipinfo.F_TotalScore = 0.00M;
                                    vipinfo.F_TotalScore += modelOrder.F_ShouldPrice * model.F_GetPercent * multiple;
                                    await cus_vip_infoRepository.Update(vipinfo);
                                }
                            }
                            UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                        }
                        await cus_vip_infoRepository.Update(vip);
                    }
                   // UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                  //  modelOrder.VipCount = 1;
                }
                string msg = "";
                if (status == 2)
                    msg = "签收";
                else if (status == 4)
                    msg = "拒收";

                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 + "更新物流状态"+ msg;
                        t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
                        logs.Add(t_Bus_Orderlogs);
                orders.Add(modelOrder);
            }
            if (orders.Count >0)
            {
                if (await bus_OrderRepository.UpdateList (orders))
                {
                    await busOrderlogsRepository.AddMany(logs);
                    return Success("成功");
                }
            }
            else
                return Error("请选择订单！");
            return Error("失败,请重试！");
        }
        /// <summary>
        /// 修改任务当前金额
        /// </summary>
        /// <param name="id"></param>
        /// <param name="money"></param>
        /// <returns></returns>
        public int UpdateTaskAmount(int Belong,decimal ShouldPrice)
        {
            //0成功1任务暂停2任务终止3修改任务金额失败4任务不存在5父级任务不存在6父级任务修改失败7父级任务暂停8父级任务终止
            int n = 0;

            var model = _sys_taskmanagement_Repository.GetListALL(x => x.F_Tasker == Belong  && x.F_IsDelete == 0);
            if (model == null)
                return 4;
            foreach (var it in model.Result)
            {
                if (it.F_State == 0)
                {
                    it.F_Currentamount += (float)ShouldPrice;
                    it.F_Taskprogress = string.Format("{0:f2}", it.F_Currentamount / it.F_Money * 100);
                    var res = _sys_taskmanagement_Repository.Update(it);
                    if (!res.Result)
                        return 3;
                    if (it.F_Parentid > 0)
                    {
                        n = TreeRecursion(it.F_Parentid, (float)ShouldPrice);
                    }
                }
                else
                    n = (int)it.F_State;
            }

            return n;
        }
        /// <summary>
        /// 递归算法
        /// </summary>
        /// <param name="data"></param>
        /// <param name="parentId"></param>
        /// <returns></returns>
        private int TreeRecursion(int parentId = 0, float money = 0)
        {
            int n = 0;
            var model = _sys_taskmanagement_Repository.GetSingle(x => x.F_ID == parentId).Result;
            if (model == null)
                return 5;
            if (model.F_State == 0)
            {
                model.F_Currentamount += money;
                model.F_Taskprogress = string.Format("{0:f2}", model.F_Currentamount / model.F_Money * 100);
                var res = _sys_taskmanagement_Repository.Update(model);
                if (!res.Result)
                    return 6;
                if (model.F_Parentid > 0)
                {
                    n = TreeRecursion(model.F_Parentid, money);
                }
            }
            else
                n = (int)model.F_State + 6;
            return n;
        }
        /// <summary>
        /// 客服签收改代收
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="status">0 未发出 1未签收2签收3改代收4拒收</param>
        /// <returns></returns>
        [HttpPost("afterSignfor")]
        public async Task<IActionResult> AfterSignfor(string orderids, string id, int Status = 2)
        {

            #region 验证参数 必填项  
            
            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(id))
                return Error("请选择售后订单");
            #endregion
            string[] ids = id.Split(',');
            string[] orderid = orderids.Split(',');
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            string log = "签收";
            if(Status !=2)
            {
                log = "拒收";
            }
            foreach (var it in orderid )
            {
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                t_Bus_Orderlogs.F_WoID = it;
                t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + log+"改代收";
                t_Bus_Orderlogs.F_WoState =-1;
                logs.Add(t_Bus_Orderlogs);
            }
            if (await bus_OrderRepository .Update(s => new T_Bus_Order () { F_Status  = Status }, q => orderid.Contains(q.F_Id)))
            {
                await busOrderlogsRepository.AddMany(logs);
                if (Status==2)
                {
                    if (await busAfterSaleRepository.Update(s => new T_Bus_AfterSale() { F_IsSignfor = 1 }, q => ids.Contains(q.F_Id)))
                    {
                        return Success("成功");
                    }
                }
                else
                {
                    if (await busAfterSaleRepository.Update(s => new T_Bus_AfterSale() { F_IsSignfor = 2}, q => ids.Contains(q.F_Id)))
                    {
                        return Success("成功");
                    }
                }
               

            }
            return Error("失败,请重试！");

        }
        [HttpPost("updateexpress")]
        public async Task<IActionResult> UpdateExpress(string orderids, string express)
        {

            #region 验证参数 必填项  

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(express))
                return Error("请选择快递");
            #endregion
            //更新所选订单的快递，并标记为客服已分配快递
            string[] ids = orderids.Split(',');
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            foreach (var it in ids)
            {
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                t_Bus_Orderlogs.F_WoID = it;
                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "分快递,流转"+ express;
                t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                t_Bus_Orderlogs.F_WoState = 3;
                logs.Add(t_Bus_Orderlogs);
            }
            if (await bus_OrderRepository.Update(s => new T_Bus_Order() { F_ExpressTime=DateTime .Now , F_Express = express,F_State =3, F_IsExpress = 1 }, q => ids.Contains(q.F_Id)))
            {
                await busOrderlogsRepository.AddAndUpdateList(logs);
                return Success("成功");
            }

            return Error("失败,请重试！");

        }
        /// <summary>
        /// 分仓
        /// </summary>
        /// <param name="orderids"></param>
        /// <param name="stock"></param>
        /// <returns></returns>
        [HttpPost("updatestock")]
        public async Task<IActionResult> UpdateStock(string orderids, string stock)
        {

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
            if (string.IsNullOrEmpty(stock))
                return Error("请选择出货仓");
            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;
            }
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
          
            string msg="";
            string[] ids = orderids.Split(',');
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            if (stock =="无货")
            {
                foreach (var it in ids)
                {
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                    modelOrder.F_CheckUserName = UserLogin.UserName;
                    modelOrder.F_CheckTime = DateTime.Now;
                    modelOrder.F_Stock = stock;
                    modelOrder.F_State = 4;
                    modelOrder.F_IsExpress = 0;
                    orderLIst.Add(modelOrder);
                    t_Bus_Orderlogs.F_WoID = it;
                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "分仓，无货";
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                    t_Bus_Orderlogs.F_WoState = 4;
                    logs.Add(t_Bus_Orderlogs);
                }
            }
            else
            {
                foreach (var it in ids)
                {
                    T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                    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;

                    }
                    modelOrder.F_Stock = stock;
                    List<T_Bus_OrderDetail> detaillist = await bus_OrderDetailRepository.GetListALL(q => q.F_OrderId == modelOrder.F_Id, o => o.F_Sort, OrderByType.Asc);
                    string strStock = await busOrderFunctionController.ChangeStockOne(modelOrder, 1, detaillist);
                    modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                    modelOrder.F_CheckUserName = UserLogin.UserName;
                    modelOrder.F_CheckTime = DateTime.Now;
                    modelOrder.F_Stock = stock;
                    if (strStock != "1")
                    {
                        msg += "订单" + modelOrder.F_Id + strStock;
                        modelOrder.F_State = 4;
                        modelOrder.F_IsExpress = 0;
                        t_Bus_Orderlogs.F_WoState = 4;
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "分仓，无货";
                        string strStok = await busOrderFunctionController.ChangeStockOne(modelOrder, 0, detaillist);
                        //   { return Error(strStock); }
                    }
                    else
                    {
                        modelOrder.F_State = 8;
                        modelOrder.F_IsExpress = 0;
                        t_Bus_Orderlogs.F_WoState = 8;
                       // List<T_Bus_Product> Productlist = new List<T_Bus_Product>();
                        //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);
                        //    }
                        //}
                        //if (Productlist != null && Productlist.Count > 0)
                        //{
                        //    await bus_productRepository.UpdateList(Productlist);
                        //}
                        t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "分仓，"+ stock+"流转待分物流列表";
                    }
                    t_Bus_Orderlogs.F_WoID = it;
                  
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                   
                    logs.Add(t_Bus_Orderlogs);
                    orderLIst.Add(modelOrder);
                }
            }
          
            if (await bus_OrderRepository.UpdateList(orderLIst))
            {
               if (msg =="")
                {
                    await busOrderlogsRepository.AddMany (logs);
                    return Success("分仓成功");
                }
                
               else
                    return Error (msg);
            }
            else
                return Error("分仓失败"+ msg);

        }

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

                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("请选择条目");

                if (string.IsNullOrEmpty(input.F_RemarkKF))
                    input.F_RemarkKF = "";
                if (string.IsNullOrEmpty(input.F_RemarkXS))
                    input.F_RemarkXS = "";
                if (input.F_Money <= 0)
                    return Error("请输入金额");

                #endregion

                T_Bus_OrderMoney modelOrderMoeny = await busOrderMoneyRepository.GetSingle(q => q.F_Id == input.F_Id);

                modelOrderMoeny.F_CheckUserId = UserLogin.UserId.ObjToInt();
                modelOrderMoeny.F_CheckUserName = UserLogin.UserName;
                modelOrderMoeny.F_Money = modelOrderMoeny.F_Money;
                modelOrderMoeny.F_State = input.F_State;
                modelOrderMoeny.F_RemarkKF = input.F_RemarkKF;
                if (modelOrderMoeny.F_State == 1)
                {
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == modelOrderMoeny.F_OrderId);
                    if (modelOrder.F_PayState == 1 || modelOrder.F_PayState == 3)
                    {
                        return Error("此单已结算！");
                    }
                    modelOrder.F_RealPrice = modelOrder.F_RealPrice + modelOrderMoeny.F_Money;
                    if (modelOrder.F_PayState == 0)
                    {
                        if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                        {
                            //0待回款1已支付 2待退款3已退款
                            modelOrder.F_PayState = 1;
                            //更新最终消费金额
                            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_Membership = t_Cus_Membership.F_Name;
                                        vip.F_MembershipId = t_Cus_Membership.F_ID;
                                    }
                                    await cus_vip_infoRepository.Update(vip);
                                }
                            }
                        }
                    }
                    else if (modelOrder.F_PayState == 2)
                    {
                        if (modelOrder.F_ShouldPrice <= modelOrder.F_RealPrice)
                        {
                            //0待回款1已支付 2待退款3已退款
                            modelOrder.F_PayState = 3;
                        }
                    }
                    await bus_OrderRepository.UpdateListToColumns(new List<T_Bus_Order>() { modelOrder }, s => new { s.F_PayState, s.F_RealPrice });
                }

                if (await busOrderMoneyRepository.Update(modelOrderMoeny))
                    return Success("成功！");
                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_Money = input.F_Money;
                modelOrderMoeny.F_MoneyBak = modelOrderMoeny.F_Money;
                modelOrderMoeny.F_State = 1;
                modelOrderMoeny.F_Id = Guid.NewGuid().ToString().Replace("-", "");

                T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == modelOrderMoeny.F_OrderId);
                if (modelOrder.F_PayState == 1 || modelOrder.F_PayState == 3)
                {
                    return Error("此单已结算！");
                }
                modelOrder.F_RealPrice = modelOrder.F_RealPrice + modelOrderMoeny.F_Money;
                if (modelOrder.F_PayState == 2)
                {
                    if (modelOrder.F_ShouldPrice >= modelOrder.F_RealPrice)
                    {
                        //0待回款1已支付 2待退款3已退款
                        modelOrder.F_PayState = 3;
                    }
                }
                await bus_OrderRepository.UpdateListToColumns(new List<T_Bus_Order>() { modelOrder }, s => new { s.F_PayState, s.F_RealPrice });

                if (await busOrderMoneyRepository.AddReturnCount(modelOrderMoeny))
                    return Success("成功！");
                return Error("失败！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }

        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="stock"></param>
        /// <returns></returns>
        [HttpPost("Submit")]
        public async Task<IActionResult> Submit(string orderids)
        {

            if (string.IsNullOrEmpty(orderids))
                return Error("请选择订单号");
          
            string msg = "";int res = 0;
            string[] ids = orderids.Split(',');
            List<T_Bus_Order> orderLIst = new List<T_Bus_Order>();
            List<T_Bus_Orderlogs> logs = new List<T_Bus_Orderlogs>();
            foreach (var it in ids)
                {
                    T_Bus_Order modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == it);
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                if (modelOrder.F_IsExpress<=0|| modelOrder.F_State !=3)
                  {
                    msg += "订单" + modelOrder.F_Id + "未分物流";
                    continue;
                   }
                modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                modelOrder.F_CheckUserName = UserLogin.UserName;
                modelOrder.F_CheckTime = DateTime.Now;
                modelOrder.F_State = 5;
                   orderLIst.Add(modelOrder);
                t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "客服提交订单";
                t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                t_Bus_Orderlogs.F_WoState = 5;
                logs.Add(t_Bus_Orderlogs);
            }
           

            if (await bus_OrderRepository.UpdateList(orderLIst))
            {
                await busOrderlogsRepository.AddAndUpdateList(logs);
                if (msg == "")
                    return Success("提交成功");
                else
                    return Success(msg);
            }
            else
                return Error("订单提交失败" + msg);




        }


        /// <summary>
        /// 上传文件并导入数据库批量提交
        /// </summary>
        /// <returns></returns>
        [HttpPost("importordersubmitexcel")]
        public async Task<IActionResult> importordersubmitexcel(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_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 (modelOrder.F_IsExpress <= 0 || modelOrder.F_State != 3)
                    {
                        errmsg = errmsg + "\r\n第" + index + "行导入失败！该订单未分物流";
                        continue;
                    }
                    modelOrder.F_CheckUser = UserLogin.UserId.ObjToInt();
                    modelOrder.F_CheckUserName = UserLogin.UserName;
                    modelOrder.F_CheckTime = DateTime.Now;
                    modelOrder.F_State = 5;
                    orderLIst.Add(modelOrder);
                    t_Bus_Orderlogs.F_WoID = modelOrder.F_Id;
                    t_Bus_Orderlogs.F_OptContent = UserLogin.UserName + "提交订单";
                    t_Bus_Orderlogs.F_CreateUser = UserLogin.UserCode;
                    t_Bus_Orderlogs.F_CreateTime = DateTime.Now;
                    t_Bus_Orderlogs.F_WoState = 5;
                    logs.Add(t_Bus_Orderlogs);
                }
               
                if (!await bus_OrderRepository.UpdateList(orderLIst))
                {
                    await busOrderlogsRepository.AddAndUpdateList(logs);
                    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("getaftersalebypage")]
        public async Task<IActionResult> GetAfterSaleByPage(AfterSaleInput input, int State = -1, int isdc=0)
        {

            #region  拼接条件

            Expression<Func<T_Bus_AfterSale, bool>> eq = a => a.F_Money != 0 && a.F_CheckStateSH == 1 && ((a.F_CheckStateKG == 1 && (a.F_Type == 2 || a.F_Type == 3)) );


            if (!string.IsNullOrEmpty(input.F_Id))
            {
                eq = eq.And(a => a.F_Id == input.F_Id);
            }
            if (State > -1)
            {
                eq = eq.And(a => a.F_State == State);
            }
            if (input.F_Type > 0)
            {
                eq = eq.And(a => a.F_Type == input.F_Type);
            }
            if (!string.IsNullOrEmpty(input.F_ReturnType))
            {
                eq = eq.And(a => a.F_ReturnType == input.F_ReturnType);
            }

            #endregion
            RefAsync<int> count = 0;
            PageData<T_Bus_AfterSale> list = await busAfterSaleRepository.GetListByPage(eq, new MyPageModel() { PageIndex = input.pageindex, PageSize = input.pagesize, PageCount = count }, " F_AddTime DESC");
           if (isdc == 2)
            {
                List<AfterSaleInput> returnlist = new List<AfterSaleInput>();
                foreach (var t in list.Rows)
                {
                    AfterSaleInput m = new AfterSaleInput();
                    ModelConvertHelper<AfterSaleInput, T_Bus_AfterSale>.ModeToModel(m, t);
                    //1调换货 2退货 3部分退货 4对发货 5补发货 6补差额 7错发 8漏发 9改代收
                    if (m.F_Type == 1)
                        m.F_TypeName = "调换货";
                    else if (m.F_Type == 2)
                        m.F_TypeName = "退货";
                    else if (m.F_Type == 3)
                        m.F_TypeName = "部分退货";
                    else if (m.F_Type == 4)
                        m.F_TypeName = "对发货";
                    else if (m.F_Type == 5)
                        m.F_TypeName = "补发货";
                    else if (m.F_Type == 6)
                        m.F_TypeName = "补差额";
                    else if (m.F_Type == 7)
                        m.F_TypeName = "错发";
                    else if (m.F_Type == 8)
                        m.F_TypeName = "漏发";
                    else if (m.F_Type == 9)
                        m.F_TypeName = "改代收";
                    if (m.F_CheckStateSH == 0)
                        m.F_CheckStateSHName = "未审核";
                    else
                        m.F_CheckStateSHName = "已审核";
                    if (m.F_CheckStateKG == 0)
                        m.F_CheckStateKGName = "未审核";
                    else
                        m.F_CheckStateKGName = "已审核";
                    returnlist.Add(m);
                }
                var tb = ModelConvertHelper<AfterSaleInput>.ConvertListToDataTable(returnlist);
                NPOIHelper npoi = new NPOIHelper();
                string dbkeys = config["Import:shorderkey"].ToString();
                string title = config["Import:shordervalue"].ToString();
                string[] colname = dbkeys.Split(",");
                string[] cols = title.Split(",");
                byte[] sm = npoi.ExportToExcel1(tb, cols, colname);
                if (sm != null)
                {
                    return File(sm, "application/vnd.ms-excel", "快递信息.xlsx");
                }
                else
                {
                    return Error("导出失败");
                }
            }
            return Success("成功", list);

        }

        /// <summary>
        /// 更新售后退款状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("updatestate")]
        public async Task<IActionResult> UpdateState(string orderids, int  stock=0)
        {
            try
            {
                #region 验证参数 必填项  
                if (string.IsNullOrEmpty(orderids))
                    return Error("请选择售后单");
                if (stock<=0)
                    return Error("更新状态不正确");
                #endregion
                List<T_Cus_VipInfo> vips = new List<T_Cus_VipInfo>();
                T_Bus_AfterSale modelAfterSale = await busAfterSaleRepository.GetSingle(q => q.F_Id == orderids);
          

               
                //1收到货（根据状态自动创建订单）2货物不符3未收到货
                if ((modelAfterSale.F_Type == 2 || modelAfterSale.F_Type == 3 || modelAfterSale.F_Type == 1) && modelAfterSale.F_CheckStateKG != 1)
                {
                    return Error("仓库暂未确认收到退货");
                }
              
                modelAfterSale.F_CheckTimeXS = DateTime.Now;
                modelAfterSale.F_State = 1;
                var modelOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == modelAfterSale.F_OrderId );
                T_Bus_Orderlogs t_Bus_Orderlogs = new T_Bus_Orderlogs();
                if (modelOrder == null)
                    return Error("订单" + modelAfterSale.F_OrderId + "不存在");
                modelOrder.F_RealPrice += modelAfterSale.F_Money;
                modelOrder.F_ShouldPrice += modelAfterSale.F_Money;
                if (modelOrder.F_Status >0)
                {
                    var vip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
                    if (vip != null)
                    {
                        vip.F_Money += modelAfterSale.F_Money;
                        var membership = await _cus_membershiprepository.GetListALL(x => x.F_State != 2);
                        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_Membership = t_Cus_Membership.F_Name;
                            vip.F_MembershipId = t_Cus_Membership.F_ID;
                        }
                        if (modelOrder.F_Status == 2 && modelOrder.VipCount < 1
                            && modelOrder.F_ShouldPrice > 0)
                        {
                            //    modelOrder.VipCount = 1;
                            vip.F_Count += 1;

                            var model = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                            vip.F_Score += modelAfterSale.F_Money * model.F_GetPercent;
                            if (vip.F_TotalScore == null)
                                vip.F_TotalScore = 0.00M;
                            vip.F_TotalScore += modelAfterSale.F_Money * model.F_GetPercent;
                            if (vip.F_RecommenderID > 0)
                            {
                                T_Cus_VipInfo vipinfo = await cus_vip_infoRepository.GetSingle(x => x.F_ID == vip.F_RecommenderID);
                                if (vipinfo != null)
                                {
                                    vipinfo.F_Score += modelAfterSale.F_Money * model.F_GetPercent;
                                    if (vipinfo.F_TotalScore == null)
                                        vipinfo.F_TotalScore = 0.00M;
                                    vipinfo.F_TotalScore += modelAfterSale.F_Money * model.F_GetPercent;
                                    await cus_vip_infoRepository.Update(vipinfo);
                                }
                            }
                            UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                        }
                        await cus_vip_infoRepository.Update(vip);
                    }
                 
                   // modelOrder.VipCount = 1;
                }
                else
                {
                    if (modelOrder.F_RealPrice > 0 && stock == 2 && modelOrder.VipCount < 1)
                    {
                        var vip = await cus_vip_infoRepository.GetSingle(x => x.F_ID == modelOrder.F_VipId);
                      
                        if (vip != null)
                        {
                            vip.F_Money += modelOrder.F_RealPrice;
                            var membership = await _cus_membershiprepository.GetListALL(x => x.F_State != 2);
                            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_Membership = t_Cus_Membership.F_Name;
                                vip.F_MembershipId = t_Cus_Membership.F_ID;
                            }
                            if (modelOrder.F_Status == 2 && modelOrder.VipCount < 1
                                && modelOrder.F_ShouldPrice > 0)
                            {
                                modelOrder.VipCount = 1;
                                vip.F_Count += 1;

                                var model = await cus_score_setRepository.GetSingle(x => x.F_State == 1);
                                vip.F_Score += modelOrder.F_ShouldPrice * model.F_GetPercent;
                                if (vip.F_TotalScore == null)
                                    vip.F_TotalScore = 0.00M;
                                vip.F_TotalScore += modelOrder.F_ShouldPrice * model.F_GetPercent;
                                if (vip.F_RecommenderID > 0)
                                {
                                    T_Cus_VipInfo vipinfo = await cus_vip_infoRepository.GetSingle(x => x.F_ID == vip.F_RecommenderID);
                                    if (vipinfo != null)
                                    {
                                        vipinfo.F_Score += modelOrder.F_ShouldPrice * model.F_GetPercent;
                                        if (vipinfo.F_TotalScore == null)
                                            vipinfo.F_TotalScore = 0.00M;
                                        vipinfo.F_TotalScore += modelOrder.F_ShouldPrice * model.F_GetPercent;
                                        await cus_vip_infoRepository.Update(vipinfo);
                                    }
                                }
                                UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                            }
                            await cus_vip_infoRepository.Update(vip);
                        }
                       // UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                       // modelOrder.VipCount = 1;
                    }
                   /// if (modelOrder.F_RealPrice > 0 && stock == 2 && modelOrder.VipCount < 1)
                  //  {
                      //  UpdateTaskAmount(modelOrder.F_Belong, modelOrder.F_ShouldPrice);
                     //   modelOrder.VipCount = 1;
                   // }
                }
                
                string msg = "";
                if (stock == 2)
                    msg = "签收";
                else if (stock == 4)
                    msg = "拒收";
                modelOrder.F_Status = stock;
                modelOrder.F_Waybill = DateTime.Now;
                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 + "更新物流状态" + msg;
                t_Bus_Orderlogs.F_WoState = modelOrder.F_State;
               
                if (await busAfterSaleRepository.Update(modelAfterSale))
                {

                    if (await bus_OrderRepository.Update(modelOrder))
                    {
                        if (vips.Count > 0)
                        {
                            await busOrderlogsRepository.Add (t_Bus_Orderlogs);
                            //await cus_vip_infoRepository.UpdateList(vips);
                        }
                        return Success("成功");
                    }

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


        }

        /// <summary>
        /// 根据订单获取相应支付记录
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getordermoney")]
        public async Task<IActionResult> GetOrderMoneyList(OrderMoneyInput input)
        {
            if (string.IsNullOrEmpty(input.F_OrderId))
            {
                return Error("请输入订单号");
            }

            #region  拼接条件

            Expression<Func<T_Bus_OrderMoney, bool>> eq = a => a.F_OrderId== input.F_OrderId;


            #endregion

            List<T_Bus_OrderMoney> list = await busOrderMoneyRepository.GetListALL(eq,o=>o.F_AddTime,OrderByType.Asc);

            return Success("成功", list);

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


    }
}