public void Everything_should_match_hash() { var bindingInfo = new BindingInfo(new QueueInfo("the queue", true, false, false, null), "#"); bindingInfo.RoutingKeyMatches("abc").ShouldBeTrue(); bindingInfo.RoutingKeyMatches("def").ShouldBeTrue(); }
// private DomainModel.Person.PersonRole TransformRole(DTO.Role role) // { // return (DomainModel.Person.PersonRole)Enum.Parse( // typeof(DomainModel.Person.PersonRole), role.ToString(), true); // } public void AddPerson(DTO.Person dto, BindingInfo personBinding, BindingInfo[] addressBindings) { // DomainModel.Person person = new DomainModel.Person(dto.Name, dto.Password); DomainModel.Person person = ((Person.PersonFactory)Registry.Instance.getFactory(typeof(Person))) .createPerson(dto.Name, dto.Password); // if(dto.Roles != null) // { // foreach(DTO.Role role in dto.Roles) // { // person.AddRole(TransformRole(role)); // } // } new TimestampIdBinding(person, personBinding); if(dto.Addresses != null) { for(int i = 0; i < dto.Addresses.Length; i++) { DTO.Address dtoAddress = dto.Addresses[i]; Address address = ((Address.AddressFactory)Registry.Instance.getFactory(typeof(Address))) .createAddress(person, dtoAddress.City, dtoAddress.Street, dtoAddress.Postalcode, dtoAddress.Phone, dtoAddress.Email); person.addAddress(address); // DomainModel.Address address = // person.AddAddress(dtoAddress.Street, // dtoAddress.City, dtoAddress.Postalcode, // dtoAddress.Email, dtoAddress.Phone); new TimestampIdBinding(address, addressBindings[i]); } } }
public void Should_exact_match_should_match() { var bindingInfo = new BindingInfo(new QueueInfo("the queue", true, false, false, null), "abc"); bindingInfo.RoutingKeyMatches("abc").ShouldBeTrue(); bindingInfo.RoutingKeyMatches("def").ShouldBeFalse(); }
public void Dot_separated_keys_should_match_with_wild_cards() { var bindingInfo = new BindingInfo(new QueueInfo("the queue", true, false, false, null), "a.*.c"); bindingInfo.RoutingKeyMatches("a.b.c").ShouldBeTrue(); bindingInfo.RoutingKeyMatches("a.d.c").ShouldBeTrue(); bindingInfo.RoutingKeyMatches("a.b.d").ShouldBeFalse(); }
public DomainModel.Product AddProduct(DTO.Product dto, BindingInfo bindingInfo) { // DomainModel.Product product = new DomainModel.Product( // dto.Name, dto.QuantityPerUnit, dto.UnitPrice, dto.Category); Product product = ((Product.ProductFactory)Registry.Instance.getFactory(typeof(Product))) .createProduct(dto.Name, dto.QuantityPerUnit, dto.UnitPrice, dto.Category); new TimestampIdBinding(product, bindingInfo); return product; }
// public void AddRole(int personId, DTO.Role role, BindingInfo bindingInfo) // { // DomainModel.Person person = LoadPerson(personId); // person.AddRole(TransformRole(role)); // new TimestampIdBinding(person, bindingInfo); // } // // public void RemoveRole(int personId, DTO.Role role, BindingInfo bindingInfo) // { // DomainModel.Person person = LoadPerson(personId); // person.RemoveRole(TransformRole(role)); // new TimestampIdBinding(person, bindingInfo); // } public void AddAddress(int personId, DTO.Address dto, BindingInfo bindingInfo) { DomainModel.Person person = LoadPerson(personId); Address address = ((Address.AddressFactory)Registry.Instance.getFactory(typeof(Address))) .createAddress(person, dto.City, dto.Street, dto.Postalcode, dto.Phone, dto.Email); person.addAddress(address); // DomainModel.Address address = person.AddAddress( // dto.Street, dto.City, dto.Postalcode, dto.Email, dto.Phone); new TimestampIdBinding(address, bindingInfo); }
public void AddOrderDetail(int orderId, DTO.OrderDetail dto, BindingInfo bindingInfo) { DomainModel.Order order = LoadOrder(orderId); if(order != null) { DomainModel.Product product = ProductService.LoadProduct(dto.ProductId); DomainModel.OrderDetail detail = order.AddOrderDetail(product, dto.UnitPrice, dto.Quantity); new TimestampIdBinding(detail, bindingInfo); } }
public void UpdateProduct(DTO.Product dto, BindingInfo bindingInfo) { DomainModel.Product product = LoadProduct(dto.Id); if(product != null) { if(product.Timestamp.Equals(new Timestamp(dto.Timestamp)) == false) throw new ApplicationException("ConcurrencyException"); product.ProductName = dto.Name; product.QuantityPerUnit = dto.QuantityPerUnit; product.UnitPrice = dto.UnitPrice; new TimestampIdBinding(product, bindingInfo); } }
public void Bind( INotifyPropertyChanged source, string sourcePropertyName, INotifyPropertyChanged target, string targetPropertyName) { var bindingInfo = new BindingInfo { Source = source, SourcePropertyName = sourcePropertyName, Target = target, TargetPropertyName = targetPropertyName }; _binding.Add(bindingInfo); source.PropertyChanged += PropertyChangedEventHandler; target.PropertyChanged += PropertyChangedEventHandler; }
/// <summary> /// Creates a group with the fields for send port parsing. /// </summary> /// <returns>A populated <see cref="ParsedBizTalkApplicationGroup"/>.</returns> private static ParsedBizTalkApplicationGroup CreateGroup() { var group = new ParsedBizTalkApplicationGroup(); var application = new ParsedBizTalkApplication(); var bindingInfo = new BindingInfo(); var distributionLists = new List <DistributionList> { new DistributionList() { Name = "Send Port Group 1", Filter = "" } }; bindingInfo.DistributionListCollection = distributionLists.ToArray(); application.Application.Bindings = new BindingFile("TestContainer", "BindingInfo") { BindingInfo = bindingInfo }; group.Applications.Add(application); return(group); }
public static bool HasExistingBinding(List <BindingInfo> bindings, BindingInfo spec) { foreach (var b in bindings) { // same protocol if (b.Protocol == spec.Protocol && b.Port == spec.Port) { // same or blank host if (b.Host == spec.Host || (string.IsNullOrEmpty(b.Host) && string.IsNullOrEmpty(spec.Host))) { // same or unassigned IP if (spec.IP == b.IP || (unassignedIPs.Contains(spec.IP) && unassignedIPs.Contains(b.IP))) { return(true); } } } } return(false); }
private void ConfigureParameters(ControllerModel controller) { foreach (var action in controller.Actions) { foreach (var para in action.Parameters) { if (para.BindingInfo != null) { continue; } if (!TypeHelper.IsPrimitiveExtendedIncludingNullable(para.ParameterInfo.ParameterType)) { if (CanUseFormBodyBinding(action, para)) { para.BindingInfo = BindingInfo.GetBindingInfo(new[] { new FromBodyAttribute() }); } } } } }
public override IModelBinder CreateBinder(ModelMetadata metadata, BindingInfo bindingInfo) { if (metadata == null) { throw new ArgumentNullException(nameof(metadata)); } if (bindingInfo == null) { throw new ArgumentNullException(nameof(bindingInfo)); } // For non-root nodes we use the ModelMetadata as the cache token. This ensures that all non-root // nodes with the same metadata will have the same binder. This is OK because for an non-root // node there's no opportunity to customize binding info like there is for a parameter. var token = metadata; var nestedContext = new DefaultModelBinderProviderContext(this, metadata, bindingInfo); return(_factory.CreateBinderCoreCached(nestedContext, token)); }
private int FindAncestorLevel(BindingInfo binding) { int level = 1; var parent = (TypeNode)Parent; while (parent != null) { if (binding != null) { if (binding.AncestorLevel == level || parent.Type == binding.AncestorType) { return(level); } } parent = (TypeNode)parent.Parent; level++; } return(level); }
private void CreateSampleStep(StepDefinition stepDefinition) { BindingInfo bindingInfo = bindingByStepDef[stepDefinition]; Debug.Assert(bindingInfo != null); switch (stepDefinition.Type) { case "Given": stepDefinition.ScenarioStep = new Given(); break; case "When": stepDefinition.ScenarioStep = new When(); break; case "Then": stepDefinition.ScenarioStep = new Then(); break; default: throw new InvalidOperationException(); } stepDefinition.ScenarioStep.Text = GetSampleText(bindingInfo); }
public async Task BindModelAsync_WithBindProperty_EnforcesBindRequired(int?input, bool isValid) { // Arrange var parameterBinder = ModelBindingTestHelper.GetParameterBinder(); var parameter = new ParameterDescriptor() { Name = nameof(TestController.BindRequiredProp), ParameterType = typeof(string), BindingInfo = BindingInfo.GetBindingInfo(new[] { new BindPropertyAttribute() }), }; var testContext = ModelBindingTestHelper.GetTestContext(request => { request.Method = "POST"; if (input.HasValue) { request.QueryString = new QueryString($"?{parameter.Name}={input.Value}"); } }); var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var modelMetadata = modelMetadataProvider .GetMetadataForProperty(typeof(TestController), parameter.Name); // Act var result = await parameterBinder.BindModelAsync( parameter, testContext, modelMetadataProvider, modelMetadata); // Assert Assert.Equal(input.HasValue, result.IsModelSet); Assert.Equal(isValid, testContext.ModelState.IsValid); if (isValid) { Assert.Equal(input.Value, Assert.IsType <int>(result.Model)); } }
private ControllerActionDescriptor CreateActionDescriptor( string httpMethod, string routeTemplate, string actionFixtureName) { var descriptor = new ControllerActionDescriptor(); descriptor.SetProperty(new ApiDescriptionActionData()); descriptor.DisplayName = actionFixtureName; descriptor.ActionConstraints = new List <IActionConstraintMetadata> { new HttpMethodConstraint(new[] { httpMethod }) }; descriptor.AttributeRouteInfo = new AttributeRouteInfo { Template = routeTemplate }; descriptor.MethodInfo = typeof(ActionFixtures).GetMethod(actionFixtureName); if (descriptor.MethodInfo == null) { throw new InvalidOperationException( string.Format("{0} is not declared in ActionFixtures", actionFixtureName)); } descriptor.Parameters = descriptor.MethodInfo.GetParameters() .Select(paramInfo => new ParameterDescriptor { Name = paramInfo.Name, ParameterType = paramInfo.ParameterType, BindingInfo = BindingInfo.GetBindingInfo(paramInfo.GetCustomAttributes(false)) }) .ToList(); // Set some additional properties - typically done via IApplicationModelConvention var attributes = descriptor.MethodInfo.GetCustomAttributes(true); descriptor.Properties.Add("ActionAttributes", attributes); descriptor.Properties.Add("IsObsolete", attributes.OfType <ObsoleteAttribute>().Any()); return(descriptor); }
private void ApplyDockingLayout(string text) { // Save the binding expressions of all the current anchorables var bindings = new Dictionary <string, List <BindingInfo> >(); foreach (var anchorable in AvalonDockHelper.GetAllAnchorables(DockingManager).Where(x => !string.IsNullOrEmpty(x.ContentId))) { var titleBindingInfo = BindingInfo.FromBindingExpression(BindingOperations.GetBindingExpression(anchorable, LayoutContent.TitleProperty)); var isVisibleBindingInfo = BindingInfo.FromBindingExpression(BindingOperations.GetBindingExpression(anchorable, AvalonDockHelper.IsVisibleProperty)); bindings.Add(anchorable.ContentId, new List <BindingInfo> { titleBindingInfo, isVisibleBindingInfo }); } // Unregister docking manager AvalonDockHelper.UnregisterDockingManager(DockingManager); // Deserialize the string using (var stream = new MemoryStream()) { var writer = new StreamWriter(stream); writer.Write(text); writer.Flush(); stream.Seek(0, SeekOrigin.Begin); var serializer = new XmlLayoutSerializer(DockingManager); serializer.Deserialize(stream); } // Apply saved the binding expressions to the newly deserialized anchorables foreach (var anchorable in AvalonDockHelper.GetAllAnchorables(DockingManager).Where(x => !string.IsNullOrEmpty(x.ContentId))) { List <BindingInfo> bindingInfos; if (bindings.TryGetValue(anchorable.ContentId, out bindingInfos)) { foreach (var bindingInfo in bindingInfos) { BindingOperations.SetBinding(anchorable, bindingInfo.Property, bindingInfo.Binding); } } } // Re-register docking manager with new layout AvalonDockHelper.RegisterDockingManager(session.ServiceProvider, DockingManager); }
public async Task FromBodyOnParameterType_WithData_Succeeds(BindingInfo bindingInfo) { // Arrange var inputText = "{ \"Street\" : \"someStreet\" }"; var metadataProvider = new TestModelMetadataProvider(); metadataProvider .ForType <Address6>() .BindingDetails(binding => binding.BindingSource = BindingSource.Body); var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider); var parameter = new ParameterDescriptor { Name = "parameter-name", BindingInfo = bindingInfo, ParameterType = typeof(Address6), }; var testContext = ModelBindingTestHelper.GetTestContext( request => { request.Body = new MemoryStream(Encoding.UTF8.GetBytes(inputText)); request.ContentType = "application/json"; }); testContext.MetadataProvider = metadataProvider; var modelState = testContext.ModelState; // Act var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext); // Assert Assert.True(modelBindingResult.IsModelSet); var address = Assert.IsType <Address6>(modelBindingResult.Model); Assert.Equal("someStreet", address.Street, StringComparer.Ordinal); Assert.True(modelState.IsValid); Assert.Empty(modelState); }
public async Task BinderTypeOnParameterType_WithDataEmptyPrefixAndVersion20_GetsBound( BindingInfo bindingInfo) { // Arrange var testContext = ModelBindingTestHelper.GetTestContext( // ParameterBinder will use ModelMetadata for typeof(Address), not Parameter1's ParameterInfo. updateOptions: options => options.AllowValidatingTopLevelNodes = false); var modelState = testContext.ModelState; var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext.HttpContext.RequestServices); var parameter = new ParameterDescriptor { Name = "Parameter1", BindingInfo = bindingInfo, ParameterType = typeof(Address), }; // Act var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext); // Assert // ModelBindingResult Assert.True(modelBindingResult.IsModelSet); // Model var address = Assert.IsType <Address>(modelBindingResult.Model); Assert.Equal("SomeStreet", address.Street); // ModelState Assert.True(modelState.IsValid); var kvp = Assert.Single(modelState); Assert.Equal("Street", kvp.Key); var entry = kvp.Value; Assert.NotNull(entry); Assert.Equal(ModelValidationState.Valid, entry.ValidationState); Assert.NotNull(entry.RawValue); // Value is set by test model binder, no need to validate it. }
protected virtual BindingInfo CreateBindingInfo <TNamingConvention>(IApplicationBinding <TNamingConvention> applicationBinding) where TNamingConvention : class { ((ISupportValidation)applicationBinding).Validate(); var bi = new BindingInfo(); bi.BindingParameters = new BindingParameters(new Version(bi.Version)) { BindingActions = BindingParameters.BindingActionTypes.Bind, BindingItems = BindingParameters.BindingItemTypes.All, BindingScope = BindingParameters.BindingScopeType.Application, BindingSetState = BindingParameters.BindingSetStateType.UseServiceState }; bi.Description = applicationBinding.Description; bi.ModuleRefCollection = new ModuleRefCollection { new ModuleRef(string.Format("[Application:{0}]", ApplicationName), string.Empty, string.Empty, string.Empty) // TODO ref schemas, transforms, and other artifacts }; bi.Timestamp = applicationBinding.Timestamp; return(bi); }
private static bool TrySourceAdditionalParameter( BindingInfo bindingInfo, IWebHookBindingMetadata bindingMetadata, string parameterName) { var parameter = bindingMetadata?.Parameters .FirstOrDefault(item => string.Equals(parameterName, item.Name, StringComparison.OrdinalIgnoreCase)); if (parameter == null) { return(false); } bindingInfo.BinderModelName = parameter.SourceName; switch (parameter.ParameterType) { case WebHookParameterType.Header: bindingInfo.BindingSource = BindingSource.Header; break; case WebHookParameterType.RouteValue: bindingInfo.BindingSource = BindingSource.Path; break; case WebHookParameterType.QueryParameter: bindingInfo.BindingSource = BindingSource.Query; break; default: var message = string.Format( CultureInfo.CurrentCulture, Resources.General_InvalidEnumValue, nameof(WebHookParameterType), parameter.ParameterType); throw new InvalidOperationException(message); } return(true); }
public async Task BinderTypeOnParameterType_WithData_EmptyPrefix_GetsBound(BindingInfo bindingInfo) { // Arrange var parameterBinder = ModelBindingTestHelper.GetParameterBinder(); var parameters = typeof(TestController).GetMethod(nameof(TestController.Action)).GetParameters(); var parameter = new ControllerParameterDescriptor { Name = "Parameter1", BindingInfo = bindingInfo, ParameterInfo = parameters[0], ParameterType = typeof(Address), }; var testContext = ModelBindingTestHelper.GetTestContext(); var modelState = testContext.ModelState; // Act var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext); // Assert // ModelBindingResult Assert.True(modelBindingResult.IsModelSet); // Model var address = Assert.IsType <Address>(modelBindingResult.Model); Assert.Equal("SomeStreet", address.Street); // ModelState Assert.True(modelState.IsValid); var kvp = Assert.Single(modelState); Assert.Equal("Street", kvp.Key); var entry = kvp.Value; Assert.NotNull(entry); Assert.Equal(ModelValidationState.Valid, entry.ValidationState); Assert.NotNull(entry.RawValue); // Value is set by test model binder, no need to validate it. }
protected override BindingInfo <IThreadManager> GetThreadManager() { if (Context.Platform.Platform != PlatformType.WinForms) { return(BindingInfo <IThreadManager> .Empty); } if (UseSimpleThreadManager) { return(BindingInfo <IThreadManager> .FromType <SynchronousThreadManager>(DependencyLifecycle.SingleInstance)); } return(BindingInfo <IThreadManager> .FromMethod((container, list) => { var context = SynchronizationContext.Current as WindowsFormsSynchronizationContext; if (context == null) { context = new WindowsFormsSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(context); WindowsFormsSynchronizationContext.AutoInstall = false; } return new ThreadManager(context); }, DependencyLifecycle.SingleInstance)); }
public async Task <IActionResult> Post(BindingInfo info) { var table = _utilities.GetCloudTable("Bindings"); var operation = TableOperation.InsertOrReplace(new TableEntity { PartitionKey = info.SourceId, RowKey = info.TargetId }); await table.ExecuteAsync(operation); operation = TableOperation.InsertOrReplace(new TableEntity { PartitionKey = info.TargetId, RowKey = info.SourceId }); await table.ExecuteAsync(operation); return(new NoContentResult()); }
public void Test_Apply_AddsParameterMetadataSetsBinding() { var metadata = new MethodMetadata(new JsonRpcMethodOptions(), new JsonName("", ""), new JsonName("", "")); var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object>()).Object; var actionModel = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(MvcTestController.VoidAction)), new List <object>()).Object; actionModel.Properties[typeof(MethodMetadata)] = metadata; var model = new Mock <ParameterModel>(typeof(JsonRpcTestController).GetMethod(nameof(MvcTestController.VoidAction)).GetParameters()[0], new List <object>()).Object; actionModel.Controller = controllerModel; model.Action = actionModel; var binding = new BindingInfo(); model.BindingInfo = binding; model.ParameterName = "test"; var parameterConvention = testEnvironment.ServiceProvider.GetRequiredService <ParameterConvention>(); parameterConvention.Apply(model); metadata.ParametersInternal.Should().HaveCount(1); model.BindingInfo.Should().NotBeNull(); }
public async Task BinderTypeOnProperty_WithData_EmptyPrefix_GetsBound(BindingInfo bindingInfo) { // Arrange var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(); var parameter = new ParameterDescriptor { Name = "Parameter1", BindingInfo = bindingInfo, ParameterType = typeof(Person3), }; var testContext = ModelBindingTestHelper.GetTestContext(); var modelState = testContext.ModelState; // Act var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext); // Assert // ModelBindingResult Assert.True(modelBindingResult.IsModelSet); // Model var person = Assert.IsType <Person3>(modelBindingResult.Model); Assert.NotNull(person.Address); Assert.Equal("SomeStreet", person.Address.Street); // ModelState Assert.True(modelState.IsValid); var kvp = Assert.Single(modelState); Assert.Equal("Address.Street", kvp.Key); var entry = kvp.Value; Assert.NotNull(entry); Assert.Equal(ModelValidationState.Valid, entry.ValidationState); Assert.NotNull(entry.RawValue); // Value is set by test model binder, no need to validate it. }
/// <summary> /// Creates a <see cref="PagePropertyModel"/> for the <paramref name="property"/>. /// </summary> /// <param name="property">The <see cref="PropertyInfo"/>.</param> /// <returns>The <see cref="PagePropertyModel"/>.</returns> protected virtual PagePropertyModel CreatePropertyModel(PropertyInfo property) { if (property == null) { throw new ArgumentNullException(nameof(property)); } var propertyAttributes = property.GetCustomAttributes(inherit: true); // BindingInfo for properties can be either specified by decorating the property with binding-specific attributes. // ModelMetadata also adds information from the property's type and any configured IBindingMetadataProvider. var propertyMetadata = _modelMetadataProvider.GetMetadataForProperty(property.DeclaringType, property.Name); var bindingInfo = BindingInfo.GetBindingInfo(propertyAttributes, propertyMetadata); if (bindingInfo == null) { // Look for BindPropertiesAttribute on the handler type if no BindingInfo was inferred for the property. // This allows a user to enable model binding on properties by decorating the controller type with BindPropertiesAttribute. var declaringType = property.DeclaringType; var bindPropertiesAttribute = declaringType.GetCustomAttribute <BindPropertiesAttribute>(inherit: true); if (bindPropertiesAttribute != null) { var requestPredicate = bindPropertiesAttribute.SupportsGet ? _supportsAllRequests : _supportsNonGetRequests; bindingInfo = new BindingInfo { RequestPredicate = requestPredicate, }; } } var model = new PagePropertyModel(property, propertyAttributes) { PropertyName = property.Name, BindingInfo = bindingInfo, }; return(model); }
internal void SendFunctionLoadRequest(FunctionRegistrationContext context) { FunctionMetadata metadata = context.Metadata; // associate the invocation input buffer with the function _functionInputBuffers[context.Metadata.FunctionId] = context.InputBuffer; // send a load request for the registered function FunctionLoadRequest request = new FunctionLoadRequest() { FunctionId = metadata.FunctionId, Metadata = new RpcFunctionMetadata() { Name = metadata.Name, Directory = metadata.FunctionDirectory ?? string.Empty, EntryPoint = metadata.EntryPoint ?? string.Empty, ScriptFile = metadata.ScriptFile ?? string.Empty } }; if (_managedDependencyOptions?.Value != null) { _workerChannelLogger?.LogInformation($"Adding dependency download request to {_workerConfig.Language} language worker"); request.ManagedDependencyEnabled = _managedDependencyOptions.Value.Enabled; } foreach (var binding in metadata.Bindings) { BindingInfo bindingInfo = binding.ToBindingInfo(); request.Metadata.Bindings.Add(binding.Name, bindingInfo); } SendStreamingMessage(new StreamingMessage { FunctionLoadRequest = request }); }
public void LongPropertyPathForSource() { var simpleClass1 = new SimpleClass1 { Child = new SimpleClass1() }; var simpleClass2 = new SimpleClass1(); var bindingInfo = new BindingInfo { BindingMode = BindingMode.OneWay, SourcePath = nameof(simpleClass1.Child) + "." + LastName, Source = simpleClass1, Target = simpleClass2, TargetPath = LastName }; bindingInfo.Connect(); simpleClass1.Child.LastName = "Alex0"; MustEqual("Alex0", simpleClass2.LastName); }
/// <summary> /// Parses the service bindings. /// </summary> /// <param name="bindingInfo">The binding info containing the service bindings to parse.</param> /// <param name="bindingResourceDefintion">The binding resource definition to add the new resources to.</param> private void ParseServiceBindings(BindingInfo bindingInfo, ResourceDefinition bindingResourceDefintion) { foreach (var serviceBinding in bindingInfo.ModuleRefCollection.SelectMany(m => m.Services)) { // Create the resource under the binding definition. var serviceBindingResource = new ResourceItem { Key = string.Concat(bindingResourceDefintion.Key, ":", serviceBinding.Name), Name = serviceBinding.Name, Description = serviceBinding.Description, Type = ModelConstants.ResourceServiceBinding, ParentRefId = bindingResourceDefintion.RefId, Rating = ConversionRating.NotSupported }; serviceBinding.ResourceKey = serviceBindingResource.Key; serviceBinding.Resource = serviceBindingResource; // Maintain pointer to the resource. serviceBindingResource.SourceObject = serviceBinding; // Maintain backward pointer. bindingResourceDefintion.Resources.Add(serviceBindingResource); _logger.LogTrace(TraceMessages.ResourceCreated, nameof(BindingFileParser), serviceBindingResource.Key, serviceBindingResource.Name, serviceBindingResource.Type, bindingResourceDefintion.Key); } }
protected override BindingInfo <IViewModelPresenter> GetViewModelPresenter() { #if WPF if (Context.Platform.Platform != PlatformType.WPF) { MvvmApplication.Initialized += MvvmApplicationOnInitialized; return(BindingInfo <IViewModelPresenter> .Empty); } #endif return(BindingInfo <IViewModelPresenter> .FromMethod((container, list) => { var presenter = new ViewModelPresenter(); presenter.DynamicPresenters.Add(new DynamicViewModelNavigationPresenter()); #if !WINDOWS_PHONE presenter.DynamicPresenters.Add( new DynamicViewModelWindowPresenter(container.Get <IViewMappingProvider>(), container.Get <IViewManager>(), container.Get <IWrapperManager>(), container.Get <IThreadManager>(), container.Get <IOperationCallbackManager>())); #endif return presenter; }, DependencyLifecycle.SingleInstance)); }
/// <summary> /// The function is responsible for binding a source objects property to a target objects property. Both properties have to have the usual qooxdoo getter and setter. The source property also needs to fire change-events on every change of its value. Please keep in mind, that this binding is unidirectional. If you need a binding in both directions, you have to use two of this bindings. /// It’s also possible to bind some kind of a hierarchy as a source. This means that you can separate the source properties with a dot and bind by that the object referenced to this property chain. Example with an object ‘a’ which has object ‘b’ stored in its ‘child’ property. Object b has a string property named abc: /// /// qx.data.SingleValueBinding.bind(a, "child.abc", textfield, "value"); /// /// In that case, if the property abc of b changes, the textfield will automatically contain the new value. Also if the child of a changes, the new value (abc of the new child) will be in the textfield. /// There is also a possibility of binding an array. Therefore the array qx.data.IListData is needed because this array has change events which the native does not. Imagine a qooxdoo object a which has a children property containing an array holding more of its own kind. Every object has a name property as a string. /// /// var svb = qx.data.SingleValueBinding; /// // bind the first child's name of 'a' to a textfield /// svb.bind(a, "children[0].name", textfield, "value"); /// // bind the last child's name of 'a' to a textfield /// svb.bind(a, "children[last].name", textfield2, "value"); /// // also deeper bindings are possible /// svb.bind(a, "children[0].children[0].name", textfield3, "value"); /// /// As you can see in this example, the abc property of a’s b will be bound to the textfield. If now the value of b changed or even the a will get a new b, the binding still shows the right value. /// </summary> /// <param name="sourcePropertyChain">The property chain which represents the source property.</param> /// <param name="targetObject">The object which the source should be bind to.</param> /// <param name="targetProperty">The property chain to the target object.</param> /// <param name="options">A map containing the options. /// • converter: A converter function which takes four parameters and should return the converted value. /// 1. The data to convert /// 2. The corresponding model object, which is only set in case of the use of an controller. /// 3. The source object for the binding /// 4. The target object. /// If no conversion has been done, the given value should be returned. e.g. a number to boolean converter function(data, model, source, target) {return data > 100;} /// • onUpdate: A callback function can be given here. This method will be called if the binding was updated successful. There will be three parameter you do get in that method call. /// 1. The source object /// 2. The target object /// 3. The data /// Here is a sample: onUpdate : function(source, target, data) {...} /// • onSetFail: A callback function can be given here. This method will be called if the set of the value fails. /// • ignoreConverter: A string which will be matched using the current property chain. If it matches, the converter will not be called. /// </param> /// <returns></returns> public object Bind(string sourcePropertyChain, qxDotNet.Core.Object targetObject, string targetProperty, Map options = null) { var b = new BindingInfo(); b.sourceProperty = sourcePropertyChain; b.target = targetObject; b.targetProperty = targetProperty; b.options = options; var key = b.getKey(); _bindings[key] = b; var c = new ClientMethodCall("bind") .SetKeyParameter(b.sourceProperty) .SetKeyParameter(b.target) .SetKeyParameter(b.targetProperty); if (b.options != null) { c.SetParameter(b.options); } CallClientMethod(c); return(b); }
public DefaultModelBinderProviderContext( ModelBinderFactory factory, ModelBinderFactoryContext factoryContext) { _factory = factory; Metadata = factoryContext.Metadata; BindingInfo bindingInfo; if (factoryContext.BindingInfo != null) { bindingInfo = new BindingInfo(factoryContext.BindingInfo); } else { bindingInfo = new BindingInfo(); } bindingInfo.TryApplyBindingInfo(Metadata); BindingInfo = bindingInfo; MetadataProvider = _factory._metadataProvider; Visited = new Dictionary <Key, IModelBinder?>(); }
public async Task BindModelAsync_WithBindProperty_DoesNotBindModel_WhenRequestIsGet() { // Arrange var parameterBinder = ModelBindingTestHelper.GetParameterBinder(); var parameter = new ParameterDescriptor() { Name = "parameter", ParameterType = typeof(Person), BindingInfo = BindingInfo.GetBindingInfo(new[] { new BindPropertyAttribute() }), }; var testContext = ModelBindingTestHelper.GetTestContext(request => { request.Method = "GET"; request.QueryString = new QueryString("?parameter.Name=Joey"); }); // Act var result = await parameterBinder.BindModelAsync(parameter, testContext); // Assert Assert.False(result.IsModelSet); }
protected IMyInput CreateInput(BindingInfo info) { if (info.Input != null) { if (info.Input == "none") { return(null); } switch (info.Input[0]) { case 'd': return(new MyDateBox()); case 't': return(new MyTimeBox()); case 'm': return(new MyMultyLineBox()); case 'p': return(new MyPasswordBox()); case 'c': return(new MyComboBox()); } } return(new MyTextBox()); }
/// <summary> /// Creates a <see cref="PagePropertyModel"/> for the <paramref name="property"/>. /// </summary> /// <param name="property">The <see cref="PropertyInfo"/>.</param> /// <returns>The <see cref="PagePropertyModel"/>.</returns> protected virtual PagePropertyModel CreatePropertyModel(PropertyInfo property) { if (property == null) { throw new ArgumentNullException(nameof(property)); } var propertyAttributes = property.GetCustomAttributes(inherit: true); var handlerAttributes = property.DeclaringType.GetCustomAttributes(inherit: true); // Look for binding info on the handler if nothing is specified on the property. // This allows BindProperty attributes on handlers to apply to properties. var bindingInfo = BindingInfo.GetBindingInfo(propertyAttributes) ?? BindingInfo.GetBindingInfo(handlerAttributes); var model = new PagePropertyModel(property, propertyAttributes) { PropertyName = property.Name, BindingInfo = bindingInfo, }; return(model); }
public async Task BindModelAsync(ModelBindingContext bindingContext) { var contentType = bindingContext.ActionContext.HttpContext.Request.ContentType; BindingInfo bindingInfo = new BindingInfo(); if (contentType == "application/json") { } else if (contentType == "application/x-www-form-urlencoded") { bindingInfo.BindingSource = BindingSource.Form; } else { bindingContext.Result = ModelBindingResult.Failed(); } var binder = factory.CreateBinder(new ModelBinderFactoryContext { Metadata = bindingContext.ModelMetadata, BindingInfo = bindingInfo, }); await binder.BindModelAsync(bindingContext); }
static void DownloadAsync(string url, string filePath, string name, Action <string, string, object, byte[]> callBack, object context = null) { for (int i = 0; i < lbi.Count; i++) { if (lbi[i].filePath == filePath) { return; } } var uwr = UnityWebRequest.Get(url); var ao = uwr.SendWebRequest(); ao.completed += DownloadComplete; BindingInfo info = new BindingInfo(); info.url = url; info.filePath = filePath; info.webRequest = uwr; info.name = name; info.context = context; info.CallBack = callBack; lbi.Add(info); }
public DomainModel.Order AddOrder(int personId, DTO.Order dto, BindingInfo orderBinding, BindingInfo[] orderDetailBindings) { DomainModel.Person person = PersonService.LoadPerson(personId); DomainModel.Order order = ((Order.OrderFactory)Registry.Instance.getFactory(typeof(Order))) .createOrder(person, dto.OrderDate, DateTime.MaxValue, ""); person.addOrder(order); // DomainModel.Order order = person.AddOrder(dto.OrderDate); new TimestampIdBinding(order, orderBinding); for(int i = 0; i < dto.OrderDetails.Length; i++) { DTO.OrderDetail dtoDetail = dto.OrderDetails[i]; DomainModel.Product product = ProductService.LoadProduct(dtoDetail.ProductId); if(product != null) { DomainModel.OrderDetail orderDetail = order.AddOrderDetail(product, product.UnitPrice, dtoDetail.Quantity); new TimestampIdBinding(orderDetail, orderDetailBindings[i]); } } return order; }
private string GetSampleText(BindingInfo bindingInfo, string text, Match match) { StringBuilder sampleText = new StringBuilder(text); for (int groupIndex = match.Groups.Count - 1; groupIndex >= 1; groupIndex--) { int paramIndex = groupIndex - 1; var paramText = paramIndex >= bindingInfo.ParameterNames.Length ? "{?param?}" : "{" + bindingInfo.ParameterNames[paramIndex] + "}"; var gr = match.Groups[groupIndex]; sampleText.Remove(gr.Index, gr.Length); sampleText.Insert(gr.Index, paramText); } return sampleText.ToString(); }
public override void CreateWebSite(string name, string path, string appPool, bool https, BindingInfo binding) { throw new NotSupportedException(); }
private int FindAncestorLevel(BindingInfo binding) { var level = 1; var parent = (TypeNode) Parent; while (parent != null) { if (binding != null) { if (binding.AncestorLevel == level || parent.Type == binding.AncestorType) { return level; } } parent = (TypeNode) parent.Parent; level++; } return level; }
public void UpdateOrderData(int orderId, DateTime orderDate, DateTime shippedDate, byte[] timestamp, BindingInfo bindingInfo) { DomainModel.Order order = LoadOrder(orderId); if(order != null) { if(order.Timestamp.Equals(new Timestamp(timestamp)) == false) throw new ApplicationException("ConcurrencyException"); order.OrderDate = orderDate; order.ShippedDate = shippedDate; if(bindingInfo != null) new TimestampIdBinding(order, bindingInfo); } }
public void UpdateOrderDetail(int orderId, DTO.OrderDetail dto, BindingInfo bindingInfo) { DomainModel.Order order = LoadOrder(orderId); if(order != null) { DomainModel.OrderDetail detail = order[dto.ProductId]; if(detail != null) { if(detail.Timestamp.Equals(new Timestamp(dto.Timestamp)) == false) throw new ApplicationException("ConcurrencyException"); detail.Quantity = dto.Quantity; detail.UnitPrice = dto.UnitPrice; new TimestampIdBinding(detail, bindingInfo); } } }
public void UpdatePersonData(int personId, string name, string password, byte[] timestamp, BindingInfo bindingInfo) { DomainModel.Person person = LoadPerson(personId); if(person == null) return; if(person.Timestamp.Equals(new Timestamp(timestamp)) == false) { throw new ApplicationException("ConcurrencyException"); } person.Name = name; person.Password = password; new TimestampIdBinding(person, bindingInfo); }
private void ExportBindings() { // not supported, only export bindings at application level // -GroupLevel Optional. If specified, all bindings in the current group are exported. // -GlobalParties Optional. If specified, the global party information for the group is exported. // -AssemblyName Optional. The full name of the BizTalk assembly. if (this.BindingFile == null) { // -Destination Required. Path and file name of the XML binding file to write. this.Log.LogError("BindingFile is required"); return; } // use default app if no app name is provided if (string.IsNullOrEmpty(this.Application)) { // -ApplicationName Optional. The name of the BizTalk application. this.Application = this.explorer.DefaultApplication.Name; this.LogTaskMessage(string.Format(CultureInfo.InvariantCulture, "Using default application {0}", this.Application)); } // create dir if it doesn't exist string dir = Path.GetDirectoryName(Path.GetFullPath(this.BindingFile.ItemSpec)); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); this.LogTaskMessage(string.Format(CultureInfo.InvariantCulture, "Created directory {0}", dir)); } using (SqlConnection sqlConnection = new SqlConnection(this.explorer.ConnectionString)) { using (BindingInfo info = new BindingInfo()) { BindingParameters bindingParameters = new BindingParameters(new Version(info.Version)) { BindingItems = BindingParameters.BindingItemTypes.All, BindingScope = BindingParameters.BindingScopeType.Application }; info.AddApplicationRef(sqlConnection, this.Application); info.Select(sqlConnection, bindingParameters); info.SaveXml(this.BindingFile.ItemSpec); this.LogTaskMessage(string.Format(CultureInfo.InvariantCulture, "Exported {0} bindings to {1}", this.Application, this.BindingFile.ItemSpec)); } } }
public override void CreateWebSite(string name, string path, string appPool, bool https, BindingInfo binding) { using (var manager = new ServerManager()) { var site = manager.Sites.Add(name, https ? "https" : "http", binding.ToString(), path); site.ApplicationDefaults.ApplicationPoolName = appPool; manager.CommitChanges(); } }
private string GetSampleText(BindingInfo bindingInfo) { var sampleText = bindingInfo.Regex.ToString().Trim('$', '^'); Regex re = new Regex(@"\([^\)]+\)"); int paramIndex = 0; sampleText = re.Replace(sampleText, delegate { return paramIndex >= bindingInfo.ParameterNames.Length ? "{?param?}" : "{" + bindingInfo.ParameterNames[paramIndex++] + "}"; }); return sampleText; }
/// <summary> /// Sets a new binding /// </summary> /// <param name="buffer">VertexBufferObject for the binding</param> /// <param name="vertexOffset">Vertex offset in the buffer</param> /// <param name="frequency">Number of instance to draw</param> /// <param name="index">Index where to insert the binding</param> public void SetBinding(VertexBufferObject buffer, int vertexOffset, int frequency, int index) { if (buffer == null) throw new ArgumentNullException("buffer"); BindingInfo inf = new BindingInfo { BufferObject = buffer, VertexOffset = vertexOffset, Frequency = frequency }; if(index >= _bindings.Count) _bindings.Add(inf); else _bindings.Insert(index, inf); buffer.VertexBufferAllocated += BufferAllocated; ResizeBindingArray(); }
public CallToConstraint(BindingInfo call, string functionName) : base(call) { _functionName = functionName; CorrectCall = call; }
public void UpdateAddress(int personId, DTO.Address dto, BindingInfo bindingInfo) { DomainModel.Person person = LoadPerson(personId); if(person == null) return; DomainModel.Address address = person.findAddress(dto.Id); if(address == null) return; if(address.Timestamp.Equals(new Timestamp(dto.Timestamp)) == false) throw new ApplicationException("ConcurrencyException"); address.Street = dto.Street; address.Phone = dto.Phone; address.PostalCode = dto.Postalcode; address.Email = dto.Email; address.City = dto.City; new TimestampIdBinding(address, bindingInfo); }
public static bool Bind (WebBrowser control, IntPtr handle, int width, int height) { if (!isInitialized ()) return false; BindingInfo info = new BindingInfo (); info.callback = new CallbackBinder (control.callbacks); IntPtr ptrCallback = Marshal.AllocHGlobal (Marshal.SizeOf (info.callback)); Marshal.StructureToPtr (info.callback, ptrCallback, true); info.gluezilla = gluezilla_bind (ptrCallback, handle, width, height, Environment.CurrentDirectory, monoMozDir, control.platform); lock (initLock) { if (info.gluezilla == IntPtr.Zero) { Marshal.FreeHGlobal (ptrCallback); info = null; initialized = false; return false; } } boundControls.Add (control as IWebBrowser, info); return true; }
/// <summary> /// Creates a new website. /// </summary> /// <param name="name">The name of the website.</param> /// <param name="path">The physical path of the website.</param> /// <param name="appPool">The name of the application pool.</param> /// <param name="https">Binds to HTTPS instead of HTTP</param> /// <param name="binding">The port, hostname, and IP of the website.</param> public abstract void CreateWebSite(string name, string path, string appPool, bool https, BindingInfo binding);
public int GetBindingLevel(BindingInfo binding) { var level = 0; switch (binding.RelativeSourceMode) { case RelativeSourceMode.Self: level = 1; break; case RelativeSourceMode.FindAncestor: level = FindAncestorLevel(binding); break; case RelativeSourceMode.PreviousData: throw new NotImplementedException(); case RelativeSourceMode.SerializationContext: level = FindAncestorLevel(null); break; } return level; }