public override void Update(GameTime gameTime)
{
foreach (var entityId in _addedEntities)
{
_entityToComponentBits[entityId] = _componentManager.CreateComponentBits(entityId);
ActiveCount++;
EntityAdded?.Invoke(entityId);
}
foreach (var entityId in _changedEntities)
{
_entityToComponentBits[entityId] = _componentManager.CreateComponentBits(entityId);
EntityChanged?.Invoke(entityId);
}
foreach (var entityId in _removedEntities)
{
// we must notify subscribers before removing it from the pool
// otherwise an entity system could still be using the entity when the same id is obtained.
EntityRemoved?.Invoke(entityId);
var entity = _entityBag[entityId];
_entityBag[entityId] = null;
_componentManager.Destroy(entityId);
_entityToComponentBits[entityId] = default(BitVector32);
ActiveCount--;
_entityPool.Free(entity);
}
_addedEntities.Clear();
_removedEntities.Clear();
_changedEntities.Clear();
}
private async Task OnEntityChangedAsync(EntityChanged entityChanged, CancellationToken cancellationToken = default(CancellationToken))
{
if (entityChanged == null)
{
return;
}
var appEntityChanged = AppEntityChanged.Create(entityChanged);
if (appEntityChanged.Type == typeof(User).Name)
{
foreach (var connectionId in await _connectionMapping.GetConnectionsAsync(appEntityChanged.Id))
{
await Context.Connection.TypedSendAsync(connectionId, appEntityChanged);
}
return;
}
if (!String.IsNullOrEmpty(appEntityChanged.OrganizationId))
{
await GroupSendAsync(appEntityChanged.OrganizationId, appEntityChanged);
}
if (appEntityChanged.Type == "Organization")
{
await GroupSendAsync(appEntityChanged.Id, appEntityChanged);
}
}
private void LandingSiteCollection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
LandingSite editedLandingSite = new LandingSite();
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
int newIndex = e.NewStartingIndex;
editedLandingSite = LandingSiteCollection[newIndex];
LandingSites.Add(editedLandingSite);
}
break;
case NotifyCollectionChangedAction.Remove:
{
List <LandingSite> tempListOfRemovedItems = e.OldItems.OfType <LandingSite>().ToList();
editedLandingSite = tempListOfRemovedItems[0];
LandingSites.Delete(editedLandingSite.LandingSiteID);
}
break;
case NotifyCollectionChangedAction.Replace:
{
List <LandingSite> tempListOfLandingSites = e.NewItems.OfType <LandingSite>().ToList();
editedLandingSite = tempListOfLandingSites[0];
LandingSites.Update(editedLandingSite); // As the IDs are unique, only one row will be effected hence first index only
}
break;
}
EntityChangedEventArgs args = new EntityChangedEventArgs(editedLandingSite.GetType().Name, editedLandingSite);
EntityChanged?.Invoke(this, args);
}
protected EntityChanged CreateEntityChanged(ChangeType changeType, string organizationId = null, string projectId = null, string stackId = null, string id = null, IDictionary <string, object> data = null)
{
var model = new EntityChanged {
ChangeType = changeType,
Type = EntityTypeName,
Id = id
};
if (data != null)
{
foreach (var kvp in data)
{
model.Data[kvp.Key] = kvp.Value;
}
}
if (organizationId != null)
{
model.Data[ExtendedEntityChanged.KnownKeys.OrganizationId] = organizationId;
}
if (projectId != null)
{
model.Data[ExtendedEntityChanged.KnownKeys.ProjectId] = projectId;
}
if (stackId != null)
{
model.Data[ExtendedEntityChanged.KnownKeys.StackId] = stackId;
}
return(model);
}
protected virtual void PublishMessage(ChangeType changeType, IEnumerable <T> documents)
{
if (_isOwnedByOrganization && _isOwnedByProject)
{
foreach (var projectDocs in documents.Cast <IOwnedByOrganizationAndProjectWithIdentity>().GroupBy(d => d.ProjectId))
{
var firstDoc = projectDocs.FirstOrDefault();
if (firstDoc == null)
{
continue;
}
int count = projectDocs.Count();
var message = new EntityChanged {
ChangeType = changeType,
OrganizationId = firstDoc.OrganizationId,
ProjectId = projectDocs.Key,
Id = count == 1 ? firstDoc.Id : null,
Type = _entityType
};
PublishMessage(message, TimeSpan.FromSeconds(1.5));
}
}
else if (_isOwnedByOrganization)
{
foreach (var orgDocs in documents.Cast <IOwnedByOrganizationWithIdentity>().GroupBy(d => d.OrganizationId))
{
var firstDoc = orgDocs.FirstOrDefault();
if (firstDoc == null)
{
continue;
}
int count = orgDocs.Count();
var message = new EntityChanged {
ChangeType = changeType,
OrganizationId = orgDocs.Key,
Id = count == 1 ? firstDoc.Id : null,
Type = _entityType
};
PublishMessage(message, TimeSpan.FromSeconds(1.5));
}
}
else
{
foreach (var doc in documents)
{
var message = new EntityChanged {
ChangeType = changeType,
Id = doc.Id,
Type = _entityType
};
PublishMessage(message, TimeSpan.FromSeconds(1.5));
}
}
}
/// <summary>
/// Removes a component from the entity with the given ID. Notifies all systems that the entity has changed.
/// </summary>
/// <param name="entityId">The entity to remove the component from.</param>
/// <param name="component">The component to remove from the entity.</param>
public void RemoveComponent(uint entityId, IComponent component)
{
entityTable[componentIndices[component.GetType()], entityId] = null;
if (entityInWorld[entityId])
{
EntityChanged?.Invoke(this, new EntityEventArgs(entityId, GetEntityBitmask(entityId)));
}
}
protected virtual void OnEntityChanged(object oldValue, object newValue)
{
EntityChanged?.Invoke(this, isUserInteraction, oldValue, newValue);
AutomationProperties.SetItemStatus(this, Common.GetEntityStringAndHashCode(newValue));
UpdateVisibility();
}
private void OnEntityChanged(EntityChanged entityChanged)
{
if (String.IsNullOrEmpty(entityChanged.OrganizationId))
{
return;
}
Clients.Group(entityChanged.OrganizationId).entityChanged(entityChanged);
}
private Task OnEntityChangedAsync(EntityChanged entityChanged, CancellationToken cancellationToken = default(CancellationToken))
{
if (entityChanged != null)
{
Clients.All.entityChanged(entityChanged);
}
return(Task.FromResult(0));
}
private Task <int> GetNumberOfListeners(EntityChanged message)
{
var entityChanged = ExtendedEntityChanged.Create(message, false);
if (String.IsNullOrEmpty(entityChanged.OrganizationId))
{
return(Task.FromResult(1)); // Return 1 as we have no idea if people are listening.
}
return(_connectionMapping.GetGroupConnectionCountAsync(entityChanged.OrganizationId));
}
public T PopAt(Key i)
{
T val;
if (DataSet.TryRemove(i, out val))
{
EntityChanged.Invoke(this, new DSChangedArgs <Key, T>(i, NotifyCollectionChangedAction.Remove, val, default(T)));//this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, new KeyValuePair<int, T>(i, val)));
return(val);
}
return(default(T));
}
protected virtual void PublishMessage(EntityChangeType changeType, T document)
{
var orgEntity = document as IOwnedByOrganization;
var message = new EntityChanged {
ChangeType = changeType,
Id = document.Id,
OrganizationId = orgEntity != null ? orgEntity.OrganizationId : null,
Type = _entityType
};
PublishMessage(message);
}
private void OnEntityChanged(EntityChanged entityChanged)
{
if (entityChanged.Type == typeof(User).Name && Clients.User(entityChanged.Id) != null)
{
Clients.User(entityChanged.Id).entityChanged(entityChanged);
return;
}
if (String.IsNullOrEmpty(entityChanged.OrganizationId))
{
return;
}
Clients.Group(entityChanged.OrganizationId).entityChanged(entityChanged);
}
/// <summary>
/// Работа с сущностью при нажатии ОК.
/// </summary>
/// <param name="entity"></param>
/// <param name="ec"></param>
public override void ApplyChanged(EntityBase entity, EntityController ec)
{
if (entity as Hierarchy != null)
{
var entities = ec.AddRangeHierarchy(entity as Hierarchy, countCopy).ToArray();
ec.SaveChanges();
HierarchyChangedRange?.Invoke(entities);
}
else
{
ec.AddEntity(entity);
ec.SaveChanges();
EntityChanged?.Invoke(entity);
}
}
void ChangeTracker_EntityPropertyChanged(object sender, EntityEntryPropertyChangedEventArgs e)
{
#region Trigger entity set validation if ValidateOnPropertyChanged is set to true
var entitySet = e.EntityEntry.EntitySet;
var validationResults = new Collection <ValidationResultWithSeverityLevel>();
if (entitySet.ValidateOnPropertyChanged)
{
entitySet.ValidateProperty(e.EntityEntry.Entity, e.PropertyName, validationResults);
}
#endregion Trigger entity set validation if ValidateOnPropertyChanged is set to true
EntityChanged?.Invoke(this, e);
}
private IObservable <ITransition> getCorrectTransitionFromResults(
IEnumerable <IConflictResolutionResult <TThreadsafeModel> > results,
TThreadsafeModel originalEntity)
{
foreach (var result in results)
{
switch (result)
{
case UpdateResult <TThreadsafeModel> u when u.OriginalId == originalEntity.Id:
return(Observable.Return(Done.Transition(extractFrom(result))));
case IgnoreResult <TThreadsafeModel> i when i.Id == originalEntity.Id:
return(Observable.Return(EntityChanged.Transition(originalEntity)));
}
}
throw new ArgumentException("Results must contain result with one of the specified ids.");
}
private void ProjectSettings_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
ProjectSetting editedEntity = new ProjectSetting();
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
{
int newIndex = e.NewStartingIndex;
editedEntity = ProjectSettingCollection[newIndex];
if (ProjectSettings.Add(editedEntity))
{
EditedEntity = new EditedEntity(EditAction.Add, editedEntity);
}
}
break;
case NotifyCollectionChangedAction.Remove:
{
List <ProjectSetting> tempListOfRemovedItems = e.OldItems.OfType <ProjectSetting>().ToList();
editedEntity = tempListOfRemovedItems[0];
if (ProjectSettings.Delete(editedEntity.ProjectID))
{
EditedEntity = new EditedEntity(EditAction.Delete, editedEntity);
}
}
break;
case NotifyCollectionChangedAction.Replace:
{
List <ProjectSetting> tempListOfProjectSettings = e.NewItems.OfType <ProjectSetting>().ToList();
editedEntity = tempListOfProjectSettings[0];
if (ProjectSettings.Update(tempListOfProjectSettings[0])) // As the IDs are unique, only one row will be effected hence first index only
{
EditedEntity = new EditedEntity(EditAction.Update, editedEntity);
}
}
break;
}
EntityChangedEventArgs args = new EntityChangedEventArgs(editedEntity.GetType().Name, editedEntity);
EntityChanged?.Invoke(this, args);
}
// Component removed observable
public IObservable <EntityChangedEventArgs <T> > OnComponentRemovedAsObservable <T>()
{
var componentRemoved = Observable.FromEvent <EntityChanged, EntityChangedEventArgs <T> >(handler => {
EntityChanged componentRemovedHandler = (entity, index, component) => {
if (component is T)
{
var args = new EntityChangedEventArgs <T>();
args.entity = entity;
args.index = index;
args.component = (T)component;
handler(args);
}
};
return(componentRemovedHandler);
},
componentRemovedHandler => OnComponentRemoved += componentRemovedHandler,
componentRemovedHandler => OnComponentRemoved -= componentRemovedHandler);
return(componentRemoved);
}
public T this[Key i]
{
get
{
return(DataSet[i]);//DataSet.GetOrAdd(i,default(T));
}
set
{
if (!DataSet.ContainsKey(i))
{
DataSet[i] = value;
EntityChanged.Invoke(this, new DSChangedArgs <Key, T>(i, NotifyCollectionChangedAction.Add, default(T), value));
}
else if (!EqualityComparer <T> .Default.Equals(DataSet[i], value))
{
DataSet[i] = value;
EntityChanged.Invoke(this, new DSChangedArgs <Key, T>(i, NotifyCollectionChangedAction.Replace, default(T), value));//(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, new KeyValuePair<int, T>(i, value)));
}
}
}
protected override async Task PublishMessageAsync(EntityChangeType changeType, User user)
{
if (user.OrganizationIds.Any())
{
foreach (var organizationId in user.OrganizationIds)
{
var message = new EntityChanged {
ChangeType = changeType,
Id = user.Id,
OrganizationId = organizationId,
Type = _entityType
};
await _messagePublisher.PublishAsync(message);
}
}
else
{
await base.PublishMessageAsync(changeType, user);
}
}
protected override void PublishMessage(EntityChangeType changeType, User user)
{
if (user.OrganizationIds.Any())
{
foreach (var organizationId in user.OrganizationIds)
{
var message = new EntityChanged {
ChangeType = changeType,
Id = user.Id,
OrganizationId = organizationId,
Type = _entityType
};
_messagePublisher.Publish(message);
}
}
else
{
base.PublishMessage(changeType, user);
}
}
private async Task OnEntityChangedAsync(EntityChanged entityChanged, CancellationToken cancellationToken = default(CancellationToken))
{
if (entityChanged == null)
{
return;
}
if (entityChanged.Type == typeof(User).Name)
{
foreach (var connectionId in _userIdConnections.GetConnections(entityChanged.Id))
{
await Context.Connection.TypedSend(connectionId, entityChanged);
}
return;
}
if (!String.IsNullOrEmpty(entityChanged.OrganizationId))
{
await Context.Groups.TypedSend(entityChanged.OrganizationId, entityChanged);
}
}
public static ExtendedEntityChanged Create(EntityChanged entityChanged, bool removeWhenSettingProperties = true)
{
var model = new ExtendedEntityChanged {
Id = entityChanged.Id,
Type = entityChanged.Type,
ChangeType = entityChanged.ChangeType,
Data = entityChanged.Data
};
if (model.Data.TryGetValue(KnownKeys.OrganizationId, out object organizationId))
{
model.OrganizationId = organizationId.ToString();
if (removeWhenSettingProperties)
{
model.Data.Remove(KnownKeys.OrganizationId);
}
}
if (model.Data.TryGetValue(KnownKeys.ProjectId, out object projectId))
{
model.ProjectId = projectId.ToString();
if (removeWhenSettingProperties)
{
model.Data.Remove(KnownKeys.ProjectId);
}
}
if (model.Data.TryGetValue(KnownKeys.StackId, out object stackId))
{
model.StackId = stackId.ToString();
if (removeWhenSettingProperties)
{
model.Data.Remove(KnownKeys.StackId);
}
}
return(model);
}
public static AppEntityChanged Create(EntityChanged entityChanged)
{
var appEntityChanged = new AppEntityChanged {
Id = entityChanged.Id,
Type = entityChanged.Type,
ChangeType = entityChanged.ChangeType,
Data = entityChanged.Data
};
if (appEntityChanged.Data.ContainsKey(KnownKeys.OrganizationId))
{
appEntityChanged.OrganizationId = appEntityChanged.Data[KnownKeys.OrganizationId].ToString();
appEntityChanged.Data.Remove(KnownKeys.OrganizationId);
}
if (appEntityChanged.Data.ContainsKey(KnownKeys.ContactId))
{
appEntityChanged.ContactId = appEntityChanged.Data[KnownKeys.ContactId].ToString();
appEntityChanged.Data.Remove(KnownKeys.ContactId);
}
return(appEntityChanged);
}
private void OnEntityChanged(EntityChanged entityChanged)
{
if (entityChanged == null)
{
return;
}
if (entityChanged.Type == typeof(User).Name && Clients.User(entityChanged.Id) != null)
{
try {
Clients.User(entityChanged.Id).entityChanged(entityChanged);
} catch (NullReferenceException) { } // TODO: Remove this when SignalR bug is fixed.
return;
}
if (String.IsNullOrEmpty(entityChanged.OrganizationId))
{
return;
}
try {
Clients.Group(entityChanged.OrganizationId).entityChanged(entityChanged);
} catch (NullReferenceException) {} // TODO: Remove this when SignalR bug is fixed.
}
protected async Task SetSelectedValue(string value)
{
SetValue(value);
FilteredValues = null;
await EntityChanged.InvokeAsync(Entity).ConfigureAwait(false);
}
private void OnComponentsChanged(int entityId)
{
_changedEntities.Add(entityId);
_entityToComponentBits[entityId] = _componentManager.CreateComponentBits(entityId);
EntityChanged?.Invoke(entityId);
}
void ChangeTracker_EntityChanged(object sender, EntityEntryEventArgs e)
{
EntityChanged?.Invoke(this, e);
}
protected void InvokeEntityChanged(T entity)
{
EntityChanged?.Invoke(entity);
}
private async Task OnEntityChangedAsync(EntityChanged ec, CancellationToken cancellationToken = default)
{
if (ec == null)
{
return;
}
var entityChanged = ExtendedEntityChanged.Create(ec);
if (UserTypeName == entityChanged.Type)
{
// It's pointless to send a user added message to the new user.
if (entityChanged.ChangeType == ChangeType.Added)
{
_logger.LogTrace("Ignoring {UserTypeName} message for added user: {user}.", UserTypeName, entityChanged.Id);
return;
}
var userConnectionIds = await _connectionMapping.GetUserIdConnectionsAsync(entityChanged.Id);
_logger.LogTrace("Sending {UserTypeName} message to user: {user} (to {UserConnectionCount} connections)", UserTypeName, entityChanged.Id, userConnectionIds.Count);
foreach (string connectionId in userConnectionIds)
{
await TypedSendAsync(connectionId, entityChanged);
}
return;
}
// Only allow specific token messages to be sent down to the client.
if (TokenTypeName == entityChanged.Type)
{
string userId = entityChanged.Data.GetValueOrDefault <string>(ExtendedEntityChanged.KnownKeys.UserId);
if (userId != null)
{
var userConnectionIds = await _connectionMapping.GetUserIdConnectionsAsync(userId);
_logger.LogTrace("Sending {TokenTypeName} message for added user: {user} (to {UserConnectionCount} connections)", TokenTypeName, userId, userConnectionIds.Count);
foreach (string connectionId in userConnectionIds)
{
await TypedSendAsync(connectionId, entityChanged);
}
return;
}
if (entityChanged.Data.GetValueOrDefault <bool>(ExtendedEntityChanged.KnownKeys.IsAuthenticationToken))
{
_logger.LogTrace("Ignoring {TokenTypeName} Authentication Token message: {user}.", TokenTypeName, entityChanged.Id);
return;
}
entityChanged.Data.Clear();
}
if (!String.IsNullOrEmpty(entityChanged.OrganizationId))
{
_logger.LogTrace("Sending {MessageType} message to organization: {organization}", entityChanged.Type, entityChanged.OrganizationId);
await GroupSendAsync(entityChanged.OrganizationId, entityChanged);
}
}