using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
using iWareSql;
|
using System.Data.Entity.Migrations;
|
using iWareSql.Orm;
|
using iWareCommon;
|
using iWareCommon.Utils;
|
using iWareSql.Entity.ViewMode;
|
|
using iWareSql.DBModel;
|
using iWareModel;
|
using iWareCommon.Common.Globle;
|
using XiGang.Core.Model;
|
using iWareSql.WmsDBModel;
|
|
namespace iWareSql.DataAccess
|
{
|
public class StationHandler
|
{
|
private static readonly object lockObject = new object();
|
private static readonly object lockRemoveObject = new object();
|
private static readonly object lockFindBestEmptyPlaceForOrdinaryMaterial = new object();
|
private static Dictionary<int, string> lockPlaceDict = new Dictionary<int, string>();
|
|
/// <summary>
|
/// 验证站点是否可以被使用
|
/// </summary>
|
/// <param name="stationId"></param>
|
/// <returns></returns>
|
public static MessageModel<bool> ValidateStationIsAllowUse(int stationId, DbModel context)
|
{
|
var stationList = context.Base_Station.Where(x => x.Id == stationId).ToList();
|
if (stationList == null || stationList.Count == 0)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = "站点ID'" + stationId + "'不存在！"
|
};
|
}
|
if (stationList.Count > 1)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = "站点ID'" + stationId + "'存在" + stationList.Count + "条数据！"
|
};
|
}
|
var station = stationList[0];
|
var stationName = "库位[";
|
if (station.IsRgvStation)
|
{
|
stationName += "RGV站点" + station.RgvStationCode;
|
}
|
else if (station.IsSrmStation)
|
{
|
stationName += "堆垛机站点" + station.SrmStationCode;
|
}
|
stationName += "]";
|
if (station.IsDeleted == true)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = stationName + "'已经被禁用！"
|
};
|
}
|
else if (station.IsFull)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = stationName + "'已经有货！"
|
};
|
}
|
else if (station.IsLock)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = stationName + "'已经被锁定！"
|
};
|
}
|
//判断库位是否目前有任务在执行 TODO
|
//var isUse = await task_PartServices.IsExistOtherTaskDoing(station.Id);
|
var isUse = PartTaskHandler.IsExistOtherTaskDoing(station.Id);
|
if (isUse)
|
{
|
return new MessageModel<bool>()
|
{
|
data = false,
|
success = false,
|
msg = stationName + "'被其他任务占用！"
|
};
|
}
|
|
return new MessageModel<bool>()
|
{
|
data = true,
|
success = true,
|
msg = "验证站点可以被使用！"
|
};
|
}
|
|
#region 锁定库位的方法
|
|
/// <summary>
|
/// 在事务处理完毕后，释放被锁定的库位( 供 配板余料回库线程、RGV提前配板任务创建时，成品料回库线程、原料入库线程使用)
|
/// 一定要放到finaly里执行
|
/// </summary>
|
/// <returns></returns>
|
public static void RemoveLockPlaceDict(Base_Station validatePlace)
|
{
|
if (validatePlace == null)
|
{
|
return;
|
}
|
lock (lockRemoveObject)
|
{
|
if (lockPlaceDict.ContainsKey(validatePlace.Id))
|
{
|
lockPlaceDict.Remove(validatePlace.Id);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 寻找空库位
|
|
/// <summary>
|
/// 寻找空闲的立库空库位 (普通物料)
|
/// </summary>
|
/// <returns></returns>
|
public static Base_Station FindBestEmptyPlaceForOrdinaryMaterial(DbModel edm, string orderNo, MaterialTypeEnum _MaterialTypeEnum)
|
{
|
try
|
{
|
lock (lockFindBestEmptyPlaceForOrdinaryMaterial)
|
{
|
Thread.Sleep(1000);
|
var emptyStationList = edm.V_EmptySrmStation.ToList();
|
////模拟，暂时，先只用1号堆垛机的1排库位 [EditBy shaocx,2022-04-23]
|
//emptyStationList = emptyStationList.Where(x => x.Area == "1" && x.Row == 1).ToList();
|
|
//不随机排序
|
emptyStationList = emptyStationList.OrderByDescending(x => x.Row).ThenByDescending(x => x.Column).ThenBy(x => x.Layer).ToList();
|
//var isRandomFindPlace = WCSConfigHelper.GetConfig_IsRandomFindPlace();
|
//if (!isRandomFindPlace)
|
//{
|
// emptyStationList = emptyStationList.OrderByDescending(x => x.Row).ThenByDescending(x => x.Column).ThenBy(x => x.Layer).ToList();
|
//}
|
//else
|
//{//随机排序
|
// emptyStationList = ListHelper.RandomList<V_EmptySrmStation>(emptyStationList);
|
//}
|
|
emptyStationList = FindEmptyPlaceByCommonFilter(emptyStationList);
|
|
emptyStationList = FindPlacesFilterByBreakdown(emptyStationList);//通过设备状态来过滤库位 [EditBy shaocx,2020-12-13]
|
if (emptyStationList == null || emptyStationList.Count == 0)
|
{
|
//无空余库位
|
return null;
|
}
|
//增加该库位是否被任务占用的筛选 [EditBy shaocx,2022-06-02]
|
emptyStationList = FilterStationForDoingTask(edm, emptyStationList);
|
|
//获取目前可放物料的库区
|
List<string> usableAreaList = emptyStationList.Select(x => x.Area).Distinct().ToList();
|
Dictionary<int, int> dict_usableArea = new Dictionary<int, int>();
|
foreach (var usableArea in usableAreaList)
|
{
|
dict_usableArea.Add(Convert.ToInt32(usableArea), emptyStationList.Where(x => x.Area == usableArea).Count());
|
}
|
//string minKey_Area = GetMinKey_Area_V1(orderNo, edm, usableAreaList, dict_usableArea);
|
int minKey_Area = GetMinKey_Area_V2(orderNo, edm, usableAreaList, dict_usableArea);
|
switch (_MaterialTypeEnum)
|
{
|
case MaterialTypeEnum.一般物料:
|
minKey_Area = GetMinKey_Area_V2(orderNo, edm, usableAreaList, dict_usableArea);
|
break;
|
case MaterialTypeEnum.托盘:
|
minKey_Area = GetMinKey_AreaForSalver(edm, usableAreaList, dict_usableArea);
|
break;
|
}
|
if (minKey_Area == 0)
|
throw new Exception("获取分配库位的库区号为空");
|
|
emptyStationList = emptyStationList.Where(x => x.Area == minKey_Area.ToString()).ToList();//库区过滤
|
//1-01-03-04 2-02-04-05
|
//同一个库区，采取先放底层，先放序号小的规则
|
//寻找库里第一排的数据
|
emptyStationList = emptyStationList
|
//先按照层，升序排列
|
.OrderBy(x => x.Layer)
|
//再按照列，升序排列
|
.ThenBy(x => x.Column).ToList();
|
Base_Station toPlace = StationHandler.GetPlaceByPlaceId(emptyStationList.First().Id, edm);
|
return toPlace;
|
}
|
}
|
catch (Exception ex)
|
{
|
throw;
|
}
|
}
|
|
private static List<V_EmptySrmStation> FilterStationForDoingTask(DbModel context, List<V_EmptySrmStation> emptyStationList)
|
{
|
List<V_EmptySrmStation> new_emptyStationList = new List<V_EmptySrmStation>();
|
//增加该库位是否被任务占用的筛选 [EditBy shaocx,2022-06-02]
|
if (emptyStationList != null && emptyStationList.Count > 0)
|
{
|
foreach (var _findStore in emptyStationList)
|
{
|
var isExistOtherTaskDoing = PartTaskHandler.IsExistOtherTaskDoing(context, _findStore.Id);
|
if (!isExistOtherTaskDoing)
|
{
|
new_emptyStationList.Add(_findStore);
|
}
|
}
|
}
|
return new_emptyStationList;
|
}
|
|
|
/// <summary>
|
/// 获取分配库位的库区号-版本1，库存分摊，同一个订货号分摊四个库区
|
/// </summary>
|
/// <param name="orderNo"></param>
|
/// <param name="edm"></param>
|
/// <param name="usableAreaList"></param>
|
/// <param name="dict_usableArea">可用空库位数</param>
|
/// <returns></returns>
|
private static int GetMinKey_Area_V1(string orderNo, DbModel edm, List<string> usableAreaList, Dictionary<int, int> dict_usableArea)
|
{
|
int minKey_Area = 0;
|
if (!string.IsNullOrEmpty(orderNo))
|
{//需要按照订货号均分的库位分配方式
|
//寻找同一订货号的库存,并且是在可用空库位库区中
|
var wareHoustStoreList = edm.V_Store.Where(x => x.OrderNo == orderNo && usableAreaList.Contains(x.Area)).ToList();
|
if (wareHoustStoreList != null && wareHoustStoreList.Count > 0)
|
{
|
Dictionary<int, int> new_dict_usableArea = new Dictionary<int, int>();//计算现有可放库区的现有订货号的库存数字典
|
foreach (var item in dict_usableArea)
|
{
|
new_dict_usableArea.Add(item.Key, edm.V_Store.Where(x => x.OrderNo == orderNo && x.Area == item.Key.ToString()).Count());
|
}
|
//var areaList = wareHoustStoreList.Select(x => x.Area).Distinct().ToList();
|
//Dictionary<string, int> area_dict = new Dictionary<string, int>();
|
//foreach (var item in areaList)
|
//{
|
// area_dict.Add(item, wareHoustStoreList.Where(x => x.Area == item).Count());
|
//}
|
minKey_Area = new_dict_usableArea.OrderBy(d => d.Value).Select(d => d.Key).FirstOrDefault();
|
}
|
else
|
{
|
minKey_Area = dict_usableArea.OrderByDescending(d => d.Value).Select(d => d.Key).FirstOrDefault();
|
}
|
}
|
else
|
{//不需要按照订货号均分的库位分配方式
|
//寻找哪个库区现在空余数最小
|
//var minKey = dict.Keys.Select(x => new { x, y = dict[x] }).OrderBy(x => x.y).First();
|
minKey_Area = dict_usableArea.OrderByDescending(d => d.Value).Select(d => d.Key).FirstOrDefault();
|
}
|
return minKey_Area;
|
}
|
|
/// <summary>
|
/// 获取分配库位的库区号-版本2，入库任务循环入库四个库区
|
/// </summary>
|
/// <param name="orderNo"></param>
|
/// <param name="edm"></param>
|
/// <param name="usableAreaList"></param>
|
/// <param name="dict_usableArea">可用空库位数</param>
|
/// <returns></returns>
|
private static int GetMinKey_Area_V2(string orderNo, DbModel edm, List<string> usableAreaList, Dictionary<int, int> dict_usableArea)
|
{
|
int myKey_Area = 0;
|
if (dict_usableArea.Count == 1)
|
{
|
myKey_Area = dict_usableArea.First().Key;
|
return myKey_Area;
|
}
|
//判断上一个入库任务是调用的哪个库区，当前任务就入另一个库区,按顺序 1，2，3，4跳跃入库
|
var queryDeviceTaskTypeEnum1 = (int)DeviceTaskTypeEnum.组盘入库;
|
var queryDeviceTaskTypeEnum2 = (int)DeviceTaskTypeEnum.空托转运到立体库;
|
|
var queryDeviceType = (int)EDeviceType.堆垛机;
|
|
//使用 最新下发时间，来取最后一个任务 【editby shaocx，2022-04-28】
|
var queryState = (int)DeviceTaskStatusEnum.已取消;
|
var lastPart = edm.Task_Part.Where(x => x.DeviceType == queryDeviceType && (x.TaskType == queryDeviceTaskTypeEnum1 || x.TaskType == queryDeviceTaskTypeEnum2) && x.TaskState != queryState).OrderByDescending(x => x.CreateTime).FirstOrDefault();
|
if (lastPart == null)
|
{
|
myKey_Area = dict_usableArea.OrderBy(d => d.Key).Select(d => d.Key).FirstOrDefault();//默认从可用库区中调第一个
|
}
|
else
|
{
|
var current_srmNo = Convert.ToInt32(lastPart.DeviceId);//当前上一个任务执行的库区号
|
//取不包含current_srmNo的最大值
|
int max_Area = dict_usableArea.Where(x => x.Key != current_srmNo).OrderByDescending(d => d.Key).Select(d => d.Key).FirstOrDefault();
|
//取不包含current_srmNo的最小值
|
int min_Area = dict_usableArea.Where(x => x.Key != current_srmNo).OrderBy(d => d.Key).Select(d => d.Key).FirstOrDefault();
|
|
if (current_srmNo > Convert.ToInt32(max_Area))
|
{
|
myKey_Area = min_Area;
|
}
|
else
|
{
|
//取除了current_srmNo，比current_srmNo大的字典的最小值
|
myKey_Area = dict_usableArea.Where(x => x.Key > current_srmNo).OrderBy(d => d.Key).Select(d => d.Key).FirstOrDefault();
|
}
|
}
|
return myKey_Area;
|
}
|
|
/// <summary>
|
/// 获取分配库位的库区号-版本1，库存分摊，托盘分摊四个库区
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="usableAreaList"></param>
|
/// <param name="dict_usableArea">可用空库位数</param>
|
/// <returns></returns>
|
private static int GetMinKey_AreaForSalver(DbModel edm, List<string> usableAreaList, Dictionary<int, int> dict_usableArea)
|
{
|
int minKey_Area = 0;
|
//需要按照托盘均分的库位分配方式
|
//寻找托盘的库存,并且是在可用空库位库区中
|
var wareHoustStoreList = edm.V_Store.Where(x => x.MaterialType == (int)MaterialTypeEnum.托盘 && usableAreaList.Contains(x.Area)).ToList();
|
if (wareHoustStoreList != null && wareHoustStoreList.Count > 0)
|
{
|
Dictionary<int, int> new_dict_usableArea = new Dictionary<int, int>();//计算现有可放库区的现有订货号的库存数字典
|
foreach (var item in dict_usableArea)
|
{
|
new_dict_usableArea.Add(item.Key, edm.V_Store.Where(x => x.MaterialType == (int)MaterialTypeEnum.托盘 && x.Area == item.Key.ToString()).Count());
|
}
|
//var areaList = wareHoustStoreList.Select(x => x.Area).Distinct().ToList();
|
//Dictionary<string, int> area_dict = new Dictionary<string, int>();
|
//foreach (var item in areaList)
|
//{
|
// area_dict.Add(item, wareHoustStoreList.Where(x => x.Area == item).Count());
|
//}
|
minKey_Area = new_dict_usableArea.OrderBy(d => d.Value).Select(d => d.Key).FirstOrDefault();
|
}
|
else
|
{
|
minKey_Area = dict_usableArea.OrderByDescending(d => d.Value).Select(d => d.Key).FirstOrDefault();
|
}
|
return minKey_Area;
|
}
|
|
|
/// <summary>
|
/// 通用的寻找空库位过滤条件
|
/// </summary>
|
/// <param name="places"></param>
|
/// <returns></returns>
|
private static List<V_EmptySrmStation> FindEmptyPlaceByCommonFilter(List<V_EmptySrmStation> places)
|
{
|
if (places != null && places.Count() > 0)
|
{
|
places = places.Where(x => !SysGloble.Dict_SpecialPlace.ContainsKey(x.SrmStationCode)).ToList();
|
return places.ToList();
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 过滤掉特殊库位
|
/// </summary>
|
/// <param name="places"></param>
|
/// <returns></returns>
|
public static List<Base_Station> FindCommonFilter(List<Base_Station> places)
|
{
|
if (places != null && places.Count() > 0)
|
{
|
places = places.Where(x => !SysGloble.Dict_SpecialPlace.ContainsKey(x.SrmStationCode)).ToList();
|
return places.ToList();
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
///// <summary>
|
///// 寻找立库中的空库位
|
///// </summary>
|
///// <param name="reamrk"></param>
|
///// <returns></returns>
|
//public static Base_Station FindBestEmptyPlaceByAreaLogic(EItemType itemType, string reamrk, DbModel edm)
|
//{
|
// Base_Station place = null;
|
|
// place = InnerFindBestEmptyPlaceByAreaLogic(edm);
|
|
// var isLock = ValidateFindPlaceIsLocked(place, reamrk);
|
// if (isLock)
|
// {
|
// return null;
|
// }
|
// return place;
|
//}
|
|
///// <summary>
|
///// 寻找在立体库中 可放的空托物料的空库位
|
///// </summary>
|
///// <param name="edm"></param>
|
///// <returns></returns>
|
//public static Base_Station FindBestEmptyPlaceBySubplate(DbModel edm, string reamrk)
|
//{
|
// List<Base_Station> orderedQueryable_places = edm.Base_Station.Where(x => x.Srm_C_V_P.Count == 0
|
// && x.IsAsrsPlace == 1 && x.IsTrussPlace == 0 && x.IsConveyorPlace == 0
|
// && x.Islock == 0
|
// ).ToList();
|
// var isRandomFindPlace = WCSConfigHelper.GetConfig_IsRandomFindPlace();
|
// if (!isRandomFindPlace)
|
// {
|
// orderedQueryable_places = orderedQueryable_places.OrderByDescending(x => x.Row).ThenBy(x => x.Col).ThenBy(x => x.Layer).ToList();
|
// }
|
// else
|
// {//随机排序
|
// orderedQueryable_places = ListHelper.RandomList<Base_Station>(orderedQueryable_places);
|
// }
|
// var findPlaces = SrmPlaceHandels.FindPlaceByCommonFilter(orderedQueryable_places);
|
|
// findPlaces = FindPlacesFilterByBreakdown(findPlaces);//通过设备状态来过滤库位 [EditBy shaocx,2020-12-13]
|
|
// if (findPlaces == null)
|
// {
|
// //无空余 可放的垫板垛物料的库位
|
// return null;
|
// }
|
// Base_Station fullPlace = findPlaces.FirstOrDefault();
|
// var isLock = ValidateFindPlaceIsLocked(fullPlace, reamrk);
|
// if (isLock)
|
// {
|
// return null;
|
// }
|
// return fullPlace;
|
//}
|
|
//private static Base_Station InnerFindBestEmptyPlaceByAreaLogic(DbModel edm)
|
//{
|
// //符合逻辑区域（物料类型）的、没有CVP绑定关系的库位视为空库位，然后再按行、列、层次序选择
|
// //同时根据 Islock
|
// var emptyPlaces = edm.Srm_EmptyPlaceView.Where(x =>
|
// x.Islock == 0
|
// ).ToList();
|
// var isRandomFindPlace = WCSConfigHelper.GetConfig_IsRandomFindPlace();
|
// if (!isRandomFindPlace)
|
// {
|
// emptyPlaces = emptyPlaces.OrderByDescending(x => x.Row).ThenBy(x => x.Col).ThenBy(x => x.Layer).ToList();
|
// }
|
// else
|
// {//随机排序
|
// emptyPlaces = ListHelper.RandomList<Srm_EmptyPlaceView>(emptyPlaces);
|
// }
|
|
// emptyPlaces = FindPlacesFilterByBreakdown(emptyPlaces);//通过设备状态来过滤库位 [EditBy shaocx,2020-12-13]
|
|
// if (emptyPlaces == null)
|
// return null;
|
// var emptyPlace = emptyPlaces.FirstOrDefault();
|
// if (emptyPlace == null) //修复提示为NULL的问题
|
// return null;
|
// return edm.Base_Station.First(x => x.SrmPlaceNo == emptyPlace.SrmPlaceNo);
|
//}
|
|
|
#endregion
|
|
|
/// <summary>
|
/// 获取RGV库位
|
/// </summary>
|
/// <returns></returns>
|
public static Base_Station GetRgvPlace(DbModel edm, string rgvStationNo)
|
{
|
var place = edm.Base_Station.Where(o => o.RgvStationCode == rgvStationNo).FirstOrDefault();
|
if (place == null)
|
throw new Exception("没有找到RGV" + rgvStationNo + "库位!");
|
return place;
|
}
|
|
/// <summary>
|
/// [入库]通过立体库的库位获取RGV入库的位置
|
/// </summary>
|
/// <returns></returns>
|
public static Base_Station GetRgvPlaceBySrmPlaceForInStore(DbModel edm, Base_Station srmPlace)
|
{
|
string rgvStationNo = "";
|
EDevice rgvLcation;
|
|
switch (srmPlace.Area)
|
{
|
case "1":
|
rgvLcation = EDevice.堆垛机1入库口1002;
|
break;
|
case "2":
|
rgvLcation = EDevice.堆垛机2入库口1004;
|
break;
|
case "3":
|
rgvLcation = EDevice.堆垛机3入库口1006;
|
break;
|
case "4":
|
rgvLcation = EDevice.堆垛机4入库口1007;
|
break;
|
default:
|
throw new Exception("错误的立库库位" + srmPlace.SrmStationCode);
|
}
|
rgvStationNo = ((int)rgvLcation).ToString();
|
var place = edm.Base_Station.Where(o => o.RgvStationCode == rgvStationNo).FirstOrDefault();
|
if (place == null)
|
throw new Exception("没有找到RGV" + rgvStationNo + "库位!");
|
return place;
|
}
|
|
/// <summary>
|
/// [出库]通过立体库的库位获取RGV出库的位置
|
/// </summary>
|
/// <returns></returns>
|
public static Base_Station GetRgvPlaceBySrmPlaceForOutStore(DbModel edm, Base_Station srmPlace)
|
{
|
string rgvStationNo = "";
|
EDevice rgvLcation;
|
switch (srmPlace.Area)
|
{
|
case "1":
|
rgvLcation = EDevice.堆垛机1出库口1001;
|
break;
|
case "2":
|
rgvLcation = EDevice.堆垛机2出库口1003;
|
break;
|
case "3":
|
rgvLcation = EDevice.堆垛机3出库口1005;
|
break;
|
case "4":
|
rgvLcation = EDevice.堆垛机4出库口1008;
|
break;
|
default:
|
throw new Exception("错误的立库库位" + srmPlace.SrmStationCode);
|
}
|
rgvStationNo = ((int)rgvLcation).ToString();
|
var place = edm.Base_Station.Where(o => o.RgvStationCode == rgvStationNo).FirstOrDefault();
|
if (place == null)
|
throw new Exception("没有找到RGV" + rgvStationNo + "库位!");
|
return place;
|
}
|
|
|
/// <summary>
|
/// 根据库位号去判断 所在 排、列、层
|
/// </summary>
|
/// <param name="place"></param>
|
/// <returns></returns>
|
public static PlaceLocationView GetPlaceLocationView(Base_Station place)
|
{
|
string no = place.SrmStationCode;
|
List<String> list = no.Split('-').ToList<string>();
|
if (list.Count != 3)
|
{
|
throw new Exception("库位格式不正确");
|
}
|
PlaceLocationView result = new PlaceLocationView();
|
result.Row = Convert.ToInt32(list[0]);
|
result.Col = Convert.ToInt32(list[1]);
|
result.Layer = Convert.ToInt32(list[2]);
|
return result;
|
}
|
|
|
/// <summary>
|
/// 重新验证库位是否可以允许被使用
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="placeId"></param>
|
/// <returns></returns>
|
public static bool IsAllowUsePlace(DbModel edm, Base_Station place)
|
{
|
var new_place = GetPlaceByPlaceId(place.Id, edm);
|
if (new_place.IsLock == false)
|
return true;
|
return false;
|
}
|
|
/// <summary>
|
/// 重新验证库位是否可以允许被使用
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="placeId"></param>
|
/// <returns></returns>
|
public static bool IsAllowUsePlace(DbModel edm, Base_Station place, ref string errMsg)
|
{
|
var new_place = GetPlaceByPlaceId(place.Id, edm);
|
var stationName = "库位[";
|
if (new_place.IsRgvStation)
|
{
|
stationName += "RGV站点" + new_place.RgvStationCode;
|
}
|
else if (new_place.IsSrmStation)
|
{
|
stationName += "堆垛机站点" + new_place.SrmStationCode;
|
}
|
stationName += "]";
|
if (new_place.IsLock == true)
|
{
|
errMsg = stationName + "]被锁定!";
|
return false;
|
}
|
if (new_place.IsDeleted == true)
|
{
|
errMsg = stationName + "被禁用!";
|
return false;
|
}
|
if (new_place.IsHasTaskDoing == true)
|
{
|
errMsg = stationName + "被任务占用!";
|
return false;
|
}
|
//判断库位是否目前有任务在执行 TODO
|
var isUse = PartTaskHandler.IsExistOtherTaskDoing(edm, place.Id);
|
if (isUse)
|
{
|
errMsg = stationName + "被其他任务占用!";
|
return false;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 重新根据库位ID获取库位是否可以允许被使用
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="placeId"></param>
|
/// <returns></returns>
|
public static bool IsAllowUsePlaceByPlaceId(DbModel edm, int placeId)
|
{
|
var place = GetPlaceByPlaceId(placeId, edm);
|
if (place.IsLock == false)
|
return true;
|
return false;
|
}
|
|
|
|
|
/// <summary>
|
/// 设置Place的IsLock
|
/// </summary>
|
/// <param name="isLock"></param>
|
/// <param name="place"></param>
|
public static void SetPlaceLockStatus(bool isLock, string userName, ref Base_Station place, string remark)
|
{
|
place.ModifyBy = userName;
|
place.Remark = remark + "[更新锁定/解锁库位,isLock:" + isLock + "]";
|
place.ModifyTime = DateTime.Now;
|
if (isLock)
|
{
|
place.IsLock = true;
|
//place.Void = (int)VoidEnum.禁用;
|
}
|
else
|
{
|
place.IsLock = false;
|
//place.Void = (int)VoidEnum.可用;
|
}
|
}
|
|
/// <summary>
|
/// 设置Place的isTaskDoing
|
/// </summary>
|
/// <param name="isTaskDoing">是否有任务占用</param>
|
/// <param name="place"></param>
|
public static void SetPlaceTaskDoingStatus(bool isTaskDoing, string userName, ref Base_Station place, string remark)
|
{
|
place.ModifyBy = userName;
|
place.Remark = remark + "[更新是否有任务占用库位,isTaskDoing:" + isTaskDoing + "]";
|
place.ModifyTime = DateTime.Now;
|
if (isTaskDoing)
|
{
|
place.IsHasTaskDoing = true;
|
}
|
else
|
{
|
place.IsHasTaskDoing = false;
|
}
|
}
|
|
/// <summary>
|
/// 根据库位ID查找库位对象
|
/// </summary>
|
/// <returns></returns>
|
public static Base_Station GetPlaceByPlaceId(int placeId, DbModel edm)
|
{
|
return edm.Base_Station.Where(x => x.Id == placeId).FirstOrDefault();
|
}
|
|
/// <summary>
|
/// 根据库位ID查找库位对象
|
/// </summary>
|
/// <returns></returns>
|
public static wms_base_place GetPlaceByPlaceId(long placeId, WmsDBModel.WmsDBModel edm)
|
{
|
return edm.wms_base_place.Where(x => x.Id == placeId).FirstOrDefault();
|
}
|
|
/// <summary>
|
/// 根据库位编号查找库位对象
|
/// </summary>
|
/// <returns></returns>
|
public static wms_base_place GetPlaceByPlaceCode(string placeCode, WmsDBModel.WmsDBModel edm)
|
{
|
return edm.wms_base_place.Where(x => x.PlaceCode == placeCode).FirstOrDefault();
|
}
|
|
|
/// <summary>
|
/// 根据库位号查找库位对象
|
/// </summary>
|
/// <param name="srmPlaceNo">库位号</param>
|
/// <param name="edm"></param>
|
/// <returns></returns>
|
public static Base_Station GetPlaceBySrmPlaceNo(string srmPlaceNo, DbModel edm)
|
{
|
return edm.Base_Station.Where(x => x.SrmStationCode == srmPlaceNo).FirstOrDefault();
|
}
|
|
/// <summary>
|
/// 根据RGV站点号查找库位对象
|
/// </summary>
|
/// <param name="rgvStationNo">RGV站点号</param>
|
/// <param name="edm"></param>
|
/// <returns></returns>
|
public static Base_Station GetPlaceByRgvStationNo(string rgvStationNo, DbModel edm)
|
{
|
return edm.Base_Station.Where(x => x.RgvStationCode == rgvStationNo).FirstOrDefault();
|
}
|
|
|
///// <summary>
|
///// 根据ItemId查找库位对象
|
///// </summary>
|
///// <returns></returns>
|
//public static Base_Station GetPlaceByItemId(string itemId, DbModel edm)
|
//{
|
// var cvi = Salver_Material_Handler.GetIVCByItemId(edm, itemId);
|
// var cvp = Salver_Station_Handler.GetCVPByContainerId(edm, cvi.SalverId);
|
// return GetPlaceByPlaceId(cvp.StationId, edm);
|
//}
|
|
|
|
///// <summary>
|
///// 按照排锁定库位
|
///// </summary>
|
///// <param name="edm"></param>
|
///// <param name="selectRow"></param>
|
///// <param name="remark"></param>
|
//public static void LockPlaceByRow(DbModel edm, int selectRow, string remark)
|
//{
|
// var places = edm.Base_Station.Where(x => x.Row == selectRow).OrderBy(x => x.Row).ToList();
|
// var s_places = FindPlaceByCommonFilter(places);
|
// foreach (var item in s_places)
|
// {
|
// item.Islock = 1;
|
// item.Void = 1;
|
// item.LastModifier = MachineHelper.GetHostName();
|
// item.ModifyTime = DateTime.Now;
|
// item.Remark = remark;
|
// }
|
|
//}
|
|
/// <summary>
|
/// 通过设备类型获取库位编号
|
/// </summary>
|
/// <param name="station"></param>
|
/// <param name="deviceType"></param>
|
public static String GetStationCodeByDeviceType(Base_Station station, EDeviceType deviceType)
|
{
|
var placeNo = "";
|
switch (deviceType)
|
{
|
case EDeviceType.RGV:
|
placeNo = station.RgvStationCode;
|
break;
|
case EDeviceType.堆垛机:
|
placeNo = station.SrmStationCode;
|
break;
|
}
|
return placeNo;
|
}
|
|
|
#region 通过设备状态来过滤库位
|
|
/// <summary>
|
/// 通过设备状态来过滤库位
|
/// </summary>
|
/// <param name="findPlaces"></param>
|
/// <returns></returns>
|
private static List<V_EmptySrmStation> FindPlacesFilterByBreakdown(List<V_EmptySrmStation> findPlaces)
|
{
|
if (findPlaces == null && findPlaces.Count == 0)
|
{
|
return findPlaces;
|
}
|
//判读堆垛机故障
|
FunRetEntity srm1 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.一号堆垛机);
|
if (srm1.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "1").ToList();
|
}
|
FunRetEntity srm2 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.二号堆垛机);
|
if (srm2.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "2").ToList();
|
}
|
FunRetEntity srm3 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.三号堆垛机);
|
if (srm3.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "3").ToList();
|
}
|
FunRetEntity srm4 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.四号堆垛机);
|
if (srm4.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "4").ToList();
|
}
|
return findPlaces;
|
}
|
|
/// <summary>
|
/// 通过设备状态来过滤库位
|
/// </summary>
|
/// <param name="findPlaces"></param>
|
/// <returns></returns>
|
public static List<V_Store> FindPlacesFilterByBreakdown(List<V_Store> findPlaces)
|
{
|
if (findPlaces == null && findPlaces.Count == 0)
|
{
|
return findPlaces;
|
}
|
//判读堆垛机故障
|
FunRetEntity srm1 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.一号堆垛机);
|
if (srm1.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "1").ToList();
|
}
|
FunRetEntity srm2 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.二号堆垛机);
|
if (srm2.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "2").ToList();
|
}
|
FunRetEntity srm3 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.三号堆垛机);
|
if (srm3.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "3").ToList();
|
}
|
FunRetEntity srm4 = Wms_EquipmentSituationHandler.IsEquipmentBreakdown((int)EDevice.四号堆垛机);
|
if (srm4.result)
|
{//故障
|
findPlaces = findPlaces.Where(x => x.Area != "4").ToList();
|
}
|
return findPlaces;
|
}
|
|
#endregion
|
|
|
/// <summary>
|
/// 获取站点，新建转运任务时
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="rgvLocation"></param>
|
/// <param name="errMsg"></param>
|
/// <returns></returns>
|
public static FunRetEntity GetTargtStationForAddTransferTask(DbModel edm, EDevice rgvLocation, ref string errMsg, ref Base_Station targtPlace)
|
{
|
//目标点
|
targtPlace = StationHandler.GetRgvPlace(edm, ((int)rgvLocation).ToString());
|
if (targtPlace == null)
|
{
|
return FunRetEntity.Fail("没有找到站点");
|
}
|
//判断起点是否有任务被占用
|
if (StationHandler.IsAllowUsePlace(edm, targtPlace, ref errMsg) == false)
|
{
|
return FunRetEntity.Fail(errMsg);
|
}
|
return FunRetEntity.Success("成功");
|
}
|
|
}
|
}
|
