Пример #1
0
        /// <summary>
        /// Generate Azure TypeScript client code
        /// </summary>
        /// <param name="cm"></param>
        /// <returns></returns>
        public override async Task Generate(CodeModel cm)
        {
            var codeModel = cm as CodeModelTSa;

            if (codeModel == null)
            {
                throw new InvalidCastException("CodeModel is not a Azure TypeScript code model.");
            }

            codeModel.PackageName    = Settings.Instance.PackageName;
            codeModel.PackageVersion = Settings.Instance.PackageVersion;

            // Service client
            var serviceClientTemplate = new AzureServiceClientTemplate {
                Model = codeModel
            };

            await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".ts");
            await Write(new AzureServiceClientContextTemplate { Model = codeModel }, codeModel.ContextName.ToCamelCase() + ".ts");

            var modelIndexTemplate = new AzureModelIndexTemplate {
                Model = codeModel
            };

            await Write(modelIndexTemplate, Path.Combine("models", "index.ts"));

            var mapperIndexTemplate = new AzureMapperIndexTemplate {
                Model = codeModel
            };

            await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));

            //MethodGroups
            if (codeModel.MethodGroupModels.Any())
            {
                var methodGroupIndexTemplate = new MethodGroupIndexTemplate {
                    Model = codeModel
                };
                await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.ts"));

                foreach (var methodGroupModel in codeModel.MethodGroupModels)
                {
                    var methodGroupTemplate = new AzureMethodGroupTemplate {
                        Model = methodGroupModel
                    };
                    await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".ts"));
                }
            }

            var generateMetadata = Singleton <GeneratorSettingsTS> .Instance.GenerateMetadata;

            if (generateMetadata)
            {
                // package.json
                var packageJson = new PackageJson {
                    Model = codeModel
                };
                await Write(packageJson, Path.Combine("../", "package.json"));

                // tsconfig.json
                var browserTsConfig = new TsConfig {
                    Model = new TsConfigModel(true)
                };
                await Write(browserTsConfig, Path.Combine("../", "tsconfig.json"));

                // webpack.config.js
                var webpackConfig = new WebpackConfig {
                    Model = codeModel
                };
                await Write(webpackConfig, Path.Combine("../", "webpack.config.js"));

                // .npmignore
                var npmIgnore = new NpmIgnore {
                    Model = codeModel
                };
                await Write(npmIgnore, Path.Combine("../", ".npmignore"));

                //README.md
                var readme = new AzureReadmeTemplate {
                    Model = codeModel
                };
                await Write(readme, Path.Combine("../", "README.md"));
            }
        }
        /// <summary>
        ///     Generate TypeScript client code
        /// </summary>
        /// <param name="serviceClient"></param>
        /// <returns></returns>
        public override async Task Generate(CodeModel cm)
        {
            var codeModel = cm as CodeModelTS;

            if (codeModel == null)
            {
                throw new InvalidCastException("CodeModel is not a TypeScript code model.");
            }

            InitializeSettings(codeModel);

            // Service client
            var serviceClientTemplate = new ServiceClientTemplate {
                Model = codeModel
            };

            await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".ts");
            await Write(new ServiceClientContextTemplate { Model = codeModel }, codeModel.ContextName.ToCamelCase() + ".ts");

            //Models
            if (codeModel.ModelTypes.Any())
            {
                var modelIndexTemplate = new ModelIndexTemplate {
                    Model = codeModel
                };
                await Write(modelIndexTemplate, Path.Combine("models", "index.ts"));

                var mapperIndexTemplate = new MapperIndexTemplate {
                    Model = codeModel
                };
                await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));
            }

            bool serviceHasMappableParameters = codeModel.Methods
                                                .SelectMany(m => m.LogicalParameters)
                                                .Any(p => p.Location != ParameterLocation.Body);

            if (serviceHasMappableParameters)
            {
                await Write(new ParameterTemplate { Model = codeModel }, Path.Combine("models", "parameters.ts"));
            }

            //MethodGroups
            if (codeModel.MethodGroupModels.Any())
            {
                var methodGroupIndexTemplate = new MethodGroupIndexTemplate {
                    Model = codeModel
                };
                await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.ts"));

                foreach (var methodGroupModel in codeModel.MethodGroupModels)
                {
                    var mappersTemplate = new MethodGroupMappersTemplate {
                        Model = methodGroupModel
                    };
                    await Write(mappersTemplate, Path.Combine("models", methodGroupModel.MappersModuleName + ".ts"));

                    var methodGroupTemplate = new MethodGroupTemplate {
                        Model = methodGroupModel
                    };
                    await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".ts"));
                }
            }

            if (codeModel.GenerateMetadata)
            {
                // package.json
                var packageJson = new PackageJson {
                    Model = codeModel
                };
                await Write(packageJson, Path.Combine("../", "package.json"));

                //tsconfig.json
                var nodeTsConfig = new TsConfig {
                    Model = new TsConfigModel(false)
                };
                await Write(nodeTsConfig, Path.Combine("../", "tsconfig.json"));

                // webpack.config.js
                var webpackConfig = new WebpackConfig {
                    Model = codeModel
                };
                await Write(webpackConfig, Path.Combine("../", "webpack.config.js"));

                // .npmignore
                var npmIgnore = new NpmIgnore {
                    Model = codeModel
                };
                await Write(npmIgnore, Path.Combine("../", ".npmignore"));

                //README.md
                var readme = new ReadmeTemplate {
                    Model = codeModel
                };
                await Write(readme, Path.Combine("../", "README.md"));
            }
        }