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