public StandardFluentMethod(MethodJvaf innerMethod, IFluentMethodGroup methodGroup)
{
if (!CanWrap(innerMethod))
{
throw new ArgumentException($"StandardFluentMethod can wrap only inner methods that return wrappable return type, received inner method '{innerMethod.ReturnTypeResponseName} {innerMethod.Name}(..)'");
}
//
this.InnerMethod = innerMethod;
this.FluentMethodGroup = methodGroup;
}
private string InnerMethodInvocationParameter(MethodJvaf innerMethod)
{
List <string> invoke = new List <string>();
foreach (var parameter in innerMethod.LocalParameters.Where(p => !p.IsConstant && p.IsRequired))
{
invoke.Add(parameter.Name);
}
return(string.Join(", ", invoke));
}
public static bool CanWrap(MethodJvaf innerMethod)
{
if (innerMethod.HttpMethod == HttpMethod.Delete)
{
return(true);
}
else
{
return(innerMethod.HasWrappableReturnType());
}
}
private static MethodType GetMethodType(MethodJvaf method)
{
Regex leading = new Regex("^/+");
Regex trailing = new Regex("/+$");
var methodUrl = trailing.Replace(leading.Replace(method.Url, ""), "");
if (method.HttpMethod == HttpMethod.Get)
{
var urlSplits = methodUrl.Split('/');
if ((urlSplits.Count() == 5 || urlSplits.Count() == 7) &&
StringComparer.OrdinalIgnoreCase.Equals(urlSplits[0], "subscriptions") &&
HasSequenceType(method.ReturnType.Body))
{
if (urlSplits.Count() == 5)
{
if (StringComparer.OrdinalIgnoreCase.Equals(urlSplits[2], "providers"))
{
return(MethodType.ListBySubscription);
}
else
{
return(MethodType.ListByResourceGroup);
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(urlSplits[2], "resourceGroups"))
{
return(MethodType.ListByResourceGroup);
}
}
if (IsTopLevelResourceUrl(methodUrl))
{
return(MethodType.Get);
}
}
else if (method.HttpMethod == HttpMethod.Delete)
{
if (method.Name.Value.ToLowerInvariant().StartsWith("begin") ||
method.MethodGroup.Methods.Count(x => x.HttpMethod == HttpMethod.Delete) > 1)
{
return(MethodType.Other);
}
if (IsTopLevelResourceUrl(methodUrl))
{
return(MethodType.Delete);
}
}
return(MethodType.Other);
}
public FluentMethod(bool isStandard, MethodJvaf innerMethod, FluentMethodGroup methodGroup)
{
this.isStandard = isStandard;
this.InnerMethod = innerMethod;
this.MethodGroup = methodGroup;
}
/// <summary>
/// Creates an ARMUri instance representing uri to an api call.
/// </summary>
/// <param name="method">the api method</param>
public ARMUri(MethodJvaf method)
{
this.method = method;
this.rawUrl = this.FluentConfig.MappedUrl(method.Url);
this.Init();
}
public OtherMethod(MethodJvaf innerMethod, IFluentMethodGroup methodGroup)
{
this.InnerMethod = innerMethod;
this.FluentMethodGroup = methodGroup;
}
public ARMUri(MethodJvaf method)
{
this.method = method;
this.rawUrl = method.Url;
this.Init();
}
/// <summary>
/// Given an ARM operation endpoint Uri, derive a "Segment Fluent Method Group" that the operation can possibly belongs to.
/// </summary>
/// <param name="fluentMethodGroups">the map holding all "Segment Fluent Method Group"s</param>
/// <param name="innerMethod">inner Swagger method</param>
/// <param name="segments">the ARM operation endpoint uri segments those appear after Provider name</param>
/// <returns>The segment fluent method group</returns>
public static SegmentFluentMethodGroup ResolveFluentMethodGroup(SegmentFluentMethodGroups fluentMethodGroups,
MethodJvaf innerMethod,
IEnumerable <Segment> segments,
string defaultMethodGroupName)
{
List <string> fluentMethodGroupNamesInSegments = new List <string>();
Pluralizer pluralizer = new Pluralizer();
HttpMethod httpMethod = innerMethod.HttpMethod;
segments
.Where(segment => !(segment is PositionalSegment) && Utils.IsPlural(segment.Name, fluentMethodGroups.FluentConfig))
.ForEach(segment =>
{
fluentMethodGroupNamesInSegments.Add(segment.Name);
});
//
if (fluentMethodGroupNamesInSegments.Count() == 0)
{
// Level 0 "Fluent Method Group"
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: defaultMethodGroupName,
parentMethodGroupNames: new List <string>()));
}
if (fluentMethodGroupNamesInSegments.Count() == 1)
{
// Level 0 "Fluent Method Group"
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: fluentMethodGroupNamesInSegments[0],
parentMethodGroupNames: new List <string>()));
}
else if (httpMethod == HttpMethod.Post)
{
if (segments.Last() is TerminalSegment &&
segments.Last().Name.EqualsIgnoreCase(fluentMethodGroupNamesInSegments.Last()))
{
//POST /providers/Microsoft.EventHub/namespaces/{nsname}/authorizationRules/{ruleName}/listKeys
//
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: fluentMethodGroupNamesInSegments.SkipLast(1).Last(),
parentMethodGroupNames: fluentMethodGroupNamesInSegments.SkipLast(2).ToList()));
}
else
{
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: fluentMethodGroupNamesInSegments.Last(),
parentMethodGroupNames: fluentMethodGroupNamesInSegments.SkipLast(1).ToList()));
}
}
else
{
IModelTypeJv retType = innerMethod.ReturnTypeJva.BodyClientType;
if ((httpMethod == HttpMethod.Get || httpMethod == HttpMethod.Put) &&
(retType is PrimaryType || (retType as SequenceType)?.ElementType is PrimaryType))
{
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: fluentMethodGroupNamesInSegments.SkipLast(1).Last(),
parentMethodGroupNames: fluentMethodGroupNamesInSegments.SkipLast(2).ToList()));
}
else
{
return(new SegmentFluentMethodGroup(fluentMethodGroups: fluentMethodGroups,
localName: fluentMethodGroupNamesInSegments.Last(),
parentMethodGroupNames: fluentMethodGroupNamesInSegments.SkipLast(1).ToList()));
}
}
}
public void AddInnerMethod(MethodJvaf innerMethod)
{
this.innerMethods.Add(innerMethod);
}
private static IEnumerable <ParameterJv> RequiredParametersOfMethod(MethodJvaf method)
{
return(method.LocalParameters.Where(parameter => parameter.IsRequired && !parameter.IsConstant));
}
private IEnumerable <string> FilteredMethodDecls(StandardMethodsInfo standardMethodsInfo)
{
IEnumerable <OtherMethod> otherMethods = this
.Where(o => !standardMethodsInfo.IsStandardInnerMethod(o.InnerMethod) &&
!standardMethodsInfo.IsConfictWithStandardFluentMethod(o.InnerMethod));
//
StringBuilder methodsBuilder = new StringBuilder();
foreach (OtherMethod otherMethod in otherMethods)
{
MethodJvaf innerMethod = otherMethod.InnerMethod;
string methodName = $"{innerMethod.Name.Value}Async";
//
string rxReturnType;
if (otherMethod.ReturnModel is WrappableFluentModel wrappableFluentModel)
{
rxReturnType = $"Observable<{wrappableFluentModel.JavaInterfaceName}>";
}
else if (otherMethod.ReturnModel is NonWrappableModel nonWrappableModel)
{
rxReturnType = $"Observable<{nonWrappableModel.RawModelName}>";
}
else
{
// otherMethod.ReturnModel is PrimitiveModel
rxReturnType = "Completable";
}
//
methodsBuilder.Clear();
//
methodsBuilder.AppendLine($"/**");
if (!string.IsNullOrEmpty(innerMethod.Summary))
{
methodsBuilder.AppendLine($" * {innerMethod.Summary.EscapeXmlComment().Period()}");
}
if (!string.IsNullOrEmpty(innerMethod.Description))
{
methodsBuilder.AppendLine($" * {innerMethod.Description.EscapeXmlComment().Period()}");
}
methodsBuilder.AppendLine($" *");
foreach (var param in innerMethod.LocalParameters.Where(p => !p.IsConstant && p.IsRequired))
{
methodsBuilder.AppendLine($" * @param {param.Name} {param.Documentation.Else("the " + param.ModelType.Name + " value").EscapeXmlComment().Trim()}");
}
methodsBuilder.AppendLine($" * @throws IllegalArgumentException thrown if parameters fail the validation");
methodsBuilder.AppendLine($" * @return the observable for the request");
methodsBuilder.AppendLine($" */");
if (innerMethod.HttpMethod == AutoRest.Core.Model.HttpMethod.Delete)
{
methodsBuilder.AppendLine($"{rxReturnType} {methodName}({innerMethod.MethodRequiredParameterDeclaration});");
}
else if (otherMethod.ReturnModel is PrimitiveModel)
{
methodsBuilder.AppendLine($"{rxReturnType} {methodName}({innerMethod.MethodRequiredParameterDeclaration});");
}
else
{
methodsBuilder.AppendLine($"{rxReturnType} {methodName}({innerMethod.MethodRequiredParameterDeclaration});");
}
//
yield return(methodsBuilder.ToString());
}
}
public bool IsConfictWithStandardFluentMethod(MethodJvaf method)
{
return(FluentMethodNames.Contains(method.Name.ToLowerInvariant()));
}
public bool IsStandardInnerMethod(MethodJvaf method)
{
return(InnerMethodNames.Contains(method.Name.ToLowerInvariant()));
}
public Temp(MethodJvaf innerMethod)
{
this.innerMethod = innerMethod;
}
