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

/* =============================================
-- Author:		<Author,,zhangkun>
-- Create date: <Create Date,,20200713>
-- Description:	<Description,,订单售后操作）>
-- ============================================*/

using System;
using System.Collections.Generic;
using System.Common;
using System.Common.Helpers;
using System.Data;
using System.IRepositories;
using System.Linq;
using System.Linq.Expressions;
using System.Model;
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 TVShoppingCallCenter_ZLJ.Models.Inputs;
using Utility;

namespace TVShoppingCallCenter_ZLJ.Controllers.Order
{
    [Route("api/[controller]")]
    public class AfterSaleController : BaseController
    {
        private readonly IBus_OrderDetailRepository bus_OrderDetailRepository;
        private readonly IBus_OrderRepository bus_OrderRepository;
        private readonly OrderController orderController;
        private readonly IBus_ProductRepository bus_productRepository;
        private readonly ICus_VipInfoRepository cus_vip_infoRepository;
        private readonly IBus_OrderMergeRepository busOrderMergeRepository;
        private readonly ICus_ScoreSetRepository cus_score_setRepository;
        private readonly IBus_AfterSaleRepository busAfterSaleRepository;
        public AfterSaleController(ICus_ScoreSetRepository _cus_score_setRepository, IBus_OrderMergeRepository _busOrderMergeRepository, IBus_OrderRepository _bus_OrderRepository, IBus_OrderDetailRepository _bus_OrderDetailRepository, OrderController _orderController, IBus_ProductRepository _productRepository, ICus_VipInfoRepository _cus_vip_infoRepository, IBus_AfterSaleRepository _busAfterSaleRepository)
        {
            bus_OrderDetailRepository = _bus_OrderDetailRepository;
            bus_OrderRepository = _bus_OrderRepository;
            orderController = _orderController;
            bus_productRepository = _productRepository;
            cus_vip_infoRepository = _cus_vip_infoRepository;
            busOrderMergeRepository = _busOrderMergeRepository;
            cus_score_setRepository = _cus_score_setRepository;
            busAfterSaleRepository = _busAfterSaleRepository;
        }

        #region 销售操作

        /// <summary>
        /// 销售申请售后
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("addaftersalexs")]
        public async Task<IActionResult> AddAfterSaleXS(AfterSaleInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_OrderId))
                    return Error("请选择订单");

                if (input.F_Type <= 0)
                    return Error("申请类型不符合售后");

                #endregion

                #region 验证逻辑
                if (input.F_Type == 1)
                { }
                else if (input.F_Type == 2)
                { }
                else if (input.F_Type == 3)
                { }
                else if (input.F_Type == 4)
                { }
                #endregion
                T_Bus_Order modeOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_OrderId);
                if (modeOrder == null)
                {
                    return Error("订单不存在");
                }
                else if (modeOrder.F_Status == -1)
                {
                    //物流状态0 未发出 1物流运送中2签收3改代收4拒收
                    return Error("状态不符合售后");
                }
                T_Bus_AfterSale modelAfterSale = new T_Bus_AfterSale();
                modelAfterSale.F_AddTime = DateTime.Now;
                modelAfterSale.F_CheckTimeXS = DateTime.Now;
                modelAfterSale.F_CheckStateXS = input.F_CheckStateXS;
                modelAfterSale.F_CheckUserXS = UserLogin.UserId.ObjToInt();
                modelAfterSale.F_CheckUserNameXS = UserLogin.UserName;

                modelAfterSale.F_DetailList = input.F_DetailList;
                modelAfterSale.F_Type = input.F_Type;
                modelAfterSale.F_Money = input.F_Money;
                modelAfterSale.F_OrderId = input.F_OrderId;
                modelAfterSale.F_AboutOrderId = "";
                modelAfterSale.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                //modelAfterSale.F_OurTrackingNo = input.F_OurTrackingNo;
                //modelAfterSale.F_OurTrackDes = input.F_OurTrackDes;
                //modelAfterSale.F_TrackingNo = input.F_TrackingNo;
                //modelAfterSale.F_TrackDes = input.F_TrackDes;
                if (!string.IsNullOrEmpty(input.F_Remark))
                    modelAfterSale.F_Remark = " 销售：" + input.F_Remark;

                if (await busAfterSaleRepository.AddReturnCount(modelAfterSale))
                {
                    if (input.F_State == 0)
                        return Success("售后申请已保存");
                    else if (input.F_State == 1)
                    { return Success("售后申请已提交审核"); }
                }
                return Error("申请失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }

        /// <summary>
        /// 销售编辑售后
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("editaftersalexs")]
        public async Task<IActionResult> EditAfterSaleXS(AfterSaleInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("参数缺失Id");

                if (string.IsNullOrEmpty(input.F_OrderId))
                    return Error("请选择订单");

                if (input.F_Type <= 0)
                    return Error("申请类型不符合售后");

                #endregion

                #region 验证逻辑
                if (input.F_Type == 1)
                { }
                else if (input.F_Type == 2)
                { }
                else if (input.F_Type == 3)
                { }
                else if (input.F_Type == 4)
                { }
                #endregion

                T_Bus_AfterSale modelAfterSale = await busAfterSaleRepository.GetSingle(q => q.F_Id == input.F_Id);

                if (modelAfterSale.F_CheckStateSH == 1 && modelAfterSale.F_CheckStateXS == 1)
                {
                    return Error("双审核通过不能编辑");
                }
                modelAfterSale.F_CheckTimeXS = DateTime.Now;
                modelAfterSale.F_CheckStateXS = input.F_CheckStateXS;
                modelAfterSale.F_CheckUserXS = UserLogin.UserId.ObjToInt();
                modelAfterSale.F_CheckUserNameXS = UserLogin.UserName;

                modelAfterSale.F_DetailList = input.F_DetailList;
                modelAfterSale.F_Type = input.F_Type;
                modelAfterSale.F_Money = input.F_Money;

                modelAfterSale.F_CheckStateSH = 0;//需要售后重新审核
                //modelAfterSale.F_OurTrackingNo = input.F_OurTrackingNo;
                //modelAfterSale.F_OurTrackDes = input.F_OurTrackDes;
                //modelAfterSale.F_TrackingNo = input.F_TrackingNo;
                //modelAfterSale.F_TrackDes = input.F_TrackDes;
                if (!string.IsNullOrEmpty(input.F_Remark))
                    modelAfterSale.F_Remark = modelAfterSale.F_Remark + "\\r\\n 销售：" + input.F_Remark;



                if (await busAfterSaleRepository.AddReturnCount(modelAfterSale))
                {
                    if (input.F_State == 0)
                        return Success("售后申请已保存");
                    else if (input.F_State == 1)
                    { return Success("售后申请已提交审核"); }
                }
                return Error("申请失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }

        /// <summary>
        /// 销售删除
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("deleteaftersalexs")]
        public async Task<IActionResult> DeleteAfterSaleXS(string ids)
        {
            try
            {
                if (string.IsNullOrEmpty(ids))
                {
                    return Error("参数缺失：" + ids);
                }
                string[] idlist = ids.Split(',');

                if (await busAfterSaleRepository.Delete(q => idlist.Contains(q.F_Id) && new[] { 0, 2 }.Contains(q.F_CheckStateXS)))
                {
                    return Success("删除成功/已审核通过不能删除");
                }
                return Error("删除失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }
        }

        /// <summary>
        /// 根据分页获取列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getaftersalebypagexs")]
        public async Task<IActionResult> GetAfterSaleByPageXS(AfterSaleInput input)
        {

            #region  拼接条件

            Expression<Func<T_Bus_AfterSale, bool>> eq = a => a.F_CheckUserXS == UserLogin.UserId.ObjToInt();


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

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

            return Success("成功", list);

        }

        #endregion

        #region 售后操作

        /// <summary>
        /// 销售申请售后
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("addaftersalesh")]
        public async Task<IActionResult> AddAfterSaleSH(AfterSaleInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_OrderId))
                    return Error("请选择订单");

                if (input.F_Type <= 0)
                    return Error("申请类型不符合售后");

                #endregion


                T_Bus_Order modeOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_OrderId);
                if (modeOrder == null)
                {
                    return Error("订单不存在");
                }
                else if (modeOrder.F_Status == -1)
                {
                    //物流状态0 未发出 1物流运送中2签收3改代收4拒收
                    return Error("状态不符合售后");
                }
                T_Bus_AfterSale modelAfterSale = new T_Bus_AfterSale();
                modelAfterSale.F_AddTime = DateTime.Now;
                modelAfterSale.F_CheckTimeSH = DateTime.Now;
                modelAfterSale.F_CheckStateSH = input.F_State;
                modelAfterSale.F_CheckUserSH = UserLogin.UserId.ObjToInt();
                modelAfterSale.F_CheckUserNameSH = UserLogin.UserName;

                modelAfterSale.F_CheckUserXS = modeOrder.F_AddUser;

                modelAfterSale.F_DetailList = input.F_DetailList;
                modelAfterSale.F_OldDetailList = input.F_OldDetailList;
                modelAfterSale.F_Type = input.F_Type;
                modelAfterSale.F_Money = input.F_Money;

                modelAfterSale.F_OrderId = input.F_OrderId;
                modelAfterSale.F_AboutOrderId = "";
                modelAfterSale.F_Id = Guid.NewGuid().ToString().Replace("-", "");

                modelAfterSale.F_TrackingNo = input.F_TrackingNo;
                modelAfterSale.F_TrackDes = input.F_TrackDes;
                if (!string.IsNullOrEmpty(input.F_Remark))
                    modelAfterSale.F_Remark = " 售后：" + input.F_Remark;

                List<T_Bus_OrderDetail> modelOldDetailList = new List<T_Bus_OrderDetail>();

                //更新售后流程的退货商品
                if (string.IsNullOrEmpty(modelAfterSale.F_OldDetailList))
                {
                    #region 退回商品展示

                    foreach (string product in modelAfterSale.F_OldDetailList.Split('|'))
                    {
                        string productid = product.Split(',')[0];

                        T_Bus_OrderDetail modelDetail = await bus_OrderDetailRepository.GetSingle(q => q.F_OrderId == modeOrder.F_Id && q.F_ProductId == productid);
                        if (modelDetail.F_State >= 1)
                        {
                            return Error("此商品已参加售后:" + modelDetail.F_ProductName);
                        }
                        modelDetail.F_State = 1;
                        modelOldDetailList.Add(modelDetail);
                    }

                    #endregion
                }

                if (input.F_Type == 4)
                {
                    if (input.F_CheckStateSH == 1)
                    {
                        modelAfterSale.F_AboutOrderId = "BJ" + UserLogin.UserId + "T" + DateTimeConvert.ToTimetag(DateTime.Now);
                        string addResult = await AddOrder(modelAfterSale, modeOrder);
                        if (addResult != "1")
                        {
                            return Error("订单无法创建:" + addResult);
                        }
                    }
                }
                else if (input.F_Type == 2 || input.F_Type == 3)
                {

                }
                else if (input.F_Type == 1)
                {

                }
                if (modelOldDetailList != null && modelOldDetailList.Count > 0)
                {
                    //批量更新状态 为售后中
                    await bus_OrderDetailRepository.UpdateList(modelOldDetailList);
                }
                if (await busAfterSaleRepository.AddReturnCount(modelAfterSale))
                {
                    if (input.F_CheckStateSH == 0)
                        return Success("售后已保存");
                    else if (input.F_CheckStateSH == 1)
                    { return Success("售后已提交"); }
                }
                return Error("申请失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }

        }

        /// <summary>
        /// 销售编辑售后
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("editaftersalesh")]
        public async Task<IActionResult> EditAfterSaleSH(AfterSaleInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_OrderId))
                    return Error("请选择订单");
                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("请选择售后单");
                if (input.F_Type <= 0)
                    return Error("申请类型不符合售后");

                #endregion


                T_Bus_Order modeOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == input.F_OrderId);
                if (modeOrder == null)
                {
                    return Error("订单不存在");
                }
                else if (modeOrder.F_Status == -1)
                {
                    //物流状态0 未发出 1物流运送中2签收3改代收4拒收
                    return Error("订单状态不符合售后");
                }
                T_Bus_AfterSale modelAfterSale = await busAfterSaleRepository.GetSingle(q => q.F_Id == input.F_Id);
                if (modelAfterSale.F_CheckStateSH == 1)
                {
                    return Error("不能重复审核提交");
                }
                modelAfterSale.F_CheckTimeSH = DateTime.Now;
                modelAfterSale.F_CheckStateSH = input.F_State;
                modelAfterSale.F_CheckUserSH = UserLogin.UserId.ObjToInt();
                modelAfterSale.F_CheckUserNameSH = UserLogin.UserName;

                modelAfterSale.F_CheckUserXS = modeOrder.F_AddUser;

                modelAfterSale.F_DetailList = input.F_DetailList;
                modelAfterSale.F_Type = input.F_Type;
                modelAfterSale.F_Money = input.F_Money;

                modelAfterSale.F_OrderId = input.F_OrderId;
                modelAfterSale.F_AboutOrderId = "";
                modelAfterSale.F_Id = Guid.NewGuid().ToString().Replace("-", "");

                modelAfterSale.F_TrackingNo = input.F_TrackingNo;
                modelAfterSale.F_TrackDes = input.F_TrackDes;
                if (!string.IsNullOrEmpty(input.F_Remark))
                    modelAfterSale.F_Remark = " 售后：" + input.F_Remark;


                if (modelAfterSale.F_Type == 4)
                {
                    if (modelAfterSale.F_CheckStateSH == 1)
                    {
                        modelAfterSale.F_AboutOrderId = "BJ" + UserLogin.UserId + "T" + DateTimeConvert.ToTimetag(DateTime.Now);
                        string addResult = await AddOrder(modelAfterSale, modeOrder);
                        if (addResult != "1")
                        {
                            return Error("订单无法创建:" + addResult);
                        }
                    }
                }
                if (await busAfterSaleRepository.AddReturnCount(modelAfterSale))
                {
                    if (input.F_CheckStateSH == 0)
                        return Success("售后已保存");
                    else if (input.F_CheckStateSH == 1)
                    { return Success("售后已提交"); }
                }
                return Error("申请失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }

        /// <summary>
        /// 售后删除
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("deleteaftersalesh")]
        public async Task<IActionResult> DeleteAfterSaleSH(string ids)
        {
            try
            {
                if (string.IsNullOrEmpty(ids))
                {
                    return Error("参数缺失：" + ids);
                }
                string[] idlist = ids.Split(',');

                if (await busAfterSaleRepository.Delete(q => idlist.Contains(q.F_Id) && new[] { 0, 2 }.Contains(q.F_CheckStateSH)))
                {
                    return Success("删除成功");
                }
                return Error("删除失败,请重试！已审核通过不能删除");
            }
            catch (Exception ex)
            { return Error(ex.Message); }
        }

        /// <summary>
        /// 根据分页获取列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getaftersalebypagesh")]
        public async Task<IActionResult> GetAfterSaleByPageSH(AfterSaleInput input)
        {

            #region  拼接条件

            Expression<Func<T_Bus_AfterSale, bool>> eq = a => a.F_CheckUserSH == UserLogin.UserId.ObjToInt();


            //if (input.F_CheckStateXS > -2)
            //{
            //    eq = eq.And(a => a.F_CheckStateXS == input.F_CheckStateXS);
            //}
            if (input.F_CheckStateSH > -2)
            {
                eq = eq.And(a => a.F_CheckStateSH == input.F_CheckStateSH);
            }
            if (input.F_Type > 0)
            {
                eq = eq.And(a => a.F_Type == input.F_Type);
            }
            if (!string.IsNullOrEmpty(input.F_Id))
            {
                eq = eq.And(a => a.F_Id == input.F_Id);
            }
            if (input.F_State > -2)
            {
                eq = eq.And(a => a.F_State == input.F_State);
            }

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

            return Success("成功", list);

        }

        #endregion

        #region 仓库操作

        /// <summary>
        /// 更新状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("updatestatekg")]
        public async Task<IActionResult> UpdateState(AfterSaleInput input)
        {
            try
            {
                #region 验证参数 必填项  

                if (string.IsNullOrEmpty(input.F_Id))
                    return Error("请选择售后单");

                #endregion

                T_Bus_AfterSale modelAfterSale = await busAfterSaleRepository.GetSingle(q => q.F_Id == input.F_Id);

                T_Bus_Order modeOrder = await bus_OrderRepository.GetSingle(q => q.F_Id == modelAfterSale.F_OrderId);
                if (modeOrder == null)
                {
                    return Error("订单不存在");
                }

                if (modelAfterSale.F_CheckStateKG == 1 || modelAfterSale.F_CheckStateKG == 2)
                {
                    //1收到货（根据状态自动创建订单）2货物不符3未收到货
                    return Error("不能重复审核提交");
                }
                modelAfterSale.F_CheckStateKG = input.F_State;

                modelAfterSale.F_CheckTimeKG = DateTime.Now;
                modelAfterSale.F_CheckUserKG = UserLogin.UserId.ObjToInt();
                modelAfterSale.F_CheckUserNameKG = UserLogin.UserName;
                modelAfterSale.F_CheckUserXS = modeOrder.F_AddUser;
                List<T_Bus_OrderDetail> modelOldDetailList = new List<T_Bus_OrderDetail>();

                //1收到货（根据状态自动创建订单）2货物不符3未收到货
                if (modelAfterSale.F_CheckStateKG == 1)
                {
                    #region 更新用户快递商品
                    if (string.IsNullOrEmpty(modelAfterSale.F_OldDetailList))
                    {
                        foreach (string product in modelAfterSale.F_DetailList.Split('|'))
                        {
                            string productid = product.Split(',')[0];

                            T_Bus_OrderDetail modelDetail = await bus_OrderDetailRepository.GetSingle(q => q.F_OrderId == modeOrder.F_Id && q.F_ProductId == productid);
                            if (modelDetail.F_State == 2)
                            {
                                return Error("此商品已参加过售后:" + modelDetail.F_ProductName);
                            }
                            modelDetail.F_State = 2;
                            modelOldDetailList.Add(modelDetail);
                        }
                    }
                    #endregion
                    if (modelAfterSale.F_Type == 4)
                    {

                        modelAfterSale.F_State = 1;

                    }
                    else if (modelAfterSale.F_Type == 2 || modelAfterSale.F_Type == 3)
                    {

                    }
                    else if (modelAfterSale.F_Type == 1)
                    {
                        modelAfterSale.F_AboutOrderId = "BJ" + UserLogin.UserId + "T" + DateTimeConvert.ToTimetag(DateTime.Now);
                        string addResult = await AddOrder(modelAfterSale, modeOrder);
                        if (addResult != "1")
                        {
                            return Error("订单无法创建:" + addResult);
                        }
                        modelAfterSale.F_State = 1;
                    }
                }
                else if (modelAfterSale.F_CheckStateKG == 2)
                {
                    //时间长自动作废
                    //如果没有对发货  货物不符则标记为无效
                    #region 更新用户快递商品
                    if (modelAfterSale.F_Type != 1)
                    {
                        if (string.IsNullOrEmpty(modelAfterSale.F_OldDetailList))
                        {
                            foreach (string product in modelAfterSale.F_DetailList.Split('|'))
                            {
                                string productid = product.Split(',')[0];

                                T_Bus_OrderDetail modelDetail = await bus_OrderDetailRepository.GetSingle(q => q.F_OrderId == modeOrder.F_Id && q.F_ProductId == productid);
                                if (modelDetail.F_State == 2)
                                {
                                    return Error("此商品已参加过售后:" + modelDetail.F_ProductName);
                                }
                                modelDetail.F_State = 0;
                                modelOldDetailList.Add(modelDetail);
                            }
                        }
                    }
                    #endregion
                }
                else if (modelAfterSale.F_CheckStateKG == 3)
                {     //时间长自动作废
                    //如果没有对发货  未收到货则标记为无效
                }

                if (modelOldDetailList != null && modelOldDetailList.Count > 0)
                {
                    //批量更新状态 为已售后
                    await bus_OrderDetailRepository.UpdateList(modelOldDetailList);
                }

                if (await busAfterSaleRepository.AddReturnCount(modelAfterSale))
                {
                    if (input.F_CheckStateSH == 0)
                        return Success("售后已保存");
                    else if (input.F_CheckStateSH == 1)
                    { return Success("售后已提交"); }
                }
                return Error("申请失败,请重试！");
            }
            catch (Exception ex)
            { return Error(ex.Message); }


        }



        /// <summary>
        /// 根据分页获取列表(库管)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("getaftersalebypagekg")]
        public async Task<IActionResult> GetAfterSaleByPageKG(AfterSaleInput input)
        {

            #region  拼接条件

            Expression<Func<T_Bus_AfterSale, bool>> eq = a => a.F_CheckStateSH == 1;


            if (input.F_CheckStateKG > -2)
            {
                if (input.F_CheckStateKG > 0)
                {
                    eq = eq.And(a => a.F_CheckUserKG == UserLogin.UserId.ObjToInt());
                }
                eq = eq.And(a => a.F_CheckStateKG == input.F_CheckStateKG);
            }
            if (input.F_Type > 0)
            {
                eq = eq.And(a => a.F_Type == input.F_Type);
            }
            if (!string.IsNullOrEmpty(input.F_Id))
            {
                eq = eq.And(a => a.F_Id == input.F_Id);
            }
            if (input.F_State > -2)
            {
                eq = eq.And(a => a.F_State == input.F_State);
            }

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

            return Success("成功", list);

        }

        #endregion
        #region 方法
        /// <summary>
        /// 仓库确认后创建订单  对发货直接创建订单
        /// </summary>
        /// <param name="newOrderlist">12,3|</param>
        /// <param name="OldModelOrder"></param>
        /// <param name="money"></param>
        /// <returns></returns>
        private async Task<string> AddOrder(T_Bus_AfterSale ModelAfterSale, T_Bus_Order OldModelOrder)
        {
            try
            {
                string newOrderlist = ModelAfterSale.F_DetailList;
                T_Bus_Order modelOrder = OldModelOrder;
                #region 订单属性
                //必填

                modelOrder.F_Type = "售后订单";
                modelOrder.F_Id = ModelAfterSale.F_AboutOrderId;


                //选填 快递属性

                modelOrder.F_ExpressFee = 0;
                //modelOrder.F_Stock = input.F_Stock;
                modelOrder.F_Remark = "售后订单";

                modelOrder.F_RealPrice = 0.00M;
                modelOrder.F_UseScore = 0.00M;
                //选填 关联属性

                modelOrder.F_State = 0;
                modelOrder.F_Status = 0;


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

                //计算属性  商品计算


                decimal totle = 0.00M;

                List<T_Bus_OrderDetail> modelDetailList = new List<T_Bus_OrderDetail>();

                #region 订单详情列表核算
                if (string.IsNullOrEmpty(newOrderlist))
                {
                    int n = 1;

                    #region 商品核算
                    foreach (string product in newOrderlist.Split('|'))
                    {
                        string productid = product.Split(',')[0];
                        int Count = product.Split(',')[1].ObjToInt();
                        T_Bus_Product modelProduct = await bus_productRepository.GetSingle(b => b.F_ProductId == productid);
                        if (modelProduct == null)
                            return "商品不存在:" + productid;
                        T_Bus_OrderDetail modelDetail = new T_Bus_OrderDetail();
                        modelDetail.F_ProductName = modelProduct.F_ProductName;
                        modelDetail.F_ProductId = modelProduct.F_ProductId;
                        modelDetail.F_Id = Guid.NewGuid().ToString().Replace("-", "");
                        modelDetail.F_OrderId = modelOrder.F_Id;
                        modelDetail.F_Count = Count;
                        modelDetail.F_Price = modelProduct.F_MemberPrice;

                        modelDetail.F_DealPrice = modelProduct.F_MemberPrice;
                        modelDetail.F_Remark = "售后订单：";


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

                        modelDetail.F_AddUser = modelOrder.F_AddUser;
                        modelDetail.F_AddUserName = modelOrder.F_AddUserName;
                        modelDetail.F_TotlePrice = modelDetail.F_DealPrice * modelDetail.F_Count;
                        modelDetail.F_Activity = 0;
                        modelDetailList.Add(modelDetail);
                        totle += modelDetail.F_TotlePrice;
                        n++;
                    }
                    #endregion

                    modelOrder.F_TotlePrice = totle;
                    modelOrder.F_ActivityMoney = 0.00M;
                    modelOrder.F_UseActivity = "";
                }
                else
                {
                    return "0";
                }
                #endregion




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



                modelOrder.F_FlowNum = Guid.NewGuid().ToString().Replace("-", "");
                string strStock = await orderController.ChangeStockOne(modelOrder, 1, modelDetailList);
                if (strStock != "1")
                { modelOrder.F_State = 0; }
                else
                { modelOrder.F_SubmitTime = DateTime.Now; }





                #endregion
                //计算结果  积分有规则            
                modelOrder.F_ShouldPrice = ModelAfterSale.F_Money;

                modelOrder.F_RealPrice = 0.00M;


                if (await bus_OrderRepository.AddReturnCount(modelOrder))
                {
                    if (await bus_OrderDetailRepository.AddMany(modelDetailList))
                        return "1";
                    else
                        return "订单添加失败,请重试！";
                }
                else
                {
                    return "订单添加失败,请重试！";
                }
            }
            catch (Exception ex)
            { return ex.Message; }
        }


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

                modelreturn.F_Customer = modelOrder.F_Customer;
                modelreturn.F_CustomerPhone = modelOrder.F_CustomerPhone;
                //选填 快递属性
                modelreturn.F_TrackingNo = modelOrder.F_TrackingNo;
                modelreturn.F_Addressee = modelOrder.F_Addressee;
                modelreturn.F_AddPhone = modelOrder.F_AddPhone;
                modelreturn.F_AddProvince = modelOrder.F_AddProvince;
                modelreturn.F_AddCity = modelOrder.F_AddCity;
                modelreturn.F_AddArea = modelOrder.F_AddArea;
                modelreturn.F_AddTown = modelOrder.F_AddTown;
                modelreturn.F_AddDes = modelOrder.F_AddDes;
                modelreturn.F_Address = modelOrder.F_Address;
                modelreturn.F_PostalCode = modelOrder.F_PostalCode;
                modelreturn.F_Express = modelOrder.F_Express;

                modelreturn.F_PayType = modelOrder.F_PayType;
                modelreturn.F_PayState = modelOrder.F_PayState;
                modelreturn.F_Stock = modelOrder.F_Stock;
                modelreturn.F_Remark = modelOrder.F_Remark;

                modelreturn.F_RealPrice = modelOrder.F_RealPrice;

                //选填 关联属性
                modelreturn.F_VipId = modelOrder.F_VipId;
                modelreturn.F_UseScore = modelOrder.F_UseScore;
                modelreturn.F_Score = modelOrder.F_Score;

                modelreturn.F_State = modelOrder.F_State;
                modelreturn.F_Status = modelOrder.F_Status;


                //必须属性 系统生成
                modelreturn.F_AddTime = modelOrder.F_AddTime;
                modelreturn.F_AddUser = modelOrder.F_AddUser;
                modelreturn.F_AddUserName = modelOrder.F_AddUserName;


                modelreturn.F_TotlePrice = modelOrder.F_TotlePrice;
                modelreturn.F_ShouldPrice = modelOrder.F_ShouldPrice;
                modelreturn.F_ActivityMoney = modelOrder.F_ActivityMoney;
                modelreturn.F_UseActivity = modelOrder.F_UseActivity;

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

                        model.F_DealPrice = m.F_DealPrice;
                        model.F_Sort = m.F_Sort;
                        model.F_AddTime = m.F_AddTime;
                        model.F_Remark = m.F_Remark;
                        model.F_AddUser = m.F_AddUser;
                        model.F_AddUserName = m.F_ProductName;
                        model.F_TotlePrice = m.F_TotlePrice;
                        model.F_Activity = m.F_Activity;
                        modeldetailreturn.Add(model);
                    }
                }
                modelreturn.OrderDetailList = modeldetailreturn;

                modelreturn.UseActList = null;

            }


            return Success("成功", modelreturn);


        }
        #endregion


    }
}