/// <summary> /// Initializes a new instance of RequirementsTemplateModel class. /// </summary> /// <param name="serviceClient">The service client.</param> /// <param name="sdkName">The name of the SDK.</param> /// <param name="implementationFileExtension">The files extension.</param> /// <param name="ns">The namespace of the SDK.</param> public RequirementsTemplateModel(ServiceClient serviceClient, string sdkName, string implementationFileExtension, string ns) { this.LoadFrom(serviceClient); this.ns = ns; this.sdkName = sdkName; this.implementationFileExtension = implementationFileExtension; }
public AzureFluentModelTemplateModel(CompositeType source, ServiceClient serviceClient) : base(source, serviceClient) { _namer = new AzureJavaFluentCodeNamer(serviceClient.Namespace); PropertyModels = new List<PropertyModel>(); Properties.ForEach(p => PropertyModels.Add(new FluentPropertyModel(p, serviceClient.Namespace, IsInnerModel))); }
/// <summary> /// Initializes a new instance of the AzureServiceClientTemplateModel class. /// </summary> /// <param name="serviceClient">The service client instance.</param> public AzureServiceClientTemplateModel(ServiceClient serviceClient) : base(serviceClient) { MethodTemplateModels.Clear(); Methods.Where(m => m.Group == null) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient))); }
private static async Task TestGenerate(string apiVersion, string[] methodUrls, string expectedJsonString) { MemoryFileSystem fileSystem = new MemoryFileSystem(); Settings settings = new Settings(); settings.FileSystem = fileSystem; ServiceClient serviceClient = new ServiceClient(); serviceClient.ApiVersion = apiVersion; foreach(string methodUrl in methodUrls) { serviceClient.Methods.Add(new Method() { Url = methodUrl, HttpMethod = HttpMethod.Put, }); } await CreateGenerator(settings).Generate(serviceClient); Assert.Equal(2, fileSystem.VirtualStore.Count); string folderPath = fileSystem.VirtualStore.Keys.First(); Assert.Equal("Folder", fileSystem.VirtualStore[folderPath].ToString()); JObject expectedJSON = JObject.Parse(expectedJsonString); string fileContents = fileSystem.VirtualStore[fileSystem.VirtualStore.Keys.Skip(1).First()].ToString(); JObject actualJson = JObject.Parse(fileContents); Assert.Equal(expectedJSON, actualJson); }
public void NormalizeClientModelDoesNothing() { ServiceClient serviceClient = new ServiceClient(); CreateGenerator().NormalizeClientModel(serviceClient); // Nothing happens }
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName) : base(serviceClient, methodGroupName) { MethodTemplateModels.Clear(); Methods.Where(m => m.Group == MethodGroupName) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient))); }
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName) : base(serviceClient, methodGroupName) { // Clear base initialized MethodTemplateModels and re-populate with // AzureMethodTemplateModel MethodTemplateModels.Clear(); var currentMethods = Methods.Where(m => m.Group == MethodGroupName && m.Extensions.ContainsKey(AzureExtensions.PageableExtension)); var nextListMethods = new List<Method>(); foreach (var method in currentMethods) { var pageableExtension = method.Extensions[AzureExtensions.PageableExtension] as Newtonsoft.Json.Linq.JContainer; var operationName = (string)pageableExtension["operationName"]; if (operationName != null) { var nextLinkMethod = Methods.FirstOrDefault(m => operationName.Equals(m.SerializedName, StringComparison.OrdinalIgnoreCase)); if (nextLinkMethod != null) { method.Extensions["nextLinkURL"] = nextLinkMethod.Url; method.Extensions["nextLinkParameters"] = nextLinkMethod.LogicalParameters; nextListMethods.Add(nextLinkMethod); } } } Methods.RemoveAll(m => nextListMethods.Contains(m)); Methods.Where(m => m.Group == methodGroupName) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient))); }
/// <summary> /// Normalizes client model using Azure-specific extensions. /// </summary> /// <param name="serviceClient">Service client</param> /// <param name="settings">AutoRest settings</param> /// <param name="codeNamer">AutoRest settings</param> /// <returns></returns> public static void NormalizeAzureClientModel(ServiceClient serviceClient, Settings settings, CodeNamer codeNamer) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } if (settings == null) { throw new ArgumentNullException("settings"); } if (codeNamer == null) { throw new ArgumentNullException("codeNamer"); } settings.AddCredentials = true; // This extension from general extensions must be run prior to Azure specific extensions. ProcessParameterizedHost(serviceClient, settings); ProcessClientRequestIdExtension(serviceClient); UpdateHeadMethods(serviceClient); ParseODataExtension(serviceClient); ProcessGlobalParameters(serviceClient); FlattenModels(serviceClient); FlattenMethodParameters(serviceClient, settings); ParameterGroupExtensionHelper.AddParameterGroups(serviceClient); AddLongRunningOperations(serviceClient); AddAzureProperties(serviceClient); SetDefaultResponses(serviceClient); AddPageableMethod(serviceClient, codeNamer); }
/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { string packageName = GoCodeNamer.PackageNameFromNamespace(Settings.Namespace); // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient, packageName), }; await Write(serviceClientTemplate, GoCodeNamer.FormatFileName("client")); foreach (var methodGroupName in serviceClient.MethodGroups) { var groupedMethodTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, packageName, methodGroupName), }; await Write(groupedMethodTemplate, GoCodeNamer.FormatFileName(methodGroupName.ToLowerInvariant())); } // Models var modelsTemplate = new ModelsTemplate { Model = new ModelsTemplateModel(serviceClient, packageName), }; await Write(modelsTemplate, GoCodeNamer.FormatFileName("models")); // Version var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(serviceClient, packageName), }; await Write(versionTemplate, GoCodeNamer.FormatFileName("version")); }
public override async Task Generate(ServiceClient serviceClient) { var viewModel = new SampleViewModel(); var model = new SampleModel(); model.Model = viewModel; await Write(model, Path.Combine(Settings.ModelsName, "Pet.cs")); }
public VersionTemplateModel(ServiceClient serviceClient, string packageName, string[] version) { this.LoadFrom(serviceClient); PackageName = packageName; Version = version; }
public ServiceClientTemplateModel(ServiceClient serviceClient, string packageName, string methodGroupName = null) { this.LoadFrom(serviceClient); MethodGroupName = methodGroupName == null ? string.Empty : methodGroupName; PackageName = packageName == null ? string.Empty : packageName; BaseClient = "ManagementClient"; ClientName = string.IsNullOrEmpty(MethodGroupName) ? BaseClient : MethodGroupName.IsNamePlural(PackageName) ? MethodGroupName + "Client" : (MethodGroupName + "Client").TrimPackageName(PackageName); MethodScope = new MethodScopeProvider(); MethodTemplateModels = new List<MethodTemplateModel>(); Methods.Where(m => m.BelongsToGroup(MethodGroupName, PackageName)) .OrderBy(m => m.Name) .ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, ClientName, PackageName, new MethodScopeProvider()))); Documentation = string.Format("Package {0} implements the Azure ARM {1} service API version {2}.\n\n{3}", PackageName, ServiceName, ApiVersion, !string.IsNullOrEmpty(Documentation) ? Documentation.UnwrapAnchorTags() : ""); ClientDocumentation = string.Format("{0} is the base client for {1}.", ClientName, ServiceName); }
public MethodTemplateModel(Method source, ServiceClient serviceClient) { this.LoadFrom(source); ParameterTemplateModels = new List<ParameterTemplateModel>(); source.Parameters.ForEach(p => ParameterTemplateModels.Add(new ParameterTemplateModel(p))); ServiceClient = serviceClient; if (source.Group != null) { OperationName = source.Group.ToPascalCase(); } else { OperationName = serviceClient.Name; } AddCustomHeader = true; string formatter; foreach (var parameter in LocalParameters) { if (string.IsNullOrWhiteSpace(parameter.DefaultValue)) { parameter.DefaultValue = PythonConstants.None; } } foreach (Match m in Regex.Matches(Url, @"\{[\w]+:[\w]+\}")) { formatter = m.Value.Split(':').First() + '}'; Url = Url.Replace(m.Value, formatter); } }
public void NameCollisionTestWithoutNamespace() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; var customObjectType = new CompositeType(); customObjectType.Name = "azure always rocks!"; var baseType = new CompositeType(); baseType.Name = "azure always rocks!"; serviceClient.Methods.Add(new Method { Name = "azure always rocks!", Group = "azure always rocks!", ReturnType = new Response(customObjectType, null) }); serviceClient.ModelTypes.Add(customObjectType); serviceClient.ModelTypes.Add(baseType); var framework = new CSharpCodeNamer(); framework.ResolveNameCollisions(serviceClient, null, null); Assert.Equal("azure always rocks!Client", serviceClient.Name); Assert.Equal("azure always rocks!Operations", serviceClient.MethodGroups.First()); Assert.Equal("azure always rocks!", serviceClient.Methods[0].Name); Assert.Equal("azure always rocks!", serviceClient.ModelTypes.First(m => m.Name == "azure always rocks!").Name); }
public AzureServiceClientTemplateModel(ServiceClient serviceClient, bool internalConstructors) : base(serviceClient, internalConstructors) { // TODO: Initialized in the base constructor. Why Clear it? MethodTemplateModels.Clear(); Methods.Where(m => m.Group == null) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient, SyncMethodsGenerationMode.None))); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClientModel"></param> public override void NormalizeClientModel(ServiceClient serviceClientModel) { // Add the current package name as a reserved keyword _namingFramework.ReserveNamespace(Settings.Namespace); _namingFramework.NormalizeClientModel(serviceClientModel); _namingFramework.ResolveNameCollisions(serviceClientModel, Settings.Namespace, Settings.Namespace + ".Models"); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { PopulateAdditionalProperties(serviceClient); SwaggerExtensions.NormalizeClientModel(serviceClient, Settings); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + "." + Settings.ModelsName); }
public ExtensionsTemplateModel(ServiceClient serviceClient, string operationName, SyncMethodsGenerationMode syncWrappers) { this.LoadFrom(serviceClient); MethodTemplateModels = new List<MethodTemplateModel>(); ExtensionName = operationName ?? this.Name; this.Methods.Where(m => m.Group == operationName) .ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient, syncWrappers))); }
/// <summary> /// Normalizes client model using generic extensions. /// </summary> /// <param name="serviceClient">Service client</param> /// <param name="settings">AutoRest settings</param> /// <returns></returns> public static void NormalizeClientModel(ServiceClient serviceClient, Settings settings) { ProcessGlobalParameters(serviceClient); FlattenModels(serviceClient); FlattenMethodParameters(serviceClient, settings); ParameterGroupExtensionHelper.AddParameterGroups(serviceClient); ProcessParameterizedHost(serviceClient, settings); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { SwaggerExtensions.NormalizeClientModel(serviceClient, Settings); PopulateAdditionalProperties(serviceClient); Namer.NormalizeClientModel(serviceClient); Namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); Namer.NormalizeOdataFilterParameter(serviceClient); }
public ModelTemplateModel(CompositeType source, ServiceClient serviceClient) { this.LoadFrom(source); ServiceClient = serviceClient; if (source.BaseModelType != null) { _parent = new ModelTemplateModel(source.BaseModelType, serviceClient); } }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient">The service client.</param> public override void NormalizeClientModel(ServiceClient serviceClient) { Settings.AddCredentials = true; AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, CodeNamer); CorrectFilterParameters(serviceClient); base.NormalizeClientModel(serviceClient); AddRubyPageableMethod(serviceClient); ApplyPagination(serviceClient); }
/// <summary> /// Initializes a new instance of ServiceClientTemplateModel class. /// </summary> /// <param name="serviceClient"></param> public ServiceClientTemplateModel(ServiceClient serviceClient) { this.LoadFrom(serviceClient); HasModelTypes = serviceClient.HasModelTypes(); MethodTemplateModels = new List<MethodTemplateModel>(); Methods.Where(m => m.Group == null) .ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient))); this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(SwaggerExtensions.ParameterizedHostExtension); }
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName) : base(serviceClient, methodGroupName) { // Clear base initialized MethodTemplateModels and re-populate with // AzureMethodTemplateModel MethodTemplateModels.Clear(); Methods.Where(m => m.Group == methodGroupName) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient))); }
public ServiceClientTemplateModel(ServiceClient serviceClient, bool internalConstructors) { this.LoadFrom(serviceClient); MethodTemplateModels = new List<MethodTemplateModel>(); Methods.Where(m => m.Group == null) .ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient, SyncMethodsGenerationMode.None))); ConstructorVisibility = internalConstructors ? "internal" : "public"; this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(SwaggerExtensions.ParameterizedHostExtension); }
public PackageInfoTemplateModel(ServiceClient serviceClient, string clientName, string subPackage = null) { this.LoadFrom(serviceClient); this.Title = clientName; if (serviceClient != null) { this.Description = serviceClient.Documentation; } this.SubPackage = subPackage; }
public MethodGroupTemplateModel(ServiceClient serviceClient, string packageName, string methodGroupName) : base(serviceClient, packageName, methodGroupName) { this.LoadFrom(serviceClient); Documentation = string.Format("{0} is the {1} ", ClientName, string.IsNullOrEmpty(Documentation) ? string.Format("client for the {0} methods of the {1} service.", MethodGroupName, ServiceName) : Documentation.ToSentence()); }
private static void NormalizeApiVersion(ServiceClient serviceClient) { serviceClient.Properties.Where( p => p.SerializedName.Equals(AzureExtensions.ApiVersion, StringComparison.OrdinalIgnoreCase)) .ForEach(p => p.DefaultValue = p.DefaultValue.Replace("\"", "'")); serviceClient.Properties.Where( p => p.SerializedName.Equals(AzureExtensions.AcceptLanguage, StringComparison.OrdinalIgnoreCase)) .ForEach(p => p.DefaultValue = p.DefaultValue.Replace("\"", "'")); }
public AzureServiceClientTemplateModel(ServiceClient serviceClient) : base(serviceClient) { Properties.Remove(Properties.Find(p => p.Type.Name == "ServiceClientCredentials")); MethodTemplateModels.Clear(); Methods.Where(m => m.Group == null) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient))); ModelTemplateModels.Clear(); ModelTypes.ForEach(m => ModelTemplateModels.Add(new AzureModelTemplateModel(m, serviceClient))); }
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName) : base(serviceClient, methodGroupName) { MethodGroupType = MethodGroupName + "Operations"; // Clear base initialized MethodTemplateModels and re-populate with // AzureMethodTemplateModel MethodTemplateModels.Clear(); Methods.Where(m => m.Group == methodGroupName) .ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient, SyncMethodsGenerationMode.None))); }