/// <summary> /// Initiates a new AnnotatedChildEntity instance that uses the provided {@code entityModel} to delegate command /// and event handling to an annotated child entity. /// </summary> /// <param name="entityModel">A {@link EntityModel} describing the entity.</param> /// <param name="forwardCommands">Flag indicating whether commands should be forwarded to the entity.</param> /// <param name="commandTargetResolver">Resolver for command handler methods on the target.</param> /// <param name="eventTargetResolver">Resolver for event handler methods on the target.</param> public AnnotatedChildEntity( IEntityModel <TChild> entityModel, bool forwardCommands, Func <ICommandMessage <object>, TParent, TChild> commandTargetResolver, Func <IEventMessage <object>, TParent, List <TChild> > eventTargetResolver ) { _entityModel = entityModel; _eventTargetResolver = eventTargetResolver; _commandHandlers = new List <IMessageHandlingMember <TParent> >(); if (forwardCommands) { var messageHandlingMembers = entityModel.CommandHandlers <TChild>() .Where(eh => eh.Unwrap <ICommandMessageHandlingMember <TParent> >() != null); foreach (var childHandler in messageHandlingMembers) { _commandHandlers .Add(new ChildForwardingCommandMessageHandlingMember <TParent, TChild>( entityModel.CommandHandlerInterceptors <TChild>(), childHandler, commandTargetResolver ) ); } } }
public MarketController(IEntityModel <MarketPriceModel> marketPrices, IEntityModel <MarketOrderModel> marketOrders, IEntityModel <MarketHistoryModel> marketHistory, IEntityModel <CharacterOrdersModel> marketCharacterOrders) { _marketPrices = marketPrices; _marketOrders = marketOrders; _marketHistory = marketHistory; _marketCharacterOrders = marketCharacterOrders; }
private void ExecuteAction(IEntityModel model, EActionCondition action) { switch (action) { case EActionCondition.COLLECT: Debug.Log("COLLECT"); model.Collect(); break; case EActionCondition.SCAN: Debug.Log("SCAN"); model.Scan(); break; case EActionCondition.FIND_NEW_PATH: model.MoveTo(_currentPath[0]); Debug.Log("FIND_NEW_PATH"); break; case EActionCondition.MOVE_FORWARD: Debug.Log("MOVE_FORWARD"); model.MoveForward(); break; case EActionCondition.BACK_TO_BASE: Debug.Log("BACK_TO_BASE"); break; default: break; } }
public int Update(IEntityModel entity) { var columns = entity.Columns.Where(x => x != entity.PrivateKey); StringBuilder sql = new StringBuilder(); sql.AppendFormat("UPDATE {0}", entity.TableName); sql.AppendFormat(" SET {0}", string.Join(" , ", columns.Select(x => x + " = ?"))); sql.AppendFormat(" WHERE {0} = ?", entity.PrivateKey); SQLiteCommand cmd = _conn.Command as SQLiteCommand; cmd.CommandText = sql.ToString(); cmd.Parameters.Clear(); object[] values = entity.GetRow(); for (int i = 0; i < values.Length; i++) { var param = cmd.CreateParameter(); param.Value = values[i]; cmd.Parameters.Add(param); } var keyparam = cmd.Parameters[0]; cmd.Parameters.Add(keyparam); cmd.Parameters.RemoveAt(0); return(cmd.ExecuteNonQuery()); }
/// <summary> /// Creates a new controller of tasks. /// </summary> /// <param name="model"></param> /// <param name="baseFolderPath">The base folder path to put task folders.</param> /// <param name="taskFolderNameFormatString"></param> /// <param name="taskFolderNameWildcardPattern"></param> public AppTaskController(IEntityModel model , string baseFolderPath , string taskFolderNameFormatString = "taskdir.{0:D7}" , string taskFolderNameWildcardPattern = "taskdir.*" ) { if (model == null) { throw new ArgumentNullException("model"); } if (String.IsNullOrEmpty(baseFolderPath)) { throw new ArgumentNullException("model"); } if (String.IsNullOrEmpty(taskFolderNameFormatString)) { throw new ArgumentNullException("taskFolderNameFormatString"); } if (String.IsNullOrEmpty(taskFolderNameWildcardPattern)) { throw new ArgumentNullException("taskFolderNameWildcardPattern"); } MaxConcurrentTasks = 1; // Default to sequential execution _model = model; BaseFolderPath = baseFolderPath; TaskFolderNameFormatString = taskFolderNameFormatString; TaskFolderNameWildcardPattern = taskFolderNameWildcardPattern; }
public void Initialize(PropertyInfo property, IEntityModel childEntity) { _childEntity = childEntity; _routingKey = AnnotationUtils.FindAnnotationAttributes(property, typeof(AggregateMemberAttribute)) .Map(map => (string)map.GetValueOrDefault("routingKey")) .Filter(key => !string.IsNullOrEmpty(key)) .OrElse(childEntity.RoutingKey); }
static ResolveResult GetResolveResultFromEntityModel(IEntityModel entityModel) { IEntity entity = entityModel.Resolve(); if (entity is IMember) return new MemberResolveResult(null, (IMember) entity); if (entity is ITypeDefinition) return new TypeResolveResult((ITypeDefinition) entity); return ErrorResolveResult.UnknownError; }
static ResolveResult GetResolveResultFromEntityModel(IEntityModel entityModel) { IEntity entity = entityModel.Resolve(); if (entity is IMember) return new MemberResolveResult(null, (IMember) entity); if (entity is ITypeDefinition) return new TypeResolveResult((ITypeDefinition) entity); return ErrorResolveResult.UnknownError; }
public IResponseViewModel Convert(IEntityModel model) { var modelType = model.GetType(); if (!Cache.ContainsKey(modelType)) { Cache.Add(modelType, CreateFunc(modelType)); } return((IResponseViewModel)Cache[modelType](model)); }
protected override IEntityModel ExtractChildEntityModel(IEntityModel declaringEntity, IDictionary <string, object> attributes, PropertyInfo field) { var entityType = attributes.GetValueOrDefault("type") as Type; if (entityType == null) { entityType = field.ResolveGenericType(1).OrElseThrow( () => new AxonConfigurationException($"Unable to resolve entity type of field {field.Name}. Please provide type explicitly in @AggregateMember annotation.")); } return(declaringEntity.ModelOf(entityType)); }
public EntityBuilderBase(IEntityModel model) { if (model == null) { throw new ArgumentNullException(); } Model = model; _entityByXName = new Dictionary <XName, Func <XElement, EntityBase> >(); OnRegisterKnownEntities(); }
public EntityListViewModel(IEntityModel entityModel) : base() { _entityModel = entityModel; NewEntityCommand = new RelayCommand(() => { Messenger.Default.Send<WindowNavigationArgs>(new WindowNavigationArgs() { WindowName = "EditEntity", Parameter = null }); }); }
public EntityListViewModel(IEntityModel entityModel) : base() { _entityModel = entityModel; NewEntityCommand = new RelayCommand(() => { Messenger.Default.Send <WindowNavigationArgs>(new WindowNavigationArgs() { WindowName = "EditEntity", Parameter = null }); }); }
public IEntityController GetController(IEntityModel model) { if (model == null) { return(null); } if (!_map.ContainsKey(model)) { return(null); } return(_map[model]); }
public AnnotatedChildEntity(IEntityModel entityModel, bool forwardCommands, Func <ICommandMessage, object, object> commandTargetResolver, Func <IEventMessage, object, IEnumerable <object> > eventTargetResolver) { _entityModel = entityModel; _eventTargetResolver = eventTargetResolver; _commandHandlers = new Dictionary <string, IMessageHandlingMember>(); if (forwardCommands) { _entityModel.CommandHandlers.ForEach(kv => _commandHandlers.Add(kv.Key, new ChildForwardingCommandMessageHandlingMember(entityModel.CommandHandlerInterceptors, kv.Value, commandTargetResolver))); } }
private IProperty <Object> ExtractCommandHandlerRoutingKey(IEntityModel childEntityModel, ICommandMessageHandlingMember commandHandler, PropertyInfo field) { var routingKey = commandHandler.RoutingKey.GetOrDefault(childEntityModel.RoutingKey); var property = GetProperty <object>(commandHandler.PayloadType, routingKey); if (property == null) { throw new AxonConfigurationException( $"Command of type {commandHandler.PayloadType} doesn't have a property matching the routing key {routingKey} necessary to route through field {field}"); } return(property); }
public EditEntityViewModel(IEntityModel entityModel) : base() { _entityModel = entityModel; SaveEntityCommand = new RelayCommand(() => { //_entityModel.SaveEntity(this.Entity); Messenger.Default.Send <WindowNavigationArgs>(new WindowNavigationArgs() { WindowName = "EntitiesList", Parameter = null }); }); }
public EditEntityViewModel(IEntityModel entityModel) : base() { _entityModel = entityModel; SaveEntityCommand = new RelayCommand(() => { //_entityModel.SaveEntity(this.Entity); Messenger.Default.Send<WindowNavigationArgs>(new WindowNavigationArgs() { WindowName = "EntitiesList", Parameter = null }); }); }
public void EntityFired(IEntityModel model) { if (FieldModel.BonusEntities.Contains(model)) { FieldModel.BonusEntities.Remove(model); var entityController = MapperService.GetController(model); entityController.SetBonus(false); } if (isFiring) { return; } isFiring = true; var hasBonus = false; var bonusEntitiesSnapshot = FieldModel.BonusEntities.ToList(); foreach (var fieldModelBonusEntity in bonusEntitiesSnapshot) { var firedEntityPosition = FieldDimensionModel.GetFieldPositionFromWorld(model.WorldPosition); var position = FieldDimensionModel.GetFieldPositionFromWorld(fieldModelBonusEntity.WorldPosition); if ((position + new Vector2Int(0, 1)) != firedEntityPosition) { continue; } hasBonus = true; } if (hasBonus) { var bottomRow = FieldModel.GetRow(0).ToList(); MessageSender.Send(new ActivateBonusMessage { FiredEntitiesByBonus = bottomRow }); foreach (var fireEntity in bottomRow) { FieldController.FireEntity(fireEntity); } } isFiring = false; }
public void AssignEntityBonus(IEntityModel model) { if (FieldModel.BonusEntities.Contains(model)) { return; } FieldModel.BonusEntities.Add(model); var entityController = MapperService.GetController(model); entityController.SetBonus(true); MessageSender.Send(new AssignEntityBonusMessage { EntityModel = model }); }
public void FireEntity(IEntityModel entity) { var controller = EntityMapperService.GetController(entity); if (controller == null) { return; } controller.Fire(); MessageSender.Send(new EntityFireMessage { Entity = entity }); FieldModel.Entities.Remove(entity); EntityMapperService.Remove(entity); }
private IForwardingMode InstantiateForwardingMode(PropertyInfo field, IEntityModel childEntityModel, Type forwardingModeClass) { IForwardingMode forwardingMode; try { forwardingMode = (IForwardingMode)Activator.CreateInstance(forwardingModeClass); forwardingMode.Initialize(field, childEntityModel); } catch (Exception ex) when(ex is MissingMethodException) { throw new AxonConfigurationException($"Failed to instantiate ForwardingMode of type {forwardingModeClass}."); } return(forwardingMode); }
public IEntityModel[,] GenerateEntityMap() { var map = new IEntityModel[FieldDimension.Colls, FieldDimension.Rows]; var dimension = GetMapDimensions(map); foreach (var entityController in Entities) { var fieldPosition = FieldDimension.GetFieldPositionFromWorld(entityController.WorldPosition); if (!IsPointInField(fieldPosition, dimension)) { throw new Exception("Сущность находится вне игрового поля"); } map[fieldPosition.x, fieldPosition.y] = entityController; } return(map); }
private TypedRelations GetGenericRelations(RelationType relationType, Entity entity) { Expression <Func <Relation, bool> > relationSelector = r => r.SubjectiveEntityId == entity.Id; if (relationType.IsSymmetric) { relationSelector = r => r.SubjectiveEntityId == entity.Id || r.ObjectiveEntityId == entity.Id; } else if (relationType.IsInverse) { relationSelector = r => r.ObjectiveEntityId == entity.Id; } // The relationType.Id may be nagative in case of inverse relations, but it is positive in the database. IQueryable <Relation> relationsQuery = Db.Relations.Where(r => r.RelationTypeId == Math.Abs(relationType.Id)); relationsQuery = relationsQuery.Where(relationSelector); // Retrieve all the relations and store them into the helper structure. Dictionary <long, List <Relation> > relationsByRelatedEntityIds = new Dictionary <long, List <Relation> > (); foreach (Relation relation in relationsQuery) { long relatedEntityId = relation.SubjectiveEntityId == entity.Id ? relation.ObjectiveEntityId : relation.SubjectiveEntityId; if (!relationsByRelatedEntityIds.ContainsKey(relatedEntityId)) { relationsByRelatedEntityIds[relatedEntityId] = new List <Relation> (); } relationsByRelatedEntityIds[relatedEntityId].Add(relation); } TypedRelations genericRelations = new TypedRelations(relationType); IEntityModel entityModel = RemoteFacade.Instance.GetEntityModel(relationType.ObjectiveEntityType, Db); foreach (Entity relatedEntity in entityModel.GetEntitiesByIds(relationsByRelatedEntityIds.Keys)) { foreach (Relation relation in relationsByRelatedEntityIds[relatedEntity.Id]) { genericRelations.Relations[relation] = relatedEntity; } } return(genericRelations); }
public static string ToJson(this IEntityModel entity, JsonSerializerSettings settings = null, [CallerMemberName] string callername = "", [CallerFilePath] string filename = "") { #if DEBUG var str = JsonConvert.SerializeObject(entity, Formatting.Indented, settings); if (!string.IsNullOrEmpty(callername)) { Debug.WriteLine("{1} in {3}:{0}{2}", Environment.NewLine, callername, str, filename); } else { Debug.WriteLine(str); } #else var str = JsonConvert.SerializeObject(entity, settings); #endif return(str); }
public int Delete(IEntityModel entity) { StringBuilder sql = new StringBuilder(); sql.AppendFormat("DELETE FROM {0}", entity.TableName); sql.AppendFormat(" WHERE {0} = ?", entity.PrivateKey); SQLiteCommand cmd = _conn.Command as SQLiteCommand; cmd.CommandText = sql.ToString(); cmd.Parameters.Clear(); var param = cmd.CreateParameter(); param.Value = entity.Id.ToByteArray(); cmd.Parameters.Add(param); return(cmd.ExecuteNonQuery()); }
private void initTreeNode(Dictionary <int, BaseEntity> entitiesDictionary) { //Поиск родительской сущности, которая содержит остальные сущности геометрии foreach (var item in entitiesDictionary) { //В качестве родительской выбрана сущность ADVANCED_BREP_SHAPE_REPRESENTATION if (item.Value.Name.Equals(AdvancedBrepShapeRepresentation.NAME)) { //Если название такой сущности найдено, то от этого узла начинаем инициализировать все сущности mRootEntityABSR = new AdvancedBrepShapeRepresentation(); //Присвоение имени(title) сущности mRootEntityABSR.Name = item.Value.ParsedParams[0][0].value; //Инициализация вложенных параметров mRootEntityABSR.Items = new List <RepresentationItem>(item.Value.ParsedParams[1].Count); //Инициализация корневого узла дерева mRootTreeNode = new TreeNode(mRootEntityABSR.StepName); //Инициализация узла списка вложенных параметров (сущностей) TreeNode paramsNode = new TreeNode("Items"); mRootTreeNode.Nodes.Add(paramsNode); if (mCallback != null) { mCallback.extractionStep(70); } //Примерное условное вычисление прогресса int step = 30 / entitiesDictionary.Count; progressStep = step < 30 ? step : entitiesDictionary.Count / 30; currentProgress = 70; //Запуск рекурсивной инициализации сущностей для каждого вложенного параметра родительской сущности foreach (var itemParam in item.Value.ParsedParams[1]) { IEntityModel param = parseItemParam(itemParam, entitiesDictionary, paramsNode); mRootEntityABSR.Items.Add((RepresentationItem)param); } } } }
public Optional <IChildEntity> CreateChildDefinition(PropertyInfo field, IEntityModel declaringEntity) { var attributes = FindAnnotationAttributes(field, typeof(AggregateMemberAttribute)).OrElse(null); if (attributes == null || !IsFieldTypeSupported(field)) { return(Optional <IChildEntity> .Empty); } var childEntityModel = ExtractChildEntityModel(declaringEntity, attributes, field); var eventForwardingMode = InstantiateForwardingMode( field, childEntityModel, (Type)attributes["eventForwardingMode"] ); return(Optional <IChildEntity> .Of(new AnnotatedChildEntity( childEntityModel, (bool)attributes["forwardCommands"], (msg, parent) => ResolveCommandTarget(msg, parent, field, childEntityModel), (msg, parent) => ResolveEventTargets(msg, parent, field, eventForwardingMode) ))); }
public IRelationalCommand Build <TEntity>(SqlStatementKind statementKind, IEntityModel model, TEntity entity, IEntityMapping entityMapping) { switch (statementKind) { case SqlStatementKind.CreateTable: ISqlStatementBuilder <CreateTableStatement> statementBuilder = new CreateTableStatementBuilder(model, entityMapping); ISqlStatement statement = statementBuilder.BuildStatement(); return(new RelationalCommand(statement.GetText(), null)); case SqlStatementKind.Insert: ISqlStatementBuilder <InsertStatement> insertStatementBuilder = new InsertStatementBuilder(entity, entityMapping); InsertStatement insertStatement = insertStatementBuilder.BuildStatement(); return(new RelationalCommand(insertStatement.GetText(), insertStatement.Parameters)); case SqlStatementKind.Update: ISqlStatementBuilder <UpdateStatement> updateStatementBuilder = new UpdateStatementBuilder(entity, entityMapping); UpdateStatement updateStatement = updateStatementBuilder.BuildStatement(); return(new RelationalCommand(updateStatement.GetText(), updateStatement.Parameters)); case SqlStatementKind.Delete: ISqlStatementBuilder <DeleteStatement> deleteStatementBuilder = new DeleteStatementBuilder(entity, entityMapping); DeleteStatement deleteStatement = deleteStatementBuilder.BuildStatement(); return(new RelationalCommand(deleteStatement.GetText(), deleteStatement.Parameters)); default: throw new NotImplementedException(); } }
public int Insert(IEntityModel entity) { StringBuilder sql = new StringBuilder(); sql.AppendFormat("INSERT INTO {0}", entity.TableName); sql.AppendFormat(" VALUES ( {0} )", string.Join(" , ", entity.Columns.Select(x => "?"))); SQLiteCommand cmd = _conn.Command as SQLiteCommand; cmd.CommandText = sql.ToString(); cmd.Parameters.Clear(); object[] values = entity.GetRow(); for (int i = 0; i < values.Length; i++) { var param = cmd.CreateParameter(); param.Value = values[i]; cmd.Parameters.Add(param); } return(cmd.ExecuteNonQuery()); }
public IEnumerable <Entity> GetRelatableEntities(long relationTypeId, Entity entity, string needle) { RelationType relationType = GetRelationType(relationTypeId, entity); if (relationType == null) { return(Enumerable.Empty <Entity> ()); } // Reflexive relations aren't supported so the entity id is initially added to the unrelatable entity ids. List <long> unrelatableEntityIds = new List <long> (new long[] { entity.Id }); PredefinedRelationType predefinedRelationType = relationType as PredefinedRelationType; if (predefinedRelationType != null) { unrelatableEntityIds.AddRange(predefinedRelationType.GetRelatedEntities(entity).Select <Entity, long> (e => e.Id)); } // Return the entities that are not unrelatable. IEntityModel entityModel = RemoteFacade.Instance.GetEntityModel(relationType.ObjectiveEntityType, Db); return(entityModel.GetEntitiesByIdsAndNeedle(unrelatableEntityIds, needle)); }
/// <summary> /// Конструктор класса AddDepartmentViewModel. /// </summary> /// <param name="departmentModel">Модель Отделение</param> public AddDepartmentViewModel(IEntityModel departmentModel) { deptModel = departmentModel; insertCommand = new InsertCommand(this); }
public int Delete(IEntityModel entity) { return(_conn.Delete(entity)); }
protected CodeElementsList<CodeAttribute2> GetAttributes(IEntityModel entityModel) { var list = new CodeElementsList<CodeAttribute2>(); var td = entityModel.Resolve(); if (td != null) { foreach (var attr in td.Attributes) { if (IsInFilter(attr.Region)) list.Add(new CodeAttribute2(context, attr)); } } return list; }
internal static ProjectItem FindByEntity(IProject project, IEntityModel entity) { throw new NotImplementedException(); }