private void CompleteResolverTypeBindings(
ITypeInspector inspector,
INamingConventions naming)
{
foreach (ResolverTypeBindingInfo binding in
_bindings.OfType <ResolverTypeBindingInfo>()
.ToList())
{
ComplexTypeBindingInfo typeBinding = null;
if (binding.SourceType == null)
{
binding.SourceType = typeof(object);
}
if (binding.SourceType != null && binding.TypeName.IsEmpty)
{
typeBinding = _bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Type == binding.SourceType);
if (typeBinding == null)
{
binding.TypeName = naming.GetTypeName(
binding.SourceType, TypeKind.Object);
}
else
{
binding.TypeName = typeBinding.Name;
}
}
typeBinding = _bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Name.Equals(binding.TypeName));
if (typeBinding == null)
{
_bindings.Add(new ComplexTypeBindingInfo
{
Name = binding.TypeName,
Type = binding.SourceType
});
}
else if (binding.SourceType == typeof(object))
{
binding.SourceType = typeBinding.Type;
}
foreach (ResolverFieldBindingInfo field in binding.Fields)
{
if (field.FieldName.IsEmpty)
{
field.FieldName = naming.GetMemberName(
field.FieldMember, MemberKind.ObjectField);
}
}
if (binding.BindingBehavior == BindingBehavior.Implicit)
{
AddImplicitResolverBindings(inspector, naming, binding);
}
}
}
protected override void OnComplete(
IConventionContext context,
FilterConventionDefinition definition)
{
if (definition.Provider is null)
{
throw FilterConvention_NoProviderFound(GetType(), definition.Scope);
}
if (definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <IFilterProvider>(definition.Provider) ??
throw FilterConvention_NoProviderFound(GetType(), definition.Scope);
}
else
{
_provider = definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations = definition.Operations.ToDictionary(
x => x.Id,
FilterOperation.FromDefinition);
_bindings = definition.Bindings;
_configs = definition.Configurations;
_argumentName = definition.ArgumentName;
if (_provider is IFilterProviderConvention init)
{
init.Initialize(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
}
private void CompleteResolverBindings(INamingConventions naming)
{
foreach (ResolverBindingInfo binding in
_bindings.OfType <ResolverBindingInfo>()
.ToList())
{
if (binding.TypeName.IsEmpty)
{
ComplexTypeBindingInfo typeBinding =
_bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Type == binding.SourceType);
binding.TypeName = typeBinding == null
? naming.GetTypeName(binding.SourceType)
: typeBinding.Name;
}
if (binding.FieldName.IsEmpty)
{
binding.FieldName = naming.GetMemberName(
binding.Member, MemberKind.ObjectField);
}
if (!_bindings.OfType <ComplexTypeBindingInfo>()
.Any(t => t.Name.Equals(binding.TypeName)))
{
_bindings.Add(new ComplexTypeBindingInfo
{
Name = binding.TypeName,
Type = binding.SourceType
});
}
}
}
public ConsumerConfigurationFactory(IQueueConfigurationFactory queue, IExchangeDeclarationFactory exchange, IConsumeConfigurationFactory consume, INamingConventions conventions)
{
_queue = queue;
_exchange = exchange;
_consume = consume;
_conventions = conventions;
}
protected override void OnCompleteType(
ITypeCompletionContext context,
EnumTypeDefinition definition)
{
base.OnCompleteType(context, definition);
_naming = context.DescriptorContext.Naming;
SyntaxNode = definition.SyntaxNode;
foreach (EnumValueDefinition enumValueDefinition in definition.Values)
{
if (TryCreateEnumValue(context, enumValueDefinition, out IEnumValue? enumValue))
{
_enumValues[enumValue.Name] = enumValue;
_valueLookup[enumValue.Value] = enumValue;
}
}
if (!Values.Any())
{
context.ReportError(
SchemaErrorBuilder.New()
.SetMessage(TypeResources.EnumType_NoValues, Name)
.SetCode(ErrorCodes.Schema.NoEnumValues)
.SetTypeSystemObject(this)
.AddSyntaxNode(SyntaxNode)
.Build());
}
}
/// <summary>
/// Creates a new <see cref="ResourceTypeRegistrar"/>
/// </summary>
/// <param name="namingConventions">Conventions for naming types and fields</param>
public ResourceTypeRegistrar(INamingConventions namingConventions)
{
if (namingConventions == null)
{
throw new ArgumentNullException("namingConventions");
}
_namingConventions = namingConventions;
}
public DefaultParameterValues(
INamingConventions conventions,
IValueViewFactory valueViewFactory,
IDbConnectionFactory dbConnectionFactory) : base(dbConnectionFactory)
{
this.conventions = conventions;
this.valueViewFactory = valueViewFactory;
}
public MessageSequence(IBusClient client, INamingConventions naming, RawRabbitConfiguration clientCfg, SequenceModel model = null) : base(model)
{
_client = client;
_naming = naming;
_clientCfg = clientCfg;
_triggerConfigurer = new TriggerConfigurer();
_stepDefinitions = new Queue <StepDefinition>();
_subscriptions = new List <Subscription.ISubscription>();
}
public DefaultDbConnectionFactory(
IDbConnection dbConnection,
ISqlScriptsExecutor sqlScriptsExecutor,
INamingConventions namingConventions)
{
lazyPreparedConnection = new(() => PrepareConnectionAsync(dbConnection));
this.sqlScriptsExecutor = sqlScriptsExecutor;
this.namingConventions = namingConventions;
}
public RetryLaterMiddleware(ITopologyProvider topology, INamingConventions conventions, IChannelFactory channelFactory, IRetryInformationHeaderUpdater headerUpdater, RetryLaterOptions options = null)
{
TopologyProvider = topology;
Conventions = conventions;
ChannelFactory = channelFactory;
_headerUpdater = headerUpdater;
AcknowledgementFunc = options?.AcknowledgementFunc ?? (context => context.GetMessageAcknowledgement());
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
}
public DefaultStrategy(IMessageSerializer serializer, INamingConventions conventions, IBasicPropertiesProvider propertiesProvider, ITopologyProvider topologyProvider, IChannelFactory channelFactory)
{
_serializer = serializer;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_channelFactory = channelFactory;
_errorExchangeCfg = ExchangeConfiguration.Default;
_errorExchangeCfg.ExchangeName = conventions.ErrorExchangeNamingConvention();
}
public DefaultStrategy(IMessageSerializer serializer, INamingConventions conventions, IBasicPropertiesProvider propertiesProvider, ITopologyProvider topologyProvider, IChannelFactory channelFactory)
{
_serializer = serializer;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_channelFactory = channelFactory;
_errorExchangeCfg = ExchangeConfiguration.Default;
_errorExchangeCfg.ExchangeName = conventions.ErrorExchangeNamingConvention();
}
private DescriptorContext(
IReadOnlySchemaOptions options,
INamingConventions naming,
ITypeInspector inspector)
{
Options = options;
Naming = naming;
Inspector = inspector;
}
public ExplicitAckMiddleware(INamingConventions conventions, ITopologyProvider topology, IChannelFactory channelFactory, ExplicitAckOptions options = null)
{
Conventions = conventions;
Topology = topology;
ChannelFactory = channelFactory;
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
ConsumerFunc = options?.ConsumerFunc ?? (context => context.GetConsumer());
MessageAcknowledgementFunc = options?.GetMessageAcknowledgement ?? (context => context.GetMessageAcknowledgement());
AbortExecution = options?.AbortExecution ?? (ack => !(ack is Ack));
AutoAckFunc = options?.AutoAckFunc ?? (context => context.GetConsumeConfiguration().AutoAck);
}
public void Test_SetPropNamingConvention_ShouldSetConvention()
{
//---------------Set up test pack-------------------
INamingConventions nameConvention = MockRepository.GenerateMock <INamingConventions>();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
AllClassesAutoMapper.PropNamingConvention = nameConvention;
//---------------Test Result -----------------------
Assert.AreSame(nameConvention, ManyToOneAutoMapper.PropNamingConvention);
}
public void Test_SetIdentityNameConvention_ShouldSetCustomConvention()
{
//---------------Set up test pack-------------------
INamingConventions expectedConvention = MockRepository.GenerateMock <INamingConventions>();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
AllClassesAutoMapper.PropNamingConvention = expectedConvention;
//---------------Test Result -----------------------
Assert.AreSame(expectedConvention, ClassAutoMapper.PropNamingConvention);
}
protected override void Complete(IConventionContext context)
{
if (Definition?.Provider is null)
{
throw SortConvention_NoProviderFound(GetType(), Definition?.Scope);
}
if (Definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <ISortProvider>(Definition.Provider) ??
throw SortConvention_NoProviderFound(GetType(), Definition.Scope);
}
else
{
_provider = Definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations = Definition.Operations.ToDictionary(
x => x.Id,
SortOperation.FromDefinition);
foreach (var operation in _operations.Values)
{
if (!operation.Name.HasValue)
{
throw SortConvention_OperationIsNotNamed(this, operation);
}
}
_bindings = Definition.Bindings;
_defaultBinding = Definition.DefaultBinding;
_inputTypeConfigs = Definition.Configurations;
_enumTypeConfigs = Definition.EnumConfigurations;
_argumentName = Definition.ArgumentName;
if (_provider is ISortProviderConvention init)
{
IReadOnlyList <ISortProviderExtension> extensions =
CollectExtensions(context.Services, Definition);
init.Initialize(context);
MergeExtensions(context, init, extensions);
init.Complete(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
// It is important to always call base to continue the cleanup and the disposal of the
// definition
base.Complete(context);
}
public MessageSequence(IBusClient client,
INamingConventions naming,
ZyRabbitConfiguration clientCfg,
ILogger <MessageSequence> logger,
SequenceModel model = null) : base(model)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_naming = naming ?? throw new ArgumentNullException(nameof(naming));
_clientCfg = clientCfg ?? throw new ArgumentNullException(nameof(clientCfg));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_triggerConfigurer = new TriggerConfigurer();
_stepDefinitions = new Queue <StepDefinition>();
_subscriptions = new List <Subscription.ISubscription>();
}
public SubscriptionExceptionMiddleware(
IPipeBuilderFactory factory,
IChannelFactory channelFactory,
ITopologyProvider provider,
INamingConventions conventions,
SubscriptionExceptionOptions options)
: base(factory, new ExceptionHandlingOptions {
InnerPipe = options.InnerPipe
})
{
_channelFactory = channelFactory;
_provider = provider;
_conventions = conventions;
ChannelFunc = options?.ChannelFunc ?? ((c, f) => f.CreateChannelAsync());
}
public SubscriptionExceptionMiddleware(
IPipeBuilderFactory factory,
IChannelFactory channelFactory,
ITopologyProvider provider,
INamingConventions conventions,
ILogger <ExceptionHandlingMiddleware> logger,
SubscriptionExceptionOptions options)
: base(factory, logger, new ExceptionHandlingOptions {
InnerPipe = options.InnerPipe
})
{
_channelFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
_provider = provider ?? throw new ArgumentNullException(nameof(provider));
_conventions = conventions ?? throw new ArgumentNullException(nameof(conventions));
ChannelFunc = options?.ChannelFunc ?? ((c, f) => f.CreateChannelAsync());
}
public RetryLaterMiddleware(
ITopologyProvider topology,
INamingConventions conventions,
IChannelFactory channelFactory,
IRetryInformationHeaderUpdater headerUpdater,
ILogger <RetryLaterMiddleware> logger,
RetryLaterOptions options = null)
{
TopologyProvider = topology ?? throw new ArgumentNullException(nameof(topology));
Conventions = conventions ?? throw new ArgumentNullException(nameof(conventions));
ChannelFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
_headerUpdater = headerUpdater ?? throw new ArgumentNullException(nameof(headerUpdater));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
AcknowledgementFunc = options?.AcknowledgementFunc ?? (context => context.GetMessageAcknowledgement());
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
}
protected override void OnComplete(
IConventionContext context,
SortConventionDefinition definition)
{
if (definition.Provider is null)
{
throw SortConvention_NoProviderFound(GetType(), definition.Scope);
}
if (definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <ISortProvider>(definition.Provider) ??
throw SortConvention_NoProviderFound(GetType(), definition.Scope);
}
else
{
_provider = definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations = definition.Operations.ToDictionary(
x => x.Id,
SortOperation.FromDefinition);
foreach (var operation in _operations.Values)
{
if (!operation.Name.HasValue)
{
throw SortConvention_OperationIsNotNamed(this, operation);
}
}
_bindings = definition.Bindings;
_defaultBinding = definition.DefaultBinding;
_inputTypeConfigs = definition.Configurations;
_enumTypeConfigs = definition.EnumConfigurations;
_argumentName = definition.ArgumentName;
if (_provider is ISortProviderConvention init)
{
init.Initialize(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
}
public TypeDescriptorHelper(
INamingConventions namingConventions,
ITypeInspector typeInspector
)
{
this.namingConventions = namingConventions;
this.typeInspector = typeInspector;
typeRegistrar = new DefaultTypeRegistrar <IType>(
placeholderGenerator: MockITypeGenerator,
interceptor: TryGetScalarType
);
xmlDocumentationProvider = new XmlDocumentationProvider(
new XmlDocumentationFileResolver()
);
}
private DescriptorContext(
INamingConventions naming,
ITypeInspector inspector)
{
if (naming == null)
{
throw new ArgumentNullException(nameof(naming));
}
if (inspector == null)
{
throw new ArgumentNullException(nameof(inspector));
}
Naming = naming;
Inspector = inspector;
}
/// <inheritdoc />
protected override void Complete(IConventionContext context)
{
if (Definition?.Provider is null)
{
throw FilterConvention_NoProviderFound(GetType(), Definition?.Scope);
}
if (Definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <IFilterProvider>(Definition.Provider) ??
throw FilterConvention_NoProviderFound(GetType(), Definition.Scope);
}
else
{
_provider = Definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations =
Definition.Operations.ToDictionary(x => x.Id, FilterOperation.FromDefinition);
_bindings = Definition.Bindings;
_configs = Definition.Configurations;
_argumentName = Definition.ArgumentName;
_useAnd = Definition.UseAnd;
_useOr = Definition.UseOr;
if (_provider is IFilterProviderConvention init)
{
IReadOnlyList <IFilterProviderExtension> extensions =
CollectExtensions(context.Services, Definition);
init.Initialize(context, this);
MergeExtensions(context, init, extensions);
init.Complete(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
// It is important to always call base to continue the cleanup and the disposal of the
// definition
base.Complete(context);
}
private void CompleteComplexTypeBindings(
INamingConventions naming)
{
foreach (ComplexTypeBindingInfo binding in
_bindings.OfType <ComplexTypeBindingInfo>())
{
if (binding.Name.IsEmpty)
{
binding.Name = naming.GetTypeName(binding.Type);
}
foreach (ComplexTypeFieldBindingInfo field in binding.Fields)
{
if (field.Name.IsEmpty)
{
field.Name = naming.GetMemberName(
field.Member, MemberKind.Field);
}
}
}
}
private void AddImplicitResolverBindings(
ITypeInspector inspector,
INamingConventions naming,
ResolverTypeBindingInfo binding)
{
var names = new HashSet <NameString>(
binding.Fields.Select(t => t.FieldName));
foreach (MemberInfo member in inspector.GetMembers(binding.ResolverType))
{
NameString fieldName =
naming.GetMemberName(member, MemberKind.ObjectField);
if (names.Add(fieldName))
{
var builder = ResolverFieldBindingBuilder.New();
builder.SetResolver(member);
builder.SetField(fieldName);
binding.Fields = binding.Fields.Add(builder.Create());
}
}
}
public BasicPublishConfigurationFactory(INamingConventions conventions, ISerializer serializer, RawRabbitConfiguration config)
{
_conventions = conventions;
_serializer = serializer;
_config = config;
}
/// <summary>
/// Creates a new <see cref="ResourceTypeRegistrar"/>
/// </summary>
/// <param name="namingConventions">Conventions for naming types and fields</param>
public ResourceTypeRegistrar(INamingConventions namingConventions)
{
if (namingConventions == null) throw new ArgumentNullException("namingConventions");
_namingConventions = namingConventions;
}
public ControllerActionLocator(INamingConventions namingConventions)
{
this.namingConventions = namingConventions;
}
public QueueDeclarationFactory(ZyRabbitConfiguration config, INamingConventions conventions)
{
_config = config;
_conventions = conventions;
}
public ActionControllerFactory(Dictionary<string, Type> actionTypes, INamingConventions namingConventions, Func<Type, object> createController)
{
_actionTypes = actionTypes;
_namingConventions = namingConventions;
_createController = createController;
}
public AttributeConfigEvaluator(RawRabbitConfiguration config, INamingConventions conventions)
{
_fallback = new ConfigurationEvaluator(config, conventions);
}
public ApplicationContextEnhancer(IChannelFactory channelFactory, INamingConventions conventions)
{
_channelFactory = channelFactory;
_conventions = conventions;
}
