public object GetKanBan([FromQuery] int wId, int page)
{
var result = new SmartTaskOrderNeedWithOrderResult();
var workshop = SmartWorkshopHelper.Instance.Get <SmartWorkshop>(wId);
if (workshop == null)
{
return(result);
}
page = page < 0 ? 0 : page;
var limit = workshop.Length < 0 ? 20 : workshop.Length;
var allData = SmartTaskOrderKanBanHelper.GetDetail(wId);
var data = allData.Skip(page * limit).Take(limit);
var orders = data.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
});
result.Orders.AddRange(orders.OrderBy(z => z.Order));
result.datas.AddRange(data);
result.Count = allData.Count();
return(result);
}
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);
}
