public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo parameter = context.Parameter; HttpTriggerAttribute attribute = parameter.GetCustomAttribute <HttpTriggerAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <ITriggerBinding>(null)); } // Can bind to user types, HttpRequestMessage, object (for dynamic binding support) and all the Read // Types supported by StreamValueBinder IEnumerable <Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.Read) .Union(new Type[] { typeof(HttpRequest), typeof(object), typeof(HttpRequestMessage) }); bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes); bool isUserTypeBinding = !isSupportedTypeBinding && IsValidUserType(parameter.ParameterType); if (!isSupportedTypeBinding && !isUserTypeBinding) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind HttpTriggerAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <ITriggerBinding>(new HttpTriggerBinding(attribute, context.Parameter, isUserTypeBinding, _responseHook))); }
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo parameter = context.Parameter; ManualTriggerAttribute attribute = parameter.GetCustomAttribute <ManualTriggerAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <ITriggerBinding>(null)); } // Can bind to user types, and all the Read Types supported by StreamValueBinder IEnumerable <Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.Read); bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes); bool isUserTypeBinding = !isSupportedTypeBinding && Utility.IsValidUserType(parameter.ParameterType); if (!isSupportedTypeBinding && !isUserTypeBinding) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ManualTriggerAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <ITriggerBinding>(new ManualTriggerBinding(context.Parameter, isUserTypeBinding))); }
/// <inheritdoc/> public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo parameter = context.Parameter; FileTriggerAttribute attribute = parameter.GetCustomAttribute <FileTriggerAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <ITriggerBinding>(null)); } // next, verify that the type is one of the types we support IEnumerable <Type> types = StreamValueBinder.GetSupportedTypes(FileAccess.Read) .Union(new Type[] { typeof(FileStream), typeof(FileSystemEventArgs), typeof(FileInfo) }); if (!ValueBinder.MatchParameterType(context.Parameter, types)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind FileTriggerAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <ITriggerBinding>(new FileTriggerBinding(_config, parameter, _logger))); }
public Task <IBinding> TryCreateAsync(BindingProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } ParameterInfo parameter = context.Parameter; FtpAttribute attribute = parameter.GetCustomAttribute <FtpAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <IBinding>(null)); } string path = attribute.Path; if (_nameResolver != null) { path = _nameResolver.ResolveWholeString(path); } BindingTemplate bindingTemplate = BindingTemplate.FromString(path); bindingTemplate.ValidateContractCompatibility(context.BindingDataContract); IEnumerable <Type> types = StreamValueBinder.GetSupportedTypes(FileAccess.Read); if (!ValueBinder.MatchParameterType(context.Parameter, types)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind FtpAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <IBinding>(new FtpBinding(_config, parameter, bindingTemplate))); }
public Task <IBinding> TryCreateAsync(BindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } // Determine whether we should bind to the current parameter ParameterInfo parameter = context.Parameter; SampleAttribute attribute = parameter.GetCustomAttribute <SampleAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <IBinding>(null)); } // TODO: Include any other parameter types this binding supports in this check IEnumerable <Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.ReadWrite); if (!ValueBinder.MatchParameterType(context.Parameter, supportedTypes)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind SampleAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <IBinding>(new SampleBinding(parameter))); }
public void GetSupportedTypes_FileAccessWrite_ReturnsExpectedTypes() { Type[] expected = new Type[] { typeof(Stream), typeof(TextWriter), typeof(StreamWriter), typeof(string), typeof(byte[]) }; IEnumerable <Type> result = StreamValueBinder.GetSupportedTypes(FileAccess.Write); Assert.True(expected.SequenceEqual(result)); }
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo parameter = context.Parameter; WebHookTriggerAttribute attribute = parameter.GetCustomAttribute <WebHookTriggerAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <ITriggerBinding>(null)); } // Can bind to user types, HttpRequestMessage, WebHookContext, and all the Read // Types supported by StreamValueBinder IEnumerable <Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.Read) .Union(new Type[] { typeof(HttpRequestMessage), typeof(WebHookContext) }); bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes); bool isUserTypeBinding = !isSupportedTypeBinding && WebHookTriggerBinding.IsValidUserType(parameter.ParameterType); if (!isSupportedTypeBinding && !isUserTypeBinding) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind WebHookTriggerAttribute to type '{0}'.", parameter.ParameterType)); } if (!isUserTypeBinding && attribute.FromUri) { throw new InvalidOperationException("'FromUri' can only be set to True when binding to custom Types."); } // Validate route format if (!string.IsNullOrEmpty(attribute.Route)) { string[] routeSegements = attribute.Route.Split('/'); if (routeSegements.Length > 2) { throw new InvalidOperationException("WebHook routes can only have a maximum of two segments."); } } return(Task.FromResult <ITriggerBinding>(new WebHookTriggerBinding(_dispatcher, context.Parameter, isUserTypeBinding, attribute))); }
/// <inheritdoc/> public Task <IBinding> TryCreateAsync(BindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } // Determine whether we should bind to the current parameter ParameterInfo parameter = context.Parameter; FileAttribute attribute = parameter.GetCustomAttribute <FileAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <IBinding>(null)); } // first, verify the file path binding (if it contains binding parameters) string path = attribute.Path; if (_nameResolver != null) { path = _nameResolver.ResolveWholeString(path); } BindingTemplate bindingTemplate = BindingTemplate.FromString(path); bindingTemplate.ValidateContractCompatibility(context.BindingDataContract); IEnumerable <Type> types = StreamValueBinder.GetSupportedTypes(attribute.Access) .Union(new Type[] { typeof(FileStream), typeof(FileInfo) }); if (!ValueBinder.MatchParameterType(context.Parameter, types)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind FileAttribute to type '{0}'.", parameter.ParameterType)); } return(Task.FromResult <IBinding>(new FileBinding(_options, parameter, bindingTemplate))); }