wcs/WCS.BLL/Services/Service/OutstoreService.cs

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.Model;

namespace WCS.BLL.Services.Service
{
    public class OutstoreService : IOutstoreService
    {
        public OutstoreService()
        {

        }
        public async Task<ResponseBase> SysOutOrderByMatCode(SysOutOrderByMatCodeRequest request)
        {
            //参数合法性校验
            if (request.ItemList == null || request.ItemList.Count == 0)
            {
                return new ResponseBase()
                {
                    Code = 201,
                    Message = "单据同步失败：缺少需要出库的物料类型！"
                };
            }
            //判断是否有单据号 没有单据号系统自动生成一个
            if (string.IsNullOrEmpty(request.OrderNumber))
            {
                request.OrderNumber = GenerateOrderNumber();
            }
            Console.WriteLine(DateTime.Now);
            //保存数据
            await DbHelp.db.BeginTranAsync();
            try
            {
                var order = new OutOrder()
                {
                    OrderNumber = request.OrderNumber,
                    OrderSource = request.OrderSource,
                    OrderType = request.OrderType,
                    SyncType = SyncTypeEnum.ByMatCode,
                    CreateUser = request.UserName,
                };
                order.Id = await DbHelp.db.Insertable(order).ExecuteReturnIdentityAsync();
                request.ItemList.ForEach(async item =>
                {
                    var orderDetail = new OutOrderDetail()
                    {
                        OrderId = order.Id,
                        OrderNumber = order.OrderNumber,
                        MatCode = item.MatCode,
                        MatBatch = item.MatBatch,
                        ReqQty = item.ReqQty,
                        CreateUser = request.UserName
                    };
                    await DbHelp.db.Insertable(orderDetail).ExecuteCommandAsync();
                });
                await DbHelp.db.CommitTranAsync();
                return new ResponseCommon()
                {
                    Code = 200,
                    Message = "单据同步成功！"
                }; ;
            }
            catch (Exception ex)
            {
                await DbHelp.db.RollbackTranAsync();
                Console.WriteLine(ex.Message);
                return new ResponseBase()
                {
                    Code = 200,
                    Message = $"单据同步失败：{ex.Message}"
                };
            }
        }

        public async Task<ResponseBase> SysOutOrderByMatSn(SysOutOrderByMatSnRequest request)
        {

            //参数合法性校验
            if (request.SnList == null || request.SnList.Count == 0)
            {
                return new ResponseBase()
                {
                    Code = 201,
                    Message = "单据同步失败：缺少物料明细！"
                };
            }
            //库存有无校验 & 库存已锁校验
            try
            {
                await DbHelp.db.BeginTranAsync();
                var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
                                            .Where(t => request.SnList.Contains(t.MatSN))
                                            .TranLock(DbLockType.Wait)
                                            .ToListAsync();
                if (inventoryDetails.Count < request.SnList.Count)//库存的物料少于需求的物料数量
                {
                    var existsSns = inventoryDetails.Select(t => t.MatSN).ToList();
                    request.SnList.RemoveAll(t => existsSns.Contains(t));
                    await DbHelp.db.RollbackTranAsync();
                    //返回提示哪些物料库存不存在
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = "单据同步失败：存在物料不在库存中！",
                        Data = request.SnList

                    };
                }
                else if (inventoryDetails.Where(t => t.IsLocked).Any())
                {
                    await DbHelp.db.RollbackTranAsync();
                    //返回提示哪些物料库存已被锁定
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = "单据同步失败：存在物料被锁定！",
                        Data = inventoryDetails.Where(t => t.IsLocked).Select(t => t.MatSN).ToList()
                    };
                }

                //判断是否有单据号 没有单据号系统自动生成一个
                if (string.IsNullOrEmpty(request.OrderNumber))
                {
                    request.OrderNumber = GenerateOrderNumber();
                }

                #region 保存数据

                //锁库存
                inventoryDetails.ForEach(t =>
                {
                    t.IsLocked = true;
                });
                var lockTask = DbHelp.db.Updateable(inventoryDetails).ExecuteCommandAsync();

                //保存数据
                var order = new OutOrder()
                {
                    OrderNumber = request.OrderNumber,
                    OrderSource = request.OrderSource,
                    OrderType = request.OrderType,
                    SyncType = SyncTypeEnum.ByMatSn,
                    CreateUser = request.UserName,
                };
                order.Id = await DbHelp.db.Insertable(order).ExecuteReturnIdentityAsync();

                //通过库存数据保存出库物料明细表
                var matDetailTasks = inventoryDetails.Select(async t =>
                {
                    var orderMatDetail = new OutOrderMatDetail()
                    {
                        OrderId = order.Id,
                        OrderNumber = order.OrderNumber,
                        InventoryDetailId = t.Id,
                        StoreId = t.StoreId,
                        StoreCode = t.StoreCode,
                        MatSN = t.MatSN,
                        MatCode = t.MatCode,
                        MatName = t.MatName,
                        MatSpec = t.MatSpec,
                        MatBatch = t.MatBatch,
                        MatQty = t.MatQty,
                        MatSupplier = t.MatSupplier,
                        MatCustomer = t.MatCustomer,
                        CreateUser = request.UserName
                    };
                    await DbHelp.db.Insertable(orderMatDetail).ExecuteCommandAsync();
                }).ToList();

                await lockTask;
                await Task.WhenAll(matDetailTasks);

                await DbHelp.db.CommitTranAsync();
                return new ResponseCommon()
                {
                    Code = 200,
                    Message = $"单据同步成功！",
                    Data = order.Id
                };
                #endregion
            }
            catch (Exception ex)
            {
                await DbHelp.db.RollbackTranAsync();
                return new ResponseBase()
                {
                    Code = 201,
                    Message = $"单据同步失败：{ex.Message}"
                };
            }

        }

        public async Task<ResponseBase> GetOutOrderList(GetOutOrderListRequest request)
        {
            //直接查询
            var outOrderList = await DbHelp.db.Queryable<OutOrder>()
                                        .WhereIF(!string.IsNullOrEmpty(request.OrderNumber), t => t.OrderNumber.Contains(request.OrderNumber))
                                        .Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
                                        .ToListAsync();
            return new PageQueryResponse<OutOrder>()
            {
                Code = 200,
                Message = "success",
                Data = new PageQueryResponseData<OutOrder>()
                {
                    Lists = outOrderList,
                    Count = outOrderList.Count
                }
            };
        }

        public async Task<ResponseBase> GetOutOrderDetail(GetOutOrderDetailRequest request)
        {
            OutOrder outOrder = null;

            #region 查询出库单
            if (request.OrderId != 0)
            {
                outOrder = await DbHelp.db.Queryable<OutOrder>().Where(t => t.Id == request.OrderId).FirstAsync();
                if (outOrder == null)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"查询失败：不存在Id为{request.OrderId}的出库单！",
                    };
                }
            }
            else if (string.IsNullOrEmpty(request.OrderNumber))
            {
                outOrder = await DbHelp.db.Queryable<OutOrder>().Where(t => t.OrderNumber == request.OrderNumber)
                                                                .FirstAsync();
                if (outOrder == null)
                {
                    return new ResponseCommon()
                    {
                        Code = 201,
                        Message = $"查询失败：不存在单据号为{request.OrderNumber}的出库单！",
                    };
                }
            }
            else
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"查询失败：缺少必要参数！",
                };
            }
            #endregion

            #region 查询出库单明细
            var orderDetailTask = DbHelp.db.Queryable<OutOrderDetail>()
                                        .Where(t => t.OrderId == outOrder.Id)
                                        .ToListAsync();
            #endregion

            #region 出库物料明细
            var orderMatDetailTask = DbHelp.db.Queryable<OutOrderMatDetail>()
                            .Where(t => t.OrderId == outOrder.Id)
                            .ToListAsync();
            #endregion

            var orderDetail = await orderDetailTask;
            var orderMatDetail = await orderMatDetailTask;
            return new ResponseCommon()
            {
                Code = 200,
                Message = "Success",
                Data = new
                {
                    OrderDetailLists = orderDetail,
                    OrderMatDetailLists = orderMatDetail,
                }
            };
        }


        private string GenerateOrderNumber()
        {
            var orderNumber = "PD" + DateTime.Now.ToString("yyyyMMddHHmmss");
            return orderNumber;
        }

        public async Task<ResponseBase> GoInOutstore(GetOutOrderDetailRequest request)
        {
            //获取出库单
            var order = await DbHelp.db.Queryable<OutOrder>()
                                 .WhereIF(request.OrderId != 0, t => t.Id == request.OrderId)
                                 .WhereIF(!string.IsNullOrEmpty(request.OrderNumber), t => t.OrderNumber == request.OrderNumber)
                                 .FirstAsync();
            if (order == null)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = "不存在对应的出库单据！",
                    Data = null
                };
            }
            //获取出库单据明细
            //TO DO 如果是按物料编码出库  需要计算物料明细保存并进行锁定
            if (order.SyncType == SyncTypeEnum.ByMatCode)
            {

            }

            //分组 按物料找到对应的货架
            {

            }

            //对应的货架进入出库模式 亮灯
            {

            }

            //返回
            return new ResponseCommon()
            {
                Code = 200,
                Message = "Success",
                Data = null
            };
        }

        public async Task<ResponseBase> GoOutOutstore(GetOutOrderDetailRequest request)
        {
            //找到正在出对应出库单的货架
            var shelves = ShelfManager.Shelves.Where(t => t.OrderNumber == request.OrderNumber)
                                              .ToList();
            //退出出库模式
            shelves.ForEach(t =>
            {
                t.GoOutOutstore();
            });

            return new ResponseCommon()
            {
                Code = 200,
                Message = "Success",
                Data = null
            };
        }
    }
}