private IProductionEvents Deserialize(MemoryStream stream)
{
IProductionEvents events = null;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
if (stream.Length < 16)
{
return(events);
}
stream.Position = 1; // Skip the version to get the event list type
var eventType = reader.ReadInt32();
if (!Enum.IsDefined(typeof(ProductionEventType), eventType))
{
return(events);
}
events = DIContext.Obtain <IProductionEventsFactory>().NewEventList(-1, Guid.Empty, (ProductionEventType)eventType);
stream.Position = 0;
events.ReadEvents(reader);
}
return(events);
}
/// <summary>
/// Checks the new override event has a valid date range. It cannot overlap existing override events.
/// </summary>
private bool ValidateNewOverrideEventAgainstExistingOverridingEvents <T>(IProductionEvents <OverrideEvent <T> > existingList, OverrideEventRequestArgument arg)
{
//Test if we override event within the range or we have overlapping overriding
bool noOverlap = true;
//Test if we have overlapping for the start date of the event
//Note closest prior and closest subsequent include event at date itself
var index = existingList.IndexOfClosestEventPriorToDate(arg.EndUTC);
if (index >= 0)
{
existingList.GetStateAtIndex(index, out var startDate, out var evt);
if (startDate != arg.EndUTC) //Ignore exact event time matches
{
noOverlap = arg.StartUTC >= evt.EndDate;
}
}
//Test if we have overlapping for the end date of the event
index = existingList.IndexOfClosestEventSubsequentToDate(arg.StartUTC);
if (index >= 0)
{
existingList.GetStateAtIndex(index, out var startDate, out _);
if (startDate != arg.StartUTC)
{
noOverlap = noOverlap && arg.EndUTC <= startDate;
}
}
return(noOverlap);
}
private void CheckMergedList <T>(int startMins, int endMins, IProductionEvents <T> eventsList, T overrideId, T[] ids, DateTime[] dateTimes, DateTime startOverride, DateTime endOverride)
{
DateTime[] expectedDates;
T[] expectedIds;
if (startMins == -105 && endMins == -75) //override spanning start
{
expectedDates = new[] { startOverride, endOverride, dateTimes[1], dateTimes[2] };
expectedIds = new[] { overrideId, ids[0], ids[1], ids[2] };
}
else if (startMins == -75 && endMins == -45) //override the middle
{
expectedDates = new[] { dateTimes[0], startOverride, endOverride, dateTimes[2] };
expectedIds = new[] { ids[0], overrideId, ids[1], ids[2] };
}
else if (startMins == -45 && endMins == -15) //override spanning end
{
expectedDates = new[] { dateTimes[0], dateTimes[1], startOverride, endOverride };
expectedIds = new[] { ids[0], ids[1], overrideId, ids[2] };
}
else if (startMins == -105 && endMins == -15) //override whole range
{
expectedDates = new[] { startOverride, endOverride };
expectedIds = new[] { overrideId, ids[2] };
}
else //startMins == -80 && endMins == -70 //override within machine events
{
expectedDates = new[] { dateTimes[0], startOverride, endOverride, dateTimes[1], dateTimes[2] };
expectedIds = new[] { ids[0], overrideId, ids[0], ids[1], ids[2] };
}
var mutableStream = eventsList.GetMutableStream();
var targetEventList = Deserialize(mutableStream);
Assert.Equal(expectedDates.Length, targetEventList.Count());
var eventList = ((ProductionEvents <T>)targetEventList).Events;
for (var i = 0; i < eventList.Count; i++)
{
Assert.Equal(expectedDates[i], eventList[i].Date);
Assert.Equal(expectedIds[i], eventList[i].State);
}
var immutableStream = eventsList.GetImmutableStream();
targetEventList = Deserialize(immutableStream);
Assert.Equal(expectedDates.Length, targetEventList.Count());
eventList = ((ProductionEvents <T>)targetEventList).Events;
for (var i = 0; i < eventList.Count; i++)
{
Assert.Equal(expectedDates[i], eventList[i].Date);
Assert.Equal(expectedIds[i], eventList[i].State);
}
}
public SiteModelMachineTargetValueTrackingState(IProductionEventLists machineEventLists, ProductionEventType eventType)
{
EventList = (IProductionEvents <T>)machineEventLists.GetEventList(eventType);
StartDate = Consts.MIN_DATETIME_AS_UTC;
EndDate = Consts.MIN_DATETIME_AS_UTC;
Index = -1;
Stamp = -1;
ThisEvent = default;
NextEvent = default;
}
// IntegrateList takes a list of machine events and merges them into the machine event list.
// Note: This method assumes that the methods being merged into the new list
// are machine events only, and do not include custom events.
private void IntegrateList(IProductionEvents source, IProductionEvents target)
{
if (source.Count() == 0)
{
return;
}
if (source.Count() > 1)
{
source.Sort();
}
target.CopyEventsFrom(source);
target.Collate(_targetLists);
}
/// <summary>
/// Integrate together all the events lists for a machine between the source and target lists of machine events
/// </summary>
private void IntegrateMachineEvents()
{
if (_sourceLists == null)
{
return;
}
IntegrateMachineDesignEventNames();
IProductionEvents sourceStartEndRecordedDataList = _sourceLists.StartEndRecordedDataEvents;
// Always integrate the machine recorded data start/stop events first, as collation
// of the other events depends on collation of these events
PerformListIntegration(sourceStartEndRecordedDataList, _targetLists.StartEndRecordedDataEvents);
var sourceEventLists = _sourceLists.GetEventLists();
var targetEventLists = _targetLists.GetEventLists();
// Integrate all remaining event lists and collate them wrt the machine start/stop recording events
foreach (var evt in ProductionEventTypeValues)
{
var sourceList = sourceEventLists[evt];
if (sourceList != null && sourceList != sourceStartEndRecordedDataList && sourceList.Count() > 0)
{
// The source event list is always an in-memory list. The target event list
// will be an in-memory list unless IntegratingIntoPersistentDataModel is true,
// in which case the source events are being integrated into the data model events
// list present in the persistent store.
var targetList = targetEventLists[evt] ?? _targetLists.GetEventList(sourceList.EventListType);
if (_integratingIntoPersistentDataModel && targetList == null)
{
Log.LogError($"Event list {evt} not available in IntegrateMachineEvents");
}
if (targetList != null)
{
PerformListIntegration(sourceList, targetList);
}
}
}
}
/// <summary>
/// Remove requested override events of required type for given machine
/// </summary>
private bool RemoveOverrideEventsForMachine <T>(DateTime startUtc, DateTime endUtc, IProductionEvents <T> existingList)
{
if (startUtc == Consts.MIN_DATETIME_AS_UTC && endUtc == Consts.MAX_DATETIME_AS_UTC)
{
//No date range - remove all override events of required type for machine
existingList.Clear();
}
else
{
existingList.RemoveValueAtDate(startUtc);
}
return(existingList.EventsChanged);
}
private void PerformListIntegration(IProductionEvents source, IProductionEvents target)
{
IntegrateList(source, target);
}
