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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.HardWare;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.Model;
using WCS.Model.ApiModel.MatBaseInfo;

namespace WCS.BLL.Services.Service
{
    public class InstoreService : IInstoreService
    {
        public InstoreService() { }

        public ResponseBase shelfGoInInStore(ShelfGoInInstoreRequest request)
        {
            //校验货架编码规则
            bool isValid = Regex.IsMatch(request.ModuleCode, LocalFile.ModuleCodePattern);
            if (!isValid)
            {
                return new ResponseBase()
                {
                    Code = 202,
                    Message = $"模组编码{request.ModuleCode}不满足模组编码规则！",
                };
            }
            //找到模组对应的货架
            var shelf = ShelfManager.Shelves.Where(t => t.ModulesStr.Contains(request.ModuleCode)).FirstOrDefault();
            if (shelf == null)//未找到
            {
                return new ResponseBase()
                {
                    Code = 201,
                    Message = "未找到模组对应的货架",
                };
            }
            //已找到模组对应货架
            shelf.GoInInstore(request.IpAdress);

            if (shelf.CurentMode == Mode.入库模式)
                //成功进入入库模式
                return new ShelfGoInInstoreResponse()
                {
                    Code = 200,
                    Message = "货架进入入库模式成功！",
                    Data = new ShelfGoInInstoreDto()
                    {
                        ShelfCode = shelf.ShelfCode,
                        ModulesStr = shelf.ModulesStr,
                    }
                };
            else
                return new ShelfGoInInstoreResponse()
                {
                    Code = 201,
                    Message = $"货架进入入库模式失败：{string.Join(",", shelf.ExceptionMessages)}",
                    Data = null
                };
        }

        public ResponseBase shelfGoOutInStore(ShelfGoOutInStoreRequest request)
        {
            //获取货架
            var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
            if (shelf == null)//货架不存在
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"退出入库模式失败：货架[{request.ShelfCode}]不存在!",
                };
            }
            //TO DO 判断扫码枪 是否被其他扫码枪所占用 如果占用 直接退出入库模式 不发指令
            //两个扫码枪互相占用入库会有问题
            shelf.GoOutInstore();

            return new ResponseCommon()
            {
                Code = 200,
                Message = $"货架[{request.ShelfCode}]已退出入库模式!",
            };
        }

        public async Task<ResponseBase> queryByMatSn(QueryByMatSnRequest request)
        {
            //获取货架
            var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
            if (shelf == null)//货架不存在
            {
                return new ResponseCommon<MatInfo>()
                {
                    Code = 201,
                    Message = $"操作失败：货架[{request.ShelfCode}]不存在!",
                };
            }
            //判断当前是否是入库模式
            if (shelf.CurentMode != Mode.入库模式)
            {
                return new ResponseCommon<MatInfo>()
                {
                    Code = 201,
                    Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurentMode}",
                };
            }
            //判断物料是否已入库
            var inventory = await DbHelp.db.Queryable<InventoryDetail>().Where(t => t.MatSN == request.MatSn).FirstAsync();
            if (inventory != null)
            {
                return new ResponseCommon<MatInfo>()
                {
                    Code = 201,
                    Message = $"操作失败：物料{inventory.MatSN}已入库，库位为{inventory.StoreCode}",
                };
            }
            #region 获取物料数据
            //调用接口或者直接查询数据库
            if (1 != 1)
            {

            }
            //查询数据库
            else
            {
                var matInfo = await DbHelp.db.Queryable<MatInfo>().Where(t => t.MatSn == request.MatSn).FirstAsync();
                if (matInfo != null)
                {

                    shelf.InStoreData = new MatInfoResponse()
                    {
                        materialBar = matInfo.MatSn,
                        materialCode = matInfo.MatCode,
                        materialName = matInfo.MatName,
                        materialQty = matInfo.MatQty,
                        materialSpec = matInfo.MatSpec,
                        batchNo = matInfo.MatBatch,
                        supplier = matInfo.MatSupplier,
                        customer = matInfo.MatCustomer,

                        InstoreUser = request.UserName
                    };

                    return new ResponseCommon<MatInfo>()
                    {
                        Code = 200,
                        Data = matInfo,
                        Message = "success"
                    };
                }
                else
                    return new ResponseCommon<MatInfo>()
                    {
                        Code = 201,
                        Data = null,
                        Message = $"不存在物料{request.MatSn}"
                    };
            }

            #endregion
        }

        public async Task<ResponseBase> queryInstoreStatus(QueryByMatSnRequest request)
        {
            //获取货架
            var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
            if (shelf == null)//货架不存在
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"货架[{request.ShelfCode}]不存在!",
                };
            }

            //判断当前是否是入库模式
            if (shelf.CurentMode != Mode.入库模式)
            {
                return new ResponseCommon()
                {
                    Code = 201,
                    Message = $"货架[{request.ShelfCode}]已退出入库模式!\r\n当前为{shelf.CurentMode}",
                };
            }

            //这个时间相当于需要入库扫码后需要等待的时间
            var timeOut = 5000;
            var timeSpan = TimeSpan.FromMilliseconds(0);
            var beginTime = DateTime.Now;
            while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
            {
                timeSpan = DateTime.Now - beginTime;
                //已入库当前扫码的物料时 查询数据库
                if (shelf.InStoreData == null || (shelf.InStoreData as object) == null)
                {
                    await Task.Delay(50);
                    var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>()
                                                   .Where(t => t.MatSN == request.MatSn)
                                                   .First();
                    if (inventoryDetail != null)
                    {
                        return new ResponseCommon()
                        {
                            Code = 200,
                            Message = $"入库成功！物料已放入库位{inventoryDetail.StoreCode}",
                            Data = new
                            {
                                StoreCode = inventoryDetail.StoreCode,
                            }
                        };
                    }
                    else
                        break;
                }
                //延时处理
                Thread.Sleep(50);
            }
            //超时未成功入库
            shelf.InStoreData = null;
            return new ResponseCommon()
            {
                Code = 201,
                Message = $"超时未入库！请重新扫码后入库！",
            };
        }
    }
}