public object PostSmartScheduleConfirm([FromBody] SmartTaskOrderArrangeParam arrange)
{
var taskOrders = arrange.Confirms;
if (taskOrders == null || !taskOrders.Any())
{
return(Result.GenError <Result>(Error.ParamError));
}
if (taskOrders.Any(x => !x.Needs.Any()))
{
return(Result.GenError <Result>(Error.SmartScheduleNeedLost));
}
var userId = Request.GetIdentityInformation();
var markedDateTime = DateTime.Now;
var schedules = new List <SmartTaskOrderScheduleDetail>();
var costDays = HScheduleHelper.ArrangeSchedule(arrange.WorkshopId, ref taskOrders, ref schedules, out _, true, userId, markedDateTime);
OldWorkFlowHelper.Instance.OnTaskOrderArrangeChanged();
return(Result.GenError <Result>(Error.Success));
}
public object PostSmartScheduleCostDay([FromBody] SmartTaskOrderArrangeParam arrange)
{
var taskOrders = arrange.Confirms;
var wId = arrange.WorkshopId;
if (taskOrders == null || !taskOrders.Any())
{
return(Result.GenError <Result>(Error.ParamError));
}
if (taskOrders.Any(x => !x.Needs.Any()))
{
return(Result.GenError <Result>(Error.SmartScheduleNeedLost));
}
var today = DateTime.Today;
var schedules = new List <SmartTaskOrderScheduleDetail>();
var costDays = HScheduleHelper.ArrangeSchedule(wId, ref taskOrders, ref schedules, out var indexes);
var eStartTime = costDays.Any() ? costDays.Min(x => x.EstimatedStartTime) : today;
if (eStartTime == default(DateTime))
{
eStartTime = today;
}
var eEndTime = costDays.Any() ? costDays.Max(x => x.EstimatedEndTime) : today;
if (eEndTime == default(DateTime))
{
eEndTime = today;
}
var put = new List <object>();
var orders = new List <SmartTaskOrderNeedWithOrder>();
//设备型号数量
var deviceList = SmartDeviceHelper.Instance.GetAll <SmartDevice>();
//人员等级数量
var operatorList = SmartOperatorHelper.GetAllSmartOperators();
//按工序排
var processes = schedules.GroupBy(x => new { x.PId, x.Process, x.Order }).Select(y => y.Key);
var ts = costDays.SelectMany(costDay =>
{
var taskNeeds = taskOrders.First(x => x.Id == costDay.Id).Needs;
return(taskNeeds.Where(n => taskOrders.Any(task => task.Id == n.TaskOrderId)).Select(x =>
{
var task = taskOrders.First(t => t.Id == x.TaskOrderId);
var schedule = schedules.Where(sc =>
sc.TaskOrderId == x.TaskOrderId && sc.ProcessId == x.ProcessId && sc.PId == x.PId).ToList();
var totalDays = (eEndTime - eStartTime).TotalDays + 1;
if (schedule.Count < totalDays)
{
for (var i = 0; i < (eEndTime - eStartTime).TotalDays + 1; i++)
{
var t = eStartTime.AddDays(i);
if (schedule.All(p => p.ProcessTime != t))
{
schedule.Add(new SmartTaskOrderScheduleDetail()
{
ProcessTime = t
});
}
}
schedule = schedule.OrderBy(sc => sc.ProcessTime).ToList();
}
var scs = schedule.Select(y =>
{
var d = new SmartTaskOrderSchedulePutAndWarehouseInfoResult
{
ProcessTime = y.ProcessTime,
TaskOrderId = y.TaskOrderId,
TaskOrder = y.TaskOrder,
Target = y.Target,
DoneTarget = y.DoneTarget,
Put = y.Put,
HavePut = y.HavePut,
};
if (y.ProductType == 0)
{
d.Arranges = y.DeviceList.ToDictionary(de => de.Key,
de =>
{
var ope = deviceList.FirstOrDefault(dl => dl.Id == de.Key);
return new Tuple <string, int>(ope?.Code ?? "", de.Value);
});
}
else if (d.ProductType == 1)
{
d.Arranges = y.OperatorsList.ToDictionary(op => op.Key,
op =>
{
var ope = operatorList.FirstOrDefault(dl => dl.Id == op.Key);
return new Tuple <string, int>(ope?.Name ?? "", op.Value);
});
}
;
var s = new
{
Id = y.Id,
ProductType = y.ProductType,
ProcessTime = y.ProcessTime,
Put = y.Put,
HavePut = y.HavePut,
Target = y.Target,
DoneTarget = y.DoneTarget,
Data = d
};
return s;
});
var need = new
{
Id = x.Id,
TaskOrderId = x.TaskOrderId,
TaskOrder = task.TaskOrder,
ProductId = x.ProductId,
Product = task.Product,
DeliveryTime = task.DeliveryTime,
ArrangedTime = task.ArrangedTime,
PId = x.PId,
ProcessId = x.ProcessId,
Process = x.Process,
Order = x.Order,
Put = x.Put,
HavePut = x.HavePut,
Target = x.Target,
DoneTarget = x.DoneTarget,
Schedules = scs
};
return need;
}));
});
put.AddRange(ts);
orders.AddRange(costDays.SelectMany(x => x.CostDays).GroupBy(y => new { y.PId, y.Process, y.Order }).Select(z => new SmartTaskOrderNeedWithOrder
{
Id = z.Key.PId,
Process = z.Key.Process,
Order = z.Key.Order
}).OrderBy(z => z.Order));
var arrangeIndexes = new List <SmartTaskOrderScheduleIndex>();
foreach (var order in orders)
{
for (var i = 0; i < (eEndTime - eStartTime).TotalDays + 1; i++)
{
var t = eStartTime.AddDays(i);
if (!indexes.Any(p => p.ProcessTime == t && p.PId == order.Id))
{
arrangeIndexes.Add(new SmartTaskOrderScheduleIndex
{
ProcessTime = t,
PId = order.Id,
});
}
else
{
var ins = indexes.Where(p => p.ProcessTime == t && p.PId == order.Id);
arrangeIndexes.Add(new SmartTaskOrderScheduleIndex
{
ProcessTime = t,
PId = order.Id,
Index = !ins.Any() ? 0 : (ins.Sum(index => index.Index) / ins.Count()).ToRound(2)
});
}
}
}
var indexs = arrangeIndexes.OrderBy(x => orders.FirstOrDefault(y => y.Id == x.PId)?.Order ?? 0)
.ThenBy(z => z.ProcessTime);
return(new
{
errno = 0,
errmsg = "成功",
StartTime = eStartTime,
EndTime = eEndTime,
Orders = orders,
Cost = costDays,
//Schedule = schedules,
Schedule = schedules.Select(x =>
new
{
x.ProcessTime,
x.PId,
x.TaskOrder,
x.TaskOrderId,
x.ProcessId,
x.ProductId,
x.Target,
x.Put,
x.Have,
x.HavePut,
x.LeftPut,
x.Rate,
x.Stock,
x.LeftTarget,
x.DoneTarget,
x.Done
}),
Put = put,
Indexes = indexs
});
}
public object PostSmartSchedulePreview([FromBody] SmartTaskOrderArrangeParam arrange)
{
var taskOrders = arrange.Previews;
var wId = arrange.WorkshopId;
if (taskOrders == null)
{
return(Result.GenError <Result>(Error.ParamError));
}
var taskIds = taskOrders.GroupBy(x => x.Id).Select(y => y.Key);
if (taskIds.Count() != taskOrders.Count())
{
return(Result.GenError <Result>(Error.SmartTaskOrderDuplicate));
}
var result = new DataResult();
var allTasks = new List <SmartTaskOrderPreview>();
if (taskOrders.Any())
{
var tOrders = SmartTaskOrderHelper.Instance.GetByIds <SmartTaskOrderPreview>(taskIds);
if (taskIds.Count() != tOrders.Count())
{
result.errno = Error.SmartTaskOrderNotExist;
result.datas.AddRange(taskOrders.Where(x => tOrders.All(y => y.Id != x.Id)).Select(x => x.TaskOrder.IsNullOrEmpty() ? x.Id.ToString() : x.TaskOrder));
return(result);
}
//var arranged = tOrders.Where(x => x.Arranged);
//if (arranged.Any())
//{
// result.errno = Error.SmartTaskOrderArranged;
// result.datas.AddRange(arranged.Select(x => x.TaskOrder));
// return result;
//}
foreach (var task in tOrders)
{
var t = taskOrders.FirstOrDefault(x => x.Id == task.Id);
if (t == null)
{
result.errno = Error.SmartTaskOrderNotExist;
result.datas.Add(task.TaskOrder);
}
else
{
//页面选择顺序
task.Order = !t.Arranged && t.Order == 0 ? int.MaxValue : t.Order;
task.StartTime = t.StartTime;
task.EndTime = t.EndTime;
task.Needs = t.Needs;
}
}
allTasks.AddRange(tOrders);
}
if (result.errno != Error.Success)
{
return(result);
}
var otherTasks = SmartTaskOrderHelper.GetArrangedButNotDoneSmartTaskOrders(wId);
if (otherTasks.Any())
{
taskIds = otherTasks.Select(x => x.Id);
var taskNeeds = SmartTaskOrderNeedHelper.GetSmartTaskOrderNeedsByTaskOrderIds(wId, taskIds);
foreach (var otherTask in otherTasks)
{
var aTask = allTasks.FirstOrDefault(x => x.Id == otherTask.Id);
var needs = taskNeeds.Where(need => need.TaskOrderId == otherTask.Id);
if (aTask != null)
{
aTask.Arranged = true;
if (!aTask.Needs.Any())
{
aTask.Needs.AddRange(needs);
}
else
{
aTask.Needs = aTask.Needs.Select(x =>
{
var need = needs.FirstOrDefault(y => y.TaskOrderId == x.TaskOrderId && y.PId == x.PId);
if (need != null)
{
x.DoneTarget = need.DoneTarget;
x.HavePut = need.HavePut;
}
return(x);
}).ToList();
}
}
else
{
var t = ClassExtension.ParentCopyToChild <SmartTaskOrder, SmartTaskOrderPreview>(otherTask);
t.Arranged = true;
t.Needs.AddRange(needs);
allTasks.Add(t);
}
}
}
if (result.errno != Error.Success)
{
return(result);
}
var productIds = allTasks.GroupBy(x => x.ProductId).Select(y => y.Key);
if (!productIds.Any())
{
return(Result.GenError <Result>(Error.SmartProductNotExist));
}
var products = SmartProductHelper.Instance.GetByIds <SmartProduct>(productIds);
if (products.Count() != productIds.Count())
{
return(Result.GenError <Result>(Error.SmartProductNotExist));
}
var productCapacities = SmartProductCapacityHelper.GetSmartProductCapacities(productIds);
if (!productCapacities.Any())
{
return(Result.GenError <Result>(Error.SmartProductCapacityNotExist));
}
var capacityIds = products.GroupBy(x => x.CapacityId).Select(y => y.Key);
if (!capacityIds.Any())
{
return(Result.GenError <Result>(Error.SmartCapacityNotExist));
}
var capacityLists = SmartCapacityListHelper.GetSmartCapacityListsWithOrder(capacityIds);
foreach (var productId in productIds)
{
var tasks = allTasks.Where(x => x.ProductId == productId);
var product = products.FirstOrDefault(x => x.Id == productId);
var pCapacities = productCapacities.Where(x => x.ProductId == productId);
var cLists = capacityLists.Where(x => x.CapacityId == product.CapacityId);
if (cLists.Count() != pCapacities.Count())
{
result.errno = Error.SmartProductCapacityNotExist;
result.datas.AddRange(tasks.Select(x => x.TaskOrder));
}
}
if (result.errno != Error.Success)
{
return(result);
}
var data = allTasks.ToDictionary(x => x.Id, x =>
{
var t = ClassExtension.ParentCopyToChild <SmartTaskOrder, SmartTaskOrderPreview>(x);
t.Product = products.FirstOrDefault(y => y.Id == x.ProductId)?.Product ?? "";
return(t);
});
foreach (var task in allTasks)
{
var productId = task.ProductId;
var product = products.FirstOrDefault(x => x.Id == productId);
var pCapacities = productCapacities.Where(x => x.ProductId == productId);
var cLists = capacityLists.Where(x => x.CapacityId == product.CapacityId);
var target = task.Target;
foreach (var list in cLists.Reverse())
{
var need = task.Needs.FirstOrDefault(x => x.Order == list.Order && x.ProcessId == list.ProcessId);
var stock = need?.Stock ?? 0;
var doneTarget = need?.DoneTarget ?? 0;
var havePut = need?.HavePut ?? 0;
if (target < stock)
{
stock = target;
target = 0;
}
else
{
target -= stock;
}
var pCapacity = pCapacities.FirstOrDefault(x => x.ProcessId == list.ProcessId);
var rate = 0m;
var y = pCapacity;
if (y.DeviceList.Any())
{
rate = y.DeviceList.First().Rate;
}
else if (y.OperatorList.Any())
{
rate = y.OperatorList.First().Rate;
}
var put = rate != 0 ? (int)Math.Ceiling((target) * 100 / rate) : 0;
data[task.Id].Needs.Insert(0, new SmartTaskOrderNeedDetail
{
TaskOrderId = task.Id,
ProductId = productId,
ProcessId = list.ProcessId,
PId = list.PId,
Target = target,
DoneTarget = doneTarget,
Stock = stock,
Rate = rate,
Put = put,
HavePut = havePut,
Process = list.Process,
Order = list.Order
});
target = put;
}
}
var r = new SmartTaskOrderNeedWithOrderResult();
r.datas.AddRange(data.Values.OrderBy(x => x.Arranged).ThenBy(x => x.ModifyId));
var orders = data.Values.SelectMany(x => x.Needs).GroupBy(y => new { y.PId, y.Order, y.Process }).Select(z => new SmartTaskOrderNeedWithOrder
{
Id = z.Key.PId,
Process = z.Key.Process,
Order = z.Key.Order
});
r.Orders.AddRange(orders.OrderBy(z => z.Order));
return(r);
}