/// <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);
}
