public static DateTime GetAverageDate(HistoricalEvent he) { DateTime dt1 = new DateTime(he.Events_Year_from, he.Events_Month_from, he.Events_Day_from, he.Events_H_from, he.Events_M_from, 0); DateTime dt2 = new DateTime(he.Events_Year_to, he.Events_Month_to, he.Events_Day_to, he.Events_H_to, he.Events_M_to, 0); return(GetAverageDate(dt1, dt2)); }
public void HistoricalEvent_ChangeHFStateXML_Parses() { var world = LoadingWorld.GetTestWorld(); var xdoc = new XDocument(new XElement("historical_event", new XElement("id", 0), new XElement("year", 1), new XElement("seconds72", -1), new XElement("type", "change hf state"), new XElement("hfid", 264), new XElement("state", "settled"), new XElement("site_id", -1), new XElement("subregion_id", 4), new XElement("feature_layer_id", -1), new XElement("coords", "20,16") ) ); var historicalevent = HistoricalEvent.Create(xdoc, world); Assert.AreEqual(historicalevent.Id, 0); Assert.AreEqual(historicalevent.Year, 1); Assert.AreEqual(HistoricalEvent.Types[historicalevent.Type], "change hf state"); Assert.IsInstanceOfType(historicalevent, typeof(HE_ChangeHFState)); var changehfstateEvent = historicalevent as HE_ChangeHFState; Assert.AreEqual(changehfstateEvent.HfId, 264); Assert.AreEqual(HE_ChangeHFState.States[changehfstateEvent.State.Value], "settled"); Assert.IsNull(changehfstateEvent.SiteId); Assert.AreEqual(changehfstateEvent.SubregionId.Value, 4); Assert.IsNull(changehfstateEvent.FeatureLayerId); Assert.AreEqual(changehfstateEvent.Coords, new Point(20, 16)); }
private static TEvent MaterializeEvent <TEvent>(HistoricalEvent historicalEvent) where TEvent : EventBase { var type = Type.GetType(historicalEvent.EventType, true); var @event = (TEvent)JsonConvert.DeserializeObject(historicalEvent.ContentJson, type, GlobalSettings.EventSerializerSettings); @event.Id = historicalEvent.Id; @event.TimestampUtc = historicalEvent.TimestampUtc; return(@event); }
public void GenerateEvent(int year, HistoricalEvent.EventType type, List <HistoricalFigure> relatedFigs, string desc) { HistoricalEvent histEvent = new HistoricalEvent(); histEvent.year = year; histEvent.type = type; histEvent.relatedFigures = relatedFigs; histEvent.description = desc; importantEvents.Add(histEvent); }
public HistoricalEvent GetPreviousEvent(HistoricalEvent referenceEvt) { for (int i = 1; i < Event.Count; i++) { if (Event[i] == referenceEvt) { return(Event[i - 1]); } } return(null); }
public HistoricalEvent GetNextEvent(HistoricalEvent referenceEvt) { for (int i = 0; i < Event.Count - 1; i++) { if (Event[i] == referenceEvt) { return(Event[i + 1]); } } return(null); }
public String GetEventType(HistoricalEvent hevent) { String st = String.Empty; if (hevent.EventKeywords != null && hevent.EventKeywords.Length > 0) { foreach (KeyWord kw in hevent.EventKeywords) { st = String.Format("{0},{1}", st, kw.KeyWordDescription); } st = st.Substring(1, st.Length - 1); } return(st); }
public virtual async Task MarkOneAsRead(T1 id) { var entity = await _repository.GetByIdAsync <T1, T2>(id); var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Read.ToString(), EntityId = entity.Id.ToString(), EntityName = entity.GetType().FullName }; await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent); await _repository.SaveChangesAsync(); }
public void HistoricalEvent_NewTypeXML_Parses() { var world = LoadingWorld.GetTestWorld(); var xdoc = new XDocument(new XElement("historical_event", new XElement("id", 0), new XElement("year", 1), new XElement("seconds72", -1), new XElement("type", "unknown event type") ) ); var historicalevent = HistoricalEvent.Create(xdoc, world); Assert.AreEqual(historicalevent.Id, 0); Assert.AreEqual(historicalevent.Year, 1); Assert.IsInstanceOfType(historicalevent, typeof(HE_UnassessedEvent)); }
/// <summary> /// Updates the specified identifier. /// </summary> /// <param name="id">The identifier.</param> /// <param name="entity">The entity.</param> /// <returns></returns> public new virtual T Update(Guid id, T entity) { var originalEntity = base.GetById(id); var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Update.ToString(), Changeset = originalEntity.DetailedCompare(entity), EntityId = originalEntity.Id, EntityName = entity.GetType().Name }; var modifiedEntity = base.Update(id, entity); _repository.Create(historicalEvent); _repository.SaveChanges(); return(modifiedEntity); }
/// <summary> /// Creates the specified entity. /// </summary> /// <param name="entity">The entity.</param> /// <returns></returns> public new virtual T Create(T entity) { var createdEntity = base.Create(entity); var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Create.ToString(), Changeset = new T().DetailedCompare(entity), EntityId = entity.Id, EntityName = entity.GetType().Name }; _repository.Create(historicalEvent); _repository.SaveChanges(); // TODO: Do I need to call the other repo for both repositories, or do I need a UoW (bugfix created) return(createdEntity); }
/// <summary> /// Deletes the asynchronous. /// </summary> /// <param name="id">The identifier.</param> /// <returns></returns> public new virtual async Task <T> DeleteAsync(Guid id) { var entity = await base.DeleteAsync(id); // store all object in historical event var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Delete.ToString(), Changeset = new T().DetailedCompare(entity), EntityId = entity.Id, EntityName = entity.GetType().Name }; await _repository.CreateAsync(historicalEvent); _repository.SaveChanges(); return(entity); }
public virtual async Task MarkAllAsRead() { // TODO: Check if the userinfo repository is available, if not, throw exception var entities = await _repository.GetAllAsync <T1, T2>(); foreach (var entity in entities) { var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Read.ToString(), EntityId = entity.Id.ToString(), EntityName = entity.GetType().FullName }; await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent); } await _repository.SaveChangesAsync(); }
private bool IsNewStuffAvailable(T2 entity, HistoricalEvent historicalEvent) { if (!(entity is ICreatedInfo && entity is IModifiedInfo)) { throw new NotSupportedException("Entity must implement ICreatedInfo and IModifiedInfo"); } var modifiedInfo = entity as IModifiedInfo; var createdInfo = entity as ICreatedInfo; var createdByMe = modifiedInfo.ModifiedBy == null && createdInfo.CreatedBy == _userInfoRepository.GetUserInfo(); var modifiedByMe = modifiedInfo.ModifiedBy != null && modifiedInfo.ModifiedBy == _userInfoRepository.GetUserInfo(); var createdOrModifiedByMe = createdByMe || modifiedByMe; var createdBySomeone = modifiedInfo.ModifiedBy == null && createdInfo.CreatedBy != _userInfoRepository.GetUserInfo(); var modifiedBySomeone = modifiedInfo.ModifiedBy != null && modifiedInfo.ModifiedBy != _userInfoRepository.GetUserInfo(); var createdOrModifiedBySomeone = createdBySomeone || modifiedBySomeone; var viewedLately = modifiedInfo.ModifiedDate == null && historicalEvent?.CreatedDate > createdInfo.CreatedDate || modifiedInfo.ModifiedDate != null && historicalEvent?.CreatedDate > modifiedInfo.ModifiedDate; if (!viewedLately) { if (_options.ShowMyNewStuff && createdOrModifiedByMe) { return(true); } else if (_options.ShowMyNewStuff && createdOrModifiedBySomeone) { return(true); } else if (!_options.ShowMyNewStuff && createdOrModifiedBySomeone) { return(true); } else { return(false); } } else { return(false); } }
/// <summary> /// Deletes the asynchronous. /// </summary> /// <param name="id">The identifier.</param> /// <returns></returns> public virtual async Task <T2> DeleteAsync(T1 id) { var entity = await _service.DeleteAsync(id); // store all object in historical event var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Delete.ToString(), Changeset = new HistoricalChangeset() { ObjectData = new T2().DetailedCompare(entity) }, EntityId = entity.Id.ToString(), EntityName = entity.GetType().FullName }; await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent); await _repository.SaveChangesAsync(); return(entity); }
public Changeset ExtractOneDifferentialChangeset <T2>(HistoricalEvent currentEvent, HistoricalEvent nextEvent) where T2 : class, IEntity <T1>, new() { var currentObject = JsonConvert.DeserializeObject <T2>(currentEvent.Changeset.ObjectDelta); var nextObject = nextEvent.Action == HistoricalActions.Delete.ToString() ? JsonConvert.DeserializeObject <T2>(nextEvent.Changeset?.ObjectData) : JsonConvert.DeserializeObject <T2>(nextEvent.Changeset?.ObjectDelta); var changeset = new Changeset(); changeset.EventDate = nextEvent.CreatedDate.Value; changeset.UserId = nextEvent.CreatedBy; changeset.ChangesetId = nextEvent.Changeset.Id; changeset.EventName = nextEvent.Action; changeset.Changes = currentEvent.Action != HistoricalActions.Delete.ToString() ? ExtractChanges(currentObject, nextObject) : null; return(changeset); }
/// <summary> /// Creates the asynchronous. /// </summary> /// <param name="entity">The entity.</param> /// <returns></returns> public virtual async Task <T2> CreateAsync(T2 entity) { var createdEntity = await _service.CreateAsync(entity); var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Create.ToString(), Changeset = new HistoricalChangeset() { ObjectDelta = new T2().DetailedCompare(entity) }, EntityId = entity.Id.ToString(), EntityName = entity.GetType().FullName }; await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent); await _repository.SaveChangesAsync(); return(createdEntity); }
public void Save(EventBase @event) { if (@event == null) { throw new ArgumentNullException(nameof(@event)); } var json = JsonConvert.SerializeObject(@event, GlobalSettings.EventSerializerSettings); var historicalEvent = new HistoricalEvent() { Id = @event.Id, TimestampUtc = @event.TimestampUtc, EventType = @event.GetType().AssemblyQualifiedName, ContentJson = json, }; lock (_sync) { _dbContext.HistoricalEvents.Add(historicalEvent); _dbContext.SaveChanges(); } }
/// <summary> /// Updates the asynchronous. /// </summary> /// <param name="id">The identifier.</param> /// <param name="entity">The entity.</param> /// <returns></returns> public virtual async Task <T2> UpdateAsync(T1 id, T2 entity) { var originalEntity = await _service.GetByIdAsync(id); var historicalEvent = new HistoricalEvent { Action = HistoricalActions.Update.ToString(), Changeset = new HistoricalChangeset() { ObjectData = JsonConvert.SerializeObject(originalEntity), ObjectDelta = originalEntity.DetailedCompare(entity) }, EntityId = originalEntity.Id.ToString(), EntityName = entity.GetType().FullName }; var modifiedEntity = await _service.UpdateAsync(id, entity); await _repository.CreateAsync <Guid, HistoricalEvent>(historicalEvent); await _repository.SaveChangesAsync(); return(modifiedEntity); }
private Changeset ExtractOneDifferentialChangeset <TEntity>(HistoricalEvent currentEvent, HistoricalEvent nextEvent) where TEntity : class, IEntity <TId>, new() { var currentObject = JsonConvert.DeserializeObject <TEntity>(currentEvent.Changeset.ObjectDelta); var currentDto = _mapper.Map <TDto>(currentObject); var nextObject = nextEvent.Action == HistoricalActions.Delete.ToString() ? JsonConvert.DeserializeObject <TEntity>(nextEvent.Changeset?.ObjectData) : JsonConvert.DeserializeObject <TEntity>(nextEvent.Changeset?.ObjectDelta); var nextDto = _mapper.Map <TDto>(currentObject); var changeset = new Changeset(); changeset.EventDate = nextEvent.CreatedDate.Value; changeset.UserId = nextEvent.CreatedBy; changeset.ChangesetId = nextEvent.Changeset.Id; changeset.EventName = nextEvent.Action; changeset.Changes = currentEvent.Action != HistoricalActions.Delete.ToString() ? _historicalCrudReadService.ExtractChanges(currentDto, nextDto) : null; return(changeset); }
/// <summary> /// Now at the open tag of a single object in our XML, we want to dump the entire contents into an XDocument. /// If we have a historical event or historical event collection we want to use their factory methods to create a new version of those with the given XDocument. /// For all other object types we want to use their constructor to make a new object of that type. /// In any case we add the object after making it to the appropriate dictionary. /// Individual object reads are separated out to allow us to work past failing to load any specific XML item for some weird reason. /// </summary> private static void LoadItem <T>(IDictionary <int, T> WorldList, World world, XmlReader xReader) where T : XMLObject { XDocument xdoc = null; try { xdoc = XDocument.Load(xReader.ReadSubtree()); if (typeof(T) == typeof(HistoricalEvent)) { var evt = HistoricalEvent.Create(xdoc, world); world.HistoricalEvents.Add(evt.ID, evt); } else if (typeof(T) == typeof(HistoricalEventCollection)) { var evtcol = HistoricalEventCollection.Create(xdoc, world); world.HistoricalEventCollections.Add(evtcol.ID, evtcol); } else { var WorldObject = (T)Activator.CreateInstance(typeof(T), new object[] { xdoc, world }); WorldList.Add(WorldObject.ID, WorldObject); } } catch (OutOfMemoryException e) { Program.Log(LogType.Error, "Error reading XML item: id\n" + e.Message); var fi = new FileInfo(_path); Program.Log(LogType.Error, "XML file is" + Math.Round(fi.Length / 1024f / 1024f / 1024f, 2) + " GB"); Program.Log(LogType.Error, string.Format("Running {0} Bit World Viewer", (Environment.Is64BitProcess ? "64" : "32"))); Program.Log(LogType.Error, string.Format("Running {0} Bit Operating System", (Environment.Is64BitOperatingSystem ? "64" : "32"))); if (!Environment.Is64BitOperatingSystem) //Running 32 bit OS { Program.Log(LogType.Error, "32 Bit World Viewer does not support Huge XML files"); } else if (!Environment.Is64BitProcess) //Running 32 bit app in 64 bit OS { Program.Log(LogType.Error, "Recommend using 64 Bit World Viewer"); } else { Program.Log(LogType.Error, "Please report Log"); } MemoryFailureQuitParsing = true; } catch (Exception e) { try { if (xdoc != null) { int id = Int32.Parse(((XElement)xdoc.Root.Nodes().ToArray()[1]).Value); if (id < 0) { if (xdoc.Root.Name.LocalName == "historical_event") { if (!workflowDetected) { Program.Log(LogType.Error, "Negative ID historical event. Likely due to dfHack Workflow, ignoring\n" + xdoc); workflowDetected = true; } } else if (xdoc.Root.Name.LocalName == "historical_figure") { if (!autochopDetected) { Program.Log(LogType.Error, "Negative ID historical figure detected. Likely due to autochop, ignoring\n" + xdoc); autochopDetected = true; } } else { Program.Log(LogType.Error, "Negative ID " + xdoc.Root.Name.LocalName + " detected. Unknown cause, ignoring\n" + xdoc); } } else { Program.Log(LogType.Error, "Error reading XML item: id\n" + e.Message); } } } catch (Exception) { Program.Log(LogType.Error, "Error reading XML item: id\n" + e.Message); throw; } } }
private List <Changeset> ExtractDifferentialChanges(TId id, IOrderedEnumerable <HistoricalEvent> events, HistoricalEvent sourceEvent, TEntity sourceObject) { var differentialChangeset = new List <Changeset>(); var currentEvent = sourceEvent; var currentObject = sourceObject; var currentDto = _mapper.Map <TDto>(currentObject); for (int i = 1; i < events.Count(); i++) { var nextEvent = events.ToArray()[i]; var nextEventObject = JsonConvert.DeserializeObject <TEntity>(currentEvent.Changeset.ObjectDelta); var nextEventDto = _mapper.Map <TDto>(nextEventObject); var changeset = new Changeset(); changeset.EventDate = currentEvent.CreatedDate.Value; changeset.UserId = currentEvent.CreatedBy; changeset.ChangesetId = currentEvent.Changeset.Id; changeset.EventName = currentEvent.Action; changeset.Changes = _historicalCrudReadService.ExtractChanges(currentDto, nextEventDto); differentialChangeset.Add(changeset); currentObject = nextEventObject; currentDto = _mapper.Map <TDto>(currentObject); currentEvent = nextEvent; } // add last event to current object var lastChangeset = new Changeset(); var lastEvent = events.Last(); lastChangeset.EventDate = lastEvent.CreatedDate.Value; lastChangeset.UserId = lastEvent.CreatedBy; lastChangeset.ChangesetId = lastEvent.Changeset.Id; lastChangeset.Changes = lastEvent.Action != HistoricalActions.Delete.ToString() ? _historicalCrudReadService.ExtractChanges( _mapper.Map <TDto>(currentObject), _mapper.Map <TDto>(_repository.GetById <TId, TEntity>(id))) : null; lastChangeset.EventName = lastEvent.Action; differentialChangeset.Add(lastChangeset); return(differentialChangeset); }
public String GetAverageDate(HistoricalEvent hevent) { DateTime dt = ADUtilities.GetAverageDate(hevent); return(String.Format("{0}/{1}/{2}", dt.Day, dt.Month, dt.Year)); }