private bool IsLastPieceOfPallet(WorkOrderOperation workOrderOperation, decimal processQuantity)
{
decimal producedQuantity = workOrderOperation.ProducedQuantity + 1;
if (producedQuantity % processQuantity == 0)
{
return(true);
}
else if (IsLastSerial(workOrderOperation))
{
return(true);
}
return(false);
}
private CompleteWOOperationSerialized.Response CompletePreviousOperations(WorkOrderOperation workOrderOperation, string serialNumber)
{
var predecessorsIds = workOrderOperation.Predecessors.Select(p => p.From_Id).Distinct().ToList();
foreach (var predecessorId in predecessorsIds)
{
var predecesor = Platform.ProjectionQuery <WorkOrderOperation>().Include(wo => wo.ToBeUsedMachines).First(wo => wo.Id == predecessorId);
int equipId = predecesor.ToBeUsedMachines.First().Machine.GetValueOrDefault();
string equipNid = Platform.ProjectionQuery <Equipment>().Where(e => e.Id == equipId).Select(e => e.NId).FirstOrDefault();
var mateialItem = Platform.ProjectionQuery <ActualProducedMaterial>().Include(pmi => pmi.MaterialItem).Where(pmi => pmi.WorkOrderOperation_Id == predecesor.Id).Where(pmi => pmi.MaterialItem.SerialNumberCode == serialNumber && pmi.PartialWorkedQuantity == 1).Select(pmi => pmi.MaterialItem).FirstOrDefault();
if (mateialItem == null)
{
continue;
}
var materialItemNId = mateialItem.NId;
var matDefId = mateialItem.MaterialDefinition;
var matDefNId = Platform.ProjectionQuery <MaterialDefinition>().Where(m => m.Id == matDefId).Select(m => m.NId).FirstOrDefault();
var completeInput = new CompleteWOOperationSerialized
{
CompleteSerializedWoOpParameter = new CompleteSerializedParameterType
{
Id = predecesor.Id,
NId = predecesor.NId,
EquipmentNId = equipNid,
ActualProducedMaterials = new List <MaterialItemParameterType>
{
new MaterialItemParameterType
{
EquipmentNId = equipNid,
MaterialDefinitionNId = matDefNId,
NId = materialItemNId,
SerialNumber = serialNumber
}
}
}
};
var completeResponse = Platform.CallCommand <CompleteWOOperationSerialized, CompleteWOOperationSerialized.Response>(completeInput);
if (!completeResponse.Succeeded)
{
return(completeResponse);
}
}
return(new CompleteWOOperationSerialized.Response());
}
private ImportERPOrder.Response ImportERPOrderHandler(ImportERPOrder command)
{
ImportERPOrder.Response response = new ImportERPOrder.Response()
{
WorkOrderIds = new List <int>()
};
var matDefId = Platform.ProjectionQuery <MaterialDefinition>().Where(m => m.NId == command.ERPOrderInfo.FinalMaterialCode && m.Revision == command.ERPOrderInfo.FinalMaterialRevision).Select(m => m.Id).FirstOrDefault();
if (matDefId == 0)
{
var matDefs = Platform.ProjectionQuery <MaterialDefinition>().Where(m => m.NId == command.ERPOrderInfo.FinalMaterialCode).ToList();
if (!matDefs.Any())
{
response.SetError(-1000, "No Material Definition Found with NId: " + command.ERPOrderInfo.FinalMaterialCode);
CleanUp(response);
return(response);
}
matDefId = matDefs.Where(m => m.Revision == matDefs.Max(md => md.Revision)).Select(m => m.Id).FirstOrDefault();
}
var lastOrderSequence = command.ERPOrderInfo.Orders.Where(o => o.NextOrder == 0).Select(o => o.Sequence).First();
var processes = Platform.ProjectionQuery <Process>().Where(p => p.FinalMaterialId == matDefId).Where(p => p.Sequence == lastOrderSequence).ToList();
if (!processes.Any())
{
response.SetError(-1000, "No Process Found with FinalMaterial: " + command.ERPOrderInfo.FinalMaterialCode);
CleanUp(response);
return(response);
}
var process = processes.First(p => p.Revision == processes.Max(pr => pr.Revision));
//prendere as planned e poi il process per sequence
foreach (var phase in command.ERPOrderInfo.Orders)
{
var createInput = new CreateWorkOrderFromProcess
{
AsPlannedId = process.AsPlannedBOP_Id,
ERPOrder = command.ERPOrderInfo.ERPId,
EstimatedStartTime = command.ERPOrderInfo.EstimatedStartTime,
EstimatedEndTime = command.ERPOrderInfo.EstimatedEndTime,
Priority = command.ERPOrderInfo.Priority,
Quantity = command.ERPOrderInfo.Quantity,
ProcessId = process.Id,
Plant = process.Plant,
FinalMaterialId = matDefId,
ProductionTypeNId = "Serialized",
NId = $"{command.ERPOrderInfo.ERPId}_{phase.Name}_{phase.Sequence}"
};
//rimuovere tutte le to be used non sotto la phase.WorkArea specificata
//creare tutti i phase.ToBeConsumedMaterials;
var createResponse = Platform.CallCommand <CreateWorkOrderFromProcess, CreateWorkOrderFromProcess.Response>(createInput);
if (!createResponse.Succeeded)
{
response.SetError(createResponse.Error.ErrorCode, createResponse.Error.ErrorMessage);
CleanUp(response);
return(response);
}
response.WorkOrderIds.Add(createResponse.Id);
var workOrder = Platform.ProjectionQuery <WorkOrder>().Include("WorkOrderOperations.ToBeUsedMachines").First(w => w.Id == createResponse.Id);
var createWOExtResponse = Platform.CallCommand <CreateWorkOrderExt, CreateWorkOrderExt.Response>(new CreateWorkOrderExt()
{
WorkOrderId = createResponse.Id,
CycleTime = command.ERPOrderInfo.CycleTime,
SetupTime = command.ERPOrderInfo.SetupTime,
Operators = command.ERPOrderInfo.Operators,
NextOrder = phase.NextOrder,
Sequence = phase.Sequence,
Warehouse = command.ERPOrderInfo.Warehouse
});
// Manca Sequence, EstimatedDuration, Operators, SetupTime
//phase.NextOrder da gestire
//phase.Sequence
var machineIds = workOrder.WorkOrderOperations.SelectMany(wo => wo.ToBeUsedMachines).Where(m => m.Machine.HasValue).Select(m => m.Machine.Value).Distinct().ToList();
var workAreaMachines = Platform.ProjectionQuery <Equipment>().Where(e => machineIds.Contains(e.Id)).Where(e => e.Parent == phase.WorkArea).Select(e => e.Id);
if (!workAreaMachines.Any())
{
response.SetError(-1000, $"No ToBeUsedMachines found in {workOrder.NId} for WorkArea {phase.WorkArea}");
CleanUp(response);
return(response);
}
int minSequnece = int.MaxValue;
WorkOrderOperation firstOperation = null;
foreach (var wo in workOrder.WorkOrderOperations)
{
if (wo.Sequence < minSequnece)
{
minSequnece = wo.Sequence;
firstOperation = wo;
}
//Delete ToBeUsedMachines outside the secified WorkArea
foreach (var machine in wo.ToBeUsedMachines.Where(tum => tum.Machine.HasValue && !workAreaMachines.Contains(tum.Machine.Value)))
{
var deleteInput = new DeleteToBeUsedMachine
{
ToBeUsedMachineId = machine.Id
};
var deleteMachineResponse = Platform.CallCommand <DeleteToBeUsedMachine, DeleteToBeUsedMachine.Response>(deleteInput);
if (!deleteMachineResponse.Succeeded)
{
response.SetError(deleteMachineResponse.Error.ErrorCode, deleteMachineResponse.Error.ErrorMessage);
CleanUp(response);
return(response);
}
}
}
if (firstOperation == null)
{
response.SetError(-1000, $"Error Creating {command.ERPOrderInfo.ERPId} - {phase.Name}. Process {process.Name} does not contain Operations");
CleanUp(response);
return(response);
}
//Crate ToBeConsumedMaterials
if (phase.ToBeConsumedMaterials.Any())
{
var createToBeConsumedMaterialsInput = new CreateToBeConsumedMaterials(new List <ToBeConsumedMaterialParameter>());
var defNids = phase.ToBeConsumedMaterials.Select(m => m.MaterialCode);
var matDefs = Platform.ProjectionQuery <MaterialDefinition>().Where(md => defNids.Contains(md.NId)).ToList();
foreach (var mat in phase.ToBeConsumedMaterials)
{
var consMatDefId = matDefs.Where(md => md.NId == mat.MaterialCode && md.Revision == mat.MaterialRevision).Select(m => m.Id).FirstOrDefault();
if (consMatDefId == 0)
{
response.SetError(-1000, $"Error Creating {command.ERPOrderInfo.ERPId} - {phase.Name}. No Material Definition has been found with code {mat.MaterialCode} and revision {mat.MaterialRevision}");
CleanUp(response);
return(response);
}
createToBeConsumedMaterialsInput.WorkOrderOperationId = firstOperation.Id;
createToBeConsumedMaterialsInput.ToBeConsumedMaterials.Add(
new ToBeConsumedMaterialParameter
{
MaterialDefinitionId = consMatDefId,
Quantity = mat.Quantity,
Sequence = mat.Sequence,
LogicalPosition = mat.Sequence.ToString(),
MaterialSpecificationType = "Reference"
});
}
var createToBeConsumedMaterialsResponse = Platform.CallCommand <CreateToBeConsumedMaterials, CreateToBeConsumedMaterials.Response>(createToBeConsumedMaterialsInput);
if (!createToBeConsumedMaterialsResponse.Succeeded)
{
response.SetError(createToBeConsumedMaterialsResponse.Error.ErrorCode, createToBeConsumedMaterialsResponse.Error.ErrorMessage);
}
Dictionary <int, decimal> toBeConsumedQuantities = createToBeConsumedMaterialsInput.ToBeConsumedMaterials.ToDictionary(m => m.Sequence.Value, m => m.Quantity);
Dictionary <int, string> toBeConsumedIds = Platform.ProjectionQuery <ToBeConsumedMaterial>().Where(m => m.WorkOrderOperation_Id == firstOperation.Id).ToDictionary(m => m.Id, m => m.LogicalPosition);
var toBeConsMatInput = new CreateToBeConsumedMaterialExt
{
WorkOrderOperationId = firstOperation.Id,
ToBeConsumedMaterials = toBeConsumedIds.Select(m => new ToBeConsumedMaterialExtParameter {
ToBeConsumedMaterialId = m.Key, Sequence = int.Parse(m.Value), ToBeConsumedQuantity = toBeConsumedQuantities[int.Parse(m.Value)]
}).ToList()
};
var createTBCMExtResponse = Platform.CallCommand <CreateToBeConsumedMaterialExt, CreateToBeConsumedMaterialExt.Response>(toBeConsMatInput);
if (!createTBCMExtResponse.Succeeded)
{
response.SetError(createTBCMExtResponse.Error.ErrorCode, createTBCMExtResponse.Error.ErrorMessage);
}
}
Platform.CallCommand <CreateWorkOrderNotification, CreateWorkOrderNotification.Response>(new CreateWorkOrderNotification
{
WorkOrderEstimatedStartTime = workOrder.EstimatedStartTime,
WorkOrderFinalMaterial = command.ERPOrderInfo.FinalMaterialCode,
WorkOrderId = workOrder.Id,
WorkOrderNId = workOrder.NId,
WorkOrderStatus = workOrder.Status
});
}
return(response);
}
private bool SerialIsCompletedOnAllPreviousOperations(WorkOrderOperation workOrderOpration, string serialNumber)
{
var predecessorIds = workOrderOpration.Predecessors.Select(wo => wo.From_Id).ToList();
return(!Platform.ProjectionQuery <ToBeProducedMaterial>().Include(tpm => tpm.MaterialItem).Where(tpm => predecessorIds.Contains(tpm.WorkOrderOperation_Id)).Any(tpm => tpm.MaterialItem.SerialNumberCode == serialNumber));
}
private bool IsLastSerialOfLastOperationOfERPOrder(WorkOrderOperation workOrderOperation, WorkOrderExt workOrderExt)
{
return(workOrderExt.NextOrder == 0 && IsLastSerial(workOrderOperation));
}
private bool IsLastSerial(WorkOrderOperation workOrderOperation)
{
return((workOrderOperation.ProducedQuantity + 1) == workOrderOperation.TargetQuantity);
}
private bool IsLastOperationOfOrder(WorkOrderOperation workOrderOperation)
{
return(!workOrderOperation.Successors.Any());
}
private bool IsFirstOperation(WorkOrderOperation workOrderOperation)
{
return(!workOrderOperation.Predecessors.Any());
}
