/// <summary> /// Creates the parameter view model. /// </summary> /// <param name="model"> /// The model. /// </param> /// <param name="baseType"> /// The base type. /// </param> /// <param name="parentViewModel"> /// The parent view model. /// </param> /// <returns> /// The parameter view-model. /// </returns> public IWebMethodCallParameterViewModel CreateParameterViewModel( IWebMethodCallParameter model, IWebServiceTypeDescription baseType, IWebMethodCallSettingsViewModel parentViewModel) { return new WebMethodCallParameterViewModel(model, baseType, parentViewModel, this, PopupFactory); }
/// <summary> /// Initializes a new instance of the <see cref="WebServiceTypeFieldDescription"/> class. /// </summary> /// <param name="declaringType"> /// The declaring type. /// </param> /// <exception cref="ArgumentNullException"> /// The <paramref name="declaringType"/> parameter is null. /// </exception> public WebServiceTypeFieldDescription(IWebServiceTypeDescription declaringType) { if (declaringType == null) throw new ArgumentNullException("declaringType"); _declaringType = declaringType; }
/// <summary> /// Initializes a new instance of the <see cref="WebMethodCallParameterViewModel"/> class. /// </summary> /// <param name="model"> /// The model. /// </param> /// <param name="baseType"> /// The base type. /// </param> /// <param name="parentViewModel"> /// The parent view model. /// </param> /// <param name="parameterViewModelFactory"> /// The parameter view model factory. /// </param> /// <param name="popupFactory"> /// The popup factory. /// </param> public WebMethodCallParameterViewModel( IWebMethodCallParameter model, IWebServiceTypeDescription baseType, IWebMethodCallSettingsViewModel parentViewModel, IWebMethodCallParameterViewModelFactory parameterViewModelFactory, PopupFactory popupFactory) { if (model == null) throw new ArgumentNullException("model"); if (baseType == null) throw new ArgumentNullException("baseType"); if (parentViewModel == null) throw new ArgumentNullException("parentViewModel"); if (parameterViewModelFactory == null) throw new ArgumentNullException("parameterViewModelFactory"); if (popupFactory == null) throw new ArgumentNullException("popupFactory"); ParentViewModel = parentViewModel; ParameterViewModelFactory = parameterViewModelFactory; PopupFactory = popupFactory; RefreshInternal(model, baseType); }
private void ValidateArrayType(IWebServiceTypeDescription type) { Assert.IsFalse(string.IsNullOrEmpty(type.DisplayName)); Assert.IsFalse(string.IsNullOrEmpty(type.Name)); Assert.IsFalse(string.IsNullOrEmpty(type.ElementTypeName)); Assert.IsNotNull(type.DeclaringService.FindTypeByName(type.ElementTypeName)); Assert.IsFalse(type.IsSimple); Assert.IsTrue(type.IsArray); Assert.IsFalse(type.IsAbstract); Assert.IsFalse(type.IsEnum); Assert.IsTrue(type.IsNullable); Assert.AreEqual(0, type.Fields.Count); }
private void ValidateComplexType(IWebServiceTypeDescription type) { Assert.IsFalse(string.IsNullOrEmpty(type.DisplayName)); Assert.IsFalse(string.IsNullOrEmpty(type.Name)); Assert.IsTrue(string.IsNullOrEmpty(type.ElementTypeName)); Assert.IsFalse(type.IsSimple); Assert.IsFalse(type.IsArray); Assert.IsFalse(type.IsEnum); Assert.IsTrue(type.IsNullable); foreach (var field in type.Fields) { Assert.IsFalse(string.IsNullOrEmpty(field.Name)); Assert.IsNotNull(type.DeclaringService.FindTypeByName(field.TypeName)); } }
private void ValidateType(IWebServiceTypeDescription type) { if (type.IsArray) { ValidateArrayType(type); return; } if (type.IsSimple) { ValidateSimpleType(type); return; } ValidateComplexType(type); }
/// <summary> /// Determines whether this type is assignable from the specified type. /// </summary> /// <param name="type">The target type.</param> /// <returns><c>true</c> if this type is assignable from the specified type; otherwise, <c>false</c>.</returns> public bool IsAssignableFrom(IWebServiceTypeDescription type) { if (Name == type.Name) return true; return AssignableTypes.Any(t => t.TypeName == type.Name); }
/// <summary> /// Gets the collection of types that can be assigned to a specified type. /// </summary> /// <param name="type">The base type.</param> /// <returns>Returns the collections of types that can be assigned to <paramref name="type" />.</returns> public ICollection<IWebServiceTypeDescription> GetAssignableTypesForType(IWebServiceTypeDescription type) { if (_assignableTypesCache.ContainsKey(type)) return _assignableTypesCache[type]; var assignableTypes = new List<IWebServiceTypeDescription>(); if (!type.IsAbstract) assignableTypes.Add(type); foreach (var typeReference in type.AssignableTypes) { var includedType = FindTypeByName(typeReference.TypeName); if (includedType != null && !includedType.IsAbstract) assignableTypes.Add(includedType); } _assignableTypesCache[type] = assignableTypes.OrderBy(t => t.Name).ToArray(); return _assignableTypesCache[type]; }
/// <summary> /// Initializes the view-model. /// </summary> /// <param name="availableTypes"> /// The available types. /// </param> /// <param name="usedFields"> /// The used fields. /// </param> public void Initialize(IEnumerable<IWebServiceTypeDescription> availableTypes, IEnumerable<IWebMethodCallResultField> usedFields) { if (availableTypes == null) throw new ArgumentNullException("availableTypes"); if (usedFields == null) throw new ArgumentNullException("usedFields"); SelectedFields.Clear(); AvailableTypes = availableTypes.OrderBy(t => t.DisplayName).ToArray(); UsedFields = usedFields.ToArray(); _selectedType = AvailableTypes.FirstOrDefault(); RaisePropertyChanged(() => SelectedType); _availableFields = null; RaisePropertyChanged(() => AvailableFields); }
/// <summary> /// Refreshes the internal. /// </summary> /// <param name="model"> /// The model. /// </param> /// <param name="baseType"> /// The base type. /// </param> private void RefreshInternal(IWebMethodCallParameter model, IWebServiceTypeDescription baseType) { Model = model; Name = model.Name; _isNull = model.IsNull; _itemCountIsSpecified = model.ArrayItemCount.HasValue; _itemCount = model.ArrayItemCount ?? 0; RaisePropertyChanged(() => IsNull); RaisePropertyChanged(() => IsNullable); RaisePropertyChanged(() => ItemCountIsSpecified); RaisePropertyChanged(() => ItemCount); BaseType = baseType; UpdateAvailableTypes(); UpdateChildren(false); }
private IExpressionFieldsRetriever GetSubfieldsRetriever( IWebServiceTypeDescription type, IEnumerable<IWebMethodCallResultField> resultFields) { if (type.IsSimple || type.TypeCode == WebServiceTypeCode.ByteArray) return null; return new ServiceTypeSubfieldsRetriever(type, CanBeSourceField, CreateSourceField, resultFields); }
private NodeDataType GetNodeDataType(IWebServiceTypeDescription type) { if (type.IsEnum) return NodeDataType.String; if (type.TypeCode == WebServiceTypeCode.ByteArray) return NodeDataType.ByteArray; if (type.IsArray) return NodeDataType.Array; if (type.TypeCode == WebServiceTypeCode.None) return NodeDataType.Entity; return DestinationNodeFactory.GetDataType(type.GetCommonType()); }
/// <summary> /// Updates the available types. /// </summary> private void UpdateAvailableTypes() { try { SuppressSelectedTypeUpdate = true; var selectedType = BaseType.DeclaringService.FindTypeByName(Model.TypeName); if (selectedType == null || selectedType.IsAbstract) selectedType = BaseType; if (selectedType.IsAbstract) selectedType = null; _selectedType = selectedType; AvailableTypes = BaseType.DeclaringService.GetAssignableTypesForType(BaseType); } finally { SuppressSelectedTypeUpdate = false; RaisePropertyChanged(() => SelectedType); } }
private IEnumerable<IWebServiceTypeFieldDescription> GetFields(IWebServiceTypeDescription type) { if (type.IsSimple) yield break; if (type.IsArray) { yield return new WebServiceTypeFieldDescription(type) { Name = Constants.ArrayItemGenericFieldName, TypeName = type.ElementTypeName }; yield break; } foreach (var field in type.Fields) { yield return field; } }
public ServiceTypeSubfieldsRetriever( IWebServiceTypeDescription type, Func<IWebServiceTypeFieldDescription, bool> fieldFilter, Func<IWebServiceTypeFieldDescription, IWebMethodCallResultField, ExpressionObjectBase, IExpressionField> fieldFactory, IEnumerable<IWebMethodCallResultField> resultFields) { if (type == null) throw new ArgumentNullException("type"); _type = type; _fieldFilter = fieldFilter; _fieldFactory = fieldFactory; if (resultFields != null) _resultFields = resultFields.ToArray(); }
private IWebServiceTypeFieldDescription CreateField(string name, IWebServiceTypeDescription declaringType) { var field = Mock.Create<IWebServiceTypeFieldDescription>(Behavior.Loose); Mock.Arrange(() => field.Name).Returns(name); Mock.Arrange(() => field.DeclaringType).Returns(declaringType); return field; }
/// <summary> /// Refreshes the specified model. /// </summary> /// <param name="model"> /// The model. /// </param> /// <param name="baseType"> /// The base type. /// </param> /// <exception cref="System.ArgumentNullException"> /// The <paramref name="model"/> parameter is null. /// </exception> /// <exception cref="ArgumentNullException"> /// The <paramref name="baseType"/> parameter is null. /// </exception> public void Refresh(IWebMethodCallParameter model, IWebServiceTypeDescription baseType) { if (model == null) throw new ArgumentNullException("model"); if (baseType == null) throw new ArgumentNullException("baseType"); RefreshInternal(model, baseType); }