public ScanIndex()
{
AssemblyTypes = new Dictionary<Assembly, List<Type>>();
TypeAssemblies = new Dictionary<Type, Assembly>();
ImplementorsOfType = new Dictionary<Type, List<Type>>();
TypeHierarchies = new Dictionary<Type, List<Type>>();
Closers = new Dictionary<Type, List<Type>>();
AssemblyExclusionList = new List<string>();
ReferenceLookup = new Dictionary<Assembly, List<Assembly>>();
ConfiguredSymbiotes = new Dictionary<Assembly, bool>();
SingleImplementations = new Dictionary<Type, Type>();
Scanner = new TypeScanner();
InitExclusions();
var initialList = new List<Assembly>( Scanner.GetAssembliesFromBaseDirectory().ToList() );
var references = initialList
.SelectMany( GetReferenceList )
.ToList();
initialList.AddRange( references.Where( r => !initialList.Any( a => a.FullName.Equals( r.FullName ) ) ) );
var uniqueList = initialList.Distinct();
var filtered = uniqueList.Where( x => !AssemblyExclusionList.Any( e => x.FullName.StartsWith( e ) ) );
CompleteAssemblyList = new List<Assembly>( filtered.ToList() );
}
public void Write()
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(EndpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterDefer>(typeof(ConfigErrorQueue));
busConfiguration.TypesToScan(typesToScan);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
using (var bus = Bus.Create(busConfiguration).Start())
{
bus.Defer(TimeSpan.FromMilliseconds(10), new MessageToSend());
ManualResetEvent.WaitOne();
}
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterAudit>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.AuditProcessedMessagesTo(endpointName);
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.RegisterMessageMutator(new Mutator());
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await endpointInstance.SendLocal(new MessageToSend())
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(EndpointName);
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterDefer>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
SendOptions options = new SendOptions();
options.DelayDeliveryWith(TimeSpan.FromMilliseconds(10));
await endpoint.Send(new MessageToSend(), options);
ManualResetEvent.WaitOne();
await endpoint.Stop();
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var ascii = Encoding.ASCII;
var encryptionService = new RijndaelEncryptionService(
encryptionKeyIdentifier: "2015-10",
key: ascii.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6"));
endpointConfiguration.EnableMessagePropertyEncryption(
encryptionService: encryptionService,
encryptedPropertyConvention: propertyInfo =>
{
return(propertyInfo.Name.EndsWith("EncryptedProperty"));
}
);
var conventions = endpointConfiguration.Conventions();
var typesToScan = TypeScanner.NestedTypes <HeaderWriterEncryption>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var messageToSend = new MessageToSend
{
EncryptedProperty1 = "String 1",
EncryptedProperty2 = "String 2"
};
await endpointInstance.SendLocal(messageToSend)
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterSend>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await endpointInstance.SendLocal(new MessageToSend())
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
}
public void Write()
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(endpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterSaga>(typeof(ConfigErrorQueue));
busConfiguration.TypesToScan(typesToScan);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
using (var bus = (UnicastBus)Bus.Create(busConfiguration).Start())
{
var message = new StartSaga1Message();
bus.SendLocal(message);
CountdownEvent.Wait();
}
}
public void Write()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(endpointName);
busConfiguration.UseDataBus <FileShareDataBus>().BasePath(@"..\..\..\storage");
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterDataBusProperty>(typeof(ConfigErrorQueue));
busConfiguration.TypesToScan(typesToScan);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
using (IBus bus = Bus.Create(busConfiguration).Start())
{
bus.SendLocal(new MessageToSend
{
LargeProperty1 = new DataBusProperty <byte[]>(new byte[10]),
LargeProperty2 = new DataBusProperty <byte[]>(new byte[10])
});
ManualResetEvent.WaitOne();
}
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var dataBus = endpointConfiguration.UseDataBus <FileShareDataBus>();
dataBus.BasePath(@"..\..\..\storage");
var typesToScan = TypeScanner.NestedTypes <HeaderWriterDataBusConvention>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
var conventions = endpointConfiguration.Conventions();
conventions.DefiningDataBusPropertiesAs(property =>
{
return(property.Name.StartsWith("LargeProperty"));
});
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var messageToSend = new MessageToSend
{
LargeProperty1 = new byte[10],
LargeProperty2 = new byte[10]
};
await endpointInstance.SendLocal(messageToSend)
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
IBus StartBus(State state)
{
var busConfiguration = new BusConfiguration();
busConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent(x => state, DependencyLifecycle.SingleInstance);
});
busConfiguration.EndpointName(endpointName);
busConfiguration.UseSerialization <JsonSerializer>();
var transport = busConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connectionString);
var sqlTypes = typeof(SqlServerTransport).Assembly.GetTypes();
busConfiguration.TypesToScan(TypeScanner.NestedTypes <Tests>(sqlTypes));
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.DisableFeature <SecondLevelRetries>();
return(Bus.Create(busConfiguration).Start());
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterSaga>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await endpointInstance.SendLocal(new StartSaga1Message())
.ConfigureAwait(false);
CountdownEvent.Wait();
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(endpointName);
var callbackTypes = typeof(RequestResponseExtensions).Assembly.GetTypes();
var typesToScan = TypeScanner.NestedTypes <HeaderWriterReturn>(callbackTypes);
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.MakeInstanceUniquelyAddressable("A");
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.RegisterComponents(
registration: components =>
{
components.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await endpointInstance.SendLocal(new MessageToSend())
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
}
public void Write()
{
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(EndpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterPublish>(typeof(ConfigErrorQueue));
busConfiguration.TypesToScan(typesToScan);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterComponents(
registration: c =>
{
c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall);
});
using (var bus = Bus.Create(busConfiguration).Start())
{
// give time for the subscription to happen
Thread.Sleep(3000);
bus.Publish(new MessageToPublish());
ManualResetEvent.WaitOne();
}
}
public void Write()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName(endpointName);
busConfiguration.RijndaelEncryptionService("key1", Encoding.ASCII.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6"));
busConfiguration.Conventions().DefiningEncryptedPropertiesAs(info => info.Name.StartsWith("EncryptedProperty"));
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterEncryption>(typeof(ConfigErrorQueue));
busConfiguration.TypesToScan(typesToScan);
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence <InMemoryPersistence>();
busConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
using (IBus bus = Bus.Create(busConfiguration).Start())
{
bus.SendLocal(new MessageToSend
{
EncryptedProperty1 = "String 1",
EncryptedProperty2 = "String 2"
});
ManualResetEvent.WaitOne();
}
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.RijndaelEncryptionService("2015-10", Encoding.ASCII.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6"));
endpointConfiguration.Conventions().DefiningEncryptedPropertiesAs(info => info.Name.StartsWith("EncryptedProperty"));
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterEncryption>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
await endpoint.SendLocal(new MessageToSend
{
EncryptedProperty1 = "String 1",
EncryptedProperty2 = "String 2"
});
ManualResetEvent.WaitOne();
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration("StartUpDiagnosticsWriter");
var typesToScan = TypeScanner.NestedTypes <HeaderWriterSend>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.UseTransport <LearningTransport>();
string diagnostics = null;
endpointConfiguration.CustomDiagnosticsWriter(x =>
{
diagnostics = x;
return(Task.CompletedTask);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
var jsonFormatted = JToken.Parse(diagnostics).ToString(Formatting.Indented);
var substring = string.Join("\r", jsonFormatted.Split('\r').Take(20)) + "\r\n...";
SnippetLogger.Write(substring);
await endpointInstance.Stop();
}
public async Task Write()
{
var endpointConfiguration = new EndpointConfiguration(EndpointName);
var typesToScan = TypeScanner.NestedTypes <HeaderWriterPublish>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
//give time for the subscription to happen
await Task.Delay(3000)
.ConfigureAwait(false);
await endpointInstance.Publish(new MessageToPublish())
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public async Task Write()
{
var errorIngestion = new EndpointConfiguration("error");
errorIngestion.SetTypesToScan(TypeScanner.NestedTypes <ErrorMutator>());
errorIngestion.EnableInstallers();
errorIngestion.UseTransport <LearningTransport>();
errorIngestion.Pipeline.Register(typeof(ErrorMutator), "Capture headers on failed messages");
await Endpoint.Start(errorIngestion);
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.SendFailedMessagesTo("error");
var typesToScan = TypeScanner.NestedTypes <HeaderWriterError>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.EnableInstallers();
endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.Pipeline.Register(typeof(Mutator), "Capture headers on sent messages");
var recoverability = endpointConfiguration.Recoverability();
recoverability.Immediate(settings => settings.NumberOfRetries(1));
recoverability.Delayed(settings =>
{
settings.NumberOfRetries(0);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await endpointInstance.SendLocal(new MessageToSend())
.ConfigureAwait(false);
ManualResetEvent.WaitOne();
}
public async Task Write()
{
EndpointConfiguration endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.UseDataBus <FileShareDataBus>().BasePath(@"..\..\..\storage");
IEnumerable <Type> typesToScan = TypeScanner.NestedTypes <HeaderWriterDataBusProperty>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.RegisterComponents(c => c.ConfigureComponent <Mutator>(DependencyLifecycle.InstancePerCall));
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
await endpoint.SendLocal(new MessageToSend
{
LargeProperty1 = new DataBusProperty <byte[]>(new byte[10]),
LargeProperty2 = new DataBusProperty <byte[]>(new byte[10])
});
ManualResetEvent.WaitOne();
await endpoint.Stop();
}
public void SetupScanner()
{
_scanner = new TypeScanner(MetadataReader, ModelFactory, Logger);
}
public IPagedQuery <T, U> GetPaged <T, U>() where T : IPagedQueryParameters
{
return(TypeScanner.Get <IPagedQuery <T, U> >());
}
protected BaseEndpointConfig(string endpointName)
{
_configEndpointName = string.IsNullOrEmpty(endpointName) ? GetEndpointName() : endpointName;
typeScanner = new TypeScanner(GetAssembliesToScan());
}
public NonEmptyRegistry()
{
Part()
.ForTypesMatching(x => x.Equals(typeof(FakePart)))
.AddMetadata(new { Foo = "Bar" })
.MakeShared()
.ImportConstructor()
.Exports(x =>
{
x.Export()
.Members(m => new[] { ReflectionServices.GetProperty<FakePart>(z => z.Delegate) })
.AddMetadata(new { Name = "Delegate" });
x.Export()
.Members(m => new[] { ReflectionServices.GetProperty<FakePart>(z => z.Name) })
.AddMetadata(new { Name = "Name" });
})
.Imports(x =>
{
x.Import()
.Members(m => new[] { ReflectionServices.GetProperty<FakePart>(z => z.Delegate) })
.RequireMetadata<string>("Name")
.AllowDefaultValue()
.Recomposable();
x.Import()
.Members(m => new[] { ReflectionServices.GetProperty<FakePart>(z => z.Name) })
.RequireMetadata<string>("Description");
x.Import()
.Members(m => new[] { ReflectionServices.GetProperty<FakePart>(z => z.Values) });
});
Part()
.ForTypesMatching(x => false);
ContractService.Configure(x => {
x.ForType<Func<string, string, object>>().ContractType<FakePart>().ContractName("Test");
x.ForType<string>().ContractType<FakePart>().ContractName("Test");
});
//Scan(x => {
// x.ExecutingAssembly();
// x.Assembly
//})
var scanner =
new TypeScanner();
scanner.AddTypes(() => Assembly.GetExecutingAssembly().GetExportedTypes());
this.TypeScanner = scanner;
}
static void Main(string[] args)
{
XmlConfigurator.Configure();
var types = TypeScanner.Scan(x => { x.AssembliesFromApplicationBaseDirectory(); }).Where(x => x.Namespace == "V1Antlr.Sample").ToArray();
var metaModel = new MetaModel();
metaModel.RegisterTypes(types);
var testTokens = new[] {
"Product.ID",
"Product.Title",
"Product.BodyHtml",
"Product.Variants.Price.@Min",
"OrderLineItem.Order.Name",
"OrderLineItem.Order.CreatedAt",
"OrderLineItem.Quantity",
"OrderLineItem.Title",
"OrderLineItem.VariantTitle",
"OrderLineItem.Order.CreatedAt",
//"Product.Visible",
"OrderLineItem.Product",
"OrderLineItem.Order.ID",
"Product.Images[(Position='1'|Position='2');(Position>'0')].Source",
"OrderLineItem.Properties[Name='Add a Monogram'].Value",
"OrderLineItem.Properties[Name='Custom Text'].Value",
"OrderLineItem.Properties[Name='Font'].Value",
"OrderLineItem.Properties[Name='Thread Color'].Value",
"OrderLineItem.Properties[Name='Color'].Value",
"Order.LineItems.Properties[Name='Color'].Value",
"Order.LineItems[+Properties;Quantity>'0'].Properties[Value!=''].Value"
//"Product.Url", // Calculated?
};
foreach (var testToken in testTokens)
{
var attr = metaModel.GetAttributeDefinition(testToken);
Console.WriteLine(attr.Token);
}
Query query = QueryBuilder.For("Product", metaModel)
.Select("Variants.Title", "Variants.Images", "Variants.Images.@Count", "Variants.Product.ID")
//.Where("ID='3'")
//.Where("Variants;ID>'0'")
//.Order("Title", "-BodyHtml", "+ID")
//.Skip(1)
//.Take(10)
.ToQuery();
var products = new Product[]
{
new Product
{
ID = 1,
Title = "Product #1",
BodyHtml = "Product #1 Body",
},
new Product
{
ID = 2,
Title = "Product #2",
BodyHtml = "Product #2 Body",
},
new Product
{
ID = 3,
Title = "Product #3",
BodyHtml = "Product #3 Body",
Variants = new List <ProductVariant>
{
new ProductVariant
{
ID = 30,
Price = 30.30m,
Quantity = 30,
Title = "Variant 30",
Images = new List <ProductImage>
{
new ProductImage
{
ID = 300,
Position = 1,
Source = "http://google.com"
},
new ProductImage
{
ID = 301,
Position = 2,
Source = "http://microsoft.com"
},
new ProductImage
{
ID = 302,
Position = 3,
Source = "http://amazon.com"
}
}
},
new ProductVariant
{
ID = 31,
Price = 31.31m,
Quantity = 31,
Title = "Variant 31"
},
new ProductVariant
{
ID = 32,
Price = 32.32m,
Quantity = 32,
Title = "Variant 32"
},
}
},
new Product
{
ID = 4,
Title = "Product #4",
BodyHtml = "Product #4 Body",
Variants = new List <ProductVariant>
{
new ProductVariant
{
ID = 40,
Price = 40.40m,
Quantity = 40,
Title = "Variant 40"
},
new ProductVariant
{
ID = 41,
Price = 41.41m,
Quantity = 41,
Title = "Variant 41"
},
new ProductVariant
{
ID = 42,
Price = 42.42m,
Quantity = 42,
Title = "Variant 42"
},
new ProductVariant
{
ID = 43,
Price = 43.43m,
Quantity = 43,
Title = "Variant 43"
},
}
},
};
var sortQuery = QueryBuilder.For("Product", metaModel).Select("ID").Order("-ID").ToQuery();
var sorted = products.AsQueryable().ApplyQuery(sortQuery);
var selected = products.AsQueryable().ApplyQuery(query);
foreach (var asset in selected.Assets)
{
Console.WriteLine("==========");
var titlesDef = metaModel.GetAttributeDefinition("Product.Variants.Title");
var imagesDef = metaModel.GetAttributeDefinition("Product.Variants.Images");
var titles = asset.GetAttributeValue <IEnumerable <string> >(titlesDef).ToList();
var images = asset.GetAttributeValue <IEnumerable <object> >(imagesDef).ToList();
foreach (var attributeDefinition in query.Selection)
{
var value = asset.GetAttributeValue <object>(attributeDefinition);
Console.WriteLine("\t{0}={1}", attributeDefinition.Name, value);
}
}
var singleRelationJoinQuery = QueryBuilder.For("ProductImage", metaModel).Select("Product.Title").ToQuery();
var testImages = new List <ProductImage>
{
new ProductImage
{
ID = 1,
Product = new Product
{
ID = 11,
Title = "Product #11"
}
},
new ProductImage
{
ID = 2,
Product = new Product
{
ID = 22,
Title = "Product #22"
}
},
new ProductImage
{
ID = 3,
Product = new Product
{
ID = 33,
Title = "Product #33"
}
},
};
var singleRelationJoinResults = testImages.AsQueryable().ApplyQuery(singleRelationJoinQuery);
Console.WriteLine("Done");
Console.ReadLine();
}
public AdminController(TypeScanner<IViewModel> viewModelScanner, ViewModelRebuilder vmBuilder)
{
_viewModelScanner = viewModelScanner;
_vmBuilder = vmBuilder;
}
private static MemberReference GetMemberReferenceFrom(MethodDefinition methodDefinition)
{
return(TypeScanner.ScanMethod(methodDefinition).MemberAccesses[0].MemberReference);
}
async Task RunTest(Action <EndpointConfiguration> testCase)
{
manualResetEvent.Reset();
string message = null;
Execute(endpointName, OutboxScriptBuilder.BuildDropScript(BuildSqlDialect.MsSqlServer));
Execute(endpointName, OutboxScriptBuilder.BuildCreateScript(BuildSqlDialect.MsSqlServer));
Execute(createUserDataTableText);
var endpointConfiguration = EndpointConfigBuilder.BuildEndpoint(endpointName);
//Hack: enable outbox to force sql session since we have no saga
endpointConfiguration.EnableOutbox();
var typesToScan = TypeScanner.NestedTypes <UserDataConsistencyTests>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.DisableFeature <TimeoutManager>();
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
testCase(endpointConfiguration);
transport.UseCustomSqlConnectionFactory(async() =>
{
var connection = MsSqlConnectionBuilder.Build();
await connection.OpenAsync().ConfigureAwait(false);
return(connection);
});
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.SqlDialect <SqlDialect.MsSqlServer>();
persistence.ConnectionBuilder(MsSqlConnectionBuilder.Build);
persistence.DisableInstaller();
persistence.SubscriptionSettings().DisableCache();
endpointConfiguration.DefineCriticalErrorAction(c =>
{
message = c.Error;
manualResetEvent.Set();
return(Task.FromResult(0));
});
endpointConfiguration.LimitMessageProcessingConcurrencyTo(1);
endpointConfiguration.Pipeline.Register(new FailureTrigger(), "Failure trigger");
var endpoint = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
var dataId = Guid.NewGuid();
var failingMessage = new FailingMessage
{
EntityId = dataId
};
await endpoint.SendLocal(failingMessage).ConfigureAwait(false);
var checkMessage = new CheckMessage
{
EntityId = dataId
};
await endpoint.SendLocal(checkMessage).ConfigureAwait(false);
manualResetEvent.WaitOne();
await endpoint.Stop().ConfigureAwait(false);
Assert.AreEqual("Success", message);
}
public void SetupScanner()
{
_assembly = NetAssembly("TestLibrary");
_scanner = new TypeScanner(Module, ModelFactory, Logger);
}
public IQuery <T, U> Get <T, U>() where T : class
{
return(TypeScanner.Get <IQuery <T, U> >());
}
async Task RunTest(Action <EndpointConfiguration> testCase)
{
ManualResetEvent.Reset();
string message = null;
var sagaDefinition = new SagaDefinition(
tableSuffix: nameof(Saga1),
name: nameof(Saga1),
correlationProperty: new CorrelationProperty
(
name: nameof(Saga1.SagaData.CorrelationId),
type: CorrelationPropertyType.Guid
)
);
Execute(SagaScriptBuilder.BuildDropScript(sagaDefinition, BuildSqlVariant.MsSqlServer));
Execute(OutboxScriptBuilder.BuildDropScript(BuildSqlVariant.MsSqlServer));
Execute(SagaScriptBuilder.BuildCreateScript(sagaDefinition, BuildSqlVariant.MsSqlServer));
Execute(OutboxScriptBuilder.BuildCreateScript(BuildSqlVariant.MsSqlServer));
var endpointConfiguration = EndpointConfigBuilder.BuildEndpoint(endpointName);
var typesToScan = TypeScanner.NestedTypes <SagaConsistencyTests>();
endpointConfiguration.SetTypesToScan(typesToScan);
endpointConfiguration.DisableFeature <NServiceBus.Features.TimeoutManager>();
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
testCase(endpointConfiguration);
transport.ConnectionString(MsSqlConnectionBuilder.ConnectionString);
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.ConnectionBuilder(MsSqlConnectionBuilder.Build);
persistence.SubscriptionSettings().DisableCache();
persistence.DisableInstaller();
endpointConfiguration.DefineCriticalErrorAction(c =>
{
message = c.Error;
ManualResetEvent.Set();
return(Task.FromResult(0));
});
endpointConfiguration.LimitMessageProcessingConcurrencyTo(1);
endpointConfiguration.Pipeline.Register(new FailureTrigger(), "Failure trigger");
var endpoint = await Endpoint.Start(endpointConfiguration).ConfigureAwait(false);
var sagaId = Guid.NewGuid();
await endpoint.SendLocal(new StartSagaMessage
{
SagaId = sagaId
}).ConfigureAwait(false);
await endpoint.SendLocal(new FailingMessage
{
SagaId = sagaId
}).ConfigureAwait(false);
await endpoint.SendLocal(new CheckMessage
{
SagaId = sagaId
}).ConfigureAwait(false);
ManualResetEvent.WaitOne();
await endpoint.Stop().ConfigureAwait(false);
Assert.AreEqual("Success", message);
}
