/*
* Take the raw input from the equipment text boxes and create a list of
* EquipmentRequirement objects. We also create a new Equipment object if needed
*
*/
private List <EquipmentRequirement> ParseEquipmentInput(string[] EquipmentName)
{
// create a list of Recipe Equipment objects
List <EquipmentRequirement> recipeEquipment = new List <EquipmentRequirement>();
// loop over the list of names
foreach (var eqstring in EquipmentName)
{
// check if already exists in the database
Equipment eqEntry = _context.Equipment.FirstOrDefault(e => e.Name == eqstring);
// if not then create a new Equipment Object
if (eqEntry == null)
{
eqEntry = new Equipment {
Name = eqstring
};
// not necessary to save this to DB. Entity Framework does the magic for us!
// will be automatically propogated when we save our recipe
}
EquipmentRequirement newEquipmentRequirement = new EquipmentRequirement {
Equipment = eqEntry, Recipe = Recipe
};
recipeEquipment.Add(newEquipmentRequirement);
}
return(recipeEquipment);
}
/*
*
*
*/
private void UpdateEquipment(string[] EquipmentName, Recipe recipeToUpdate)
{
// loop over our current list of equipment, and remove any that are not present in the new one
for (int i = recipeToUpdate.EquipmentRequirements.Count() - 1; i > -1; i--)
{
var recEquip = recipeToUpdate.EquipmentRequirements[i];
var equipmentName = recEquip.Equipment.Name;
if (!EquipmentName.Contains(equipmentName))
{
recipeToUpdate.EquipmentRequirements.RemoveAt(i);
}
}
// loop over the array of new Equipment Names
foreach (var eqName in EquipmentName)
{
// check if there is already an Equipment with that name
var eqEntry = _context.Equipment.FirstOrDefault(e => e.Name == eqName);
if (eqEntry == null)
{
eqEntry = new Equipment {
Name = eqName
};
}
// check if there is already an existing EquipmentRequirement entry tying the Equipment to this Recipe
var equipmentReqiurement = _context.EquipmentRequirements.FirstOrDefault(er => er.EquipmentId == eqEntry.Id && er.RecipeId == recipeToUpdate.Id);
// if the above exists, then we don't do anything, but if it does not we need to add it
if (equipmentReqiurement == null)
{
equipmentReqiurement = new EquipmentRequirement {
Equipment = eqEntry, Recipe = recipeToUpdate
};
recipeToUpdate.EquipmentRequirements.Add(equipmentReqiurement);
}
}
}
private ProcessProductionSchedule CreateObjectForTestWrite()
{
// Applying identifiers (such as "SEG1") to items to enable a
// verification that this test implementation has same items
// as those in other environments, particularly Java.
// SEG1a Creating a segment requirement
SegmentRequirement segReq1 = new SegmentRequirement
{
ProcessSegmentIdentifier = new IdentifierType("1"),
EarliestStartTime = ParseDateTimeInUtc("2019-05-09T13:36:02Z"),
LatestEndTime = ParseDateTimeInUtc("2019-05-09T13:37:02Z")
};
// EQ1 Add equipment requirement
EquipmentRequirement eqReq = new EquipmentRequirement()
{
Quantities = new List <QuantityValue>()
{
new QuantityValue(true)
}
};
segReq1.EquipmentRequirements.Add(eqReq);
// MAT1 Add material requirement
MaterialRequirement matReq = new MaterialRequirement()
{
MaterialDefinitionIdentifiers = new List <IdentifierType>()
{
new IdentifierType("slag")
},
MaterialLotIdentifiers = new List <IdentifierType>()
{
new IdentifierType("my-lot-1")
},
MaterialUse = new MaterialUse(MaterialUseType.Produced),
Quantities = new List <QuantityValue>()
{
new QuantityValue(12.2)
{
UnitOfMeasure = "t",
Key = new IdentifierType("my-mat-key")
}
},
AssemblyRequirements = new List <MaterialRequirement>()
{
new MaterialRequirement()
{
MaterialDefinitionIdentifiers = new List <IdentifierType>()
{
new IdentifierType("Ni")
}
}
}
};
segReq1.MaterialRequirements.Add(matReq);
// SEG1-1 Add nested segment requirement
segReq1.SegmentRequirements.Add(new SegmentRequirement()
{
EarliestStartTime = ParseDateTimeInUtc("2019-08-29T15:31:38Z")
});
// PROD1a Create one production request (for the unit "psc3")
ProductionRequest request1 = new ProductionRequest
{
// PROD1-ID Set identifier
Identifier = new IdentifierType("some-id"),
// PROD1-HS Set hierarchy scope
HierarchyScopeObj = new HierarchyScope(
new IdentifierType("psc3"),
EquipmentElementLevelType.ProcessCell
),
SegmentRequirements = new List <SegmentRequirement>()
{
// SEG1b Add segment requirement to production request
segReq1,
// SEG2 Add another (empty) segment requirement
new SegmentRequirement()
}
};
// SCH Create schedule object
ProductionSchedule schedule = new ProductionSchedule()
{
ProductionRequests = new List <ProductionRequest>()
{
// PROD1b Add the production request to schedule
request1,
// PROD2 Adding another (empty) production request
new ProductionRequest()
}
};
// PROPS Creating object to be serialised
ProcessProductionSchedule testObject1 = new ProcessProductionSchedule()
{
// PROPS-CR Set creation time
CreationDateTime = ParseDateTimeInUtc("2019-05-09T12:20:19Z")
};
// Add schedule to the test object
testObject1.ProductionSchedules.Add(schedule);
return(testObject1);
}
public void ProcProdSched_Write()
{
// Serialising, validating and deserialising
byte[] xmlData = CreateObjectForTestWrite().ToXmlBytes();
Validate(xmlData);
ProcessProductionSchedule testObject2 = new ProcessProductionSchedule(xmlData);
// Assert creation time
TestCommon.TestHelper.AssertDateTime(ParseDateTimeInUtc("2019-05-09T12:20:19Z"), testObject2.CreationDateTime);
ProductionSchedule schedule = testObject2.ProductionSchedules[0];
// Assert request count
Assert.AreEqual(2, schedule.ProductionRequests.Count);
// Asserting a production request
ProductionRequest request1 = schedule.ProductionRequests[0];
Assert.AreEqual(2, request1.SegmentRequirements.Count);
// Asserting identifier
Assert.AreEqual("some-id", request1.Identifier.Value);
// Asserting a hierarchy scope
Assert.AreEqual("psc3", request1.HierarchyScopeObj.EquipmentIdentifier.Value);
Assert.AreEqual(EquipmentElementLevelType.ProcessCell, request1.HierarchyScopeObj.EquipmentElementLevel);
// Asserting a segment requirement
SegmentRequirement segReq = request1.SegmentRequirements[0];
Assert.AreEqual("1", segReq.ProcessSegmentIdentifier.Value);
AssertDateTime(ParseDateTimeInUtc("2019-05-09T13:36:02Z"), segReq.EarliestStartTime.Value);
AssertDateTime(ParseDateTimeInUtc("2019-05-09T13:37:02Z"), segReq.LatestEndTime.Value);
Assert.AreEqual(1, segReq.MaterialRequirements.Count);
Assert.AreEqual(1, segReq.EquipmentRequirements.Count);
// Asserting nested segment requirement
SegmentRequirement segReqNested = segReq.SegmentRequirements[0];
AssertDateTime(ParseDateTimeInUtc("2019-08-29T15:31:38Z"), segReqNested.EarliestStartTime.Value);
// Asserting equipment requirement
EquipmentRequirement eqReq = segReq.EquipmentRequirements[0];
Assert.AreEqual(1, eqReq.Quantities.Count);
Assert.IsTrue(eqReq.Quantities[0].TryParseValueAsXmlBoolean());
MaterialRequirement matReq = segReq.MaterialRequirements[0];
// Asserting material definition ID
Assert.AreEqual(1, matReq.MaterialDefinitionIdentifiers.Count);
Assert.AreEqual("slag", matReq.MaterialDefinitionIdentifiers[0].Value);
// Asserting a material lot ID
Assert.AreEqual(1, matReq.MaterialLotIdentifiers.Count);
Assert.AreEqual("my-lot-1", matReq.MaterialLotIdentifiers[0].Value);
// Asserting material use
Assert.AreEqual(MaterialUseType.Produced, matReq.MaterialUse.Value);
// Asserting a material quantity
Assert.AreEqual(1, matReq.Quantities.Count);
QuantityValue quantity = matReq.Quantities[0];
Assert.AreEqual("12.2", quantity.RawQuantityString);
Assert.AreEqual(12.2, quantity.TryParseValueAsXmlDouble(), 0.001);
Assert.AreEqual("t", quantity.UnitOfMeasure);
Assert.AreEqual(DataType.TypeType.doubleXml, quantity.DataType.Type);
Assert.AreEqual("my-mat-key", quantity.Key.Value);
// Asserting an assembly requirement
Assert.AreEqual(1, matReq.AssemblyRequirements.Count);
Assert.AreEqual("Ni", matReq.AssemblyRequirements[0].MaterialDefinitionIdentifiers[0].Value);
}
public void ProcProdSched_Read()
{
// Testing reading a regular XML file with all supported features included.
var filepath = TestCommon.TestHelper.TestFileFolder + "\\ProcessProductionSchedule.xml";
var xmlBytes = System.IO.File.ReadAllBytes(filepath);
var testObject = new ProcessProductionSchedule(xmlBytes);
// Assert creation time
AssertDateTime(ParseDateTimeInUtc("2019-04-24T14:10:25Z"), testObject.CreationDateTime);
// Assert schedule count
Assert.AreEqual(1, testObject.ProductionSchedules.Count);
// Assert request count
var schedule1 = testObject.ProductionSchedules[0];
Assert.AreEqual(2, schedule1.ProductionRequests.Count);
// Assert request 1
var request1 = schedule1.ProductionRequests[0];
Assert.AreEqual(2, request1.SegmentRequirements.Count);
// Asserting identifier
Assert.AreEqual("my-identifier-1", request1.Identifier.Value);
// Asserting hierarchy scope
Assert.AreEqual("fsf", request1.HierarchyScopeObj.EquipmentIdentifier.Value);
Assert.AreEqual(EquipmentElementLevelType.ProcessCell, request1.HierarchyScopeObj.EquipmentElementLevel);
// Asserting one segment requirement
var segReq1 = request1.SegmentRequirements[0];
// Assert process segment identifier
Assert.AreEqual("1", segReq1.ProcessSegmentIdentifier.Value);
// Assert times
AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:00:00Z"), segReq1.EarliestStartTime.Value);
AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:30:00Z"), segReq1.LatestEndTime.Value);
// Asserting equipment requirement
Assert.AreEqual(1, segReq1.EquipmentRequirements.Count);
EquipmentRequirement equipmentReq = segReq1.EquipmentRequirements[0];
QuantityValue quantityEquipmentAvailability1 = equipmentReq.Quantities[0];
QuantityValue quantityEquipmentAvailability2 = equipmentReq.Quantities[1];
Assert.AreEqual("false", quantityEquipmentAvailability1.RawQuantityString);
Assert.AreEqual("true", quantityEquipmentAvailability2.RawQuantityString);
Assert.IsFalse(quantityEquipmentAvailability1.TryParseValueAsXmlBoolean());
Assert.IsTrue(quantityEquipmentAvailability2.TryParseValueAsXmlBoolean());
Assert.AreEqual(DataType.TypeType.booleanXml, quantityEquipmentAvailability1.DataType.Type);
Assert.AreEqual(DataType.TypeType.booleanXml, quantityEquipmentAvailability2.DataType.Type);
// Asserting material requirement
Assert.AreEqual(2, segReq1.MaterialRequirements.Count);
var matReq = segReq1.MaterialRequirements[0];
// Asserting material definition ID
Assert.AreEqual("matte", matReq.MaterialDefinitionIdentifiers[0].Value);
// Asserting material lot ID
Assert.AreEqual(1, matReq.MaterialLotIdentifiers.Count);
Assert.AreEqual("psc2-15", matReq.MaterialLotIdentifiers[0].Value);
// Assert material use
Assert.AreEqual(MaterialUseType.Produced, matReq.MaterialUse.Value);
// Assert quantity 1
var matProdQuantity1 = matReq.Quantities[0];
Assert.AreEqual("41.9", matProdQuantity1.RawQuantityString);
Assert.AreEqual(41.9, matProdQuantity1.TryParseValueAsXmlDouble(), 0.001);
Assert.AreEqual("t/h", matProdQuantity1.UnitOfMeasure);
Assert.AreEqual(DataType.TypeType.doubleXml, matProdQuantity1.DataType.Type);
Assert.AreEqual("ProdRate", matProdQuantity1.Key.Value);
// Assert quantity 2
var matProdQuantity2 = matReq.Quantities[1];
Assert.AreEqual("11.9", matProdQuantity2.RawQuantityString);
// Not asserting other fields, because this would be redundant to the previous quantity value.
// -- Asserting assembly requirements. Only one field is included in the test,
// because the assembly requirements have a structure similar to the enclosing requirements.
Assert.AreEqual(2, matReq.AssemblyRequirements.Count);
Assert.AreEqual("Cu", matReq.AssemblyRequirements[0].MaterialDefinitionIdentifiers[0].Value);
Assert.AreEqual("S", matReq.AssemblyRequirements[1].MaterialDefinitionIdentifiers[0].Value);
// Asserting another segment requirement (with nested segment requirement)
var segReq2_1 = request1.SegmentRequirements[1].SegmentRequirements[0];
AssertDateTime(ParseDateTimeInUtc("2019-04-24T15:31:00Z"), segReq2_1.EarliestStartTime.Value);
// Assert request 2
var request2 = schedule1.ProductionRequests[1];
Assert.AreEqual("my-identifier-2", request2.Identifier.Value);
}
