public IEntityChangeManager Create(EntityChange entityChange, ComparisonResult comparisonResult)
{
var changeManager = new EntityChangeManager(entityChange);
if (comparisonResult.AreEqual)
{
return(changeManager);
}
//根据实体与快照的差异进行分析实体的变动
foreach (var difference in comparisonResult.Differences)
{
EntityType type = this.GetEntityType(difference);
//非基础类检查是否为添加或者删除变动类型
if (type != EntityType.Basis)
{
if (this.RemoveDiff(entityChange, difference))
{
continue;
}
if (this.AdditionDiff(entityChange, difference))
{
continue;
}
}
this.ModifyDiff(entityChange, difference);
}
return(changeManager);
}
public async Task <IActionResult> GetAsync(string locatorType, string locator, [FromQuery] long?minRevision,
CancellationToken ct)
{
if (minRevision != null)
{
EntityChange <Build> change = await _buildRepo.GetNewerRevisionAsync(GetLocatorType(locatorType),
locator, minRevision.Value, ct).Timeout(_options.Value.BuildLongPollTimeout, ct);
switch (change.Type)
{
case EntityChangeType.None:
return(NoContent());
case EntityChangeType.Delete:
return(NotFound());
default:
return(Ok(CreateDto(change.Entity)));
}
}
Build build = await _buildRepo.GetByLocatorAsync(GetLocatorType(locatorType), locator);
if (build == null)
{
return(NotFound());
}
return(Ok(CreateDto(build)));
}
private static EntityChange CreateTombstoneEntityFields(IEntitySync entity)
{
var fields = new EntityChange();
fields.Add(EntityTombstone <EntitySync, IEntitySync> .IdColumnName, entity.Id);
return(fields);
}
private static Dictionary <string, PropertyData> WriteProperties(EntityChange entityChange)
{
var propertiesData = new Dictionary <string, PropertyData>();
var entityClass = EntityRefUtils.GetClass(entityChange.EntityRef);
foreach (var prop in entityChange.PropertyChanges)
{
var pi = entityClass.GetProperty(prop.PropertyName);
// special handling of extended properties collections
// note that we need to check pi != null because it may represent a field-access "property"
// which has no corresponding .NET property
if (pi != null && AttributeUtils.HasAttribute <ExtendedPropertiesCollectionAttribute>(pi))
{
var extendedProps = WriteExtendedProperties(prop, entityChange.ChangeType);
foreach (var extendedProp in extendedProps)
{
propertiesData.Add(extendedProp.Key, extendedProp.Value);
}
}
else
{
var propertyData = WriteProperty(prop.OldValue, prop.NewValue, entityChange.ChangeType);
propertiesData.Add(prop.PropertyName, propertyData);
}
}
return(propertiesData);
}
/// <summary>
/// Tracks the property changes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity">The entity.</param>
/// <param name="propName">Name of the property.</param>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
public void TrackProperty <T>(T entity, string propName, string oldValue, string newValue) where T : DomainObject
{
var name = typeof(T).Name;
switch (typeof(T).Name)
{
case "ProductModel":
name = (entity as ProductModel).Name;
break;
case "ProductComponent":
name = (entity as ProductComponent).ComponentName;
break;
case "WorkInstruction":
name = (entity as GTSWorkInstruction).Title;
break;
}
var change = new EntityChange
{
Id = Guid.NewGuid(),
ChangedEntityId = entity.Id,
ChangedEntityType = typeof(T),
ChangeDate = DateTime.Now,
ChangeDescription = string.Format("{3} '{4}'s property '{0}' was changed from '{1}' to '{2}'.", propName, oldValue, newValue, typeof(T).Name, name),
ChangeMadeBy = entity.EditedBy,
OldValue = oldValue,
NewValue = newValue
};
// save change to system
GTSDataRepository.Create <EntityChange>(change);
}
public Conflict(IEntityInfo entityInfo, EntityChange local, EntityChange remote, ISyncSessionInfo syncSessionInfo)
{
_entityInfo = entityInfo;
_local = local;
_remote = remote;
_syncSessionInfo = syncSessionInfo;
}
private void Add(EntityChange local, EntityChange remote)
{
Debug.WriteLine(local != null ? local.Headers : remote.Headers);
Debug.WriteLine(string.Format("Local value:{0}", local != null ? local.ToString() : "null"));
Debug.WriteLine(string.Format("Remote value:{0}", remote != null ? remote.ToString() : "null"));
Conflicts.Add(new Conflict(_entityInfo, local, remote, _syncSessionInfo));
}
protected override void TrackChange(EntityEntry entityEntry, ChangeAction action)
{
var entity = (T)entityEntry.Entity;
var entityType = entity.GetType();
var from = action != ChangeAction.Add ?
JsonSerializer.Serialize(entityEntry.OriginalValues.ToObject(), JsonSerializerHelper.JsonSerializerOptions) :
"";
var to = action != ChangeAction.Delete ?
JsonSerializer.Serialize(entityEntry.CurrentValues.ToObject(), JsonSerializerHelper.JsonSerializerOptions) :
"";
var change = new EntityChange()
{
EntityName = entityType.Name,
EntityId = entity.Id,
Action = action,
From = from,
To = to,
CreationDate = DateTime.UtcNow,
CreationUserId = UserId,
};
if (action == ChangeAction.Add)
{
Context.Database.ExecuteSqlRaw("insert into [EntityChanges] ([EntityName], [EntityId], [Action], [From], [To], [CreationDate], [CreationUserId]) " +
"values ({0}, {1}, {2}, {3}, {4}, {5}, {6})",
entityType.Name, entity.Id, action, from, to, DateTime.UtcNow, UserId);
}
else
{
Context.Set <EntityChange>().Add(change);
}
}
public async Task <List <DataAuditRowObject> > GetEntityAuditsAsync(string url, string entityId)
{
List <DataAuditRowObject> result = new List <DataAuditRowObject>();
var logs = await Task.Run(() => AuditLogsRepository.Include(x => x.EntityChanges).ThenInclude(x => x.PropertyChanges).Where(x => x.Url == url && x.EntityChanges != null && x.EntityChanges.Any(x => x.EntityId == entityId)).ToList());
for (int i = 0; i < logs.Count; i++)
{
AuditLog auditLog = logs[i];
var entityChanges = auditLog.EntityChanges.Where(x => x.EntityId == entityId).ToList();
for (int j = 0; j < entityChanges.Count; j++)
{
EntityChange entityChange = entityChanges[j];
result.Add(new DataAuditRowObject()
{
AuditLogId = auditLog.Id,
EntityId = entityChange.EntityId,
Id = entityChange.Id.ToString(),
ModificationDateTime = auditLog.ExecutionTime.ToShortDateString() + " " + auditLog.ExecutionTime.ToShortTimeString(),
ModifiedBy = auditLog.UserName,
PropertyChanges = entityChange.PropertyChanges.ToList(),
Type = entityChange.ChangeType.ToString()
});
}
}
return(result);
}
/// <summary>Finds the changed entity if possible.</summary>
/// <param name="x">The changed element.</param>
/// <param name="chg">The applicable change made to the entity.</param>
private XElement FindChangedEntityElement(XElement x, ref EntityChange chg)
{
// Find the owning entity (and create if performing an Add)
XElement xentity = x;
while (xentity != null)
{
if (EntityBuilder.IsEntity(xentity.Name))
{
break;
}
// Navigate up the xtree
if (chg == EntityChange.Remove && xentity.Parent == null)
{
Debug.Assert(xentity == _changingXObj, "If chg==Remove, than x must be the original node being changed because GetChangedElement changes the chg to Modified otherwise.");
xentity = _changingXObjOrigParent as XElement;
}
else
{
xentity = xentity.Parent; // null if ObjectChange == Add
}
// Since we're going up, then the entity change changes to Modified because
// either it's child is being added, removed, modified
chg = EntityChange.Modified;
}
return(xentity);
}
private XElement GetChangedElement(XObject xobj, XObjectChange xchange, out EntityChange chg)
{
chg = XChangeToEntityChange(xchange);
XElement x = xobj as XElement;
// If not an element, get the parent (assuming it's an element node)
if (x == null)
{
// Handle the case where the parent is null because the node is being removed
if (chg == EntityChange.Remove && xobj.Parent == null)
{
Debug.Assert(xobj == _changingXObj);
xobj = _changingXObjOrigParent;
}
else // navigate normally
{
xobj = xobj.Parent;
}
x = xobj as XElement;
chg = EntityChange.Modified;
}
return(x);
}
// TODO Make this a protected virtual method inheritors would override.
/// <summary>
/// When this client's player entity is updated over the network,
/// changes the ProcessInputsComponent on that player's input entity so that
/// all inputs, starting with the tick the message was sent, will be reprocessed.
/// </summary>
/// <param name="message">The message the applied entity change was part of.</param>
/// <param name="change">The entity change that was applied.</param>
/// <param name="e">The game entity the change was applied to.</param>
void OnDidApply(GameStateUpdateMessage message, EntityChange change, GameEntity e)
{
if (!e.hasPlayer)
{
return;
}
if (!game.hasThisPlayerId)
{
return;
}
var playerId = e.player.id;
if (playerId == game.thisPlayerId.value)
{
var inputEntity = input.GetEntityWithPlayer(playerId);
if (inputEntity == null)
{
return;
}
inputEntity.ReplaceProcessInputs(message.timestamp);
//Debug.LogFormat("Will reprocess inputs since tick {0}", message.timestamp);
// Delete input records earlier than message timestamp.
var inputs = inputEntity.playerInputs.inputs;
inputs.RemoveAll(record => record.timestamp < message.timestamp);
inputEntity.ReplacePlayerInputs(inputs);
}
}
public EntityChange GetEntityChange(object entity, IAbpSession abpSession, string[] propertyNames, object[] loadedState, object[] currentState, Int32[] dirtyProps)
{
var setting = entity as Setting;
if (setting == null)
{
return(null);
}
var entityChange = new EntityChange
{
ChangeType = EntityChangeType.Updated,
ChangeTime = DateTime.Now,
EntityEntry = entity, // [NotMapped]
EntityId = setting.Name + (setting.UserId != null ? "@" + setting.UserId : ""),
EntityTypeFullName = typeof(Setting).FullName,
TenantId = abpSession.TenantId,
};
object oldValue;
object newValue;
var valueIndex = Array.IndexOf(propertyNames, nameof(Setting.Value));
if (loadedState == null)
{
// changed from default
newValue = currentState[valueIndex];
oldValue = _settingDefinitionManager.GetSettingDefinition(setting.Name)?.DefaultValue; //default
}
else if (dirtyProps == null)
{
// delete = restored to default
newValue = $"default ({_settingDefinitionManager.GetSettingDefinition(setting.Name)?.DefaultValue})"; //default
oldValue = loadedState[valueIndex];
}
else
{
// changed
newValue = currentState[valueIndex];
oldValue = loadedState[valueIndex];
}
var propChange = new EntityPropertyChange()
{
OriginalValue = oldValue?.ToJsonString().TruncateWithPostfix(EntityPropertyChange.MaxValueLength),
NewValue = newValue?.ToJsonString().TruncateWithPostfix(EntityPropertyChange.MaxValueLength),
PropertyName = nameof(Setting.Value),
PropertyTypeFullName = typeof(string).FullName,
TenantId = abpSession.TenantId,
};
entityChange.PropertyChanges = new List <EntityPropertyChange>()
{
propChange
};
return(entityChange);
}
void WriteBacklog(List <EntityChange> changes)
{
foreach (var id in destroyedEntitiesBacklog)
{
changes.Add(EntityChange.MakeRemoval(id));
}
destroyedEntitiesBacklog.Clear();
}
public static EntityChange MakeRemoval(ulong entityId)
{
var change = new EntityChange();
change.entityId = entityId;
change.isRemoval = true;
return(change);
}
public static EntityChange MakeUpdate(ulong entityId, ComponentChange[] componentChanges)
{
var change = new EntityChange();
change.entityId = entityId;
change.componentChanges = componentChanges;
change.isRemoval = false;
return(change);
}
internal void OnMessageReceived(RecordChangedNotification <TEntity> recordChange)
{
if (recordChange.ChangeType == ChangeType.None)
{
return;
}
var entityChange = new EntityChange <TEntity>(recordChange.Entity, Convert(recordChange.ChangeType));
reactiveData.Publish(entityChange);
}
EntityChange MakeChangeOf(GameEntity e)
{
if (e.flagDestroy)
{
return(EntityChange.MakeRemoval(e.id.value));
}
var componentChanges = MakeComponentChangesOf(e);
return(EntityChange.MakeUpdate(e.id.value, componentChanges));
}
/// <summary>
/// Attempts to tracks changes to an entity.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="oldEntity">The old entity.</param>
/// <param name="newEntity">The new entity.</param>
public void TrackChanges <T>(T oldEntity, T newEntity) where T : DomainObject
{
// get a list of properties of the entity
var props = typeof(T).GetProperties().ToList();
var name = string.Empty;
switch (typeof(T).Name)
{
case "ProductModel":
name = (newEntity as ProductModel).Name;
break;
case "ProductComponent":
name = (newEntity as ProductComponent).ComponentName;
break;
case "GTSWorkInstruction":
name = (newEntity as GTSWorkInstruction).Title;
break;
}
// iterate over all properties and track changes
props.ForEach(prop =>
{
// get values
var oldValue = prop.GetValue(oldEntity);
var newValue = prop.GetValue(newEntity);
// check for differences
if ((oldValue != null && newValue != null) &&
!oldValue.Equals(newValue) &&
!(oldValue is IList) && !oldValue.GetType().IsGenericType &&
prop.Name != "ModificationDate")
{
// create and save new EntityChange object
var change = new EntityChange
{
Id = Guid.NewGuid(),
ChangedEntityId = oldEntity.Id,
ChangedEntityType = typeof(T),
ChangeDate = DateTime.Now,
ChangeDescription = string.Format("{3} '{4}'s property '{0}' is changed from '{1}' to '{2}'", prop.Name, oldValue, newValue, typeof(T).Name, name),
ChangeMadeBy = User.Identity.Name, //oldEntity.EditedBy,
OldValue = oldValue.ToString(),
NewValue = newValue.ToString()
};
// save change to system
GTSDataRepository.Create <EntityChange>(change);
}
});
}
public static void InsertInLocal(IDataStore localDataStore, ISyncSessionInfo syncSessionInfo, ISyncable remoteEntity)
{
var entityInfo = localDataStore.GetEntityInfo(remoteEntity);
var mergeResolution = new MergeResolution
{
OperationType = OperationTypes.Insert,
Entity = EntityChange.Create(entityInfo, remoteEntity)
};
mergeResolution.ApplyResolution(localDataStore as ISqlDataStore, syncSessionInfo);
}
public void ApplyForeignKeyChange(EntityChange entity)
{
foreach (var identityChange in _primaryKeyChanges)
{
var foreignKey = entity.GetForeignKeyOf(identityChange.EntityName);
if (foreignKey == null)
{
continue;
}
foreignKey.ApplyForeignKeyChange(identityChange);
}
}
internal void OnMessageReceived(string message)
{
var recordChange = DeserializeRecordChangedNotification(message);
if (recordChange.ChangeType == ChangeType.None)
{
return;
}
var entityChange = new EntityChange <TEntity>(recordChange.Entity, Convert(recordChange.ChangeType));
reactiveData.Publish(entityChange);
}
EntityChange[] GetMessageChanges()
{
var entities = input.GetEntities();
var changes = new EntityChange[entities.Length];
int i = 0;
foreach (var e in entities)
{
changes[i++] = MakeChangeOf(e);
}
return(changes);
}
private static EntityChange CreateEntityFields(IEntitySync entity)
{
var fields = new EntityChange();
fields.EntityName = EntitySync.TableName;
fields.HasAutoIncrement = true;
fields.Add(EntitySync.IdColumnName, entity.Id);
fields.Add(EntitySync.ColumnNameCreatedAt, entity.CreatedAt);
fields.Add(EntitySync.ColumnNameUpdatedAt, entity.UpdatedAt);
fields.Add(EntitySync.ColumnNameLastSyncAt, entity.LastSyncAt);
fields.Add(EntitySync.ColumnNameUniqueIdentifier, entity.UniqueIdentifier);
fields.Add(EntitySync.ColumnNameStringField, entity.StringField);
return(fields);
}
private void Notify(EntityChange change)
{
foreach (Type eventKeyClass in _eventMap.Keys)
{
/* // check if the eventKeyClass is the entity class, or a superclass of it
* if (eventKeyClass.IsAssignableFrom(change.EntityRef))
* {
* // create an entity ref based on the eventKeyClass, regardless of the actual entity class
* //EntityRefBase entityRef = EntityRefFactory.CreateReference(eventKeyClass, change.EntityOID, change.Version);
* //EventsHelper.Fire(_eventMap[change.EntityClass], null, new EntityChangeEventArgs(entityRef, change.ChangeType));
* }
* */
}
}
/// <summary>
/// Creates a change record for the specified entity change.
/// </summary>
/// <param name="change">The recorded change.</param>
/// <returns>
/// A new <see cref="Change"/> for <paramref name="change"/>.
/// </returns>
protected virtual Change CreateChangeRecord(EntityChange change)
{
var previousValue = JsonConvert.SerializeObject(change.OriginalValue);
var newValue = JsonConvert.SerializeObject(change.CurrentValue);
return(new Change
{
EntityId = change.Entity.Id,
EntityType = change.EntityType,
Name = change.PropertyName,
Type = change.PropertyType,
PreviousValue = previousValue,
NewValue = newValue
});
}
public static MergeResolution Create(IEntityInfo entityInfo, OperationTypes operationType, IEntity entity)
{
var entitySync = SyncEntity.Create(entityInfo);
if (entitySync.Direction == SyncDirection.UploadOnly)
{
return(null);
}
return(new MergeResolution
{
OperationType = operationType,
Entity = EntityChange.Create(entityInfo, entity)
});
}
public async Task <PS_PaySubGroup> GetPaySubGroupRawAsync(int id, string asOf = null)
{
try {
PS_PaySubGroup result = ObjectMapper.Map <PS_PaySubGroup, PS_PaySubGroup>(await Task.Run(() => Repository
.Include(x => x.PayGroup)
.Include(x => x.LegalEntity)
.Include(x => x.Frequency)
.Include(x => x.PayrollPeriod)
.ThenInclude(x => x.PayPeriods)
.Include(x => x.AllowedBanks)
.First(x => x.Id == id)));
if (asOf != null)
{
DateTime asOfDateTime = DateTime.Parse(asOf);
List <EntityChange> logs = AuditLogsRepo.WithDetails().Where(x => x.EntityChanges != null && x.EntityChanges.Any(x => x.EntityId == id.ToString() && x.EntityTenantId == CurrentTenant.Id && x.ChangeTime >= asOfDateTime))
.SelectMany(x => x.EntityChanges.Where(y => y.EntityId == id.ToString() && y.EntityTenantId == CurrentTenant.Id)).ToList();
logs.Reverse();
for (int i = 0; i < logs.Count; i++)
{
EntityChange log = logs[i];
//log.ChangeType
for (int y = 0; y < log.PropertyChanges.Count; y++)
{
EntityPropertyChange propertyChange = log.PropertyChanges.ElementAt(y);
PropertyInfo prop = typeof(PS_PaySubGroup).GetProperty(propertyChange.PropertyName);
if (prop != null)
{
try
{
prop.SetValue(result, propertyChange.OriginalValue);
}
catch (Exception ex)
{
}
}
}
}
}
return(result);
}
catch (Exception ex)
{
return(null);
}
}
private bool RemoveDiff(EntityChange entityChange, Difference difference)
{
if (difference.Object2 != null)
{
return(false);
}
if (difference.Object1 == null)
{
return(false);
}
var diff = new EntityDifference(difference.Object1.GetType().FullName, EntityChangeType.Remove, difference.ParentPropertyName);
diff.OldEntity = difference.Object1;
entityChange.DeleteEntry.Add(diff);
return(true);
}
protected override EntityChange GetEntityChange(EntityEntry entityEntry)
{
var entity = entityEntry.Entity;
EntityChangeType changeType;
switch (entityEntry.State)
{
case EntityState.Added:
changeType = EntityChangeType.Created;
break;
case EntityState.Deleted:
changeType = EntityChangeType.Deleted;
break;
case EntityState.Modified:
changeType = entityEntry.IsDeleted() ? EntityChangeType.Deleted : EntityChangeType.Updated;
break;
case EntityState.Detached:
case EntityState.Unchanged:
default:
return(null);
}
var entityId = entityEntry.GetPrimaryKeyValue();
if (entityId == null && changeType != EntityChangeType.Created)
{
return(null);
}
var entityType = entity.GetType();
var entityChange = new EntityChange
{
ChangeType = changeType,
EntityEntry = entityEntry,
EntityId = entityId,
EntityTypeFullName = entityType.FullName,
PropertyChanges = GetPropertyChanges(entityEntry).ToArray()
};
return(entityChange);
}
