public RavenProjectionSubSystem(IEntityTypeManager entityTypeManager,
IEventMessageFactory eventMessageFactory, IServiceLocator serviceLocator,
IRavenCrudRepository repository) : base(entityTypeManager, eventMessageFactory)
{
this.serviceLocator = serviceLocator;
this.repository = repository;
}
/// <summary>
/// Recupera os dados que precisam ser serializados.
/// </summary>
/// <param name="entityTypeManager"></param>
/// <param name="entity"></param>
/// <returns></returns>
private static IEnumerable <KeyValuePair <string, object> > GetSerializeData(IEntityTypeManager entityTypeManager, IEntity entity)
{
entity.Require("entity").NotNull();
var type = entity.GetType();
var loader = entityTypeManager.GetLoader(type);
var children = loader.GetChildrenAccessors().Where(f => f is IEntityPropertyAccessor).Select(f => (IEntityPropertyAccessor)f).ToArray();
var links = loader.GetLinksAccessors().Where(f => f is IEntityPropertyAccessor).Select(f => (IEntityPropertyAccessor)f).ToArray();
var references = loader.GetReferences().Where(f => f is IEntityPropertyAccessor).Select(f => (IEntityPropertyAccessor)f).ToArray();
foreach (var prop in type.GetProperties())
{
if (prop.CanRead && prop.GetIndexParameters().Length == 0 && !prop.GetCustomAttributes(true).Any(f => f is System.Xml.Serialization.XmlIgnoreAttribute) && !children.Any(f => f.PropertyName == prop.Name) && !links.Any(f => f.PropertyName == prop.Name) && !references.Any(f => f.PropertyName == prop.Name))
{
object value = null;
try
{
value = prop.GetValue(entity, null);
}
catch (System.Reflection.TargetInvocationException ex)
{
throw ex.InnerException;
}
yield return(new KeyValuePair <string, object>(prop.Name, value));
}
}
foreach (var i in children.Concat(links).Concat(references))
{
yield return(new KeyValuePair <string, object>(i.PropertyName, i.Get(entity)));
}
}
public ActionResult Index(string appName)
{
IEntityTypeManager typeManager = DependencyResolver.Current.GetService <IEntityTypeManager>();
DbContext context = DependencyResolver.Current.GetService <DbContext>();
IEnumerable <Type> typesInApp = typeManager.GetTypesInNamespace(appName);
//var a = context.GetType().GetProperties().Select(pi => pi.PropertyType);
//var b = a.Where(t => t.IsGenericType && t.GetGenericTypeDefinition()==typeof(DbSet<>));
//var c = b.Select(t => t.GetGenericArguments().Single());
IEnumerable <Type> typesInContext = context.GetType().GetProperties().Select(pi => pi.PropertyType)
.Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(DbSet <>)).Select(t => t.GetGenericArguments().Single());
List <string> typeNames = typesInApp.Intersect(typesInContext).Select(t => t.Name).ToList();
if (typeNames == null || !typeNames.Any())
{
Redirection redirection = Redirection.OpenRedirection(HttpContext, "ApplicationNotFound", "Error", new RouteValueDictionary()
{
{ "appName", appName }
});
return(redirection.GetResult());
}
TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
ApplicationDetailsVM details = new ApplicationDetailsVM
{
AppName = ti.ToTitleCase(appName),
TypeNames = typeNames
};
return(View(details));
}
public CrudAggregateStoreTests()
{
crudRepository = new InMemoryCrudRepository();
entityTypeManager = Substitute.For <IEntityTypeManager>();
publishEventBuffer = Substitute.For <IPublishEventBuffer>();
domainClasses = new List <DomainClassInfo>()
{
new DomainClassInfo(TestAggregateClassId, null, typeof(TestAggregate))
};
entityTypeManager.GetClassInfoByClassId(Guid.Empty)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
entityTypeManager.TryGetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
entityTypeManager.GetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));
eventMessageFactory = Substitute.For <IEventMessageFactory>();
eventMessageFactory.CreateMessageAsync(null).ReturnsForAnyArgs(ci =>
{
var @event = ci.ArgAt <IEvent>(0);
Type messageType = typeof(EventMessageDraft <>).MakeGenericType(@event.GetType());
IEventMessageDraft messageDraft = (IEventMessageDraft)messageType.GetConstructor(new[] { @event.GetType() }).Invoke(new[] { @event });
messageDraft.SetMetadata("TestKey", "TestValue");
return(messageDraft);
}); // TODO something more lightweight?
sut = new CrudAggregateStore(crudRepository, entityTypeManager, publishEventBuffer, eventMessageFactory);
}
public EventSourcedAggregateFactoryTests()
{
eventStreamUpgrader = Substitute.For <IEventStreamUpgrader>();
eventStreamUpgrader.UpgradeStream(null, null).ReturnsForAnyArgs(ci =>
{
var stream = ci.Arg <IEnumerable <IEventMessage <DomainAggregateEvent> > >();
var aggregateMetadata = ci.Arg <IReadOnlyDictionary <string, string> >();
return(eventStreamUpgradeFunc(stream, aggregateMetadata));
});
DomainClassInfo[] domainClasses = new[]
{
new DomainClassInfo(entity1ClassId, null, typeof(MyEntity)),
new DomainClassInfo(entity2ClassId, null, typeof(MyEntity2))
};
entityTypeManager = Substitute.For <IEntityTypeManager>();
entityTypeManager.GetClassInfoByClassId(Guid.Empty)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.Id == ci.Arg <Guid>()));
entityTypeManager.TryGetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.SingleOrDefault(x => x.ClrType == ci.Arg <Type>()));
entityTypeManager.GetClassInfoByClrType(null)
.ReturnsForAnyArgs(ci => domainClasses.Single(x => x.ClrType == ci.Arg <Type>()));
sut = new EventSourcedAggregateFactory(eventStreamUpgrader, new EntityFactory(), entityTypeManager);
}
public MediaHelper(
CoreInDbContext dbContext,
ITaxonomyHelper taxonomyHelper,
IEntityHelper <FileEntity, FileEntityDetail> entityHelper,
IHostingEnvironment environment, IStringLocalizer <Language> stringLocalizer,
IEntityTypeManager entityTypeManager,
IEntityTaxonomyRelationHelper <FileEntityTaxonomy> entityTaxonomyRelationHelper,
IHttpContextAccessor context
)
{
_dbContext = dbContext;
_taxonomyHelper = taxonomyHelper;
_entityHelper = entityHelper;
_entityHelper.SetContext(_dbContext);
_entityTypeManager = entityTypeManager;
_environment = environment;
_stringLocalizer = stringLocalizer;
_entityTaxonomyRelationHelper = entityTaxonomyRelationHelper;
_context = context;
}
public CrudAggregateStoreFactory(Func <ICrudRepository> crudRepositoryFunc,
IEntityTypeManager entityTypeManager, IEventMessageFactory eventMessageFactory)
{
this.crudRepositoryFunc = crudRepositoryFunc;
this.entityTypeManager = entityTypeManager;
this.eventMessageFactory = eventMessageFactory;
}
public EFCoreCrudAggregateStore(ICrudRepository crudRepository, IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer, IEventMessageFactory eventMessageFactory,
IEFCoreTransactionCoordinator transactionCoordinator)
: base(crudRepository, entityTypeManager, publishEventBuffer, eventMessageFactory)
{
this.transactionCoordinator = transactionCoordinator;
transactionCoordinator.AddTransactionParticipant(this);
}
/// <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>
/// <param name="entityTypeManager">Gerenciador dos tipos de entidas.</param>
/// <returns></returns>
public GetEntitiesEnumerable(EntityLoader <TEntity1, Model> entityLoader, Query.Queryable queryable, Colosoft.Query.ISourceContext sourceContext, string uiContext, IEntityTypeManager entityTypeManager)
{
_entityLoader = entityLoader;
_queryable = queryable;
_sourceContext = sourceContext;
_uiContext = uiContext;
_entityTypeManager = entityTypeManager;
}
/// <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;
}
/// <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 EventSourcedAggregateRepository(IEventStore eventStore,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory,
IEntityFactory entityFactory)
: base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory)
{
}
public EntityTypeManager(IEntityTypeManager entityTypeManager, UserManager <User> userManager)
{
var upperUser = userManager.FindByNameAsync(AppKey.SupperAdminUserName).Result;
Project = entityTypeManager.RegisterEntityType(
new EntityType {
Name = "project"
},
new EntityTypeDetail[] {
new EntityTypeDetail {
Field = "title", Value = "Project", Language = "en-US"
},
new EntityTypeDetail {
Field = "title", Value = "Dự Án", Language = "vi-VN"
}
}, upperUser, false);
Construction = entityTypeManager.RegisterEntityType(
new EntityType {
Name = "construction"
},
new EntityTypeDetail[] {
new EntityTypeDetail {
Field = "title", Value = "Construction", Language = "en-US"
},
new EntityTypeDetail {
Field = "title", Value = "Công trình", Language = "vi-VN"
},
new EntityTypeDetail {
Field = "group", Value = "Construction", Language = "en-US"
},
new EntityTypeDetail {
Field = "group", Value = "Công trình", Language = "vi-VN"
},
}, upperUser);
Collection = entityTypeManager.RegisterEntityType(
new EntityType {
Name = "collection"
},
new EntityTypeDetail[] {
new EntityTypeDetail {
Field = "title", Value = "Collection", Language = "en-US"
},
new EntityTypeDetail {
Field = "title", Value = "Bộ sưu tập", Language = "vi-VN"
},
new EntityTypeDetail {
Field = "group", Value = "Collection", Language = "en-US"
},
new EntityTypeDetail {
Field = "group", Value = "Bộ sưu tập", Language = "vi-VN"
},
}, upperUser);
}
public EFCoreCrudAggregateStoreFactory(Func <IEFCoreCrudRepository> crudRepositoryFunc,
IEntityTypeManager entityTypeManager, IEventMessageFactory eventMessageFactory,
IEFCoreTransactionCoordinator transactionCoordinator)
: base(crudRepositoryFunc, entityTypeManager, eventMessageFactory)
{
this.crudRepositoryFunc = crudRepositoryFunc;
this.entityTypeManager = entityTypeManager;
this.eventMessageFactory = eventMessageFactory;
this.transactionCoordinator = transactionCoordinator;
}
/// <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;
}
protected EventSourcedAggregateRepository(IEventStore eventStore,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory,
IEntityFactory entityFactory,
Dictionary <Guid, IEventSourcedAggregateRoot> aggregates)
: base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory, aggregates)
{
}
public CrudAggregateStore(ICrudRepository crudRepository,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IEventMessageFactory eventMessageFactory)
{
this.crudRepository = crudRepository;
this.entityTypeManager = entityTypeManager;
this.publishEventBuffer = publishEventBuffer;
this.eventMessageFactory = eventMessageFactory;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="dataModel"></param>
/// <param name="recordKey"></param>
/// <param name="children"></param>
/// <param name="linkContainer"></param>
/// <param name="references">Container das referências.</param>
/// <param name="uiContext"></param>
/// <param name="typeManager"></param>
public EntityLoaderCreatorArgs(Data.IModel dataModel, Query.RecordKey recordKey, EntityLoaderChildContainer children, IEntityLoaderLinksContainer linkContainer, EntityLoaderReferenceContainer references, string uiContext, IEntityTypeManager typeManager)
{
_dataModel = dataModel;
_recordKey = recordKey;
_children = children;
_links = linkContainer;
_references = references;
_uiContext = uiContext;
_entityTypeManager = typeManager;
}
public EventSourcedAggregateStore(IEventStore eventStore, IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer, IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory, IEventSourcedAggregateFactory eventSourcedAggregateFactory)
{
this.eventStore = eventStore;
this.entityTypeManager = entityTypeManager;
this.publishEventBuffer = publishEventBuffer;
this.repositoryFilters = repositoryFilters;
this.eventMessageFactory = eventMessageFactory;
this.eventSourcedAggregateFactory = eventSourcedAggregateFactory;
}
public EFCoreEventSourcedAggregateStore(IEventStore eventStore, IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer, IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory, IEventSourcedAggregateFactory eventSourcedAggregateFactory,
IEFCoreTransactionCoordinator transactionCoordinator)
: base(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory,
eventSourcedAggregateFactory)
{
this.transactionCoordinator = transactionCoordinator;
transactionCoordinator.AddTransactionParticipant(this);
}
public AppEntityTypes(IEntityTypeManager entityTypeManager)
{
var entityTypeGroup = "Menu Entity";
TypeMenu = entityTypeManager.RegisterEntityType("Menu", new Dictionary <string, string> {
{ "title", "Menu" }, { "group", entityTypeGroup }
});
TypeMenuItem = entityTypeManager.RegisterEntityType("MenuItem", new Dictionary <string, string> {
{ "title", "Menu Item" }, { "group", entityTypeGroup }
});
}
protected EventSourcedRepository(IEventStore eventStore,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory,
IEntityFactory entityFactory,
Dictionary <Guid, TBase> aggregates)
: this(eventStore, entityTypeManager, publishEventBuffer, repositoryFilters, eventMessageFactory, entityFactory)
{
this.aggregates = aggregates;
}
/// <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 SagaRepository(ICommandBus commandBus,
IRepository repository,
ISagaMetadataRepository metadataRepository,
IEntityTypeManager entityTypeManager,
IUnitOfWork unitOfWork)
{
this.commandBus = commandBus;
this.repository = repository;
this.entityTypeManager = entityTypeManager;
MetadataRepository = metadataRepository;
unitOfWork.AddInnerTransaction(new SagaRepositoryTransaction(this));
}
/// <summary>
/// Construtor padrão da classe
/// </summary>
/// <param name="entity">Entidade associada.</param>
/// <param name="entityTypeManager">Gerenciador dos tipos de entidades.</param>
/// <param name="validationManager">Instancia do gerenciador de validações.</param>
/// <param name="propertyChangeNotify">Método que receberá notificação de evento</param>
/// <param name="culture"></param>
public InstanceState(IEntity entity, IEntityTypeManager entityTypeManager, IValidationManager validationManager, System.ComponentModel.PropertyChangedEventHandler propertyChangeNotify, System.Globalization.CultureInfo culture)
{
entity.Require("entity").NotNull();
validationManager.Require("validationManager").NotNull();
propertyChangeNotify.Require("propertyChangeNotify").NotNull();
_specializedList = new Dictionary <string, Colosoft.Reflection.TypeName>();
_entityTypeManager = entityTypeManager;
_validationManager = validationManager;
_entity = entity;
_propertyChangeNotify = propertyChangeNotify;
_propertyAttributes = new Dictionary <string, IStatebleItem>();
LoadTypeSettings(culture);
_entity.PropertyChanged += EntityPropertyChanged;
}
public TaxonomyHelper(IServiceProvider serviceProvider, CoreInDbContext dbContext, IEntityTypeManager entityTypeManager, IEntityHelper <TaxonomyType, TaxonomyTypeDetail> taxTypeEntityHelper, IEntityHelper <Taxonomy, TaxonomyDetail> entityHelper)
{
_serviceProvider = serviceProvider;
_dbContext = dbContext;
_entityTypeManager = entityTypeManager;
_entityTypeManager.SetContext(dbContext);
_taxTypeEntityHelper = taxTypeEntityHelper;
_taxTypeEntityHelper.SetContext(dbContext);
_taxEntityHelper = entityHelper;
_taxEntityHelper.SetContext(dbContext);
}
protected override EventSourcedRepository <IEventSourcedAggregateRoot> CloneWithFilters(
IEventStore eventStore,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory,
Dictionary <Guid, IEventSourcedAggregateRoot> aggregates)
{
return(new EventSourcedAggregateRepository(eventStore,
entityTypeManager,
publishEventBuffer,
repositoryFilters,
eventMessageFactory,
EntityFactory,
aggregates));
}
protected virtual EventSourcedRepository <TBase> CloneWithFilters(
IEventStore eventStore,
IEntityTypeManager entityTypeManager,
IPublishEventBuffer publishEventBuffer,
IRepositoryFilter[] repositoryFilters,
IEventMessageFactory eventMessageFactory,
Dictionary <Guid, TBase> aggregates)
{
return(new EventSourcedRepository <TBase>(eventStore,
entityTypeManager,
publishEventBuffer,
repositoryFilters,
eventMessageFactory,
EntityFactory,
aggregates));
}
public SagaRepositoryTests()
{
unitOfWork = Substitute.For <IUnitOfWork>();
unitOfWork.When(x => x.AddInnerTransaction(Arg.Any <ITransaction>())).Do(ci => uowInnerTransaction = ci.ArgAt <ITransaction>(0));
commandBus = Substitute.For <ICommandBus>();
sagaMetadataRepository = Substitute.For <ISagaMetadataRepository>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
repository = Substitute.ForPartsOf <FakeRepository>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
entityTypeManager.GetClassInfoByClassId(saga1ClassId)
.Returns(new DomainClassInfo(saga1ClassId, null, typeof(Saga1)));
entityTypeManager.GetClassInfoByClrType(typeof(Saga1))
.Returns(new DomainClassInfo(saga1ClassId, null, typeof(Saga1)));
sut = new SagaRepository(commandBus, repository, sagaMetadataRepository, entityTypeManager, unitOfWork);
}
protected Entity(Model dataModel, string uiContext, bool initialize, IEntityTypeManager entityTypeManager) : base(uiContext, entityTypeManager)
{
Initialize(initialize);
if (dataModel == null)
{
SetDataModel(new Model());
InitializeModel(DataModel);
}
else
{
SetDataModel(dataModel);
}
var entityType = this.GetType();
if (TypeManager.HasUid(entityType) && Uid == 0)
{
Uid = TypeManager.GenerateInstanceUid(entityType);
}
UpdateRecordKey();
}
