/// <summary>
        /// Creates the complex source field.
        /// </summary>
        /// <param name="parameter">The parameter.</param>
        /// <param name="owner">The owner.</param>
        /// <returns>The SourceField.</returns>
        private SourceField CreateComplexSourceField(ServiceMethodParameterEdit parameter, ExpressionObjectBase owner)
        {
            var type = _knownTypes.First(t => t.Guid == parameter.TypeGuid);
            var dataType = parameter.AllowMultiple ? NodeDataType.Array : NodeDataType.Entity;
            var result = new SourceField(owner)
                {
                    DataType = dataType,
                    Name = parameter.Name,
                    ConnectorOut = { DataType = dataType, Name = parameter.Name },
                    SystemName = parameter.Name,
                    SetName = SourceFieldSetNames.IntegrationServiceSourceItem,
                    SubfieldsRetriever = new ComplexTypeSubfieldsRetriever(type, _knownTypes)
                };

            return result; 
        }
        /// <summary>
        /// Creates the primitive source field.
        /// </summary>
        /// <param name="parameter">The parameter.</param>
        /// <param name="owner">The owner.</param>
        /// <returns>The SourceField.</returns>
        private static SourceField CreatePrimitiveSourceField(ServiceMethodParameterEdit parameter, ExpressionObjectBase owner)
        {
            var type = ServicePrimitiveTypes.FindByGuid(parameter.TypeGuid);
            var dataType = parameter.AllowMultiple ? NodeDataType.Array : SourceNodeFactory.GetDataType(type.Type);
            var subfieldsRetriever = parameter.AllowMultiple ? new ArraySubfieldsRetriever(type) : null;

            if (ReferenceEquals(type, ServicePrimitiveTypes.Byte) && parameter.AllowMultiple)
            {
                dataType = NodeDataType.ByteArray;
                subfieldsRetriever = null;
            }

            var result = new SourceField(owner)
                             {
                                 DataType = dataType,
                                 Name = parameter.Name,
                                 ConnectorOut = { DataType = dataType, Name = parameter.Name },
                                 SetName = SourceFieldSetNames.IntegrationServiceSourceItem,
                                 InnerName = parameter.Name,
                                 SystemName = parameter.Name,
                                 SubfieldsRetriever = subfieldsRetriever
                             };

            return result;
        }
        /// <summary>
        /// Creates the source field.
        /// </summary>
        /// <param name="parameter">The parameter.</param>
        /// <param name="owner">The owner.</param>
        /// <returns>The SourceField.</returns>
        /// <exception cref="System.InvalidOperationException">Parameter type not found.</exception>
        private SourceField CreateSourceField(ServiceMethodParameterEdit parameter, ExpressionObjectBase owner)
        {
            if (ServicePrimitiveTypes.GetTypes().Any(t => t.Guid == parameter.TypeGuid))
                return CreatePrimitiveSourceField(parameter, owner);

            if (_knownTypes.Any(t => t.Guid == parameter.TypeGuid))
                return CreateComplexSourceField(parameter, owner);

            throw new InvalidOperationException("Parameter type not found.");
        }
        /// <summary>
        /// Determines whether this instance [can be source field] the specified parameter.
        /// </summary>
        /// <param name="parameter">The parameter.</param>
        /// <returns><c>true</c> if this instance [can be source field] the specified parameter; otherwise, <c>false</c>.</returns>
        private bool CanBeSourceField(ServiceMethodParameterEdit parameter)
        {
            if (ServicePrimitiveTypes.GetTypes().Any(t => t.Guid == parameter.TypeGuid))
                return true;

            if (_knownTypes.Any(t => t.Guid == parameter.TypeGuid))
                return true;

            return false;
        }
 /// <summary>
 /// Executes the remove parameter.
 /// </summary>
 /// <param name="parameter">The parameter.</param>
 private void ExecuteRemoveParameter(ServiceMethodParameterEdit parameter)
 {
     Model.InputParameters.Remove(parameter);
 }
 /// <summary>
 /// Determines whether this instance [can remove parameter] the specified parameter.
 /// </summary>
 /// <param name="parameter">The parameter.</param>
 /// <returns><c>true</c> if this instance [can remove parameter] the specified parameter; otherwise, <c>false</c>.</returns>
 private bool CanRemoveParameter(ServiceMethodParameterEdit parameter)
 {
     return parameter != null;
 }