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