public static async Task <string> CreateComplexTypeClass(MethodDeclarationSyntax wcfMethod, string methodName, bool isActiveWcfMethod) { if (!isActiveWcfMethod) { return(""); } var parameters = wcfMethod.ParameterList.Parameters; // add return type as class property if has 'out' keyword if (!OutKeywordGenerator.AnyHaveOutKeyword(parameters)) { return(""); } // create complex class var className = ComplexTypeNamesMapper.MapToClientComplexClassName(methodName); var complexClassDeclaration = await MultipleComplexTypesGenerator.CreateClassFromComplexTypes(parameters, className); // create return type property var wcfReturnType = wcfMethod.ReturnType.NormalizeWhitespace().ToFullString(); var returnTypePropertyCode = $"public {wcfReturnType} Result {{ get; set;}}"; var returnTypeProperty = (await CodeParser.ConvertToMemberDeclarations(returnTypePropertyCode)).Single(); // add return type property to complex class var members = complexClassDeclaration.Members.Add(returnTypeProperty); complexClassDeclaration = complexClassDeclaration.WithMembers(members); var complexTypeClass = complexClassDeclaration?.NormalizeWhitespace().ToFullString(); return(complexTypeClass); }
private static async Task <IEnumerable <MemberDeclarationSyntax> > CreateMethods(string controllerName, MethodDeclarationSyntax wcfMethod, string wcfClassName, IDictionary <string, string> duplicateMethodNamesMap, bool isAsmx) { var members = new List <MemberDeclarationSyntax>(); var wcfMethodName = wcfMethod.Identifier.ValueText; var wcfParameters = wcfMethod.ParameterList.Parameters; // create method & parameter names var methodName = DuplicateMethodNamesGenerator.TransformMethodNameIfDuplicate(duplicateMethodNamesMap, wcfMethodName, wcfParameters); var parameters = ServiceCodeParametersGenerator.CreateParameters(wcfParameters); parameters = ServiceCodeMultipleComplexTypesGenerator.TransformMultipleComplexTypeParameters(parameters, methodName); // create service type for method comment var serviceType = ServiceNamesMapper.GetServiceTypeName(isAsmx); // create http verb var httpVerb = CreateHttpVerb(wcfMethodName, parameters); // create route name var routeUriTemplate = ServiceNamesMapper.MapToRouteUriTemplate(controllerName, methodName); // create return type var wcfReturnType = wcfMethod .ReturnType .NormalizeWhitespace() .ToFullString(); var returnType = ServiceCodeOutKeywordGenerator.TransformOutKeywordReturnType(wcfReturnType, wcfParameters, methodName); // create method block arguments var arguments = CreateWcfArguments(wcfParameters); arguments = ServiceCodeMultipleComplexTypesGenerator.TransformMultipleComplexTypeArguments(arguments, wcfParameters, methodName); // create method block var block = CreateMethodBlock(wcfClassName, wcfMethodName, arguments, returnType); block = ServiceCodeOutKeywordGenerator.TransformBlockWithOutKeyword(block, wcfParameters, arguments, methodName); // create new method var method = await CreateMethodDeclaration(methodName, httpVerb, routeUriTemplate, parameters, block, returnType, serviceType); // add nested class model if have multiple complex params var className = ComplexTypeNamesMapper.MapToServiceComplexClassType(methodName); var complexClass = await MultipleComplexTypesGenerator.CreateClassFromComplexTypes(wcfParameters, className); if (complexClass != null) { complexClass = ServiceCodeOutKeywordGenerator.TransformComplexClassWithOutKeyword(complexClass, wcfParameters, wcfReturnType); members.Add(complexClass); } // add new method members.Add(method); return(members); }
private static IEnumerable <StatementSyntax> CreateEndStatements(IEnumerable <string> parameterNames, SeparatedSyntaxList <ParameterSyntax> wcfParameters, MethodDeclarationSyntax wcfMethod) { string CreatePropertyStatement(string variableName, bool isInitialized = false) { var initializeType = isInitialized ? "var " : ""; var propertyName = ComplexTypeNamesMapper.MapToComplexClassPropertyName(variableName); var statement = $"{initializeType}{variableName} = deserializeObject.{propertyName};"; return(statement); } var methodName = wcfMethod.Identifier.ValueText; var complexClassType = ComplexTypeNamesMapper.MapToClientComplexClassName(methodName); var jsonDeserializeStatements = new List <string> { $"var deserializeObject = JsonConvert.DeserializeObject<{complexClassType}>(jsonResponse, _jsonSerializerSettings);", CreatePropertyStatement("result", isInitialized: true), }; var propertyStatements = wcfParameters .Where(parameter => { var parameterName = parameter.Identifier.ValueText; var hasOutKeyword = parameterNames.Contains(parameterName); return(hasOutKeyword); }) .Select(parameter => { var parameterName = parameter.Identifier.ValueText; var statement = CreatePropertyStatement(parameterName); return(statement); }); var endStatements = jsonDeserializeStatements .Union(propertyStatements) .Select(statement => { var statementDeclaration = SyntaxFactory.ParseStatement(statement); return(statementDeclaration); }); return(endStatements); }
public static string TransformOutKeywordReturnType(string wcfReturnType, SeparatedSyntaxList <ParameterSyntax> wcfParameters, string wcfMethodName) { var isVoidReturnType = wcfReturnType == "void"; if (!OutKeywordGenerator.AnyHaveOutKeyword(wcfParameters) || isVoidReturnType) { return(wcfReturnType); } var complexVariableName = ComplexTypeNamesMapper.MapToServiceComplexClassType(wcfMethodName); var returnType = complexVariableName; return(returnType); }
private static BlockSyntax TransformReturnStatement(BlockSyntax block, string methodName) { var lastStatement = block.Statements.Last(); if (!(lastStatement is ReturnStatementSyntax)) { return(block); } var complexVariableName = ComplexTypeNamesMapper.MapToComplexClassParameterName(methodName); var outKeywordReturnStatement = $"return Ok({complexVariableName});"; var newStatements = block.Statements.Replace(lastStatement, SyntaxFactory.ParseStatement(outKeywordReturnStatement)); var newBlock = block.WithStatements(newStatements); return(newBlock); }
public static List <SyntaxNodeOrToken> TransformMultipleComplexTypeArguments(List <SyntaxNodeOrToken> arguments, SeparatedSyntaxList <ParameterSyntax> wcfParameters, string wcfMethodName) { var complexParameters = MultipleComplexTypesGenerator.FindMultipleComplexTypesOrOutKeyword(wcfParameters); if (!complexParameters.Any()) { return(arguments); } // replace all complex type arguments with complex type class properties // if any arguments already have 'out' keyword then will be ignored var newArguments = arguments .Select(nodeOrToken => { var argument = (ArgumentSyntax)nodeOrToken; var isArgument = argument != null; if (!isArgument) { return(nodeOrToken); } var argumentName = argument .NormalizeWhitespace() .ToFullString(); var isComplexArgument = complexParameters .Select(parameter => parameter.Identifier.ValueText) .Contains(argumentName); if (!isComplexArgument) { return(argument); } var complexTypeArgumentName = ComplexTypeNamesMapper.MapToComplexTypeArgument(wcfMethodName, argumentName); var complexTypeArgument = SyntaxFactory.Argument(SyntaxFactory.IdentifierName(complexTypeArgumentName)); return(complexTypeArgument); }) .ToList(); return(newArguments); }
private static IEnumerable <StatementSyntax> CreateEndStatements(IEnumerable <string> argumentNames, string wcfMethodName) { var resultStatement = $"{ComplexTypeNamesMapper.MapToComplexTypeArgument(wcfMethodName, "Result")} = result;"; var endStatements = argumentNames .Select(argumentName => { var complexTypeArgument = ComplexTypeNamesMapper.MapToComplexTypeArgument(wcfMethodName, argumentName); var statement = $"{complexTypeArgument} = {argumentName};"; var statementDeclaration = SyntaxFactory.ParseStatement(statement); return(statementDeclaration); }) .Prepend(SyntaxFactory.ParseStatement(resultStatement)); return(endStatements); }
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); }