public static IEnumerable <string> ParameterImports(ParameterJv parameter, List <string> propertiesToSkip) { foreach (string import in parameter.InterfaceImports) { yield return(import); } foreach (string import in parameter.ClientType.Imports) { yield return(import); } if (parameter.ClientType is CompositeTypeJvaf composite) { foreach (string import in composite.Imports) { yield return(import); } // We do unfolding of parameters only in one level so no recursive unfolding // var composedPropertiesImports = composite.ComposedProperties .OfType <PropertyJvaf>() .Where(p => !propertiesToSkip.Contains(p.Name.ToLowerInvariant())) .SelectMany(p => p.Imports); foreach (string import in composedPropertiesImports) { yield return(import); } } }
/// <summary> /// Get position of the parameter in the actual method call. /// </summary> /// <param name="param">the parameter</param> /// <returns></returns> private int GetParameterIndex(ParameterJv param) { int e = this.FluentMethod .InnerMethod .LocalParameters.Where(p => !p.IsConstant) // Ref: MethodJva.MethodRequiredParameterDeclaration ^ .Select((p, i) => p.Name.EqualsIgnoreCase(param.Name) ? i + 1 : -1) .FirstOrDefault(i => i > 0); return(e == 0 ? -1 : e - 1); }
private IDictionary <string, ParameterJv> RequiredPathLocalParameters() { string url = innerMethod.Url; IDictionary <string, ParameterJv> dict = new Dictionary <string, ParameterJv>(); if (String.IsNullOrEmpty(innerMethod.Url)) { return(dict); } string prevSegment = null; int index = 0; foreach (string currentSegment in url.Split('/')) { if (String.IsNullOrEmpty(currentSegment)) { continue; } if (prevSegment == null) { prevSegment = currentSegment; if (currentSegment.StartsWith("{")) { string paramName = currentSegment.Trim(new char[] { '{', '}' }); ParameterJv param = RequiredLocalParameters() .First(p => p.WireName.Equals(paramName, StringComparison.OrdinalIgnoreCase)); dict.Add($"posArg_{index}", param); } } else if (currentSegment.StartsWith("{")) { string paramName = currentSegment.Trim(new char[] { '{', '}' }); ParameterJv param = RequiredLocalParameters() .First(p => p.WireName.Equals(paramName, StringComparison.OrdinalIgnoreCase)); if (prevSegment.StartsWith("{")) { dict.Add($"posArg_{index}", param); } else { dict.Add(prevSegment, param); } } prevSegment = currentSegment; index++; } return(dict); }
public static IEnumerable <string> ParameterImportsForInterface(ParameterJv parameter, string package, List <string> propertiesToSkip) { foreach (string import in Utils.ParameterImports(parameter, propertiesToSkip)) { if (!import.StartsWith(package)) { yield return(import); } else if (import.Contains(".implementation.")) { yield return(import); } } }
private void Init() { IDictionary <string, ParameterJv> mapping = this.RequiredPathParametersMapping; // // foreach (ParameterJv parameter in this.MethodRequiredParameters.Where(p => !p.IsConstant && !p.IsClientProperty)) { FluentModelMemberVariable memberVaraible; string variableName = parameter.Name; if (parameter.Location == ParameterLocation.Path) { var entry = mapping.First(m => { ParameterJv pathParam = m.Value; return(pathParam.Name.Equals(variableName)); }); if (entry.Key.StartsWith("pos_")) { int pathPos = Int32.Parse(entry.Key.Substring("pos_".Length)); memberVaraible = new FluentModelPositionalPathMemberVariable(pathPos, variableName, parameter); } else { string parentRefName = entry.Key; memberVaraible = new FluentModelParentRefMemberVariable(parentRefName, variableName, parameter); } } else { memberVaraible = new FluentModelMemberVariable(variableName, parameter); } memberVaraible.Index = GetParameterIndex(parameter); // // this.Add(memberVaraible.VariableName, memberVaraible); } }
/// <summary> /// Creates FluentModelMemberVariable. /// </summary> /// <param name="variableName">The variable name</param> /// <param name="fromParameter">The method parameter for which the variable is needed</param> public FluentModelMemberVariable(string variableName, ParameterJv fromParameter) { this.VariableName = variableName; this.FromParameter = fromParameter; this.VariableType = fromParameter.ClientType; }
protected virtual bool IsRequiredParamter(ParameterJv parameter) { return(parameter != null && !string.IsNullOrWhiteSpace(parameter.Name) && parameter.IsRequired); }
protected override bool IsRequiredParamter(ParameterJv parameter) { return(parameter != null && !string.IsNullOrWhiteSpace(parameter.Name) && (parameter.IsRequired || parameter.Location == Core.Model.ParameterLocation.Body)); }
public static IEnumerable <string> ParameterImportsForInterface(ParameterJv parameter, string package) { return(ParameterImportsForInterface(parameter, package, new List <string>())); }
public FluentModelPositionalPathMemberVariable(int position, string name, ParameterJv fromParameter) : base(name, fromParameter) { this.Position = position; }
public FluentModelParentRefMemberVariable(string parentRefName, string name, ParameterJv fromParameter) : base(name, fromParameter) { this.ParentRefName = parentRefName; }