public virtual T Get(IEntityRequestContext context, IEntityIdentity entity)
        {
            using (Logger.CreateTrace(LoggingBoundaries.ServiceBoundary, typeof(EntityBusinessFacade <T>), "Get"))
            {
                try
                {
                    if (!context.IgnoreHandlers.HasFlag(EntityEventType.GetBefore) && !_handlers.OnGetBefore(context, entity))
                    {
                        return(null);
                    }

                    var item = _repository.Get(context, entity as T);

                    if (!context.IgnoreHandlers.HasFlag(EntityEventType.GetAfter) && !_handlers.OnGetAfter(context, item))
                    {
                        return(null);
                    }

                    return(item);
                }
                catch (Exception ex)
                {
                    if (Logger.HandleException(LoggingBoundaries.ServiceBoundary, ex))
                    {
                        throw;
                    }
                }
            }

            return(null);
        }
        /// <summary>
        /// The constructor is used for restoring the instance of <see cref="AbstractEntityIdentity{TKey}"/>
        /// from provided <see cref="IEntityIdentity"/>. It is used during restoring aggregates from persistence
        /// storage.
        /// </summary>
        protected AbstractEntityIdentity(IEntityIdentity identity)
        {
            Require.NotNull(identity, nameof(identity));
            Require.True(identity.Tag.Equals(Tag, StringComparison.Ordinal), nameof(identity), "Invalid identity.Tag value");

            Id = ParseIdValue(identity.Value);
        }
示例#3
0
        private List <EntityEvent> GetPendingEntityEvents()
        {
            return(this.ChangeTracker
                   .Entries <IEntity>()
                   .Where(x =>
                          x.Entity.GetType().IsTypeOf(typeof(IEntityIdentity <>)) &&
                          x.Entity.GetType().GetCustomAttributes <PublishAttribute>().Any() &&
                          x.State is EntityState.Added or EntityState.Deleted)
                   .Select(x =>
            {
                var type = x.Entity.GetType();
                var state = x.State.ToString();
                var name = type.Name.Replace("Proxy", string.Empty);

                return x.Entity switch
                {
                    IEntityIdentity <int> @int => new EntityEvent(@int.Id, name, state),
                    IEntityIdentity <long> @long => new EntityEvent(@long.Id, name, state),
                    IEntityIdentity <string> @string => new EntityEvent(@string.Id, name, state),
                    IEntityIdentity <Guid> guid => new EntityEvent(guid.Id, name, state),
                    IEntityIdentity <dynamic> dynamic => new EntityEvent(dynamic.Id, name, state),
                    _ => null
                };
            })
                   .Where(x => x != null)
                   .ToList());
        }
        public async Task DeleteOrder(IEntityIdentity identity)
        {
            if (identity == null)
            {
                throw new ArgumentNullException(nameof(identity));
            }

            await DataAccess.Delete(identity);
        }
        public virtual void Save(IEntityRequestContext context, IEntityIdentity entity)
        {
            using (Logger.CreateTrace(LoggingBoundaries.ServiceBoundary, typeof(EntityBusinessFacade <T>), "Save"))
            {
                var first = context.Operations.Count == 0;

                try
                {
                    var before = _repository.Get(context, entity as T);

                    if (before == null)
                    {
                        if (!context.IgnoreHandlers.HasFlag(EntityEventType.AddBefore) && !_handlers.OnAddBefore(context, entity))
                        {
                            throw new Exception("OnAddBefore handler rejected");
                        }

                        _repository.Add(context, entity as T);

                        if (!context.IgnoreHandlers.HasFlag(EntityEventType.AddAfter) && !_handlers.OnAddAfter(context, entity))
                        {
                            throw new Exception("OnAddAfter handler rejected");
                        }
                    }
                    else
                    {
                        if (!context.IgnoreHandlers.HasFlag(EntityEventType.ModifyBefore) && !_handlers.OnModifyBefore(context, before, entity))
                        {
                            throw new Exception("OnModifyBefore handler rejected");
                        }

                        _repository.Modify(context, before, entity as T);

                        if (!context.IgnoreHandlers.HasFlag(EntityEventType.ModifyAfter) && !_handlers.OnModifyAfter(context, before, entity))
                        {
                            throw new Exception("OnModifyAfter handler rejected");
                        }
                    }
                }
                catch (Exception ex)
                {
                    context.Rollback();
                    if (Logger.HandleException(LoggingBoundaries.ServiceBoundary, ex))
                    {
                        throw;
                    }
                }
                finally
                {
                    if (first)
                    {
                        context.Commit();
                    }
                }
            }
        }
示例#6
0
        private void OnTriggerEnter(Collider other)
        {
            IEntityIdentity identity = other.GetComponent <IEntityIdentity>();

            if (!PlayerCollection.ContainsId(identity.EntityId))
            {
                throw new InvalidOperationException($"Unknown Entity: {identity.EntityId} entered trigger.");
            }

            OnPlayerEnter(PlayerCollection[identity.EntityId]);
        }
示例#7
0
        public async Task Delete(IEntityIdentity id)
        {
            var result =
                await Context.Clients.FirstOrDefaultAsync(client => client.Id == id.Id);

            if (result != null)
            {
                Context.Clients.Remove(result);
                await Context.SaveChangesAsync();
            }
        }
示例#8
0
 public async Task <Client> Get(IEntityIdentity id)
 {
     if (id.Id.HasValue)
     {
         return(Mapper.Map <Client>(await Context.Clients.FirstOrDefaultAsync(client => client.Id == id.Id)));
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
示例#9
0
        public UserProjection Get(IEntityIdentity <Guid> id)
        {
            var user = _context.Users.FindById(id.Identity);

            if (user == null)
            {
                return(UserProjection.Empty());
            }

            return(user);
        }
 public async Task <Order> Get(IEntityIdentity identity)
 {
     if (identity.Id.HasValue)
     {
         return(Mapper.Map <Order>(await Context.Orders.FirstOrDefaultAsync(order => order.Id == identity.Id)));
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
        public async Task Delete(IEntityIdentity identity)
        {
            var result =
                await Context.Orders.FirstOrDefaultAsync(order => order.Id == identity.Id);

            if (result != null)
            {
                Context.Orders.Remove(result);
                await Context.SaveChangesAsync();
            }
        }
示例#12
0
        private void OnTriggerExit(Collider other)
        {
            IEntityIdentity identity = other.GetComponent <IEntityIdentity>();

            if (!PlayerCollection.ContainsId(identity.EntityId))
            {
                return;
            }

            OnPlayerExit(PlayerCollection[identity.EntityId]);
        }
        private bool isLocalPlayer(GameObject obj)
        {
            //We need to know who is entering
            IEntityIdentity identity = obj.GetComponent <IEntityIdentity>();

            //If it's not the local player's id we should not do anything
            if (identity == null || SlotModel.SlotSelected != identity.EntityId)
            {
                return(false);
            }

            return(true);
        }
示例#14
0
        public User Get(IEntityIdentity <EntityId> id)
        {
            var user = DbContext.Users.AsNoTracking()
                       .OrderByDescending(ob => ob.Id)
                       .ThenByDescending(ob => ob.RowVersion)
                       .FirstOrDefault(t => t.Id.Equals(id.Identity.Value));

            if (user == null)
            {
                return(User.Empty());
            }

            return(user.ToUser());
        }
示例#15
0
        public async Task <Order> GetOrder(IEntityIdentity identity)
        {
            if (identity == null)
            {
                throw new ArgumentNullException(nameof(identity));
            }

            var result = await DataAccess.Get(identity);

            if (result == null)
            {
                throw new InvalidOperationException($"Not find by id: {identity.Id}");
            }

            return(result);
        }
示例#16
0
 public Emp FindById(IEntityIdentity <Guid> identity)
 {
     return(FindById(identity.Id));
 }
示例#17
0
 public Emp GetById(IEntityIdentity <Guid> identity)
 {
     return(FindById(identity.Id) ?? throw new EntityNotFoundException(identity));
 }
 public TestIdentity(IEntityIdentity identity) : base(identity)
 {
 }
示例#19
0
 public void Delete(IEntityIdentity <Guid> identity)
 {
     Delete(identity.Id);
 }
示例#20
0
        public static IDBConnection GetConnection(string dbCode, EntityOperationType type, IEntityIdentity before, IEntityIdentity after, IEntityRequestContext context)
        {
            dbCode = DataConfig.Current.GetConnectionName(dbCode);

            IDBConnection connection = null;

            foreach (var operation in context.Operations)
            {
                var sqlOperation = operation as SqlOperation;
                if (sqlOperation == null)
                {
                    continue;
                }
                if (sqlOperation.DbCode == dbCode)
                {
                    connection = sqlOperation.Connection;
                }
            }

            if (connection == null && context.Who != null)
            {
                connection = DatabaseFactory.CreateDatabase(dbCode).AddClaimsDefaults(context.Who);
            }
            if (connection == null)
            {
                connection = DatabaseFactory.CreateDatabase(dbCode);
            }

            if (type != EntityOperationType.Get)
            {
                if (!connection.IsInTransaction)
                {
                    connection.BeginTrans();
                }

                context.Operations.Add(new SqlOperation
                {
                    DbCode     = dbCode,
                    Type       = type,
                    Before     = before,
                    After      = after,
                    Connection = connection
                });
            }

            return(connection);
        }
 /// <inheritdoc />
 protected StringEntityIdentity(IEntityIdentity identity) : base(identity)
 {
 }
 public static bool HasIdentity(this IEntityIdentity entity)
 {
     return(!((entity == null) || entity is NullEntity || string.IsNullOrEmpty(entity.Id)));
 }
示例#23
0
 public TodoTaskId(IEntityIdentity identity) : base(identity)
 {
 }
示例#24
0
 public ProjectId(IEntityIdentity identity) : base(identity)
 {
 }
示例#25
0
 public UserId(IEntityIdentity identity) : base(identity)
 {
 }
示例#26
0
        private void ProcessRequests(List <JObject> list, Dictionary <string, string> identities, EntityRequestContext context, List <object> result, IEntityIdentity parent)
        {
            foreach (var obj in list)
            {
                string module = null;
                if (obj.Property("_schema") != null)
                {
                    obj["_module"] = obj["_schema"].Value <string>();
                }
                if (obj.Property("_module") != null)
                {
                    module = obj["_module"].Value <string>();
                }

                if (string.IsNullOrEmpty(module))
                {
                    throw new Exception($"Missing _module on posted object {obj}");
                }
                if (obj.Property("_action") == null)
                {
                    throw new Exception($"Missing _action on posted object {obj}");
                }
                if (obj.Property("_entity") == null)
                {
                    throw new Exception($"Missing _entity name on posted object {obj}");
                }

                var action = obj["_action"].Value <string>();
                if (action == "modify")
                {
                    action = "save";
                }
                if (action == "add")
                {
                    action = "add";
                }

                var entity   = obj["_entity"].Value <string>();
                var identity = string.Empty;
                if (obj.Property("_identity") != null)
                {
                    identity = obj["_identity"].Value <string>();
                    obj.Remove("_identity");
                }

                List <JObject> children = null;
                if (obj.Property("_children") != null)
                {
                    children = obj["_children"].Value <List <JObject> >();
                    obj.Remove("_children");
                }

                var item = _factory.CreateNew(module, entity);

                if (parent != null)
                {
                    var info = EntityInfoManager.GetInfo(item);
                    if (string.IsNullOrEmpty(info.RelatedKeyName))
                    {
                        throw new Exception($"Missing RelatedKeyName is not configured not sure what property to set on child object {obj}");
                    }

                    obj[info.RelatedKeyName] = parent._key;
                }

                var replace = (from prop in obj.Properties() where prop.Value.ToString().StartsWith("{{") select prop.Name).ToList();
                foreach (var prop in replace)
                {
                    var val = obj[prop].Value <string>().ToLower();
                    if (val.StartsWith("{{") && val.EndsWith("}}"))
                    {
                        val = val.Replace("{{", "");
                        val = val.Replace("}}", "");
                        if (identities.ContainsKey(val))
                        {
                            obj[prop] = new JValue(identities[val]);
                        }
                    }
                }

                try
                {
                    var facade = _factory.CreateFacade(item);

                    switch (action.ToLowerInvariant())
                    {
                    case "remove":
                        JsonConvert.PopulateObject(obj.ToString(), item);
                        facade.Remove(context, item);

                        result.Add(item);
                        break;

                    case "save":

                        JsonConvert.PopulateObject(obj.ToString(), item);
                        facade.Save(context, item);
                        if (!string.IsNullOrEmpty(identity))
                        {
                            identities[identity.ToLower()] = item._key;
                        }

                        result.Add(item);
                        break;
                    }

                    if (children != null)
                    {
                        ProcessRequests(children, identities, context, result, item);
                    }
                }
                catch (Exception ex)
                {
                    Logger.HandleException(LoggingBoundaries.ServiceBoundary, ex);
                    context.Rollback();
                    throw;
                }
            }
        }
 public EntityNotFoundException(IEntityIdentity identity, string message, Exception inner)
     : base($"Entity with id '{identity.HumanReadableId}' could not be found. {message}", inner)
 {
 }
 public EntityNotFoundException(IEntityIdentity identity)
     : base($"Entity with id '{identity.HumanReadableId}' could not be found.")
 {
 }
 public virtual T Get(ClaimsPrincipal who, IEntityIdentity entity)
 {
     return(Get(new EntityRequestContext {
         Who = who
     }, entity));
 }
 public virtual void Remove(ClaimsPrincipal who, IEntityIdentity entity)
 {
     Remove(new EntityRequestContext {
         Who = who
     }, entity);
 }