public IEnumerable <TResult> Select <TResult>(Func <TEntity, TResult> selector, IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, IEntityLoader <TEntity> loader = null) { return(List(filter, sorter, null, null, loader).Select(selector)); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="entityLoader">Loader.</param> /// <param name="queryable">Consulta que será realizado.</param> /// <param name="sourceContext">Contexto de origem dos dados.</param> /// <param name="uiContext">Contexto de interface com o usuário.</param> public GetEntityDescriptorsEnumerable(IEntityLoader entityLoader, Query.Queryable queryable, Colosoft.Query.ISourceContext sourceContext, string uiContext) { _entityLoader = entityLoader; _queryable = queryable; _sourceContext = sourceContext; _uiContext = uiContext; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object" /> class. /// </summary> public EntitiesManager() { _entityLoader = MSSQLManager<TableContent, ColumnContent>.Instance.GetEntityLoader( new EntityExtractor(), new EntityPropertyExtractor(), new EntityRelationshipExtractor()); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object" /> class. /// </summary> public EntitiesManager() { _entityLoader = MSSQLManager <TableContent, ColumnContent> .Instance.GetEntityLoader( new EntityExtractor(), new EntityPropertyExtractor(), new EntityRelationshipExtractor()); }
public EntityManager(IEntityRecycler entityRecycler, IEntityLoader entityLoader, IEntityRepository entityRepository, IEntityFactory entityFactory) { _loader = (EntityLoader)entityLoader; _recycler = (EntityRecycler)entityRecycler; _repository = entityRepository; _factory = (EntityFactory)entityFactory; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="enumerable">Instancia do Enumerable que será adaptada.</param> /// <param name="childInfo"></param> /// <param name="childLoader">Loader da entidade do filho.</param> /// <param name="entityTypeManager">Instancia do gerenciador dos tipos de entidades.</param> /// <param name="sourceContext">Instancia do contexto de origem.</param> /// <param name="uiContext">Contexto de interface com o usuário.</param> public EntityChildEnumerable(IEnumerable <IEntity> enumerable, IEntityLoaderChildInfo childInfo, IEntityLoader childLoader, IEntityTypeManager entityTypeManager, Query.ISourceContext sourceContext, string uiContext) : base(enumerable, null, null) { _childInfo = childInfo; _childLoader = childLoader; _entityTypeManager = entityTypeManager; _sourceContext = sourceContext; _uiContext = uiContext; }
public Tracker(IEntityLoader <T> entityLoader) { this.Added = new List <T>(); this.Updated = new List <T>(); this.Deleted = new List <T>(); this.cachedEntities = new Dictionary <int, T>(); this.entityLoader = entityLoader; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="queryable">Consulta associada.</param> /// <param name="entityLoader"></param> /// <param name="uiContext"></param> /// <param name="entityTypeManager"></param> /// <param name="parentResult"></param> /// <param name="exceptions"></param> public PrepareNestedQueriesResult(Query.Queryable queryable, IEntityLoader entityLoader, string uiContext, IEntityTypeManager entityTypeManager, IList <EntityLoaderCreatorArgs> parentResult, Queue <Exception> exceptions) { _queryable = queryable; _entityLoader = entityLoader; _uiContext = uiContext; _entityTypeManager = entityTypeManager; _parentResult = parentResult; _exceptions = exceptions; }
public TEntity Single(IEntityFilter <TEntity> filter = null, IEntityLoader <TEntity> loader = null) { var entities = (filter ?? EntityFilter <TEntity> .AsQueryable()).Filter(Entities); if (loader != null) { return(loader.Single(entities)); } return(entities.Single()); }
/// <summary> /// Verifica se o tipo informado possui chaves. /// </summary> /// <param name="type"></param> /// <returns></returns> public bool HasKeys(Type type) { IEntityLoader loader = null; if (TryGetLoader(type, out loader)) { return(loader.HasKeys); } return(false); }
protected void RegisterEntityEvents(IEntityLoader item) { item.OnEntityDeleted += EntityDeleted; item.OnEntityGenerated += EntityGenerated; item.OnEntityLoaded += EntityLoaded; item.OnEntityUpdated += EntityUpdated; item.OnEntitiesUnavailable += EntitiesUnavailable; EntityProviders.Add(item); }
/// <summary> /// Recupera o loader para o tipo informado. /// </summary> /// <param name="type"></param> /// <returns></returns> public IEntityLoader GetLoader(Type type) { IEntityLoader loader = null; if (!TryGetLoader(type, out loader)) { throw new LoaderNotFoundException(string.Format("Not found loader for type '{0}'", type.FullName)); } return(loader); }
/// <summary> /// Libera a instancia. /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { if (_entityLoader != null && Colosoft.Query.RecordObserverManager.Instance.IsEnabled) { Colosoft.Query.RecordObserverManager.Instance.Unregister(_entityLoader.DataModelTypeName, this); } _entityLoader = null; _sourceContext = null; _isDisposed = false; }
/// <summary> /// Cria a instancia com o suporte para estratégia de vinculação. /// </summary> /// <param name="entityTypeManager">Gerenciador dos tipos de entidades.</param> /// <param name="entityLoader">Loader da entidade.</param> /// <param name="queryable"></param> /// <param name="countExpression"></param> /// <param name="isLazy">Identifica se é para fazer uma carga tardia.</param> /// <param name="castHandler">Instancia do manipulador que vai realizar o cast do item do resultado.</param> /// <param name="uiContext">Contexto de interface com o usuário.</param> public QueryableEntityVirtualListLoader(IEntityTypeManager entityTypeManager, IEntityLoader entityLoader, Colosoft.Query.Queryable queryable, string countExpression, bool isLazy, Func <object, TEntity> castHandler, string uiContext) { _entityTypeManager = entityTypeManager; _entityLoader = entityLoader; _queryable = queryable; _countExpression = countExpression; _isLazy = isLazy; _uiContext = uiContext; _castHandler = castHandler; }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object"/> class. /// </summary> public ScreenWorld(IScreenLoader screenLoader, ITileLoader tileLoader, IEntityLoader entityLoader, EventRunner eventRunner) : base(screenLoader) { this.tileLoader = tileLoader; this.entityLoader = entityLoader; this.eventRunner = eventRunner; worldObjects = new List <WorldObject>(); eventSwitchHandler = new EventSwitchHandler(); eventSwitchHandler.AddEventSwitch(new EventSwitch { Id = 1, Name = "Test", On = false }); }
/// <summary> /// Cria a consulta para recuperar os itens filhos. /// </summary> /// <param name="parentUid">Identificador da entidade pai.</param> /// <param name="parentLoader">Loader do pai.</param> /// <param name="parentDataModel">Instancia com os dados do pai.</param> /// <param name="sourceContext">Contexto de origem.</param> /// <returns></returns> internal EntityInfoQuery CreateQuery(int parentUid, IEntityLoader parentLoader, Colosoft.Data.IModel parentDataModel, Colosoft.Query.ISourceContext sourceContext) { var query = sourceContext.CreateQuery().From(new Query.EntityInfo(DataModelType.FullName)); if (ExecutePredicate != null) { query.ExecutePredicate = (Colosoft.Query.QueryExecutePredicate)ExecutePredicate.Clone(); } string conditionalExpression = null; if (parentLoader.HasUid) { query.Add("?parentUid", parentUid); conditionalExpression = string.Format("{0} == ?parentUid", _foreignPropertyName); } if (Conditional != null) { if (parentLoader.HasUid) { conditionalExpression = string.Format("{0} && ({1})", conditionalExpression, this.Conditional.Expression); } else { conditionalExpression = this.Conditional.Expression; } foreach (var i in this.Conditional.Parameters) { if (i.Value is Query.ReferenceParameter) { var reference = (Query.ReferenceParameter)i.Value; var property = parentDataModel.GetType().GetProperty(reference.ColumnName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); if (property == null) { throw new Exception(string.Format("Property {0} not found in type {1}", reference.ColumnName, parentDataModel.GetType().FullName)); } try { var value = property.GetValue(parentDataModel, null); query.Add(i.Name, value); } catch (System.Reflection.TargetInvocationException ex) { throw ex.InnerException; } } else { query.Add(i.Name, i.Value); } } } query.Where(conditionalExpression); return(new EntityInfoQuery(DataModelType, EntityType, query)); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="name">Nome do filho.</param> /// <param name="propertyName">Nome da propriedade do filho na entidade.</param> /// <param name="dynamicChild">Dados do filho dinamico.</param> /// <param name="parentUidSetter"></param> /// <param name="parentValueGetter"></param> /// <param name="parentValueSetter"></param> /// <param name="isSingle"></param> /// <param name="parentLoader">Instancia do loader do pai.</param> /// <param name="options">Opções de carga.</param> public EntityLoaderDynamicChildInfo(string name, string propertyName, EntityDynamicChild dynamicChild, Func <IEntity, IEntity> parentValueGetter, Action <IEntity, IEntity> parentValueSetter, Action <IEntity, IEntity> parentUidSetter, bool isSingle, IEntityLoader parentLoader, LoadOptions options) { _name = name; _propertyName = propertyName; _dynamicChild = dynamicChild; _isSingle = isSingle; _parentUidSetter = parentUidSetter ?? SetParentUid; _parentValueGetter = parentValueGetter; _parentValueSetter = parentValueSetter; _parentLoader = parentLoader; _options = options; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="entityLoader">Instancia do loader da entidade associada.</param> /// <param name="entityTypeManager">Instancia do gerenciador dos tipos de entidades.</param> /// <param name="sourceContext">Contexto de origem.</param> /// <param name="uiContext">Contexto de interface com o usuário.</param> /// <param name="typeName">Nome do associado com o observer.</param> /// <param name="collection">Coleção que sera observada.</param> public BusinessQueryResultChangedObserver(IEntityLoader entityLoader, IEntityTypeManager entityTypeManager, Query.ISourceContext sourceContext, string uiContext, Colosoft.Reflection.TypeName typeName, System.Collections.IList collection) : base(collection) { _entityLoader = entityLoader; _entityTypeManager = entityTypeManager; _sourceContext = sourceContext; _uiContext = uiContext; _typeName = typeName; if (Colosoft.Query.RecordObserverManager.Instance.IsEnabled) { Colosoft.Query.RecordObserverManager.Instance.Register(_typeName, this); } }
public static IQueryable <Song> WhereHasArtistParticipationStatus(this IQueryable <Song> query, ArtistParticipationQueryParams queryParams, IEntityLoader <Artist> artistGetter) { var various = Model.Helpers.ArtistHelper.VariousArtists; var producerRoles = ArtistRoles.Composer | ArtistRoles.Arranger; var artistId = queryParams.ArtistIds.Primary; return(EntryWithArtistsQueryableExtender.WhereHasArtistParticipationStatus(new ArtistParticipationQueryParams <Song, ArtistForSong>(query, queryParams, artistGetter, al => al.AllArtists.Any(a => a.Artist.Id == artistId && !a.IsSupport && ((a.Roles == ArtistRoles.Default) || ((a.Roles & producerRoles) != ArtistRoles.Default)) && a.Song.ArtistString.Default != various), al => al.AllArtists.Any(a => a.Artist.Id == artistId && (a.IsSupport || ((a.Roles != ArtistRoles.Default) && ((a.Roles & producerRoles) == ArtistRoles.Default)) || a.Song.ArtistString.Default == various)) ))); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="entityLoader"></param> /// <param name="sourceContext"></param> /// <param name="collection"></param> public EntityDescriptorQueryResultChangedObserver(IEntityLoader entityLoader, Query.ISourceContext sourceContext, System.Collections.IList collection) { entityLoader.Require("entityLoader").NotNull(); collection.Require("collection").NotNull(); _uid = Query.QueryResultChangedObserverUidGenerator.CreateUid(); _collectionReference = new WeakReference(collection); _entityLoader = entityLoader; _sourceContext = sourceContext; if (Colosoft.Query.RecordObserverManager.Instance.IsEnabled) { Colosoft.Query.RecordObserverManager.Instance.Register(_entityLoader.DataModelTypeName, this); } }
public IList <TEntity> List(IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, int?page = null, int?pageSize = null, IEntityLoader <TEntity> loader = null) { if ((page.HasValue || pageSize.HasValue) && sorter == null) { throw new ArgumentException("You have to define a sorting order if you specify a page or pageSize! (IEntitySorter was null)"); } if (page.HasValue && !pageSize.HasValue) { throw new ArgumentException("You have to define a pageSize if you specify a page!"); } var entities = Entities; if (filter != null) { entities = filter.Filter(entities); } if (sorter != null) { entities = sorter.Sort(entities); } if (page != null) { entities = entities.Skip(pageSize.Value * page.Value); } if (pageSize != null) { entities = entities.Take(pageSize.Value); } entities = entities.InterceptWith(new QueryableEntitiesVisitor()); if (loader != null) { return(loader.Load(entities)); } return(entities.ToList()); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="name">Nome do filho.</param> /// <param name="propertyName">Nome da propriedade do filho na entidade.</param> /// <param name="parentUidSetter">Delegate usado para define o identificador unico do pai.</param> /// <param name="parentUidGetter">Delegate usado para recupera o identificador unico do pai.</param> /// <param name="parentValueGetter">Delegate usado para recuperar o valor do pai.</param> /// <param name="parentValueSetter">Delegate usado para definir o valor do pai.</param> /// <param name="foreignProperty">Propriedade de associação.</param> /// <param name="parentLoader">Instancia do loader associado.</param> /// <param name="conditional">Condicional para ser usado na carga.</param> /// <param name="isSingle">Identifica que é um filho unico.</param> /// <param name="options">Opções de carga.</param> /// <param name="savePriority">Prioridade para salvar o filho.</param> protected EntityLoaderChildInfo(string name, string propertyName, Action <IEntity, IEntity> parentUidSetter, Func <Colosoft.Data.IModel, int> parentUidGetter, Func <IEntity, IEntity> parentValueGetter, Action <IEntity, IEntity> parentValueSetter, System.Reflection.PropertyInfo foreignProperty, ConditionalLoader conditional, IEntityLoader parentLoader, bool isSingle, LoadOptions options = LoadOptions.None, EntityChildSavePriority savePriority = EntityChildSavePriority.AfterEntity) { propertyName.Require("propertyName").NotNull().NotEmpty(); _name = name; _propertyName = propertyName; _parentLoader = parentLoader; _foreignPropertyName = foreignProperty.Name; _parentUidSetter = parentUidSetter; _parentUidGetter = parentUidGetter ?? _parentLoader.GetInstanceUid; _parentValueGetter = parentValueGetter; _parentValueSetter = parentValueSetter; _options = options; _parentUidSetter2 = (parent, child) => { if (_parentUidGetter == null) { throw new InvalidOperationException("ParentUidGetter undefined"); } foreignProperty.SetValue(child, _parentUidGetter(parent), null); }; _conditional = conditional; _isSingle = isSingle; _savePriority = savePriority; }
/// <summary> /// Recupera o loader para o tipo informado. /// </summary> /// <param name="type"></param> /// <param name="loader"></param> /// <returns></returns> public bool TryGetLoader(Type type, out IEntityLoader loader) { type.Require("type").NotNull(); var typeName = Colosoft.Reflection.TypeName.Get(type); lock (_entityLoaders) { if (!_entityLoaders.TryGetValue(typeName, out loader)) { var loaderAttribute = type.GetCustomAttributes(typeof(EntityLoaderAttribute), false).LastOrDefault() as EntityLoaderAttribute; if (loaderAttribute == null) { _entityLoaders.Add(typeName, null); } else { try { loader = (IEntityLoader)Activator.CreateInstance(loaderAttribute.EntityLoaderType); } catch (System.Reflection.TargetInvocationException ex) { throw ex.InnerException; } _entityLoaders.Add(typeName, loader); return(true); } } else { return(loader != null); } } loader = null; return(false); }
public GoalNonFulfillmentServiceController(IGoalNonFulfillmentPercentBS businessService , IEntityLoader <Goal> goalListLoader) { this.businessService = businessService; goalLoader = goalListLoader; }
public RuntimeFactory(System.Random random) : base(random) { this.entityLoader = new EntityLoader(); this.variables = new Dictionary <string, string>(); }
public RuntimeFactory(IEntityLoader entityLoader) : base(new System.Random()) { this.entityLoader = entityLoader; this.variables = new Dictionary <string, string>(); }
public TEntity FirstOrDefault(IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, IEntityLoader <TEntity> loader = null) { var entities = (filter ?? EntityFilter <TEntity> .AsQueryable()).Filter(Entities); if (loader != null) { return(loader.FirstOrDefault(entities)); } return(entities.FirstOrDefault()); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="childInfo"></param> /// <param name="childLoader">Loader da entidade filha.</param> /// <param name="entityTypeManager">Instancia do gerenciador dos tipos e entidade.</param> /// <param name="sourceContext">Instancia do contexto de origem.</param> /// <param name="uiContext">Contexto da interface com o usuário.</param> /// <param name="typeName"></param> /// <param name="collection"></param> public EntityChildQueryResultChangedObserver(IEntityLoaderChildInfo childInfo, IEntityLoader childLoader, IEntityTypeManager entityTypeManager, Query.ISourceContext sourceContext, string uiContext, Colosoft.Reflection.TypeName typeName, System.Collections.IList collection) : base(childLoader, entityTypeManager, sourceContext, uiContext, typeName, collection) { _childInfo = childInfo; }
public CollectionEntityLoader([CanBeNull] IEntityLoader <TEntity> baseLoader, [NotNull] Expression <Func <TEntity, ICollection <TProperty> > > propertyExpression) { _propertyExpression = propertyExpression; _baseLoader = baseLoader; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="entityLoader">Instancia do loader da entidade.</param> public EntityDescriptorQueryResultBindStrategy(IEntityLoader entityLoader) { entityLoader.Require("entityLoader").NotNull(); _entityLoader = entityLoader; }
public QueryExecuter(IEntityLoader loader, IEntityFactory factory) { _Loader = loader; _Factory = factory; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="name">Nome do filho.</param> /// <param name="dynamicChild">Dados do filho dinamico.</param> /// <param name="parentProperty">Lambda da propriedade da entidade pai.</param> /// <param name="parentUidSetter"></param> /// <param name="isSingle"></param> /// <param name="parentLoader">Instancia do loader do pai.</param> /// <param name="options">Opções de carga.</param> public EntityLoaderDynamicChildInfo(string name, EntityDynamicChild dynamicChild, System.Linq.Expressions.Expression <Func <TParentEntity, IEntity> > parentProperty, Action <IEntity, IEntity> parentUidSetter, bool isSingle, IEntityLoader parentLoader, LoadOptions options) : base(name, parentProperty.GetMember().Name, dynamicChild, f => parentProperty.Compile()((TParentEntity)f), GetParentValueSetter(parentProperty), parentUidSetter, isSingle, parentLoader, options) { }