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); }