void sendList(string json)
{
modelAssoc = GameObject.Find("ModelAssociation");
ModelAssociation modelScr = modelAssoc.GetComponent <ModelAssociation>();
Dictionary <string, object> resp = DeserializeJson <Dictionary <string, object> >(json);
string cid = resp["id"].ToString();
foreach (Dictionary <string, string> l in assocListToModify)
{
print(l);
if (l["value"].Equals(""))
{
l["value"] = "0";
}
if (l["assoc_id"] == null)
{
modelScr.addCollections(l["value"], l["project_id"], projectName, cid, l["ressource_id"],
l["posX"],
l["posY"]);
}
else
{
modelScr.updateField(l["assoc_id"], l["value"], l["project_id"], projectName, cid, l["ressource_id"],
l["posX"],
l["posY"]);
}
}
CallDispatcher(json);
}
public ResultAssociation Schedule(ModelAssociation currentModelAssoscation, MachineEnvironment currentMachineEnvironment, List <Constraint> currentConstraints,
OptimisationObjective currentOptimisationObjective, DateTime startingWholeProcessingDate)
{
// Sort all operations on nearest Due Date first
List <Operation> AllOperations = SchedulingUtlis.GetAllOperations(currentModelAssoscation.AllBatches);
AllOperations.Sort((operation1, operation2) => operation1.CurrentBatch.DueDate.CompareTo(operation2.CurrentBatch.DueDate));
List <OperationMachineAssignment> CurrentOperationMachineAssociations = new List <OperationMachineAssignment>();
foreach (Operation CurrentOperation in AllOperations)
{
// Find next available machine for the processing of current operation
List <Machine> CapableMachines = CurrentOperation.CapableMachinesWithProcessingTime.Keys.ToList();
CapableMachines.Sort((machine1, machine2) => machine1.NextAvailableStartProcessingDate.CompareTo(machine2.NextAvailableStartProcessingDate));
Machine ChosenMachine = CapableMachines.First();
DateTime StartProcessingDate = ChosenMachine.NextAvailableStartProcessingDate;
// if it isn't the first process on the machine in the scheduling => we have to include setup time
if (!startingWholeProcessingDate.Equals(StartProcessingDate))
{
SetupForBatch CurrentSetupForBatch = CurrentOperation.SetupTimes
.Find(setup => setup.CurrentMachine.Equals(ChosenMachine) && setup.PreviousOperation.Index.Equals(ChosenMachine.CurrentlyProcessedOperation.Index));
StartProcessingDate = StartProcessingDate.AddSeconds(CurrentSetupForBatch.SetupTime);
}
// Calculate processing time
int NeededProcessingTime = CurrentOperation.CapableMachinesWithProcessingTime[ChosenMachine] * CurrentOperation.CurrentBatch.NumberOfJobs;
// Include maintenance
DateTime FinishProcessingDate = StartProcessingDate;
while (NeededProcessingTime > ChosenMachine.TimeLeftTillMaintenance)
{
// Operation before maintenance
FinishProcessingDate = FinishProcessingDate.AddSeconds(ChosenMachine.TimeLeftTillMaintenance);
CurrentOperationMachineAssociations.Add
(new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate));
NeededProcessingTime -= ChosenMachine.TimeLeftTillMaintenance;
StartProcessingDate = FinishProcessingDate;
// Maintenance
FinishProcessingDate = StartProcessingDate.AddSeconds(ChosenMachine.TimeOfMaintenance);
CurrentOperationMachineAssociations.Add
(new OperationMachineAssignment(OperationFactory.generateMaintenance(), ChosenMachine, StartProcessingDate, FinishProcessingDate));
ChosenMachine.TimeLeftTillMaintenance = RandomGenerator.MachineTimeLeftTillMaintenanceForSmallScaleProduction();
StartProcessingDate = FinishProcessingDate;
}
// Operation
FinishProcessingDate = FinishProcessingDate.AddSeconds(NeededProcessingTime);
CurrentOperationMachineAssociations.Add(new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate));
ChosenMachine.TimeLeftTillMaintenance -= NeededProcessingTime;
// Update dates for the machine
ChosenMachine.NextAvailableStartProcessingDate = FinishProcessingDate;
ChosenMachine.CurrentlyProcessedOperation = CurrentOperation;
}
return(new ResultAssociation(CurrentOperationMachineAssociations, null, null));
}
private void LoadModelAssociations(XElement classModel)
{
ModelAssociations.Clear();
IEnumerable <XElement> modelAssociations = classModel.Elements("Association");
foreach (XElement modelAssociation in modelAssociations)
{
var ma = new ModelAssociation();
var name = modelAssociation.Attribute("name");
string modelAssociationName = name != null ? name.Value : "";
ma.Name = modelAssociationName;
var desc = modelAssociation.Attribute("description");
string description = desc != null ? desc.Value : "";
ma.Description = description;
XElement endA = modelAssociation.Element("EndA");
if (endA != null)
{
XAttribute xEndATarget = endA.Attribute("target");
string endATarget = xEndATarget != null ? xEndATarget.Value : "";
XAttribute xEndAMultiplicity = endA.Attribute("multiplicity");
string endAMultiplicity = xEndAMultiplicity != null ? xEndAMultiplicity.Value : "";
XAttribute xEndARole = endA.Attribute("role");
string endARole = xEndARole != null ? xEndARole.Value : "";
ma.Members.Add(new AssociationMember {
ClassName = endATarget, Multiplicity = endAMultiplicity, Role = endARole
});
}
XElement endB = modelAssociation.Element("EndB");
if (endB != null)
{
XAttribute xEndBTarget = endB.Attribute("target");
string endBTarget = xEndBTarget != null ? xEndBTarget.Value : "";
XAttribute xEndBMultiplicity = endB.Attribute("multiplicity");
string endBMultiplicity = xEndBMultiplicity != null ? xEndBMultiplicity.Value : "";
XAttribute xEndBRole = endB.Attribute("role");
string endBRole = xEndBRole != null ? xEndBRole.Value : "";
ma.Members.Add(new AssociationMember {
ClassName = endBTarget, Multiplicity = endBMultiplicity, Role = endBRole
});
}
ModelAssociations.Add(ma);
}
}
public AddDataBlockViewModel(ModelAssociation targetAssociation, ModelClass targetClass)
{
TargetAssociation = targetAssociation;
TargetClass = targetClass;
string multiplicity = targetAssociation.Members.FirstOrDefault(m => m.ClassName.Equals(targetClass.Name)).Multiplicity;
SheetBlock = new Model.SheetBlock()
{
Type = multiplicity.Equals("1") ? "single" : "input"
};
TypeString = SheetBlock.Type;
AssociationString = string.Format("{0} {1} {2} {3}", TargetAssociation.Members[0].ClassName,
TargetAssociation.Members[0].Multiplicity, TargetAssociation.Members[1].Multiplicity, TargetAssociation.Members[1].ClassName);
}
// Start is called before the first frame update
void Start()
{
canvas = GameObject.Find("Canvas").GetComponent <Canvas>();
modelScr = GameObject.Find("ModelAssociation").GetComponent <ModelAssociation>();
objectList = new List <GameObject>();
card = GameObject.Find("CardVisualeEditable");
trash = GameObject.Find("EditTrash");
objectList.Add(card);
objectList.Add(trash);
dragged = false;
name = "";
cardSize = card.GetComponent <RectTransform>().sizeDelta *canvas.scaleFactor;
ressSize = gameObject.GetComponent <RectTransform>().sizeDelta *canvas.scaleFactor;
validateBtn = GameObject.Find("Validate");
}
/// <summary>
/// Translate model Association into view Association (creates a view Association if not yet created)
/// </summary>
/// <param name="viewModel"></param>
/// <param name="association"></param>
/// <returns></returns>
private static ViewModelAssociation TranslateAssociation(
EntityDesignerViewModel viewModel,
ModelAssociation association)
{
var ends = association.AssociationEnds();
var end1 = ends[0];
var end2 = ends[1];
if (end1.Type.Status == BindingStatus.Known &&
end2.Type.Status == BindingStatus.Known)
{
var viewEnd1 =
ModelToDesignerModelXRef.GetExisting(viewModel.EditingContext, end1.Type.Target, viewModel.Partition) as
ViewModelEntityType;
var viewEnd2 =
ModelToDesignerModelXRef.GetExisting(viewModel.EditingContext, end2.Type.Target, viewModel.Partition) as
ViewModelEntityType;
// Only create association if both entityType exist.
if (viewEnd1 != null &&
viewEnd2 != null)
{
var viewAssoc =
ModelToDesignerModelXRef.GetNewOrExisting(viewModel.EditingContext, association, viewEnd1, viewEnd2) as
ViewModelAssociation;
viewAssoc.Name = association.LocalName.Value;
viewAssoc.SourceMultiplicity = end1.Multiplicity.Value;
viewAssoc.TargetMultiplicity = end2.Multiplicity.Value;
// There could be a situation where association is created after navigation property (for example: the user add an entity-type and then add related types ).
// In that case we need to make sure that view's association and navigation property are linked.
Debug.Assert(
end1.Type.Target != null, "Association End: " + end1.DisplayName + " does not reference a valid entity-type.");
if (end1.Type.Target != null)
{
var modelSourceNavigationProperty =
ModelHelper.FindNavigationPropertyForAssociationEnd(end1.Type.Target as ConceptualEntityType, end1);
if (modelSourceNavigationProperty != null)
{
var viewSourceNavigationProperty =
ModelToDesignerModelXRef.GetExisting(
viewModel.EditingContext, modelSourceNavigationProperty, viewModel.Partition) as
ViewModelNavigationProperty;
if (viewSourceNavigationProperty != null)
{
viewAssoc.SourceNavigationProperty = viewSourceNavigationProperty;
viewSourceNavigationProperty.Association = viewAssoc;
}
}
}
Debug.Assert(
end2.Type.Target != null, "Association End: " + end2.DisplayName + " does not reference a valid entity-type.");
if (end2.Type.Target != null)
{
var modelTargetNavigatioNProperty =
ModelHelper.FindNavigationPropertyForAssociationEnd(end2.Type.Target as ConceptualEntityType, end2);
if (modelTargetNavigatioNProperty != null)
{
var viewTargetNavigationProperty =
ModelToDesignerModelXRef.GetExisting(
viewModel.EditingContext, modelTargetNavigatioNProperty, viewModel.Partition) as
ViewModelNavigationProperty;
if (viewTargetNavigationProperty != null)
{
viewAssoc.TargetNavigationProperty = viewTargetNavigationProperty;
viewTargetNavigationProperty.Association = viewAssoc;
}
}
}
return(viewAssoc);
}
}
return(null);
}
/// <summary>
/// Translate model Association into view Association (creates a view Association if not yet created)
/// </summary>
/// <param name="viewModel"></param>
/// <param name="association"></param>
/// <returns></returns>
private static ViewModelAssociation TranslateAssociation(
EntityDesignerViewModel viewModel,
ModelAssociation association)
{
var ends = association.AssociationEnds();
var end1 = ends[0];
var end2 = ends[1];
if (end1.Type.Status == BindingStatus.Known
&& end2.Type.Status == BindingStatus.Known)
{
var viewEnd1 =
ModelToDesignerModelXRef.GetExisting(viewModel.EditingContext, end1.Type.Target, viewModel.Partition) as
ViewModelEntityType;
var viewEnd2 =
ModelToDesignerModelXRef.GetExisting(viewModel.EditingContext, end2.Type.Target, viewModel.Partition) as
ViewModelEntityType;
// Only create association if both entityType exist.
if (viewEnd1 != null
&& viewEnd2 != null)
{
var viewAssoc =
ModelToDesignerModelXRef.GetNewOrExisting(viewModel.EditingContext, association, viewEnd1, viewEnd2) as
ViewModelAssociation;
viewAssoc.Name = association.LocalName.Value;
viewAssoc.SourceMultiplicity = end1.Multiplicity.Value;
viewAssoc.TargetMultiplicity = end2.Multiplicity.Value;
// There could be a situation where association is created after navigation property (for example: the user add an entity-type and then add related types ).
// In that case we need to make sure that view's association and navigation property are linked.
Debug.Assert(
end1.Type.Target != null, "Association End: " + end1.DisplayName + " does not reference a valid entity-type.");
if (end1.Type.Target != null)
{
var modelSourceNavigationProperty =
ModelHelper.FindNavigationPropertyForAssociationEnd(end1.Type.Target as ConceptualEntityType, end1);
if (modelSourceNavigationProperty != null)
{
var viewSourceNavigationProperty =
ModelToDesignerModelXRef.GetExisting(
viewModel.EditingContext, modelSourceNavigationProperty, viewModel.Partition) as
ViewModelNavigationProperty;
if (viewSourceNavigationProperty != null)
{
viewAssoc.SourceNavigationProperty = viewSourceNavigationProperty;
viewSourceNavigationProperty.Association = viewAssoc;
}
}
}
Debug.Assert(
end2.Type.Target != null, "Association End: " + end2.DisplayName + " does not reference a valid entity-type.");
if (end2.Type.Target != null)
{
var modelTargetNavigatioNProperty =
ModelHelper.FindNavigationPropertyForAssociationEnd(end2.Type.Target as ConceptualEntityType, end2);
if (modelTargetNavigatioNProperty != null)
{
var viewTargetNavigationProperty =
ModelToDesignerModelXRef.GetExisting(
viewModel.EditingContext, modelTargetNavigatioNProperty, viewModel.Partition) as
ViewModelNavigationProperty;
if (viewTargetNavigationProperty != null)
{
viewAssoc.TargetNavigationProperty = viewTargetNavigationProperty;
viewTargetNavigationProperty.Association = viewAssoc;
}
}
}
return viewAssoc;
}
}
return null;
}
public ResultAssociation Schedule(ModelAssociation CurrentModel, MachineEnvironment CurrentMachineEnvironment, List <Constraint> CurrentConstraints, OptimisationObjective CurrentOptimisationObjective, DateTime startingWholeProcessingDate)
{
throw new NotImplementedException();
}
public ResultAssociation Schedule(ModelAssociation currentModelAssoscation, MachineEnvironment currentMachineEnvironment, List <Constraint> currentConstraints,
OptimisationObjective currentOptimisationObjective, DateTime startingWholeProcessingDate)
{
// Sort all batches on nearest Due Date first
List <Batch> AllBatches = currentModelAssoscation.AllBatches;
AllBatches.Sort((batch1, batch2) => batch1.DueDate.CompareTo(batch2.DueDate));
List <OperationMachineAssignment> CurrentOperationMachineAssociations = new List <OperationMachineAssignment>();
foreach (Batch CurrentBatch in AllBatches)
{
List <Operation> CurrentOperations = CurrentBatch.JobInBatch.ListOfOperations;
foreach (Operation CurrentOperation in CurrentOperations)
{
// First operation in Job will start immidiatelly
if (CurrentOperation.ReleaseDate.Equals(DateTime.MaxValue))
{
CurrentOperation.ReleaseDate = startingWholeProcessingDate;
}
// Find next available machine for the processing of current operation
List <Machine> CapableMachines = CurrentOperation.CapableMachinesWithProcessingTime.Keys.ToList();
CapableMachines.Sort((machine1, machine2) => machine1.NextAvailableStartProcessingDate.CompareTo(machine2.NextAvailableStartProcessingDate));
Machine ChosenMachine = CapableMachines.First();
DateTime StartProcessingDate = CurrentOperation.ReleaseDate;
// if it isn't the first process on the machine in the scheduling => we have to include setup time
SetupForBatch CurrentSetupForBatch = CurrentOperation.SetupTimes
.Find(setup => setup.CurrentMachine.Equals(ChosenMachine) &&
ChosenMachine.CurrentlyProcessedOperation != null &&
setup.PreviousOperation.Index.Equals(ChosenMachine.CurrentlyProcessedOperation.Index));
// If the machine wasn't able to be setup after previous job -> add setup time
if (CurrentSetupForBatch != null && StartProcessingDate.CompareTo(ChosenMachine.NextAvailableStartProcessingDate.AddSeconds(CurrentSetupForBatch.SetupTime)) < 0)
{
StartProcessingDate = ChosenMachine.NextAvailableStartProcessingDate.AddSeconds(CurrentSetupForBatch.SetupTime);
}
else
{
Console.WriteLine("Now " + ChosenMachine.Name + StartProcessingDate);
}
// Calculate processing time
int NeededProcessingTime = CurrentOperation.CapableMachinesWithProcessingTime[ChosenMachine] * CurrentOperation.CurrentBatch.NumberOfJobs;
// Include maintenance
DateTime FinishProcessingDate = StartProcessingDate;
while (NeededProcessingTime > ChosenMachine.TimeLeftTillMaintenance)
{
// Operation before maintenance
FinishProcessingDate = FinishProcessingDate.AddSeconds(ChosenMachine.TimeLeftTillMaintenance);
CurrentOperationMachineAssociations.Add
(new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate));
NeededProcessingTime -= ChosenMachine.TimeLeftTillMaintenance;
StartProcessingDate = FinishProcessingDate;
// Maintenance
FinishProcessingDate = StartProcessingDate.AddSeconds(ChosenMachine.TimeOfMaintenance);
CurrentOperationMachineAssociations.Add
(new OperationMachineAssignment(OperationFactory.generateMaintenance(), ChosenMachine, StartProcessingDate, FinishProcessingDate));
ChosenMachine.ResetTimeLeftTillMaintenanceWithAgingEffect();
StartProcessingDate = FinishProcessingDate;
}
// Operation
FinishProcessingDate = FinishProcessingDate.AddSeconds(NeededProcessingTime);
CurrentOperationMachineAssociations.Add(new OperationMachineAssignment(CurrentOperation, ChosenMachine, StartProcessingDate, FinishProcessingDate));
ChosenMachine.TimeLeftTillMaintenance -= NeededProcessingTime;
// Update dates for the machine
ChosenMachine.NextAvailableStartProcessingDate = FinishProcessingDate;
ChosenMachine.CurrentlyProcessedOperation = CurrentOperation;
// Next operation can start after previous one in the same job
if (CurrentOperation.CurrentJob.GetNextOperation(CurrentOperation) != null)
{
CurrentOperation.CurrentJob.GetNextOperation(CurrentOperation).ReleaseDate = FinishProcessingDate;
}
}
}
return(new ResultAssociation(CurrentOperationMachineAssociations, null, null));
}
