ICM-WCS/wcs
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1

Browse Source
This commit is contained in:
hehaibing-1996
2024-07-05 14:36:34 +08:00
parent adb0367a83
commit ed3673db03
35 changed files with 1435 additions and 1939 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
WCS.BLL/Services/IService/IMXL4Service.cs Normal file
View File

@ -0,0 +1,20 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.Model;
using WCS.Model.ApiModel.MXL4;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.WebSocketModel;
namespace WCS.BLL.Services.IService
{
/// <summary>
/// 处理、查询报警使用的服务
/// </summary>
public interface IMXL4Service
{
public Task<ResponseCommon<object>> sysOrderMXL4(SysOrderMXL4Request request);
}
}

19
WCS.BLL/Services/IService/ISingleLightService.cs Normal file
View File

@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.Model;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.WebSocketModel;
namespace WCS.BLL.Services.IService
{
/// <summary>
/// 处理、查询报警使用的服务
/// </summary>
public interface ISingleLightService
{
public Task<ResponseCommon<object>> SingleLightControl(SingleLightControlRequest request);
}
}

22
WCS.BLL/Services/IService/IUploadService.cs Normal file
View File

@ -0,0 +1,22 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.Model;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.ApiModel.UpLoad;
using WCS.Model.WebSocketModel;
namespace WCS.BLL.Services.IService
{
/// <summary>
/// 处理、查询报警使用的服务
/// </summary>
public interface IUploadService
{
public Task<ResponseBase> UploadReelInfo(UploadReelInfoRequest request);
public Task<ResponseBase> GetReelInfo(string MatSn);
}
}

552
WCS.BLL/Services/Service/InstoreService.cs.orig
View File

@ -1,552 +0,0 @@
using OracleInternal.SqlAndPlsqlParser.LocalParsing;
using System.ComponentModel.DataAnnotations.Schema;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.HardWare;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Tool;
using WCS.BLL.Tool.Api.ApiModel;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.MXBackgroundThread;
namespace WCS.BLL.Services.Service
{
public class InstoreService : IInstoreService
{
public InstoreService() { }
public ResponseBase shelfGoInInStore(ShelfGoInInstoreRequest request)
{
//校验货架编码规则
//取配置文件中得货架编码规则
bool isValid = false;
var patterns = LocalFile.Config.ModuleCodePatterns;
if (patterns != null && patterns.Count > 0)
{
foreach (var pattern in patterns)
{
isValid = Regex.IsMatch(request.ModuleCode, pattern);
//匹配到第一个符合条件的货架码 就直接退出循环 认为匹配成功
if (isValid)
break;
}
}
//如果配置文件缺失 使用默认正则进行匹配
else
{
isValid = Regex.IsMatch(request.ModuleCode, LocalFile.DefaultModuleCodePattern);
}
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.CurrentMode == Mode.入库模式)
//成功进入入库模式
return new ShelfGoInInstoreResponse()
{
Code = 200,
Message = $"货架进入入库模式成功！{string.Join(",", shelf.ExceptionMessages)}",
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}]不存在!",
};
}
//判断扫码枪 是否被其他扫码枪所占用 如果占用 直接退出入库模式 不发指令
shelf.GoOutInstore();
if (shelf.ExceptionMessages == null || shelf.ExceptionMessages.Count == 0)
//已退出
return new ResponseCommon()
{
Code = 200,
Message = $"货架[{request.ShelfCode}]已退出入库模式!",
};
else
return new ResponseCommon()
{
Code = 200,
Message = $"货架[{request.ShelfCode}]已退出入库模式!{string.Join(",", shelf.ExceptionMessages)}",
};
}
public async Task<ResponseBase> queryByMatSn(QueryByMatSnRequest request)
{
//判断物料是否已入库
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}",
};
}
IShelfBase shelf = null;
if (!request.SingleLightIn)
{
//获取货架
shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
if (shelf == null)//货架不存在
{
return new ResponseCommon<MatInfo>()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不存在!",
};
}
//判断当前是否是入库模式
if (shelf.CurrentMode != Mode.入库模式)
{
return new ResponseCommon<MatInfo>()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurrentMode}",
};
}
}
#region 获取物料数据 //调用接口或者直接查询数据库
// 调用接口
if (LocalFile.Config.IsAccessWMS)
{
#region 调用WMS接口获取物料信息
try
{
var body = new
{
materialBar = request.MatSn
};
var Result = ApiHelp.GetDataFromHttp<ResponseCommon<List<queryByBarResponse>>>("http://192.168.2.23:9213/integrate/instock/queryBybar", body, "POST", true);
//查询到物料信息
if (Result != null && Result.Code == 200 && Result.Data != null && Result.Data.Count > 0)
{
var data = Result.Data.First();
if (!request.SingleLightIn && shelf != null)
shelf.InStoreData = new MatInfoResponse()
{
materialBar = data.materialBar,
materialCode = data.materialCode,
materialName = data.materialName,
materialQty = data.materialQty,
materialSpec = data.materialSpec,
batchNo = data.batchNo,
supplier = "",
customer = "",
InstoreUser = request.UserName
};
var matInfo = new MatInfo()
{
MatSn = data.materialBar,
MatCode = data.materialCode,
MatName = data.materialName,
MatBatch = data.batchNo,
MatQty = (int)data.materialQty,
MatSpec = data.materialSpec,
MatSupplier = "",
MatCustomer = "",
};
return new ResponseCommon<MatInfo>()
{
Code = 200,
Data = matInfo,
Message = "success"
};
}
else if (Result != null && Result.Code == 200 && Result.Data == null)
{
//Mes系统中未获取到物料信息
//简单校验看是否满足海康物料
//海康物料 只扫了外箱码 未扫条码
if ((request.MatSn.Length == 54 || request.MatSn.Length == 56) && !request.MatSn.Contains("\\") && !request.MatSn.Contains("/"))
{
if (!request.SingleLightIn && shelf != null)
shelf.InStoreData = new MatInfoResponse()
{
materialBar = request.MatSn,
materialCode = "暂时未知",
materialName = "暂时未知",
materialQty = 0,
materialSpec = "暂时未知",
batchNo = "暂时未知",
supplier = "",
customer = "",
InstoreUser = request.UserName
};
var matInfo = new MatInfo()
{
MatSn = request.MatSn,
MatCode = "暂时未知",
MatName = "暂时未知",
MatBatch = "暂时未知",
MatQty = 0,
MatSpec = "暂时未知",
MatSupplier = "",
MatCustomer = "",
};
return new ResponseCommon<MatInfo>()
{
Code = 200,
Data = matInfo,
Message = "success"
};
}
return new ResponseCommon<MatInfo>()
{
Code = 201,
Message = $"操作失败：调用Mes接口未获取到物料信息！",
};
}
else
{
return new ResponseCommon<MatInfo>()
{
Code = 201,
Message = $"操作失败：调用Mes接口失败！",
};
}
}
catch (Exception e)
{
return new ResponseCommon<MatInfo>()
{
Code = 300,
Message = $"操作失败：调用Mes接口发生异常{e.Message}",
};
}
#endregion
}
//查询数据库是否存在这个物料
else
{
var matInfo = await DbHelp.db.Queryable<MatInfo>().Where(t => t.MatSn == request.MatSn).FirstAsync();
if (matInfo != null)
{
//TODO 改成wcs的实体
if (!request.SingleLightIn && shelf != 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
}
/// <summary>
/// 单灯出库时查询物料信息 这里返回库存的数据
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task<ResponseBase> queryByMatSnOut(QueryByMatSnRequest request)
{
//判断物料是否已入库
var inventory = await DbHelp.db.Queryable<InventoryDetail>().Where(t => t.MatSN == request.MatSn).FirstAsync();
if (inventory == null)
{
return new ResponseCommon<MatInfo>()
{
Code = 201,
Message = $"操作失败：物料不在库存内，无法进行出库！",
};
}
else
{
return new ResponseCommon<MatInfo>()
{
Code = 200,
Message = $"Success",
Data = new MatInfo()
{
MatSn = inventory.MatSN,
MatCode = inventory.MatCode,
MatName = inventory.MatName,
MatBatch = inventory.MatBatch,
MatQty = inventory.MatQty,
MatSpec = inventory.MatSpec,
MatSupplier = inventory.MatSupplier,
MatCustomer = inventory.MatCustomer,
}
};
}
}
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.CurrentMode != Mode.入库模式)
{
return new ResponseCommon()
{
Code = 201,
Message = $"货架[{request.ShelfCode}]已退出入库模式!\r\n当前为{shelf.CurrentMode}",
};
}
//TODO 配置这个时间相当于需要入库扫码后需要等待的时间
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 = $"超时未入库！请重新扫码后入库！",
Data = new
{
StoreCode = string.Empty,
}
};
}
public async Task<ResponseBase> queryInstoreStatusSingle(QueryByMatSnRequestSingle request)
{
//获取货架
//var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
//if (shelf == null)//货架不存在
//{
// return new ResponseCommon()
// {
// Code = 201,
// Message = $"货架[{request.ShelfCode}]不存在!",
// };
//}
List<ModuleInfo> MI = DbHelp.db.Queryable<ModuleInfo>().Where(it => it.ModuleCode == request.ShelfCode).ToList();
if (MI.Count == 0)
{
return new ResponseCommonSingle()
{
Code = 201,
Message = $"货架[{request.ShelfCode}]不存在!",
};
}
ResponseCommonSingle rcs = new ResponseCommonSingle();
rcs.Data = new List<Detail>();
string sendIP = MI[0].CleintIp; //单灯IP
int PCBId = MI[0].BoardId; //单灯PCB板ID
List<StoreInfo> SI = DbHelp.db.Queryable<StoreInfo>().Where(it => it.ModuleCode == request.ShelfCode).ToList();
List<ShelfInfo> si = DbHelp.db.Queryable<ShelfInfo>().Where(it => it.ShelfCode == MI[0].ShelfCode).ToList();
int warnLightID = si[0].LightId;
foreach (QueryByMatSnRequestSingle.MatSnListDetail matSnListDetail in request.MatSnList)
{
Detail detail = new Detail();
try
{
InventoryDetail inventoryDetail = new InventoryDetail();
inventoryDetail.MatSN = matSnListDetail.MatSn;
inventoryDetail.MatCode = matSnListDetail.MatCode;
inventoryDetail.MatName = matSnListDetail.MatName;
inventoryDetail.MatSpec = matSnListDetail.MatSpec;
inventoryDetail.MatBatch = matSnListDetail.MatBatch;
inventoryDetail.MatQty = matSnListDetail.MatQty;
inventoryDetail.MatCustomer = matSnListDetail.MatCustomer;
inventoryDetail.MatSupplier = matSnListDetail.MatSupplier;
inventoryDetail.StoreCode = request.ShelfCode;
inventoryDetail.StoreId = SI[0].Id;
int count = DbHelp.db.Insertable(inventoryDetail).ExecuteCommand();
InOutRecord ior = new InOutRecord();
ior.MatSN = matSnListDetail.MatSn;
ior.MatCode = matSnListDetail.MatCode;
ior.MatName = matSnListDetail.MatName;
ior.MatSpec = matSnListDetail.MatSpec;
ior.MatBatch = matSnListDetail.MatBatch;
ior.MatQty = matSnListDetail.MatQty;
ior.MatCustomer = matSnListDetail.MatCustomer;
ior.MatSupplier = matSnListDetail.MatSupplier;
ior.StoreCode = request.ShelfCode;
ior.StoreId = SI[0].Id;
ior.Direction = DirectionEnum.入库;
ior.OperateTime = DateTime.Now;
ior.OperateUser = request.UserName;
int count1 = DbHelp.db.Insertable(ior).ExecuteCommand();
detail.matsn = matSnListDetail.MatSn;
detail.result = "入库成功";
rcs.Data.Add(detail);
}
catch (Exception ee)
{
detail.matsn = matSnListDetail.MatSn;
detail.result = "入库失败";
detail.reason = ee.Message;
rcs.Data.Add(detail);
}
}
//亮灯
TCPClient tCPClient = TCPClientManager.GetTCPClientByIPHost(sendIP);
<<<<<<< HEAD
//byte[] data1 = new byte[8];
//data1[0] = 0xff;
//data1[1] = 0x02;
//data1[2] = 0x00;
//data1[3] = 0x0a;
//data1[4] = (byte)warnLightID;
//data1[5] = 0x03;
//data1[6] = 0x02;
//data1[7] = 0x02;
//byte[] senddata1 = Tool.Helper.Crc16(data1, data1.Length, true);
byte[] senddata1 = Tool.Helper.InstoreWarnLight(warnLightID);
=======
byte[] data1 = new byte[8];
data1[0] = 0xff;
data1[1] = 0x02;
data1[2] = 0x00;
data1[3] = 0x0a;
data1[4] = (byte)warnLightID;
data1[5] = 0x03;
data1[6] = 0x02;
data1[7] = 0x02;
byte[] senddata1 = Tool.Helper.Crc16(data1, data1.Length, false);
>>>>>>> 11
tCPClient.Send(senddata1); //报警灯短亮一次
//byte[] data2 = new byte[8];
//data2[0] = 0xff;
//data2[1] = 0x01;
//data2[2] = 0x00;
//data2[3] = 0x0a;
//data2[4] = 0x01;
//data2[5] = (byte)PCBId;
//data2[6] = 0x03;
//data2[7] = 0x02;
//byte[] senddata2 = Tool.Helper.Crc16(data2, data2.Length, true);
byte[] senddata2 = Tool.Helper.InstoreLight(PCBId);
tCPClient.Send(senddata2); //库位灯短亮一次
return new ResponseCommonSingle()
{
Code = 200,
Message = $"入库成功！",
Data = rcs.Data,
};
}
}
}

125
WCS.BLL/Services/Service/MXL4Service.cs Normal file
View File

@ -0,0 +1,125 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml.Xsl;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Tool;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.Db.AuthDb;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MXL4;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.ApiModel.User;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
using static WCS.BLL.Tool.Helper;
namespace WCS.BLL.Services.Service
{
public class MXL4Service : IMXL4Service
{
public async Task<ResponseCommon<object>> sysOrderMXL4(SysOrderMXL4Request request)
{
try
{
//第一步：获取所有库位码 校验库位在数据库中是否都存在
var storeCodeList = request.List.Select(t => t.StoreCode)
.Distinct()
.ToList();
var stores = DbHelp.db.Queryable<StoreInfo>()
.LeftJoin<ShelfTypeInfo>((si, sti) => si.ShelfTypeId == sti.Id)
.Where((si, sti) => sti.ShelfTypeName == "液晶货架")
.Where((si, sti) => storeCodeList.Contains(si.StoreCode))
.Select((st, sti) => st)
.ToList();
if (stores.Count < storeCodeList.Count)
{
var storeCodesInDB = stores.Select(t => t.StoreCode).ToList();
storeCodeList.RemoveAll(t => storeCodesInDB.Contains(t));
return new ResponseCommon<object>
{
Code = 200,
Message = $"操作失败：库位【{string.Join(",", storeCodeList)}】不存在！",
};
}
//第二步 获取当前所有库位任务
//模式相同视为可以继续发送任务
var currenTasks = DbHelp.db.Queryable<CurrentTask>()
.Where(t => storeCodeList.Contains(t.StoreCode))
.ToList();
var currenTasksNotThisMode = currenTasks.Where(t => t.TaskMode != request.OrderType).ToList(); ;
if (currenTasksNotThisMode.Any())
{
var task = currenTasksNotThisMode.First();
return new ResponseCommon<object>
{
Code = 200,
Message = $"操作失败：库位【{task.StoreCode}】当前在{task.TaskMode}！",
};
}
var tasks = new List<CurrentTask>();
//生成任务数据
foreach (var orderDetail in request.List)
{
var store = stores.Where(t => t.StoreCode == orderDetail.StoreCode).First();
var task = new CurrentTask()
{
StoreId = store.Id,
StoreCode = store.StoreCode,
Guid = orderDetail.Guid,
TaskMode = request.OrderType,
OrderNumber = request.OrderNumber,
ButtonColor = request.Corlor,
MatCode = orderDetail.MatCode,
MatName = orderDetail.MatName,
MatSpec = orderDetail.MatSpec,
MatBatch = orderDetail.MatBatch,
Qty = orderDetail.Qty
};
tasks.Add(task);
}
try
{
DbHelp.db.BeginTran();
DbHelp.db.Insertable(tasks).ExecuteCommand();
DbHelp.db.CommitTran();
}
catch (Exception ex)
{
DbHelp.db.RollbackTran();
return new ResponseCommon<object>
{
Code = 300,
Message = $"操作失败：{ex.Message}"
};
}
//发送任务至各个标签
return new ResponseCommon<object>
{
Code = 200,
Message = "success"
};
}
catch (Exception ex)
{
return new ResponseCommon<object>
{
Code = 200,
Message = "操作失败：" + ex.Message,
};
}
}
}
}

3
WCS.BLL/Services/Service/MatBaseInfoService.cs
View File

@ -386,9 +386,9 @@ namespace WCS.BLL.Services.Service
if (request.IsFromBaseData)
{
matCodeList = await DbHelp.db.Queryable<MatBaseInfo>()
.OrderBy(t => t.MatCode)
.Select(t => t.MatCode)
.Distinct()
.OrderBy(t => t)
.ToListAsync();
}
else
@ -396,7 +396,6 @@ namespace WCS.BLL.Services.Service
matCodeList = await DbHelp.db.Queryable<InventoryDetail>()
.Select(t => t.MatCode)
.Distinct()
.OrderBy(t => t)
.ToListAsync();
}
return new ResponseCommon<List<string>>()

5
WCS.BLL/Services/Service/OutstoreService.cs
View File

@ -1345,7 +1345,7 @@ namespace WCS.BLL.Services.Service
}
}
//发送间隔
Thread.Sleep(300);
//Thread.Sleep(300);
foreach (string shelfcode in WarnLightShelfCode)
{
List<ShelfInfo> si = DbHelp.db.Queryable<ShelfInfo>().Where(it => it.ShelfCode == shelfcode).ToList();
@ -1353,12 +1353,11 @@ namespace WCS.BLL.Services.Service
{
for (int i = 0; i < si.Count; i++)
{
Thread.Sleep(250);
TCPClient tCPClient = TCPClientManager.GetTCPClientByIPHost(si[i].ClientIp);
//byte[] warnlightOn = Helper.OutstoreWarnLight(si[i].LightId, LightColor, 0, 0);
byte[] warnlightOn = Helper.OutstoreWarnLight_1(si[i].LightId, LightColor, 0, 0);
tCPClient.Send(warnlightOn);
Logs.Write("出库，报警灯灭：" + BitConverter.ToString(warnlightOn));
Thread.Sleep(100);
}
}
}

1311
WCS.BLL/Services/Service/OutstoreService.cs.orig
View File

File diff suppressed because it is too large Load Diff

152
WCS.BLL/Services/Service/SingleLightService.cs Normal file
View File

@ -0,0 +1,152 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Tool;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.Db.AuthDb;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.ApiModel.User;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
using static WCS.BLL.Tool.Helper;
namespace WCS.BLL.Services.Service
{
public class SingleLightService : ISingleLightService
{
public async Task<ResponseCommon<object>> SingleLightControl(SingleLightControlRequest request)
{
try
{
//传入数据校验
if (request.StoreList == null || request.StoreList.Count == 0)
{
return new ResponseCommon<object>()
{
Code = 201,
Message = "操作失败：没有需要控制的库位",
};
}
//对应库位
var storeCodes = request.StoreList.Select(t => t.StoreCode)
.Distinct()
.ToList();
var stores = DbHelp.db.Queryable<StoreInfo>().Where(t => storeCodes.Contains(t.StoreCode))
.ToList();
if (stores == null || stores.Count == 0)
{
return new ResponseCommon<object>
{
Code = 201,
Message = $"操作失败：所有库位不存在！"
};
}
//对应货架（获取TCP和报警灯ID）
var shelfIds = stores.Select(t => t.ShelfId).Distinct().ToList();
var shelfs = DbHelp.db.Queryable<ShelfInfo>().Where(t => shelfIds.Contains(t.Id))
.ToList();
//对应模组信息
var moduleIds = stores.Select(t => t.ModuleId).Distinct().ToList();
var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => moduleIds.Contains(t.Id))
.ToList();
//加载请求参数中的库位灯 板子ID和货架ID
foreach (var store in request.StoreList)
{
var storeInDb = stores.Where(t => t.StoreCode == store.StoreCode).FirstOrDefault();
if (storeInDb == null)
{
return new ResponseCommon<object>
{
Code = 201,
Message = $"操作失败：库位{store.StoreCode}不存在(store)！"
};
}
else
store.ShelfId = storeInDb.ShelfId;
var moduleInDb = modules.Where(t => t.Id == storeInDb.ModuleId).FirstOrDefault();
if (moduleInDb == null)
{
return new ResponseCommon<object>
{
Code = 201,
Message = $"操作失败：库位{store.StoreCode}不存在(module)！"
};
}
else
store.BoardId = moduleInDb.BoardId;
}
//合并：同一个货架的库位合并
var shelfModels = new List<SingleLightShelfModel>();
foreach (var shelf in shelfs)
{
var shelfModel = new SingleLightShelfModel();
//报警灯
shelfModel.WarningLightMode = request.WarningLightMode;
shelfModel.WarningBuzzerMode = request.WarningBuzzerMode;
shelfModel.WarningLightColor = request.WarningLightColor;
shelfModel.WarningBoardId = shelf.LightId;
shelfModel.ClientIp = shelf.ClientIp;
//库位
var storesThisShelf = request.StoreList
.Where(t => t.ShelfId == shelf.Id)
.ToList();
foreach (var storeThisShelf in storesThisShelf)
{
shelfModel.StoreList.Add(new SingleLightStoreModel()
{
BoardId = storeThisShelf.BoardId,
LightColor = storeThisShelf.LightColor,
LightMode = storeThisShelf.LightMode,
});
}
shelfModels.Add(shelfModel);
}
//合并：同一个TCP的货架合并 报警灯和库位灯统一只发送一条指令
var clientIpList = shelfs.Select(t => t.ClientIp)
.Distinct()
.ToList();
foreach (var clientIp in clientIpList)
{
var shelfModelsInOneIp = shelfModels.Where(t => t.ClientIp == clientIp).ToList();
var sendData = Helper.SingleLightControl(shelfModelsInOneIp);
TCPClient tCPClient = TCPClientManager.GetTCPClientByIPHost(clientIp);
tCPClient.Send(sendData);
Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
}
//返回成功
return new ResponseCommon<object>()
{
Code = 200,
Message = "success",
};
}
catch (Exception ex)
{
//操作失败
return new ResponseCommon<object>()
{
Code = 300,
Message = $"操作失败：{ex.Message}",
};
}
}
}
}

136
WCS.BLL/Services/Service/UploadService.cs Normal file
View File

@ -0,0 +1,136 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.BLL.Tool;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.Db.AuthDb;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.SingleLight;
using WCS.Model.ApiModel.UpLoad;
using WCS.Model.ApiModel.User;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
using static WCS.BLL.Tool.Helper;
namespace WCS.BLL.Services.Service
{
public class UploadService : IUploadService
{
public async Task<ResponseBase> GetReelInfo(string MatSn)
{
if (string.IsNullOrEmpty(MatSn))
{
return new ResponseBase<object>()
{
Code = 201,
Message = "操作失败：条码不能为空"
};
}
//查询物料条码是否存在
var matInfo = await DbHelp.db.Queryable<MatInfo>()
.Where(t => t.MatSn == MatSn)
.FirstAsync();
return new ResponseBase<object>()
{
Code = 200,
Message = "success",
Data = new
{
MatSN = matInfo?.MatSn,
Qty = matInfo?.MatQty
}
};
}
public async Task<ResponseBase> UploadReelInfo(UploadReelInfoRequest request)
{
//校验参数
if (string.IsNullOrEmpty(request.MatSN) || request.Qty <= 0)
{
return new ResponseBase()
{
Code = 201,
Message = "操作失败：条码或数量不合法！"
};
}
//查询物料条码是否存在
var matInfo = await DbHelp.db.Queryable<MatInfo>()
.Where(t => t.MatSn == request.MatSN)
.FirstAsync();
if (matInfo == null)
{
return new ResponseBase()
{
Code = 201,
Message = $"操作失败：不存在此条码【{request.MatSN}】"
};
}
//是否在库存中
var inventoryDetail = await DbHelp.db.Queryable<InventoryDetail>()
.Where(t => t.MatSN == request.MatSN)
.FirstAsync();
if (inventoryDetail != null)
{
return new ResponseBase()
{
Code = 201,
Message = $"操作失败：此条码在库位{inventoryDetail.StoreCode}上，请下架后再进行操作。"
};
}
try
{
DbHelp.db.BeginTran();
//记录日志
var MatInfoLog = new MatInfoLog()
{
MatQty = request.Qty,
MatSn = request.MatSN,
Info = $"[{request.IPAddress}]数量从{matInfo.MatQty}修改为{request.Qty}!"
};
DbHelp.db.Insertable(MatInfoLog).ExecuteCommand();
//修改数量
matInfo.MatQty = request.Qty;
DbHelp.db.Updateable(matInfo).ExecuteCommand();
DbHelp.db.CommitTran();
return new ResponseBase()
{
Code = 200,
Message = "success"
};
}
catch (Exception ex)
{
DbHelp.db.RollbackTran();
return new ResponseBase()
{
Code = 300,
Message = "操作失败：" + ex.Message
};
}
}
}
}