WMS-Api/src/WMS.Web.Api/Controllers/InStockTaskController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WMS.Web.Core;
using WMS.Web.Core.Dto;
using WMS.Web.Core.Dto.InStockTask;
using WMS.Web.Core.Help;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Options;
using WMS.Web.Domain.Values;

namespace WMS.Web.Api.Controllers
{
    /// <summary>
    /// 入库任务单-接口
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class InStockTaskController : ControllerBase
    {
        private readonly QiniuOptions _option;
        private readonly IExportExcelService _exportExcelService;
        private readonly ILoginService _loginService;
        private readonly IInStockService _inStockService;
        private readonly IInStockTaskService _inStockTaskService;
        private readonly IInStockTaskRepositories _inStockTaskRepositories;
        private readonly IInventoryDetailsRepositories _inventoryDetailsRepositories;
        private readonly IInStockRepositories _inStockRepositories;
        public InStockTaskController(
            IInStockRepositories inStockRepositories,
            IOptions<QiniuOptions> option,
            IExportExcelService exportExcelService,
            ILoginService loginService,
            IInStockTaskService inStockTaskService,
            IInStockTaskRepositories inStockTaskRepositories,
            IInventoryDetailsRepositories inventoryDetailsRepositories,
            IInStockService inStockService)
        {
            _inStockRepositories = inStockRepositories;
            _inventoryDetailsRepositories = inventoryDetailsRepositories;
            this._option = option?.Value;
            this._exportExcelService = exportExcelService;
            this._loginService = loginService;
            this._inStockService = inStockService;
            this._inStockTaskService = inStockTaskService;
            this._inStockTaskRepositories = inStockTaskRepositories;
        }

        /// <summary>
        /// 列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("GetList")]
        public async Task<ResultPagedList<InStockTaskQueryResponse>> GetPagedList([FromBody] InStockTaskQueryRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultPagedList<InStockTaskQueryResponse>.ReFailure(ResultCodes.Token_Invalid_Error);
            var (list,total) = await _inStockTaskRepositories.GetPagedList(dto,loginInfo.UserInfo.CompanyId);
            return ResultPagedList<InStockTaskQueryResponse>.ReSuccess(list, total);
        }

        /// <summary>
        /// 导出
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Export")]
        public Task<Result<string>> Export([FromBody] InStockTaskQueryRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null)
                return Task.FromResult(Result<string>.ReFailure(ResultCodes.Token_Invalid_Error));
            string fileName = FileDownLoadOrderType.InStockTask.GetRemark() + loginInfo.UserInfo.CompanyId + DateTime.Now.DateTimeToLongTimeStamp() + ".xlsx";
            string res = _option.Url + fileName;

            Task.Run(async () =>
            {
                await _exportExcelService.ExportList<InStockTaskQueryResponse, InStockTaskQueryRequest>(dto, fileName, loginInfo.UserInfo.StaffId, loginInfo.UserInfo.CompanyId, FileDownLoadOrderType.InStockTask);
            });

            return Task.FromResult(Result<string>.ReSuccess(res));
        }
        /// <summary>
        /// 作废
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Repeal")]
        public async Task<Result> Repeal([FromBody]OperateRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result.ReFailure(ResultCodes.Token_Invalid_Error);

            return await _inStockTaskService.Repeal(dto, loginInfo);
        }
        /// <summary>
        /// 反作废
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("NoRepeal")]
        public async Task<Result> NoRepeal([FromBody] OperateRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result.ReFailure(ResultCodes.Token_Invalid_Error);

            return await _inStockTaskService.NoRepeal(dto, loginInfo);
        }

        /// <summary>
        /// 金蝶-拉取数据-测试用
        /// </summary>
        /// <param name="sourceBillNo"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("Test")]
        public async Task<Result> Test([FromQuery] string sourceBillNo)
        {
            var sbns = new List<string>();
            sbns.Add(sourceBillNo);

            //2.同步金蝶
            return await _inStockTaskService.Sysn(sbns);
        }

        /// <summary>
        /// 刷新
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Refresh")]
        public async Task<Result> Refresh([FromBody] OperateRequest dto)
        {
            //去重
            var ids = dto.Ids.GroupBy(x => x).Select(x=>x.Key).ToList();

            //1.先找到任务单-并找到来源单集
            var tasks= await _inStockTaskRepositories.GetList(ids);
            var sourcesBillNos = tasks.Select(x => x.SourceBillNo).ToList();

            //2.同步金蝶
             await _inStockTaskService.Sysn(sourcesBillNos);
            ////再刷新
            await _inStockTaskService.Sysn(null);
            //验证金蝶是否有删单//默认拉去8个小时以内的
           return await _inStockTaskService.ErpDel(DateTime.Now.AddHours(-8));
        }

        /// <summary>
        /// 收货-pad
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Receive")]
        public async Task<Result> Receive([FromBody] UpdateInStockTaskRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result.ReFailure(ResultCodes.Token_Invalid_Error);

            return await _inStockService.Receive(dto, loginInfo);
        }

        /// <summary>
        /// 来源单-编号模糊查询-采购上架使用-pad
        /// </summary>
        /// <param name="sourceBillNo">来源单号</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetSourceOrder/{sourceBillNo}")]
        public async Task<ResultList<SourceBillNoQueryResponse>> GetSourceOrder([FromRoute] string sourceBillNo)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<SourceBillNoQueryResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            var list= await _inStockTaskRepositories.GetListBy(new InStockTaskBillNoQueryRequest() { SourceBillNo = sourceBillNo});

            //获取物料对应的仓位
            var materialNumbers = list.GroupBy(x => x.MaterialNumber).Select(x => x.Key).ToList();
            var stockCodes = list.GroupBy(x => x.StockCode).Select(x => x.Key).ToList();
            var orgCodes = list.GroupBy(x => x.OrgCode).Select(x => x.Key).ToList();
            var materialSubStocks= await _inventoryDetailsRepositories.GetMaterialSubStocks(materialNumbers, stockCodes, orgCodes, loginInfo.UserInfo.CompanyId);
            list.ForEach(x => 
            {
                x.MaterialSubStocks = materialSubStocks.Where(t => t.MaterialNumber == x.MaterialNumber && t.StockCode == x.StockCode && t.OrgCode == x.OrgCode).Select(x => x.SubStock).ToList();
            });

            ////排除待入库数量为0的
            //var result= list.Where(x => x.WaitSlefQty != 0).ToList();

            return ResultList<SourceBillNoQueryResponse>.ReSuccess(list);
        }

        /// <summary>
        /// 来源单-已收货未入库的箱集合-采购上架使用-pad
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetReceiveBox/{taskId}")]
        public async Task<ResultList<ReceiveBoxResponse>> GetReceiveBox([FromRoute] int taskId) 
        {
            //找到收货的箱子
            var receiveBoxList=  await _inStockTaskRepositories.GetReceiveBox(taskId);

            //找到已入库的箱子
            var instockBoxList= await _inStockRepositories.GetInstockBox(taskId);
            var remobox = new List<ReceiveBoxResponse>();
            if (receiveBoxList.Count!=0 && instockBoxList.Count != 0) 
            {
                //剔除已入库的箱子
                foreach (var boxid in instockBoxList.Distinct().ToList())
                {
                    var reBox= receiveBoxList.Where(x => x.BoxId == boxid).FirstOrDefault();
                    if (reBox != null)
                        remobox.Add(reBox);
                }
            }
            if (remobox.Count != 0)
            {
                foreach (var item in remobox)
                {
                    receiveBoxList.Remove(item);
                }
            }

            return ResultList<ReceiveBoxResponse>.ReSuccess(receiveBoxList);
        }

        /// <summary>
        /// 来源单-已收货未入库的箱集合-采购上架使用-pad-post
        /// </summary>
        /// <param name="taskId"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("GetReceiveBox")]
        public async Task<ResultList<ReceiveBoxResponse>> GetReceiveBox([FromBody] ReceiveBoxRequeset dto)
        {
            //找到收货的箱子
            var receiveBoxList = await _inStockTaskRepositories.GetReceiveBox(dto.TaskId, dto.MaterialNumber);

            //找到已入库的箱子
            var instockBoxList = await _inStockRepositories.GetInstockBox(dto.TaskId);
            var remobox = new List<ReceiveBoxResponse>();
            if (receiveBoxList.Count != 0 && instockBoxList.Count != 0)
            {
                //剔除已入库的箱子
                foreach (var boxid in instockBoxList.Distinct().ToList())
                {
                    var reBox = receiveBoxList.Where(x => x.BoxId == boxid).FirstOrDefault();
                    if (reBox != null)
                        remobox.Add(reBox);
                }
            }
            if (remobox.Count != 0)
            {
                foreach (var item in remobox)
                {
                    receiveBoxList.Remove(item);
                }
            }

            return ResultList<ReceiveBoxResponse>.ReSuccess(receiveBoxList);
        }

        /// <summary>
        /// 来源单-编号模糊查询-非采购上架使用-pad
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("GetSourceOrderNoPurchase")]
        public async Task<ResultList<SourceBillNoNoPurchaseQueryResponse>> GetSourceOrderNoPurchaseBy([FromBody] InStockTaskBillNoQueryRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<SourceBillNoNoPurchaseQueryResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            var list = await _inStockTaskRepositories.GetListInfoBy(dto);
            //获取物料对应的仓位
            var materialNumbers = list.SelectMany(x=>x.Details).GroupBy(x => x.MaterialNumber).Select(x => x.Key).ToList();
            var stockCodes = list.SelectMany(x => x.Details).GroupBy(x => x.StockCode).Select(x => x.Key).ToList();
            var orgCodes = list.SelectMany(x => x.Details).GroupBy(x => x.OrgCode).Select(x => x.Key).ToList();
            var materialSubStocks = await _inventoryDetailsRepositories.GetMaterialSubStocks(materialNumbers, stockCodes, orgCodes, loginInfo.UserInfo.CompanyId);
            list.SelectMany(x=>x.Details).ToList().ForEach(x =>
            {
                x.MaterialSubStocks = materialSubStocks.Where(t => t.MaterialNumber == x.MaterialNumber && t.StockCode==x.StockCode && t.OrgCode == x.OrgCode).Select(x => x.SubStock).ToList();
            });
            foreach(var l in list)
            {
                l.WaitShelfQty = l.Details.Sum(s => s.WaitShelfQty);
            }

            return ResultList<SourceBillNoNoPurchaseQueryResponse>.ReSuccess(list);
        }

        /// <summary>
        /// 校准-来源单-采购上架使用-对应金蝶-pad
        /// </summary>
        /// <param name="sourceBillNo"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("Adjust/{sourceBillNo}")]
        public async Task<ResultList<SourceBillNoQueryResponse>> Adjust([FromRoute] string sourceBillNo)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<SourceBillNoQueryResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            //校准
            var result= await _inStockTaskService.Adjust(sourceBillNo);
            if(!result.IsSuccess)
                return ResultList<SourceBillNoQueryResponse>.ReFailure(result);

            //再一次查询新的数据：并返回最后的结果
            var request = new InStockTaskBillNoQueryRequest() { SourceBillNo = sourceBillNo };
            var list = await _inStockTaskRepositories.GetListBy(request);
            return ResultList<SourceBillNoQueryResponse>.ReSuccess(list);
        }

        /// <summary>
        /// 校准-来源单-非采购上架使用-对应金蝶-pad
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AdjustNoPurchase")]
        public async Task<ResultList<SourceBillNoNoPurchaseQueryResponse>> AdjustNoPurchaseBy([FromBody] InStockTaskBillNoQueryRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<SourceBillNoNoPurchaseQueryResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            //校准
            var result = await _inStockTaskService.Adjust(dto.SourceBillNo);
            if (!result.IsSuccess)
                return ResultList<SourceBillNoNoPurchaseQueryResponse>.ReFailure(result);

            //再一次查询新的数据：并返回最后的结果
            var request = new InStockTaskBillNoQueryRequest() { SourceBillNo = dto.SourceBillNo,StockCode=dto.StockCode };
            var list = await _inStockTaskRepositories.GetListInfoBy(request);
            return ResultList<SourceBillNoNoPurchaseQueryResponse>.ReSuccess(list);
        }

        /// <summary>
        /// 采购订单物料明细和箱物料明细-对比-pad
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Contrast")]
        public async Task<Result<ContrastMaterialsResponse>> Contrast([FromBody] ContrastMaterialsRequest dto)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<ContrastMaterialsResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            var result = await _inStockService.Contrast(dto);
            return result;
        }

        /// <summary>
        /// 入库任务单详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetInfo/{id}")]
        public async Task<Result<InStockTaskInfoDto>> GetInfo([FromRoute] int id)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<InStockTaskInfoDto>.ReFailure(ResultCodes.Token_Invalid_Error);

            var info= await _inStockTaskRepositories.GetInfo(id, loginInfo.UserInfo.CompanyId);
            return Result<InStockTaskInfoDto>.ReSuccess(info);
        }
    }
}