private static SeparatedSyntaxList <ParameterSyntax> RemoveDefaultValuesFromComplexTypeParameters(SeparatedSyntaxList <ParameterSyntax> parameters)
{
// asp.net web api does not support controller method parameters that are:
// 1) reference types with default values set to 'null'
// 2) enums with any default values
// therefore remove all default values from complex type parameters
// also the auto gen client files will include the default values so ok to remove them for enums
// otherwise perhaps need to auto gen enum as a string (and parse it) or as a nullable type
bool IsComplexTypeWithDefaultValue(ParameterSyntax parameter)
{
var param = new SeparatedSyntaxList <ParameterSyntax>().Add(parameter);
var isComplexType = ComplexTypesGenerator.FindComplexTypes(param).Any();
var hasDefaultValue = parameter.Default != null;
return(isComplexType && hasDefaultValue);
}
// split up complex type parameters into two lists: 1) has default values 2) all others
var parametersGroupByDefaults = parameters.ToLookup(IsComplexTypeWithDefaultValue);
var defaultValParameters = parametersGroupByDefaults[true].ToList();
var otherParameters = parametersGroupByDefaults[false];
if (!defaultValParameters.Any())
{
return(parameters);
}
// remove default values
var removedDefaultParameters = defaultValParameters
.Select(parameter =>
{
parameter = IsComplexTypeWithDefaultValue(parameter)
? parameter.WithDefault(null)
: parameter;
return(parameter);
});
// combine modified parameters no longer with default values back with other params
var newParameters = new SeparatedSyntaxList <ParameterSyntax>();
newParameters = newParameters.AddRange(otherParameters);
var insertIndex = ParametersGenerator.FindIndexBeforeFirstOptionalParam(newParameters);
newParameters = newParameters.InsertRange(insertIndex, removedDefaultParameters);
return(newParameters);
}
private static IEnumerable <StatementSyntax> CreateStartStatements(IEnumerable <string> parameterNames,
SeparatedSyntaxList <ParameterSyntax> wcfParameters)
{
var statements = parameterNames
.Select(parameterName =>
{
var variableName = parameterName;
var variableType = ParametersGenerator.FindParameterType(wcfParameters, parameterName);
var statement = $"{variableName} = default({variableType});";
var statementDeclaration = SyntaxFactory.ParseStatement(statement);
return(statementDeclaration);
});
return(statements);
}
private static IEnumerable <StatementSyntax> CreateStartStatements(IEnumerable <string> argumentNames, SeparatedSyntaxList <ParameterSyntax> wcfParameters)
{
// arguments with 'out' keywords requires separate local variable declarations to be passed to wcf method
// i.e. the complex class properties cannot be used as arguments with 'out' keyword...must use separate variable
var statements = argumentNames
.Select(argumentName =>
{
var variableName = argumentName;
var variableType = ParametersGenerator.FindParameterType(wcfParameters, argumentName);
var statement = $"{variableType} {variableName};";
var statementDeclaration = SyntaxFactory.ParseStatement(statement);
return(statementDeclaration);
});
return(statements);
}
public static SeparatedSyntaxList <ParameterSyntax> TransformMultipleComplexTypeParameters(SeparatedSyntaxList <ParameterSyntax> originalParameters, string methodName)
{
// handle if parameters have more two or more (i.e. multiple) complex types
var complexParameters = MultipleComplexTypesGenerator.FindMultipleComplexTypesOrOutKeyword(originalParameters);
if (!complexParameters.Any())
{
return(originalParameters);
}
var parameters = new SeparatedSyntaxList <ParameterSyntax>();
// remove all complex types from parameters
var complexNames = complexParameters
.Select(complex => complex.Identifier.ToFullString());
var filteredParameters = originalParameters
.Where(parameter =>
{
var name = parameter.Identifier.ToFullString();
return(complexNames.All(complexName => complexName != name));
});
parameters = parameters.AddRange(filteredParameters);
// add single complex class type parameter
var complexType = ComplexTypeNamesMapper.MapToServiceComplexClassType(methodName);
var complexParameterName = ComplexTypeNamesMapper.MapToComplexClassParameterName(methodName);
var complexTypeClass = SyntaxFactory.Parameter(SyntaxFactory.Identifier(complexParameterName))
.WithType(SyntaxFactory.IdentifierName(complexType));
// insert complex type before any optional parameters with default values
// otherwise insert at the end
var insertIndex = ParametersGenerator.FindIndexBeforeFirstOptionalParam(parameters);
parameters = parameters.Insert(insertIndex, complexTypeClass);
return(parameters);
}
public override string[] AllParameters()
{
return(ParametersGenerator.OrderCombination(parameters));
}
