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)
{
}
