/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelGo; if (codeModel == null) { throw new Exception("Code model is not a Go Code Model"); } // unfortunately there is an ordering issue here. during model generation we might // flatten some types (but not all depending on type). then during client generation // the validation codegen needs to know if a type was flattened so it can generate // the correct code, so we need to generate models before clients. // Models var modelsTemplate = new ModelsTemplate { Model = codeModel }; await Write(modelsTemplate, FormatFileName("models")); // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, FormatFileName("client")); // by convention the methods in the method group with an empty // name go into the client template so skip them here. HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "models", "client", "version", }; foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name))) { if (ReservedFiles.Contains(methodGroup.Name.Value)) { methodGroup.Name += "group"; } ReservedFiles.Add(methodGroup.Name); var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant()); } // Version var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, FormatFileName("version")); }
/// <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); // If version is passed in command line then pick that, else keep it 0.0.0(to make it optional for testing). string[] version = GoCodeNamer.SDKVersionFromPackageVersion( !string.IsNullOrEmpty(Settings.PackageVersion) ? Settings.PackageVersion : "0.0.0"); // 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, version), }; await Write(versionTemplate, GoCodeNamer.FormatFileName("version")); }
/// <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")); }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } writeNamespaceFolders(codeModel); if (codeModel.BasicSetupPy) { var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); } var noAsync = await Settings.Instance.Host.GetValue <bool?>("no-async"); var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.')); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var configurationTemplate = new ConfigurationTemplate { Model = codeModel }; await Write(configurationTemplate, Path.Combine(folderName, "_configuration.py")); // Writing service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(folderName, "_" + codeModel.Name.ToPythonCase() + ".py")); if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var serviceClientOpTemplate = new ServiceClientOperationsTemplate { Model = codeModel }; await Write(serviceClientOpTemplate, Path.Combine(folderName, "operations", "_" + codeModel.Name.ToPythonCase() + "_operations.py")); } // do we need to write out the version template file? var versionPath = Path.Combine(folderName, "version.py"); // protect the version file await Settings.Instance.Host.ProtectFiles(versionPath); if (true != await Settings.Instance.Host.GetValue <bool?>("keep-version-file") || string.IsNullOrEmpty(await Settings.Instance.Host.ReadFile(versionPath))) { var versionTemplate = new VersionTemplate { Model = codeModel }; // if they didn't say to keep the old file (or it was not there/empty), write it out. await Write(versionTemplate, versionPath); } //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); var modelTemplate = new ModelTemplate { Model = codeModel.getSortedModels() }; await Write(modelTemplate, Path.Combine(folderName, "models", "_models.py")); modelTemplate.Python3Mode = true; await Write(modelTemplate, Path.Combine(folderName, "models", "_models_py3.py")); } //MethodGroups if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", "_" + codeModel.Name.ToPythonCase() + "_enums.py")); } // Async if (noAsync != true) { var serviceClientInitTemplateAsync = new ServiceClientInitTemplateAsync { Model = codeModel }; await Write(serviceClientInitTemplateAsync, Path.Combine(folderName, "aio", "__init__.py")); // Writing AIO service client var serviceClientAsyncTemplate = new ServiceClientTemplateAsync { Model = codeModel }; await Write(serviceClientAsyncTemplate, Path.Combine(folderName, "aio", "_" + codeModel.Name.ToPythonCase() + "_async.py")); if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var serviceClientOpTemplateAsync = new ServiceClientOperationsTemplateAsync { Model = codeModel }; await Write(serviceClientOpTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "_" + codeModel.Name.ToPythonCase() + "_operations_async.py")); } //MethodGroups if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup)) { var methodGroupIndexTemplateAsync = new MethodGroupInitTemplate { Model = codeModel, AsyncMode = true }; await Write(methodGroupIndexTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { // Build a Py3 version that import the Py2 one var methodGroupTemplatePy3 = new MethodGroupTemplateAsync { Model = methodGroupModel }; await Write(methodGroupTemplatePy3, Path.Combine(folderName, "aio", "operations_async", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + "_async.py")); } } } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)model.Extensions[AzureExtensions.ExternalExtension]) || model.Name == "Resource" || model.Name == "SubResource") { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model, serviceClient.ModelTypes), }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new AzureRequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if (this.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (Settings.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates Ruby code for service client. /// </summary> /// <param name="cm">The code model.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelRb; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Ruby code model."); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension)); // Method groups foreach (MethodGroupRb group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup)) { var groupTemplate = new MethodGroupTemplate { Model = group }; await Write(groupTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(@group.TypeName) + ImplementationFileExtension)); } // Models foreach (CompositeTypeRb model in codeModel.ModelTypes) { var modelTemplate = new ModelTemplate { Model = model }; await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (EnumTypeRb enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsRb(codeModel, this) }; await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension); // Version File if (!string.IsNullOrEmpty(GeneratorSettingsRb.Instance.packageVersion)) { var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion }; await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (!string.IsNullOrEmpty(Settings.Instance.Namespace)) { var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations }; await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates Ruby code for Azure service client. /// </summary> /// <param name="cm">The code model.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelRba; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure Ruby code model."); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension)); // Operations foreach (MethodGroupRba group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup)) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = group }; await Write(operationsTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(operationsTemplate.Model.TypeName) + ImplementationFileExtension)); } // Models foreach (CompositeTypeRba model in codeModel.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)model.Extensions[AzureExtensions.ExternalExtension])) { continue; } if (codeModel.pageModels.Any(each => each.Name.EqualsIgnoreCase(model.Name))) { // Skip, handled in the .pageModels section below. continue; } var modelTemplate = new AzureModelTemplate { Model = model }; if (!CompositeTypeRba.resourceOrSubResourceRegEx.IsMatch(model.Name) || !CompositeTypeRba.IsResourceModelMatchingStandardDefinition(model)) { await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } } // Paged Models foreach (var pageModel in codeModel.pageModels) { var pageTemplate = new PageModelTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(pageModel.Name) + ImplementationFileExtension)); } // Enums foreach (EnumTypeRb enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsRba(codeModel, this) }; await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension); // Version File if (GeneratorSettingsRb.Instance.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion }; await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (Settings.Instance.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations }; await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generates Ruby code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Method groups foreach (var group in serviceClient.MethodGroups) { var groupTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(groupTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model, serviceClient.ModelTypes) }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace, this.packageVersion), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if (!string.IsNullOrEmpty(this.packageVersion)) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (!string.IsNullOrEmpty(Settings.Namespace)) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } // Service client string[] namespaceParts = codeModel.Namespace.Split('.'); for (int i = 1; i < namespaceParts.Length; ++i) { string initFolderName = Path.Combine(namespaceParts.Take(i).ToArray()); await Write("__import__('pkg_resources').declare_namespace(__name__)", Path.Combine(initFolderName, "__init__.py"), true); } var folderName = codeModel.Name.ToPythonCase().ToLower(); var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, Path.Combine(folderName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel }; await Write(exceptionTemplate, Path.Combine(folderName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel }; await Write(credentialTemplate, Path.Combine(folderName, "credentials.py")); //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); foreach (var modelType in codeModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in codeModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", ((string)modelType.Name).ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in codeModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", ((string)modelType.Name).ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string) methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPy; if (codeModel == null) { throw new Exception("Code model is not a Python Code Model"); } writeNamespaceFolders(codeModel); if (codeModel.BasicSetupPy) { var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); } var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.')); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py")); // do we need to write out the version template file? var versionPath = Path.Combine(folderName, "version.py"); // protect the version file await Settings.Instance.Host.ProtectFiles(versionPath); if (true != await Settings.Instance.Host.GetValue <bool?>("keep-version-file") || string.IsNullOrEmpty(await Settings.Instance.Host.ReadFile(versionPath))) { var versionTemplate = new VersionTemplate { Model = codeModel }; // if they didn't say to keep the old file (or it was not there/empty), write it out. await Write(versionTemplate, versionPath); } //Models if (codeModel.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); foreach (var modelType in codeModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + ".py")); // Rebuild the same in Python 3 mode modelTemplate.Python3Mode = true; await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + "_py3.py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPya; if (codeModel == null) { throw new Exception("CodeModel is not a Python Azure Code Model"); } // Service client string[] namespaceParts = codeModel.Namespace.Split('.'); for (int i = 1; i < namespaceParts.Length; ++i) { string initFolderName = Path.Combine(namespaceParts.Take(i).ToArray()); await Write("__import__('pkg_resources').declare_namespace(__name__)", Path.Combine(initFolderName, "__init__.py"), true); } var folderName = Path.Combine(codeModel.Namespace.Split('.')); var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel, }; await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel, }; await Write(versionTemplate, Path.Combine(folderName, "version.py")); //Models var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension)); if (models.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); foreach (var modelType in models) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(folderName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as MethodGroupPya }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } // Page class foreach (var pageModel in codeModel.PageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(folderName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
/// <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); // If version is passed in command line then pick that, else keep it 0.0.0(to make it optional for testing). string[] version = GoCodeNamer.SDKVersionFromPackageVersion( !string.IsNullOrEmpty(Settings.PackageVersion) ? Settings.PackageVersion : "0.0.0"); // 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, version), }; await Write(versionTemplate, GoCodeNamer.FormatFileName("version")); }
/// <summary> /// Generates Ruby code for Azure service client. /// </summary> /// <param name="cm">The code model.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelRba; if (codeModel == null) { throw new InvalidCastException("CodeModel is not a Azure Ruby code model."); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension)); // Operations foreach (MethodGroupRba group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup)) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = group }; await Write(operationsTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(operationsTemplate.Model.TypeName) + ImplementationFileExtension)); } // Models foreach (CompositeTypeRba model in codeModel.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool)model.Extensions[AzureExtensions.ExternalExtension]) || model.Name == "Resource" || model.Name == "SubResource") { continue; } if( codeModel.pageModels.Any( each => each.Name.EqualsIgnoreCase(model.Name ) ) ) { // Skip, handled in the .pageModels section below. continue; } var modelTemplate = new ModelTemplate { Model = model }; await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Paged Models foreach (var pageModel in codeModel.pageModels) { var pageTemplate = new PageModelTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(pageModel.Name) + ImplementationFileExtension)); } // Enums foreach (EnumTypeRb enumType in codeModel.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate{Model = new RequirementsRba(codeModel, this)}; await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension); // Version File if (GeneratorSettingsRb.Instance.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion }; await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (Settings.Instance.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations }; await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPya; if (codeModel == null) { throw new Exception("CodeModel is not a Python Azure Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel, }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel, }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel, }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel, }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension)); if (models.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in models) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as MethodGroupPya }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } // Page class foreach (var pageModel in codeModel.PageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(codeModel.PackageName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
/// <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")); }
/// <summary> /// Generates Ruby code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async task for generating SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new ServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Method groups foreach (var group in serviceClient.MethodGroups) { var groupTemplate = new MethodGroupTemplate { Model = new MethodGroupTemplateModel(serviceClient, group), }; await Write(groupTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { var modelTemplate = new ModelTemplate { Model = new ModelTemplateModel(model, serviceClient.ModelTypes) }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new RequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if (!string.IsNullOrEmpty(this.packageVersion)) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if (!string.IsNullOrEmpty(Settings.Namespace)) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPya; if (codeModel == null) { throw new Exception("CodeModel is not a Python Azure Code Model"); } // Service client var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel, }; await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel, }; await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = codeModel, }; await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = codeModel, }; await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py")); //Models var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension)); if (models.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py")); foreach (var modelType in models) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as MethodGroupPya }; await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string) methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } // Page class foreach (var pageModel in codeModel.PageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(codeModel.PackageName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="cm"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelPya; if (codeModel == null) { throw new Exception("CodeModel is not a Python Azure Code Model"); } writeNamespaceFolders(codeModel); if (codeModel.BasicSetupPy) { var setupTemplate = new SetupTemplate { Model = codeModel }; await Write(setupTemplate, "setup.py"); } var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.')); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel }; await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py")); var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel, }; await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = codeModel, }; await Write(versionTemplate, Path.Combine(folderName, "version.py")); //Models var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension)); if (models.Any()) { var modelInitTemplate = new AzureModelInitTemplate { Model = codeModel }; await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py")); foreach (var modelType in models) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(folderName, "models", modelType.Name.ToPythonCase() + ".py")); // Rebuild the same in Python 3 mode modelTemplate.Python3Mode = true; await Write(modelTemplate, Path.Combine(folderName, "models", modelType.Name.ToPythonCase() + "_py3.py")); } } //MethodGroups if (codeModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = codeModel }; await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py")); foreach (var methodGroupModel in codeModel.MethodGroupModels) { var methodGroupTemplate = new AzureMethodGroupTemplate { Model = methodGroupModel as MethodGroupPya }; await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py")); } } // Enums if (codeModel.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes }; await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py")); } // Page class foreach (var pageModel in codeModel.PageModels) { var pageTemplate = new PageTemplate { Model = pageModel }; await Write(pageTemplate, Path.Combine(folderName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py")); } }
/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { // if preview-chk:true is specified verify that preview swagger is output under a preview subdirectory. // this is a bit of a hack until we have proper support for this in the swagger->sdk bot so it's opt-in. if (Settings.Instance.Host.GetValue <bool>("preview-chk").Result) { const string previewSubdir = "/preview/"; var files = await Settings.Instance.Host.GetValue <string[]>("input-file"); // only evaluate composite builds if all swaggers are preview as we don't have a well-defined model for mixed preview/stable swaggers if (files.All(file => file.IndexOf(previewSubdir) > -1) && Settings.Instance.Host.GetValue <string>("output-folder").Result.IndexOf(previewSubdir) == -1) { throw new InvalidOperationException($"codegen for preview swagger {files[0]} must be under a preview subdirectory"); } } var codeModel = cm as CodeModelGo; if (codeModel == null) { throw new Exception("Code model is not a Go Code Model"); } // unfortunately there is an ordering issue here. during model generation we might // flatten some types (but not all depending on type). then during client generation // the validation codegen needs to know if a type was flattened so it can generate // the correct code, so we need to generate models before clients. // Models var modelsTemplate = new ModelsTemplate { Model = codeModel }; await Write(modelsTemplate, FormatFileName("models")); // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, FormatFileName("client")); // by convention the methods in the method group with an empty // name go into the client template so skip them here. HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "models", "client", "version", "interfaces", }; foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name))) { if (ReservedFiles.Contains(methodGroup.Name.Value)) { methodGroup.Name += "group"; } ReservedFiles.Add(methodGroup.Name); var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant()); } // interfaces var interfacesTemplate = new InterfacesTemplate { Model = codeModel }; await Write(interfacesTemplate, FormatFileName($"{CodeNamerGo.InterfacePackageName(codeModel.Namespace)}/interfaces")); // Version var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, FormatFileName("version")); // go.mod file, opt-in by specifying the gomod-root arg var modRoot = Settings.Instance.Host.GetValue <string>("gomod-root").Result; if (!string.IsNullOrWhiteSpace(modRoot)) { var normalized = Settings.Instance.Host.GetValue <string>("output-folder").Result.Replace('\\', '/'); var i = normalized.IndexOf(modRoot); if (i == -1) { throw new Exception($"didn't find module root '{modRoot}' in output path '{normalized}'"); } // module name is everything to the right of the start of the module root var gomodTemplate = new GoModTemplate { Model = new GoMod(normalized.Substring(i)) }; await Write(gomodTemplate, $"{StagingDir()}go.mod"); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient); if (!string.IsNullOrWhiteSpace(Version)) { serviceClientTemplateModel.Version = Version; } // Service client var setupTemplate = new SetupTemplate { Model = serviceClientTemplateModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = serviceClientTemplateModel }; await Write(serviceClientInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, Path.Combine(serviceClientTemplateModel.PackageName, serviceClientTemplateModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = serviceClientTemplateModel, }; await Write(versionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = serviceClientTemplateModel, }; await Write(exceptionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = serviceClientTemplateModel, }; await Write(credentialTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "credentials.py")); //Models if (serviceClient.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = new ModelInitTemplateModel(serviceClient) }; await Write(modelInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", "__init__.py")); foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = serviceClientTemplateModel }; await Write(methodGroupIndexTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py")); } } // Enums if (serviceClient.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(serviceClient.EnumTypes), }; await Write(enumTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", serviceClientTemplateModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generates C# code for service client. /// </summary> /// <param name="serviceClient">The service client.</param> /// <returns>Async tasks which generates SDK files.</returns> public override async Task Generate(ServiceClient serviceClient) { // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = new AzureServiceClientTemplateModel(serviceClient), }; await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension)); // Operations foreach (var group in serviceClient.MethodGroups) { // Operation var operationsTemplate = new AzureMethodGroupTemplate { Model = new AzureMethodGroupTemplateModel(serviceClient, group), }; await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension)); } // Models foreach (var model in serviceClient.ModelTypes) { if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) && (bool) model.Extensions[AzureExtensions.ExternalExtension]) || model.Name == "Resource" || model.Name == "SubResource") { continue; } var modelTemplate = new ModelTemplate { Model = new AzureModelTemplateModel(model, serviceClient.ModelTypes), }; await Write(modelTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension)); } // Enums foreach (var enumType in serviceClient.EnumTypes) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(enumType), }; await Write(enumTemplate, Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension)); } // Requirements var requirementsTemplate = new RequirementsTemplate { Model = new AzureRequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace), }; await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension); // Version File if(this.packageVersion != null) { var versionTemplate = new VersionTemplate { Model = new VersionTemplateModel(packageVersion), }; await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension)); } // Module Definition File if(Settings.Namespace != null) { var modTemplate = new ModuleDefinitionTemplate { Model = new ModuleDefinitionTemplateModel(Settings.Namespace), }; await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension)); } }
/// <summary> /// Generate Python client code for given ServiceClient. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(ServiceClient serviceClient) { var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient); if (!string.IsNullOrWhiteSpace(Version)) { serviceClientTemplateModel.Version = Version; } // Service client var setupTemplate = new SetupTemplate { Model = serviceClientTemplateModel }; await Write(setupTemplate, "setup.py"); var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = serviceClientTemplateModel }; await Write(serviceClientInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "__init__.py")); var serviceClientTemplate = new ServiceClientTemplate { Model = serviceClientTemplateModel, }; await Write(serviceClientTemplate, Path.Combine(serviceClientTemplateModel.PackageName, serviceClientTemplateModel.Name.ToPythonCase() + ".py")); var versionTemplate = new VersionTemplate { Model = serviceClientTemplateModel, }; await Write(versionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "version.py")); var exceptionTemplate = new ExceptionTemplate { Model = serviceClientTemplateModel, }; await Write(exceptionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "exceptions.py")); var credentialTemplate = new CredentialTemplate { Model = serviceClientTemplateModel, }; await Write(credentialTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "credentials.py")); //Models if (serviceClient.ModelTypes.Any()) { var modelInitTemplate = new ModelInitTemplate { Model = new ModelInitTemplateModel(serviceClient) }; await Write(modelInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", "__init__.py")); foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels) { var modelTemplate = new ModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py")); } } //MethodGroups if (serviceClientTemplateModel.MethodGroupModels.Any()) { var methodGroupIndexTemplate = new MethodGroupInitTemplate { Model = serviceClientTemplateModel }; await Write(methodGroupIndexTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", "__init__.py")); foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels) { var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroupModel }; await Write(methodGroupTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py")); } } // Enums if (serviceClient.EnumTypes.Any()) { var enumTemplate = new EnumTemplate { Model = new EnumTemplateModel(serviceClient.EnumTypes), }; await Write(enumTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", serviceClientTemplateModel.Name.ToPythonCase() + "_enums.py")); } }
/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var folder = Path.GetFullPath(Settings.Instance.Host.GetValue <string>("output-folder").Result).Replace('\\', '/'); // check if the namespace contains illegal characters var ns = Settings.Instance.Host.GetValue <string>("namespace").Result; if (Settings.Instance.Host.GetValue <bool>("namespace-chk").Result) { NamespaceCheck(ns); } // if preview-chk:true is specified verify that preview swagger is output under a preview subdirectory. // this is a bit of a hack until we have proper support for this in the swagger->sdk bot so it's opt-in. if (Settings.Instance.Host.GetValue <bool>("preview-chk").Result) { PreviewCheck(folder); } var codeModel = cm as CodeModelGo; if (codeModel == null) { throw new Exception("Code model is not a Go Code Model"); } // unfortunately there is an ordering issue here. during model generation we might // flatten some types (but not all depending on type). then during client generation // the validation codegen needs to know if a type was flattened so it can generate // the correct code, so we need to generate models before clients. // Models var modelsTemplate = new ModelsTemplate { Model = codeModel }; await Write(modelsTemplate, FormatFileName("models")); // Enums - while initially enums should be part of the models, to decrease the size of the models.go file, // we separate the enums definitions out of the models.go file var enums = codeModel.EnumTypes.Cast <EnumTypeGo>().ToList(); if (enums.Any()) { var enumsTemplate = new EnumsTemplate { Model = codeModel }; await Write(enumsTemplate, FormatFileName("enums")); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, FormatFileName("client")); // by convention the methods in the method group with an empty // name go into the client template so skip them here. HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "models", "client", "version", "interfaces", "enums", }; foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name))) { if (ReservedFiles.Contains(methodGroup.Name.Value)) { methodGroup.Name += "group"; } ReservedFiles.Add(methodGroup.Name); var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant()); } // interfaces var interfacesTemplate = new InterfacesTemplate { Model = codeModel }; await Write(interfacesTemplate, FormatFileName($"{CodeNamerGo.InterfacePackageName(codeModel.Namespace)}/interfaces")); // Version var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, FormatFileName("version")); // go.mod file, opt-in by specifying the gomod-root arg var modRoot = Settings.Instance.Host.GetValue <string>("gomod-root").Result; if (!string.IsNullOrWhiteSpace(modRoot)) { var i = folder.IndexOf(modRoot); if (i == -1) { throw new Exception($"didn't find module root '{modRoot}' in output path '{folder}'"); } var goVersion = Settings.Instance.Host.GetValue <string>("go-version").Result; if (string.IsNullOrWhiteSpace(goVersion)) { goVersion = defaultGoVersion; } // module name is everything to the right of the start of the module root var gomodTemplate = new GoModTemplate { Model = new GoMod(folder.Substring(i), goVersion) }; await Write(gomodTemplate, $"{StagingDir()}go.mod"); } // metadata var metadataOutputFolder = Settings.Instance.Host.GetValue <string>("metadata-output-folder").Result; if (!string.IsNullOrWhiteSpace(metadataOutputFolder)) { var metadataTemplate = new MetadataTemplate { Model = new MetadataGo(Settings.Instance.Host.GetValue <string[]>("input-file").Result, folder, ns) }; var tag = Settings.Instance.Host.GetValue <string>("tag").Result; await Write(metadataTemplate, $"{metadataOutputFolder}/{tag}.json"); } }