///-------------------------------------------------------------------------------------------------
/// <summary>
/// Specialised constructor for use only by derived classes.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <param name="statisticCounterName">
/// (Optional) name of the statistic counter.
/// </param>
///-------------------------------------------------------------------------------------------------
protected AbstractGraphAdapter(IServicesContainer services, string statisticCounterName = null)
{
Contract.Requires(services, "services");
_statisticCounterName = statisticCounterName ?? this.GetType().Name;
Services = services;
Store = services.Resolve <IHyperstore>();
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
public EventManager(IServicesContainer services)
{
var factory = services.Resolve <ISubjectFactory>() ?? new DefaultSubjectFactory(services);
_messageOccurs = factory.CreateSubject <ISessionResult>();
_sessionCompleted = factory.CreateSubject <ISessionInformation>();
_sessionCompleting = factory.CreateSubject <ISessionInformation>();
_attributeChanged = factory.CreateSubject <EventContext <ChangePropertyValueEvent> >();
_attributeRemoved = factory.CreateSubject <EventContext <RemovePropertyEvent> >();
_elementAdded = factory.CreateSubject <EventContext <AddEntityEvent> >();
_elementRemoved = factory.CreateSubject <EventContext <RemoveEntityEvent> >();
_relationshipAdded = factory.CreateSubject <EventContext <AddRelationshipEvent> >();
_relationshipRemoved = factory.CreateSubject <EventContext <RemoveRelationshipEvent> >();
_customEvents = factory.CreateSubject <EventContext <IEvent> >();
_metadataAdded = factory.CreateSubject <EventContext <AddSchemaEntityEvent> >();
_relationshipMetadataAdded = factory.CreateSubject <EventContext <AddSchemaRelationshipEvent> >();
_attributeChanging = factory.CreateSubject <EventContext <ChangePropertyValueEvent> >();
_attributeRemoving = factory.CreateSubject <EventContext <RemovePropertyEvent> >();
_elementAdding = factory.CreateSubject <EventContext <AddEntityEvent> >();
_elementRemoving = factory.CreateSubject <EventContext <RemoveEntityEvent> >();
_relationshipAdding = factory.CreateSubject <EventContext <AddRelationshipEvent> >();
_relationshipRemoving = factory.CreateSubject <EventContext <RemoveRelationshipEvent> >();
_customEventRaising = factory.CreateSubject <EventContext <IEvent> >();
_metadataAdding = factory.CreateSubject <EventContext <AddSchemaEntityEvent> >();
_relationshipMetadataAdding = factory.CreateSubject <EventContext <AddSchemaRelationshipEvent> >();
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <param name="instanceId">
/// The identifier of the instance.
/// </param>
/// <param name="name">
/// The name.
/// </param>
///-------------------------------------------------------------------------------------------------
protected internal InternalSchema(IServicesContainer services, string instanceId, string name)
{
Store = services.Resolve <IHyperstore>();
_services = services;
_name = name;
_instanceId = instanceId;
}
public async Task<IMessage> Handle(IMessage message, IServicesContainer servicesContainer)
{
var parameters = CollectParameters(message, _deserializer, servicesContainer);
var instance = Activator.CreateInstance(_type);
var result = _method.Invoke(instance, parameters.ToArray());
if (result == null) return null;
if (typeof(IMessage).IsAssignableFrom(result.GetType()))
return (IMessage)result;
var _returnType = _method.ReturnType;
if (_returnType.IsTask())
{
if (_method.ReturnType.IsGenericType())
_returnType = _method.ReturnType.GetGenericArguments()[0];
await ((Task)result);
result = _method.ReturnType.IsGenericType()
? result.GetType().GetProperty("Result").GetValue(result)
: null;
}
return new ObjectBasedMessage(_returnType, message.Name, result);
}
public void Registrar(IServicesContainer servicesContainer)
{
servicesContainer.AddDbContext <LivrariaContexto>();
servicesContainer.AddScoped <ILivrariaContexto, LivrariaContexto>();
servicesContainer.AddScoped(typeof(IRepositorio <>), typeof(Repositorio <>));
servicesContainer.AddScoped <ILivros, Livros>();
}
internal IServicesContainer Merge(IServicesContainer serviceContainer)
{
var container = serviceContainer as ServicesContainer;
if (container == null || !container._services.HasValue)
{
return(this);
}
_services.ExchangeValue(services =>
{
foreach (var descriptor in container._services.Value.Values)
{
ServiceDescriptor desc;
if (!services.TryGetValue(descriptor.ServiceType, out desc))
{
return(services.Add(descriptor.ServiceType, descriptor));
}
descriptor.Next = desc;
services = services.SetItem(descriptor.ServiceType, descriptor);
}
return(services);
});
return(this);
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <param name="extendedSchema">
/// The extended domain model.
/// </param>
/// <param name="mode">
/// The mode.
/// </param>
///-------------------------------------------------------------------------------------------------
public ExtensionConstraintManager(IServicesContainer services, ISchema extendedSchema, SchemaConstraintExtensionMode mode) : base(services)
{
DebugContract.Requires(services);
DebugContract.Requires(extendedSchema);
_extensionMode = mode;
_extendedSchema = extendedSchema;
}
///-------------------------------------------------------------------------------------------------
/// <summary> Creates a schema. </summary>
/// <param name="services"> The domain services. </param>
/// <returns> The new schema. </returns>
///-------------------------------------------------------------------------------------------------
protected override ISchema <T> CreateSchema <T>(IServicesContainer services)
{
return(new Hyperstore.Modeling.Scopes.DomainSchemaExtension <T>(this as T,
_extendedSchema,
services,
Behavior,
new ExtensionConstraintManager(services, _extendedSchema, _mode)));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="desc">
/// The description.
/// </param>
/// <param name="extendedMetaModel">
/// The extended meta model.
/// </param>
/// <param name="services">
/// The services container.
/// </param>
/// <param name="behavior">
/// (Optional) the behavior.
/// </param>
/// <param name="constraints">
/// (Optional)
/// The constraints.
/// </param>
///-------------------------------------------------------------------------------------------------
public DomainSchemaExtension(T desc, ISchema extendedMetaModel, IServicesContainer services, DomainBehavior behavior = DomainBehavior.Standard, IConstraintsManager constraints = null)
: base(extendedMetaModel.Name, services, behavior, constraints)
{
DebugContract.Requires(extendedMetaModel);
DebugContract.Requires(services);
DebugContract.Requires(constraints);
_extendedMetaModel = extendedMetaModel;
Definition = desc;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services container.
/// </param>
/// <param name="name">
/// The name.
/// </param>
///-------------------------------------------------------------------------------------------------
public DomainModel(IServicesContainer services, string name)
{
Contract.Requires(services, "services");
Contract.RequiresNotEmpty(name, "name");
InstanceId = Guid.NewGuid().ToString("N");
Name = name.ToLower();
_services = services;
Store = Services.Resolve <IHyperstore>();
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="extensionName">
/// Name of the extension.
/// </param>
/// <param name="extendeDomainModel">
/// The extende domain model.
/// </param>
///-------------------------------------------------------------------------------------------------
public DomainScope(IServicesContainer services, string name, string extensionName, IDomainModel extendeDomainModel)
: base(services, name)
{
DebugContract.Requires(services);
DebugContract.RequiresNotEmpty(name);
DebugContract.Requires(extendeDomainModel);
DebugContract.RequiresNotEmpty(extensionName);
ExtensionName = extensionName;
ExtendedDomainModel = extendeDomainModel;
}
// public override void DefineMetaModel(IMetaModel metaModel)
// {
// new EnumPrimitive<Direction>(metaModel);
// new CultureInfoMetadata(metaModel);
// AbstractClass = new MetaClass<AbstractBaseClass>(metaModel);
// AbstractClass.DefineProperty<string>("Name");
// XExtendsBaseClass = new MetaClass<XExtendsBaseClass>(metaModel, AbstractClass);
// XExtendsBaseClass.DefineProperty<int>("Value");
// YClass = new MetaClass<YClass>(metaModel);
// YClass.DefineProperty<int>("Value");
// YClass.DefineProperty<string>("Name");
// YClass.DefineProperty<Direction>("Direction", Direction.South);
// YClass.DefineProperty<CultureInfo>("Culture", new CultureInfo("fr"));
// XReferencesY = new MetaRelationship<XReferencesY>(XExtendsBaseClass, YClass);
// XReferencesX = new MetaRelationship("XReferencesX", XExtendsBaseClass, XExtendsBaseClass, Cardinality.OneToMany );
// XExtendsBaseClass.DefineProperty("YRelation", XReferencesY);
// XExtendsBaseClass.DefineProperty("OthersX", XReferencesX);
// }
protected override IServicesContainer PrepareScopedContainer(IServicesContainer defaultDependencyResolver)
{
Using <Hyperstore.Modeling.HyperGraph.IIdGenerator>(r => new LongIdGenerator());
var services = base.PrepareScopedContainer(defaultDependencyResolver);
if (_prepareDependency != null)
{
_prepareDependency(services);
}
return(services);
}
// public override void DefineMetaModel(IMetaModel metaModel)
// {
// new EnumPrimitive<Direction>(metaModel);
// new CultureInfoMetadata(metaModel);
// AbstractClass = new MetaClass<AbstractBaseClass>(metaModel);
// AbstractClass.DefineProperty<string>("Name");
// XExtendsBaseClass = new MetaClass<XExtendsBaseClass>(metaModel, AbstractClass);
// XExtendsBaseClass.DefineProperty<int>("Value");
// YClass = new MetaClass<YClass>(metaModel);
// YClass.DefineProperty<int>("Value");
// YClass.DefineProperty<string>("Name");
// YClass.DefineProperty<Direction>("Direction", Direction.South);
// YClass.DefineProperty<CultureInfo>("Culture", new CultureInfo("fr"));
// XReferencesY = new MetaRelationship<XReferencesY>(XExtendsBaseClass, YClass);
// XReferencesX = new MetaRelationship("XReferencesX", XExtendsBaseClass, XExtendsBaseClass, Cardinality.OneToMany );
// XExtendsBaseClass.DefineProperty("YRelation", XReferencesY);
// XExtendsBaseClass.DefineProperty("OthersX", XReferencesX);
// }
protected override IServicesContainer PrepareScopedContainer(IServicesContainer parentResolver)
{
Using <Hyperstore.Modeling.HyperGraph.IIdGenerator>(r => new LongIdGenerator());
var services = base.PrepareScopedContainer(parentResolver);
if (_prepareDependency != null)
{
_prepareDependency(services);
}
//services.Register<global::Hyperstore.Modeling.ISynchronizationContext>(new global::Hyperstore.Modeling.Utils.UIDispatcher());
return(services);
}
internal LockManager(IServicesContainer services)
{
Contract.Requires(services, "services");
_trace = services.Resolve <IHyperstoreTrace>() ?? new EmptyHyperstoreTrace();
var defaultMaxTimeBeforeDeadlockInSeconds = services.GetSettingValue <int?>(Setting.MaxTimeBeforeDeadlockInMs);
var n = defaultMaxTimeBeforeDeadlockInSeconds != null ? defaultMaxTimeBeforeDeadlockInSeconds.Value : DEFAULT_DEADLOCK_TIME;
if (n < 0)
{
n = DEFAULT_DEADLOCK_TIME;
}
DeadLockLimitTimeInMs = n;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Prepare services container.
/// </summary>
/// <param name="container">
/// The default services container.
/// </param>
/// <returns>
/// An services container.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected virtual IServicesContainer PrepareScopedContainer(IServicesContainer container)
{
Contract.Requires(container, "container");
foreach (var action in _factories)
{
action(container);
}
if (_shared != null)
{
_shared.PrepareScopedContainer(container);
}
return(container);
}
public static void CarregarRegistros(this IServicesContainer services, Type[] tipos)
{
var registros = tipos
.Where(type =>
type.IsClass &&
!type.IsAbstract &&
typeof(IRegistroContainer).IsAssignableFrom(type)
)
.Select(Activator.CreateInstance)
.Cast <IRegistroContainer>();
foreach (var registro in registros)
{
registro.Registrar(services);
}
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <param name="extendedDomain">
/// The extended domain.
/// </param>
///-------------------------------------------------------------------------------------------------
public ScopeHyperGraph(IServicesContainer services, IHyperGraphProvider extendedDomain)
: base(services)
{
DebugContract.Requires(services);
DebugContract.Requires(extendedDomain);
_extendedDomain = extendedDomain;
_extendedGraph = extendedDomain.InnerGraph as HyperGraph.HyperGraph;
System.Diagnostics.Debug.Assert(_extendedGraph != null);
_deletedElements = new Hyperstore.Modeling.MemoryStore.TransactionalMemoryStore(
_extendedDomain.Name,
5,
_extendedDomain.Services.Resolve <Hyperstore.Modeling.MemoryStore.ITransactionManager>()
);
}
public void RegisterService(IServicesContainer container){
// @"container".contract_NotNull(container);
object s = null;
if (null != Service) s = Service;
else if (null != Creator) s = Creator.CreateService(this);
else if (null != ServiceType) s = ServiceType.create<object>();
// @"s".contract_NotNull(s, "Не удалось инстанцировать сервис");
if (!string.IsNullOrEmpty(Name))
container.RegisterService(Name, s);
if (null != RegisterType){
// s.contract_Is(RegisterType);
container.RegisterService(RegisterType, s);
}
if (string.IsNullOrEmpty(Name) && null == RegisterType)
container.RegisterService(s);
}
private List<object> CollectParameters(IMessage message, HandlerParameterDeserializer handlerParameterDeserializer, IServicesContainer servicesContainer)
{
var parameters = new List<object>();
foreach (var p in _method.GetParameters())
{
object value = null;
if (p.IsRetval) continue;
if (p.HasDefaultValue)
value = p.DefaultValue;
servicesContainer.TryToResolve(p.ParameterType, out value);
if (value == null)
{
var obj = message.ValueAsObject();
var msgItem = obj[p.Name];
value = handlerParameterDeserializer.Deserialize(p.ParameterType, msgItem);
}
parameters.Add(value);
}
return parameters;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Schema factory. Create a new schema instance
/// </summary>
/// <remarks>
/// You can override this method to create a custom schema instance.
/// </remarks>
/// <param name="services">
/// The domain services container.
/// </param>
/// <returns>
/// The new schema.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected virtual ISchema <T> CreateSchema <T>(IServicesContainer services) where T : class, ISchemaDefinition
{
return(new Hyperstore.Modeling.Metadata.DomainSchema <T>(this as T, _name, services, Behavior));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Creates a schema.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
/// <returns>
/// The new schema.
/// </returns>
///-------------------------------------------------------------------------------------------------
ISchema <T> ISchemaDefinition.CreateSchema <T>(IServicesContainer services)
{
DebugContract.Requires(services);
return(CreateSchema <T>(services));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
public DefaultSubjectFactory(IServicesContainer services)
{
DebugContract.Requires(services);
_services = services;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
public HyperGraph(IServicesContainer services)
{
Contract.Requires(services, "services");
_services = services;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Prepare services container.
/// </summary>
/// <param name="container">
/// The default services container.
/// </param>
/// <returns>
/// An services container.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected override IServicesContainer PrepareScopedContainer(IServicesContainer container)
{
return(_definition.PrepareScopedContainer(container));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
public TransactionManager(IServicesContainer services)
{
DebugContract.Requires(services);
_trace = services.Resolve <IHyperstoreTrace>() ?? new EmptyHyperstoreTrace();
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
public EventBus(IServicesContainer services)
{
DebugContract.Requires(services);
_store = services.Resolve <IHyperstore>();
DefaultEventDispatcher = services.Resolve <IEventDispatcher>();
}
public void Registrar(IServicesContainer servicesContainer)
{
servicesContainer.AddScoped <IRegistroContainer, RegistroFake>();
}
public void SetupSelfServiceContainer(){
Services = new RuleServicesContainer(this);
}
public void Registrar(IServicesContainer servicesContainer)
{
servicesContainer.AddScoped <ILivrosService, LivrosService>();
}
public Task<IMessage> Handle(IMessage message, IServicesContainer servicesContainer)
{
return null;
}
public static string DomainModelName = "$"; // Name of the domain model
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Constructor.
/// </summary>
/// <param name="services">
/// The services.
/// </param>
///-------------------------------------------------------------------------------------------------
internal PrimitivesSchema(IServicesContainer services)
: base(services, "", DomainModelName)
{
}
public MicrohandlersRouter(IHandlersRegistry registry, IServicesContainer servicesContainer)
: base(registry, servicesContainer)
{
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Prepare services container.
/// </summary>
/// <param name="container">
/// The default services container.
/// </param>
/// <returns>
/// An services container.
/// </returns>
///-------------------------------------------------------------------------------------------------
IServicesContainer IDomainConfiguration.PrepareScopedContainer(IServicesContainer container)
{
return(PrepareScopedContainer(container));
}
public DomainSchema(T desc, string name, IServicesContainer services, DomainBehavior behavior = DomainBehavior.Standard, IConstraintsManager constraints = null)
: base(name, services, behavior, constraints)
{
DebugContract.Requires(desc);
_schemaDefinition = desc;
}
///-------------------------------------------------------------------------------------------------
/// <summary> Creates a schema. </summary>
/// <param name="container"> The domain services. </param>
/// <returns> The new schema. </returns>
///-------------------------------------------------------------------------------------------------
ISchema <T> ISchemaDefinition.CreateSchema <T>(IServicesContainer container)
{
return(new PrimitivesSchema(container) as ISchema <T>);
}
internal ConstraintsManager(IServicesContainer services)
{
}
protected MessageSource(IHandlersRegistry registry, IServicesContainer servicesContainer)
{
_registry = registry;
_servicesContainer = servicesContainer;
}
