public void NewInvocationContextIsConfiguredCorrectly() { var configuration = new DomainConfiguration(); configuration.EnsureCommitted(); var domainContext = new DomainContext(configuration); var context = new InvocationContext(domainContext); Assert.Same(domainContext, context.DomainContext); }
public void ConfigurationWithProfilerReturnsProfiledHookPoints() { var configuration = new DomainConfiguration(); var profiler = new TestDomainProfiler(); configuration.AddHookPoint(typeof(IDomainProfiler), profiler); // Profilers are not themselves profiled Assert.Same(profiler, configuration .GetHookPoints <IDomainProfiler>().Single()); var singletonHookPoint = new object(); var singletonHookPointProfiled = new object(); profiler.RegisterProfiledInstance( singletonHookPoint, singletonHookPointProfiled); configuration.SetHookPoint(typeof(object), singletonHookPoint); Assert.Same(singletonHookPointProfiled, configuration.GetHookPoint <object>()); var multiCastHookPoint = new object(); var multiCastHookPointProfiled = new object(); profiler.RegisterProfiledInstance( multiCastHookPoint, multiCastHookPointProfiled); configuration.AddHookPoint(typeof(object), multiCastHookPoint); Assert.True(configuration.GetHookPoints <object>() .SequenceEqual(new object[] { multiCastHookPointProfiled })); }
private void ValidateAdvancedMappingConfiguration(DomainConfiguration configuration) { Assert.That(configuration.AllowCyclicDatabaseDependencies, Is.True); Assert.That(configuration.DefaultDatabase, Is.EqualTo("main")); Assert.That(configuration.MappingRules.Count, Is.EqualTo(2)); var rule1 = configuration.MappingRules[0]; Assert.That(rule1.Namespace, Is.EqualTo("Xtensive.Orm.Tests.Configuration")); Assert.That(rule1.Schema, Is.EqualTo("myschema")); var rule2 = configuration.MappingRules[1]; Assert.That(rule2.Assembly, Is.EqualTo(GetType().Assembly)); Assert.That(rule2.Database, Is.EqualTo("other")); Assert.That(configuration.Databases.Count, Is.EqualTo(2)); var alias1 = configuration.Databases[0]; Assert.That(alias1.Name, Is.EqualTo("main")); Assert.That(alias1.RealName, Is.EqualTo("DO40-Tests")); var alias2 = configuration.Databases[1]; Assert.That(alias2.Name, Is.EqualTo("other")); Assert.That(alias2.RealName, Is.EqualTo("Other-DO40-Tests")); configuration.Lock(); // ensure configuration is correct }
private static void BuildMultipleDomain(string coreDatabaseName, string wmsDatabaseName) { var domainConfiguration = new DomainConfiguration(multiDatabaseConnectionString); domainConfiguration.DefaultDatabase = WmsAlias; domainConfiguration.DefaultSchema = SpecialSchemaAlias; var coreDatabase = new DatabaseConfiguration(CoreAlias); coreDatabase.RealName = coreDatabaseName; var wmsDatabase = new DatabaseConfiguration(WmsAlias); wmsDatabase.RealName = wmsDatabaseName; domainConfiguration.Databases.Add(coreDatabase); domainConfiguration.Databases.Add(wmsDatabase); domainConfiguration.Types.Register(typeof(Model2.Upgrader).Assembly, typeof(Model2.Upgrader).Namespace); domainConfiguration.MappingRules.Map(typeof(Model2.Core.Area).Namespace).ToDatabase(CoreAlias); domainConfiguration.MappingRules.Map(typeof(Model2.WMS.StoredObject).Namespace).ToDatabase(WmsAlias); domainConfiguration.UpgradeMode = DomainUpgradeMode.PerformSafely; using (var domain = Domain.Build(domainConfiguration)) { } }
private static void BuildSingleDomain(string wmsDatabaseName) { var domainConfiguration = new DomainConfiguration(singleDatabaseConnectionStringDatabase1); domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate; domainConfiguration.DefaultSchema = SpecialSchemaAlias; domainConfiguration.DefaultDatabase = WmsAlias; var wmsDatabase = new DatabaseConfiguration(WmsAlias); wmsDatabase.RealName = wmsDatabaseName; domainConfiguration.Databases.Add(wmsDatabase); domainConfiguration.MappingRules.Map(typeof(Model1.Area).Namespace).To(WmsAlias, SpecialSchemaAlias); domainConfiguration.Types.Register(typeof(Model1.Area)); domainConfiguration.Types.Register(typeof(Model1.StoredObject)); domainConfiguration.Types.Register(typeof(Model1.AnotherArea)); domainConfiguration.Types.Register(typeof(Model1.AnotherStoredObject)); domainConfiguration.Databases.Add(wmsDatabaseName); using (var domain = Domain.Build(domainConfiguration)) { } }
public static Domain Build(DomainConfiguration configuration, bool rebuild) { if (domain == null || rebuild) { if (rebuild) { configuration = configuration.Clone(); configuration.UpgradeMode = DomainUpgradeMode.Recreate; } try { domain = Domain.Build(configuration); } catch (Exception e) { DumpAndThrowAllExcs(e); } } if (domain != null) { //domain.SessionOpen += OnSessionOpen; } return(domain); }
public async Task GetModelUsingDefaultModelHandler() { var configuration = new DomainConfiguration(); configuration.SetHookPoint( typeof(IModelProducer), new TestModelProducer()); configuration.AddHookPoint( typeof(IModelExtender), new TestModelExtender(2)); configuration.AddHookPoint( typeof(IModelExtender), new TestModelExtender(3)); configuration.AddHookPoint( typeof(IModelVisibilityFilter), new TestModelVisibilityFilter()); configuration.EnsureCommitted(); var context = new DomainContext(configuration); var model = await Domain.GetModelAsync(context); Assert.Equal(3, model.SchemaElements.Count()); Assert.Null(model.SchemaElements .SingleOrDefault(e => e.Name == "TestName")); Assert.NotNull(model.SchemaElements .SingleOrDefault(e => e.Name == "TestName2")); Assert.NotNull(model.SchemaElements .SingleOrDefault(e => e.Name == "TestName3")); Assert.NotNull(model.EntityContainer); Assert.Null(model.EntityContainer.Elements .SingleOrDefault(e => e.Name == "TestEntitySet")); Assert.NotNull(model.EntityContainer.Elements .SingleOrDefault(e => e.Name == "TestEntitySet2")); Assert.NotNull(model.EntityContainer.Elements .SingleOrDefault(e => e.Name == "TestEntitySet3")); }
public async Task QueryAsyncCorrectlyUsesQueryHandler() { var configuration = new DomainConfiguration(); var modelHandler = new TestModelHandler(); var modelMapper = new TestModelMapper(); var queryHandler = new TestQueryHandler(); configuration.SetHookPoint(typeof(IModelHandler), modelHandler); configuration.SetHookPoint(typeof(IModelMapper), modelMapper); configuration.SetHookPoint(typeof(IQueryHandler), queryHandler); configuration.EnsureCommitted(); var context = new DomainContext(configuration); modelHandler.DomainContext = context; modelHandler.Model = new EdmModel(); queryHandler.DomainContext = context; queryHandler.Results = new string[] { "Test" }; var queryRequest = new QueryRequest( Domain.Source <string>(context, "Test"), true); var queryResult = await Domain.QueryAsync(context, queryRequest); Assert.True(queryResult.Results.Cast <string>() .SequenceEqual(new string[] { "Test" })); }
public PutBucketDomainRequest(string bucket, DomainConfiguration domain) : base(bucket) { this.method = CosRequestMethod.PUT; this.domain = domain; this.queryParameters.Add("domain", null); }
public static Domain BuildDomain(bool create = false) { if (built) { return(domain); } var userDir = Utils.GetUserProfilePath(); var dataFile = Path.Combine(userDir, "Temperatuurlogger.db3"); if (create && File.Exists(dataFile)) { throw new InvalidOperationException($"Asked to create, but file '{dataFile}' exists !"); } var domainConfiguration = new DomainConfiguration($"sqlite:///{dataFile}"); domainConfiguration.Types.Register(typeof(Logger).Assembly); domainConfiguration.UpgradeMode = create ? DomainUpgradeMode.Recreate : DomainUpgradeMode.PerformSafely; domain = Domain.Build(domainConfiguration); return(domain); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { DataConfig.Config(services, Configuration); DomainConfiguration.Config(services, Configuration); services.AddHttpContextAccessor(); services.AddMediatR(typeof(AddOrderCommand)); services.AddSwaggerGen(options => { options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Version = "v1", Title = "LogStore API", Description = "API to order of pizza", Contact = new OpenApiContact { Name = "Jonatas Marins", Email = "*****@*****.**" } }); }); services.AddControllers(); }
protected override void RegisterTypes(DomainConfiguration configuration) { configuration.Types.Register(typeof(SingleDateTimeEntity)); configuration.Types.Register(typeof(DateTimeEntity)); configuration.Types.Register(typeof(MillisecondDateTimeEntity)); configuration.Types.Register(typeof(NullableDateTimeEntity)); }
protected virtual Domain BuildDomain(DomainConfiguration configuration, bool isParallel = false) { var domain = Domain.Build(configuration); var nodes = GetAdditionalNodeConfigurations(configuration.UpgradeMode); if (isParallel) { void BuildNode(object domainAndNodeToBuild) { var pair = ((Domain domain, NodeConfiguration nodeConfig))domainAndNodeToBuild; _ = pair.domain.StorageNodeManager.AddNode(pair.nodeConfig); } var tasks = new List <Task>(); foreach (var nodeConfiguration in nodes) { tasks.Add(Task.Factory.StartNew(BuildNode, (domain, nodeConfiguration))); } Task.WaitAll(tasks.ToArray()); } else { foreach (var nodeConfiguration in nodes) { _ = domain.StorageNodeManager.AddNode(nodeConfiguration); } } return(domain); }
public void ExtendModelAsync_UpdatesModel_IfHasOnModelCreatingMethod(Type type) { // Arrange var domain = Activator.CreateInstance(type); var extender = new ConventionalModelExtender(type); var domainConfig = new DomainConfiguration(); domainConfig.EnsureCommitted(); var domainContext = new DomainContext(domainConfig); domainContext.SetProperty(type.AssemblyQualifiedName, domain); var model = GetModel(); var context = new ModelContext(domainContext) { Model = model }; // Act extender.ExtendModelAsync(context, new CancellationToken()); // Assert Assert.Same(model, context.Model); var operations = model.SchemaElements.OfType<IEdmOperation>(); Assert.Single(operations); var operation = operations.Single(); Assert.True(operation.IsBound); Assert.True(operation.IsFunction()); Assert.Equal("MostExpensive", operation.Name); Assert.Equal("ns", operation.Namespace); }
protected override DomainConfiguration BuildConfiguration() { DomainConfiguration config = base.BuildConfiguration(); config.Types.Register(typeof(Module).Assembly, typeof(Module).Namespace); return(config); }
protected override DomainConfiguration BuildConfiguration() { DomainConfiguration config = base.BuildConfiguration(); config.Types.Register(Assembly.GetExecutingAssembly(), typeof(A).Namespace); return(config); }
// Constructors public DomainModelConverter( HandlerAccessor handlers, ITypeIdProvider typeIdProvider, PartialIndexFilterCompiler compiler, MappingResolver resolver, IFullTextCatalogNameBuilder fulltextCatalogNameBuilder, bool isUpgradingStage) { ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers"); ArgumentValidator.EnsureArgumentNotNull(typeIdProvider, "typeIdProvider"); ArgumentValidator.EnsureArgumentNotNull(compiler, "compiler"); ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver"); this.handlers = handlers; this.compiler = compiler; this.typeIdProvider = typeIdProvider; this.resolver = resolver; this.isUpgradingStage = isUpgradingStage; this.fulltextCatalogNameBuilder = fulltextCatalogNameBuilder; sourceModel = handlers.Domain.Model; configuration = handlers.Domain.Configuration; providerInfo = handlers.ProviderInfo; driver = handlers.StorageDriver; nameBuilder = handlers.NameBuilder; FieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); StorageModel = null; CurrentModelTypes = new Dictionary <string, StoredTypeInfo>(); }
protected override DomainConfiguration BuildConfiguration() { DomainConfiguration config = base.BuildConfiguration(); config.Types.Register(Assembly.GetExecutingAssembly(), "Xtensive.Orm.Tests.Storage.BookAuthorModel"); return(config); }
public void GenericSourceOfComposableFunctionIsCorrect() { var configuration = new DomainConfiguration(); var modelMapper = new TestModelMapper(); configuration.SetHookPoint(typeof(IModelMapper), modelMapper); configuration.EnsureCommitted(); var context = new DomainContext(configuration); var arguments = new object[0]; var source = Domain.Source <DateTime>(context, "Namespace", "Function", arguments); Assert.Equal(typeof(DateTime), source.ElementType); Assert.True(source.Expression is MethodCallExpression); var methodCall = source.Expression as MethodCallExpression; Assert.Null(methodCall.Object); Assert.Equal(typeof(DomainData), methodCall.Method.DeclaringType); Assert.Equal("Source", methodCall.Method.Name); Assert.Equal(typeof(DateTime), methodCall.Method.GetGenericArguments()[0]); Assert.Equal(3, methodCall.Arguments.Count); Assert.True(methodCall.Arguments[0] is ConstantExpression); Assert.Equal("Namespace", (methodCall.Arguments[0] as ConstantExpression).Value); Assert.True(methodCall.Arguments[1] is ConstantExpression); Assert.Equal("Function", (methodCall.Arguments[1] as ConstantExpression).Value); Assert.True(methodCall.Arguments[2] is ConstantExpression); Assert.Equal(arguments, (methodCall.Arguments[2] as ConstantExpression).Value); Assert.Equal(source.Expression.ToString(), source.ToString()); }
public void SourceOfEntityContainerElementIsCorrect() { var configuration = new DomainConfiguration(); var modelMapper = new TestModelMapper(); configuration.AddHookPoint(typeof(IModelMapper), modelMapper); configuration.EnsureCommitted(); var context = new DomainContext(configuration); var arguments = new object[0]; var source = Domain.Source(context, "Test", arguments); Assert.Equal(typeof(string), source.ElementType); Assert.True(source.Expression is MethodCallExpression); var methodCall = source.Expression as MethodCallExpression; Assert.Null(methodCall.Object); Assert.Equal(typeof(DomainData), methodCall.Method.DeclaringType); Assert.Equal("Source", methodCall.Method.Name); Assert.Equal(typeof(string), methodCall.Method.GetGenericArguments()[0]); Assert.Equal(2, methodCall.Arguments.Count); Assert.True(methodCall.Arguments[0] is ConstantExpression); Assert.Equal("Test", (methodCall.Arguments[0] as ConstantExpression).Value); Assert.True(methodCall.Arguments[1] is ConstantExpression); Assert.Equal(arguments, (methodCall.Arguments[1] as ConstantExpression).Value); Assert.Equal(source.Expression.ToString(), source.ToString()); }
public void ConfigurationRegistersHookPointsCorrectly() { var configuration = new DomainConfiguration(); Assert.False(configuration.HasHookPoint(typeof(object))); Assert.Null(configuration.GetHookPoint <object>()); Assert.False(configuration.HasHookPoints(typeof(object))); Assert.False(configuration.GetHookPoints <object>().Any()); var singletonHookPoint = new object(); configuration.SetHookPoint(typeof(object), singletonHookPoint); Assert.True(configuration.HasHookPoint(typeof(object))); Assert.Same(singletonHookPoint, configuration.GetHookPoint <object>()); Assert.False(configuration.HasHookPoints(typeof(object))); Assert.False(configuration.GetHookPoints <object>().Any()); var multiCastHookPoint1 = new object(); configuration.AddHookPoint(typeof(object), multiCastHookPoint1); Assert.Same(singletonHookPoint, configuration.GetHookPoint <object>()); Assert.True(configuration.HasHookPoints(typeof(object))); Assert.True(configuration.GetHookPoints <object>() .SequenceEqual(new object[] { multiCastHookPoint1 })); var multiCastHookPoint2 = new object(); configuration.AddHookPoint(typeof(object), multiCastHookPoint2); Assert.True(configuration.HasHookPoints(typeof(object))); Assert.True(configuration.GetHookPoints <object>() .SequenceEqual(new object[] { multiCastHookPoint1, multiCastHookPoint2 })); }
public static string BuildDomain(DomainConfiguration domain) { StringWriter stringWriter = new StringWriter(); XmlWriterSettings xmlWriterSetting = new XmlWriterSettings(); xmlWriterSetting.Indent = true; XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSetting); xmlWriter.WriteStartDocument(); //start to write element xmlWriter.WriteStartElement("DomainConfiguration"); xmlWriter.WriteStartElement("DomainRule"); if (domain.rule != null) { xmlWriter.WriteElementString("Status", domain.rule.Status); xmlWriter.WriteElementString("Name", domain.rule.Name); xmlWriter.WriteElementString("Type", domain.rule.Type); if (domain.rule.Replace != null) { xmlWriter.WriteElementString("Replace", domain.rule.Replace); } } // end to element xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); xmlWriter.WriteEndDocument(); xmlWriter.Flush(); return(RemoveXMLHeader(stringWriter.ToString())); }
public override void Startup() { //(0)应用运行初始配置 LoggingManager.AddLoggerAdapter(new Log4netLoggerAdapter()); //增加日志组件 EngineHelper.LoggingInfo("UTH.License.Win - Startup - "); //(1)领域相关初始配置 DomainConfiguration.Initialize(opt => { opt.Repositorys.Add(new KeyValueModel <Type, Type>(typeof(IRepository <>), typeof(SqlSugarRepository <>))); opt.Repositorys.Add(new KeyValueModel <Type, Type>(typeof(IRepository <,>), typeof(SqlSugarRepository <,>))); }); //(2)组件安装初始配置 EngineHelper.Component.List.ForEach(x => x.Install()); //(4)会话访问认证授权 EngineHelper.RegisterType <IAccessor, WpfAccessor>(); EngineHelper.RegisterType <IApplicationSession, IdentifierSession>(); EngineHelper.RegisterType <ITokenService, TokenService>(); //接口访问处理 PlugCoreHelper.ApiServerAuthError = (token) => { throw new DbxException(EnumCode.认证错误); }; PlugCoreHelper.ApiServerResultError = (code, msg, obj) => { throw new DbxException(code, msg); }; //IOC注入 EngineHelper.ContainerBuilder <IContainer>(); }
public void DerivedConfigurationCannotCommitWithUncommittedBase() { var baseConfig = new DomainConfiguration(); var derivedConfig = new DomainConfiguration(baseConfig); Assert.Throws <InvalidOperationException>(() => derivedConfig.EnsureCommitted()); }
protected virtual void ApplyCustomSettingsToInitialConfiguration(DomainConfiguration domainConfiguration) { domainConfiguration.Types.Register(typeof(model.Part1.TestEntity1)); domainConfiguration.Types.Register(typeof(model.Part2.TestEntity2)); domainConfiguration.Types.Register(typeof(model.Part3.TestEntity3)); domainConfiguration.Types.Register(typeof(model.Part4.TestEntity4)); }
public async Task Should_RewriteResponseContext(string url, string method, bool redirectHttps) { var domainConfiguration = new DomainConfiguration { HttpsRedirect = redirectHttps }; hostResolver.Setup(x => x.GetMathingCofinguration(It.IsAny <HttpRequest>())) .Returns(domainConfiguration); hostResolver.Setup(x => x.GetHostUri(It.IsAny <HttpRequest>(), It.IsAny <DomainConfiguration>())) .Returns(new Uri("http://dummy.com")); var hostClient = new HostClient(httpClient, hostResolver.Object, exposedConfig); SetRequestMethod(method); await hostClient.ReverseProxy(httpContext); Assert.AreEqual(3, httpContext.Response.Headers.Count); Assert.AreEqual("1", httpContext.Response.Headers["CustomHeader"].ToString()); Assert.AreEqual("2", httpContext.Response.Headers["CustomHeader2"].ToString()); httpContext.Response.Body.Flush(); httpContext.Response.Body.Position = 0; using (var bodyStream = new StreamReader(httpContext.Response.Body)) { Assert.AreEqual(responseBodyString, bodyStream.ReadToEnd()); } }
protected override DomainConfiguration BuildConfiguration() { DomainConfiguration config = base.BuildConfiguration(); config.Types.Register(Assembly.GetExecutingAssembly(), "Xtensive.Orm.Tests.ReferentialIntegrityModel"); return(config); }
protected override Domain BuildDomain(DomainConfiguration configuration) { Domain domain; try { //throw new ApplicationException("Don't validate, just recreate ;)"); var validateConfig = configuration.Clone(); validateConfig.UpgradeMode = DomainUpgradeMode.Validate; domain = Domain.Build(validateConfig); } catch (Exception ex) { var recreateConfig = configuration.Clone(); recreateConfig.UpgradeMode = DomainUpgradeMode.Recreate; domain = base.BuildDomain(recreateConfig); } var shouldFill = false; using (var session = domain.OpenSession()) using (var t = session.OpenTransaction()) { var count = session.Query.All <Playlist>().Count(); if (count == 0) { shouldFill = true; } } if (shouldFill) { DataBaseFiller.Fill(domain); } return(domain); }
private static DomainConfiguration Create(string storage, bool useConnectionString, bool addSessionConfiguration) { if (useConnectionString) { storage += "cs"; } var configuration = typeof(DomainConfigurationFactory).Assembly.GetAssemblyConfiguration(); var domainConfiguration = DomainConfiguration.Load(configuration, storage); domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate; var customConnectionInfo = TestConfiguration.Instance.GetConnectionInfo(storage); if (customConnectionInfo != null) { domainConfiguration.ConnectionInfo = customConnectionInfo; } if (addSessionConfiguration) { var defaultConfiguration = new SessionConfiguration( WellKnown.Sessions.Default, SessionOptions.ServerProfile | SessionOptions.AutoActivation); domainConfiguration.Sessions.Add(defaultConfiguration); } return(domainConfiguration); }
/// 设置存储桶自定义域名 public void PutBucketDomain() { //.cssg-snippet-body-start:[put-bucket-domain] try { string bucket = "examplebucket-1250000000"; //格式:BucketName-APPID DomainConfiguration domain = new DomainConfiguration(); domain.rule = new DomainConfiguration.DomainRule(); domain.rule.Name = "www.qq.com"; domain.rule.Status = "ENABLED"; domain.rule.Type = "WEBSITE"; PutBucketDomainRequest request = new PutBucketDomainRequest(bucket, domain); //执行请求 PutBucketDomainResult result = cosXml.putBucketDomain(request); //请求成功 Console.WriteLine(result.GetResultInfo()); } catch (COSXML.CosException.CosClientException clientEx) { //请求失败 Console.WriteLine("CosClientException: " + clientEx); } catch (COSXML.CosException.CosServerException serverEx) { //请求失败 Console.WriteLine("CosServerException: " + serverEx.GetInfo()); } //.cssg-snippet-body-end }
public override void Startup() { //(0)应用运行初始配置 LoggingManager.AddLoggerAdapter(new Log4netLoggerAdapter()); //增加日志组件 EngineHelper.LoggingInfo("UTH Meeting Win Server - Startup - "); //(1)领域相关初始配置 DomainConfiguration.Initialize(); //(2)组件安装初始配置 EngineHelper.Component.List.ForEach(x => x.Install()); //(3)会话访问认证授权 EngineHelper.RegisterType <IAccessor, WpfAccessor>(); EngineHelper.RegisterType <IApplicationSession, IdentifierSession>(); EngineHelper.RegisterType <ITokenService, TokenService>(); //接口访问处理 PlugCoreHelper.ApiServerAuthError = (token) => { //throw new DbxException(EnumCode.认证错误); }; PlugCoreHelper.ApiServerResultError = (code, msg, obj) => { //throw new DbxException(code, msg); }; //IOC注入 EngineHelper.ContainerBuilder <IContainer>(); }
protected override Domain BuildDomain(DomainConfiguration configuration) { Domain domain = null; AssertEx.Throws <DomainBuilderException>(() => domain = base.BuildDomain(configuration)); return(domain); }
protected Domain BuildDomain(DomainConfiguration configuration, bool isParallel) { var domain = Domain.Build(configuration); var nodes = GetConfigurations(configuration.UpgradeMode); if (isParallel) { Action <object> action = nodeConfg => domain.StorageNodeManager.AddNode((NodeConfiguration)nodeConfg); var tasks = new List <Task>(); foreach (var nodeConfiguration in nodes) { tasks.Add(Task.Factory.StartNew(action, nodeConfiguration)); } Task.WaitAll(tasks.ToArray()); } else { foreach (var nodeConfiguration in nodes) { domain.StorageNodeManager.AddNode(nodeConfiguration); } } return(domain); }
public void DisposedDomainBaseCannotBeInitialized() { var domain = new TestDomain(); var expandableDomain = domain as IExpandableDomain; var derivedConfig = new DomainConfiguration( expandableDomain.Configuration); domain.Dispose(); Assert.Throws<ObjectDisposedException>(() => expandableDomain.Initialize(derivedConfig)); }
public void DomainBaseCannotBeInitializedIfAlreadyInitialized() { var domain = new TestDomain(); var expandableDomain = domain as IExpandableDomain; var derivedConfig = new DomainConfiguration( expandableDomain.Configuration); var context = expandableDomain.Context; Assert.Throws<InvalidOperationException>(() => expandableDomain.Initialize(derivedConfig)); }
/// <inheritdoc/> public static void ApplyTo( DomainConfiguration configuration, Type targetType) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(targetType, "targetType"); configuration.AddHookPoint( typeof(IChangeSetEntryAuthorizer), new ConventionalChangeSetAuthorizer(targetType)); }
/// <inheritdoc/> public static void ApplyTo( DomainConfiguration configuration, Type targetType) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(targetType, "targetType"); configuration.AddHookPoint( typeof(IQueryExpressionFilter), new ConventionalEntitySetFilter(targetType)); }
/// <inheritdoc/> public static void ApplyTo( DomainConfiguration configuration, Type targetType) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(targetType, "targetType"); var provider = new ConventionalEntitySetProvider(targetType); configuration.AddHookPoint(typeof(IModelExtender), provider); configuration.AddHookPoint(typeof(IModelMapper), provider); configuration.AddHookPoint(typeof(IQueryExpressionExpander), provider); }
public bool IsVisible( DomainConfiguration configuration, InvocationContext context, IEdmModel model, IEdmSchemaElement element) { if (element.Name == "TestName") { return false; } return true; }
public bool IsVisible( DomainConfiguration configuration, InvocationContext context, IEdmModel model, IEdmEntityContainerElement element) { if (element.Name == "TestEntitySet") { return false; } return true; }
/// <summary> /// Initializes a new instance of the <see cref="DomainContext" /> class. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> public DomainContext(DomainConfiguration configuration) { Ensure.NotNull(configuration, "configuration"); if (!configuration.IsCommitted) { // TODO GitHubIssue#24 : error message throw new ArgumentException(); } this.Configuration = configuration; }
/// <summary> /// Configures a domain configuration. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> /// <param name="type"> /// The domain type on which this attribute was placed. /// </param> public override void Configure( DomainConfiguration configuration, Type type) { var permission = DomainPermission.CreateGrant( this.PermissionType, this.To, this.OnNamespace, this.On, this.OnChild); configuration.AddPermission(permission); }
public void InvocationContextGetsHookPointsCorrectly() { var configuration = new DomainConfiguration(); var singletonHookPoint = new object(); configuration.SetHookPoint(typeof(object), singletonHookPoint); var multiCastHookPoint = new object(); configuration.AddHookPoint(typeof(object), multiCastHookPoint); configuration.EnsureCommitted(); var domainContext = new DomainContext(configuration); var context = new InvocationContext(domainContext); Assert.Same(singletonHookPoint, context.GetHookPoint<object>()); Assert.True(context.GetHookPoints<object>() .SequenceEqual(new object[] { multiCastHookPoint })); }
/// <summary> /// Applies configuration from any domain participant attributes /// specified on a domain type to a domain configuration. /// </summary> /// <param name="type"> /// A domain type. /// </param> /// <param name="configuration"> /// A domain configuration. /// </param> public static void ApplyConfiguration( Type type, DomainConfiguration configuration) { Ensure.NotNull(type, "type"); Ensure.NotNull(configuration, "configuration"); if (type.BaseType != null) { DomainParticipantAttribute.ApplyConfiguration( type.BaseType, configuration); } var attributes = type.GetCustomAttributes( typeof(DomainParticipantAttribute), false); foreach (DomainParticipantAttribute attribute in attributes) { attribute.Configure(configuration, type); } }
public void ExtendModelAsync_DoesntUpdatesModel_IfWithoutOnModelCreatingMethod() { // Arrange var domain = new AnyDomain(); var type = domain.GetType(); var extender = new ConventionalModelExtender(type); var domainConfig = new DomainConfiguration(); domainConfig.EnsureCommitted(); var domainContext = new DomainContext(domainConfig); domainContext.SetProperty(type.AssemblyQualifiedName, domain); var model = GetModel(); var context = new ModelContext(domainContext) { Model = model }; // Act extender.ExtendModelAsync(context, new CancellationToken()); // Assert Assert.Same(model, context.Model); Assert.Empty(model.SchemaElements.OfType<IEdmOperation>()); }
/// <summary> /// Indicates if a schema element is currently visible. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> /// <param name="context"> /// An optional invocation context. /// </param> /// <param name="model"> /// A model. /// </param> /// <param name="element"> /// A schema element. /// </param> /// <returns> /// <c>true</c> if the element is currently /// visible; otherwise, <c>false</c>. /// </returns> public bool IsVisible( DomainConfiguration configuration, InvocationContext context, IEdmModel model, IEdmSchemaElement element) { Ensure.NotNull(element); // TODO GitHubIssue#34 : Filter out proper visible types if (element is IEdmType || element is IEdmOperation) { return true; } return this.IsVisible( configuration, context, element.Namespace, element.Name); }
public static void ApplyTo(DomainConfiguration configuration, Type targetType) { ConventionalActionProvider provider = new ConventionalActionProvider(targetType); configuration.AddHookPoint(typeof(IModelExtender), provider); }
private bool IsVisible( DomainConfiguration configuration, InvocationContext context, string namespaceName, string securableName) { List<string> assertedRoles = null; if (context != null) { assertedRoles = context.GetProperty<List<string>>(AssertedRoles); } var permissions = configuration.GetProperty<IEnumerable<DomainPermission>>(Permissions); if (permissions == null) { return false; } permissions = permissions.Where(p => ( p.PermissionType == DomainPermissionType.All || p.PermissionType == DomainPermissionType.Inspect) && ( (p.NamespaceName == null && p.SecurableName == null) || (p.NamespaceName == namespaceName && p.SecurableName == securableName)) && p.ChildName == null && (p.Role == null || this.IsInRole(p.Role) || (assertedRoles != null && assertedRoles.Contains(p.Role)))); if (!permissions.Any() || permissions.Any(p => p.IsDeny)) { return false; } return true; }
/// <summary> /// Configures a domain configuration. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> /// <param name="type"> /// The domain type on which this attribute was placed. /// </param> public virtual void Configure( DomainConfiguration configuration, Type type) { }
/// <summary> /// Configures a domain configuration. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> /// <param name="type"> /// The domain type on which this attribute was placed. /// </param> public override void Configure( DomainConfiguration configuration, Type type) { configuration.EnableRoleBasedSecurity(); }
public void DomainBaseCannotBeInitializedWithUnrelatedConfiguration() { var domain = new TestDomain(); var expandableDomain = domain as IExpandableDomain; var otherConfig = new DomainConfiguration(); Assert.Throws<ArgumentException>(() => expandableDomain.Initialize(otherConfig)); }
public DomainModel(DomainConfiguration configuration, IEdmModel model) { this.Configuration = configuration; this.InnerModel = model; }
/// <inheritdoc/> public override void Configure( DomainConfiguration configuration, Type type) { configuration.EnableConventions(type); }
public void ExpandedDomainBaseIsInitializedCorrectly() { var domain = new TestDomain(); var expandableDomain = domain as IExpandableDomain; var derivedConfig = new DomainConfiguration( expandableDomain.Configuration); derivedConfig.EnsureCommitted(); expandableDomain.Initialize(derivedConfig); Assert.True(expandableDomain.IsInitialized); Assert.Same(derivedConfig, expandableDomain.Context.Configuration); }
/// <summary> /// Creates the domain context for this domain. /// </summary> /// <param name="configuration"> /// The domain configuration to use. /// </param> /// <returns> /// The domain context for this domain. /// </returns> protected virtual DomainContext CreateDomainContext( DomainConfiguration configuration) { return new DomainContext(configuration); }
public override void Configure( DomainConfiguration configuration, Type type) { base.Configure(configuration, type); Assert.Same(typeof(TestDomainWithParticipants), type); configuration.SetProperty(this.Value, true); }
void IExpandableDomain.Initialize( DomainConfiguration derivedConfiguration) { if (this.IsDisposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (this.domainContext != null) { throw new InvalidOperationException(); } Ensure.NotNull(derivedConfiguration, "derivedConfiguration"); var baseConfiguration = this.DomainConfiguration; var candidate = derivedConfiguration; while (candidate != baseConfiguration) { if (candidate.BaseConfiguration == null) { // TODO GitHubIssue#24 : error message throw new ArgumentException(); } candidate = candidate.BaseConfiguration; } this.domainConfiguration = derivedConfiguration; this.domainContext = this.CreateDomainContext(derivedConfiguration); DomainParticipantAttribute.ApplyInitialization( this.GetType(), this, this.domainContext); }
/// <summary> /// Indicates if an entity container element is currently visible. /// </summary> /// <param name="configuration"> /// A domain configuration. /// </param> /// <param name="context"> /// An optional invocation context. /// </param> /// <param name="model"> /// A model. /// </param> /// <param name="element"> /// An entity container element. /// </param> /// <returns> /// <c>true</c> if the element is currently /// visible; otherwise, <c>false</c>. /// </returns> public bool IsVisible( DomainConfiguration configuration, InvocationContext context, IEdmModel model, IEdmEntityContainerElement element) { Ensure.NotNull(element); return this.IsVisible( configuration, context, null, element.Name); }
/// <summary> /// Apply a <see cref="ConventionalModelExtender"/> instance to the <see cref="DomainConfiguration"/>. /// </summary> /// <param name="configuration">The domain configuration.</param> /// <param name="targetType">The target type on which to invoke model extending.</param> public static void ApplyTo(DomainConfiguration configuration, Type targetType) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(targetType, "targetType"); configuration.AddHookPoint(typeof(IModelExtender), new ConventionalModelExtender(targetType)); }