public async Task When_query_parameter_is_enum_array_then_the_enum_is_referenced()
{
//// Arrange
var settings = new WebApiOpenApiDocumentGeneratorSettings
{
DefaultUrlTemplate = "api/{controller}/{action}/{id}",
DefaultEnumHandling = EnumHandling.String,
DefaultPropertyNameHandling = PropertyNameHandling.Default,
SchemaType = SchemaType.Swagger2,
};
var generator = new WebApiOpenApiDocumentGenerator(settings);
//// Act
var document = await generator.GenerateForControllerAsync <FooController>();
var json = document.ToJson();
var clientSettings = new TypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.JQueryCallbacks
};
clientSettings.TypeScriptGeneratorSettings.TypeScriptVersion = 1.8m;
var gen = new TypeScriptClientGenerator(document, clientSettings);
var code = gen.GenerateFile();
//// Assert
Assert.NotNull(document.Operations.First().Operation.Parameters.First().Item.Reference);
Assert.Contains("getFoos(bars: Bar[], ", code);
}
static async Task Main(string[] args)
{
Console.WriteLine("准备生成，请键入回车键开始......");
Console.ReadLine();
var swaggerJsonUrl = @"https://localhost:5001/swagger/MiCake%20Demo%20Application/swagger.json";
var document = await OpenApiDocument.FromUrlAsync(swaggerJsonUrl);
var settings = new TypeScriptClientGeneratorSettings
{
ImportRequiredTypes = false,
GenerateClientClasses = false, //是否生成请求的Client，因为使用了自定义的httpClient，所以不使用生成的版本。
GenerateDtoTypes = true,
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
//生成的路径，为了避免手动手改的内容被替换，所以不直接生成到前端项目的解决方案中。
File.WriteAllText("nswagCode.ts", code);
Console.WriteLine("生成完成......");
Console.ReadLine();
}
public async Task <IActionResult> Generate()
{
string baseUrl = $"{this.Request.Scheme}://{this.Request.Host.Value.ToString()}{this.Request.PathBase.Value.ToString()}";
OpenApiDocument document = await OpenApiDocument.FromUrlAsync($"{baseUrl}/swagger/v1/swagger.json");
TypeScriptClientGeneratorSettings settings = new TypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.Axios,
PromiseType = PromiseType.Promise,
HttpClass = HttpClass.Http,
InjectionTokenType = InjectionTokenType.InjectionToken,
BaseUrlTokenName = "Authorization",
WithCredentials = true,
ClientBaseClass = "ApiClientBase",
GenerateClientClasses = true,
UseTransformOptionsMethod = true,
UseTransformResultMethod = true,
GenerateOptionalParameters = true,
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
return(Content(code));
}
/// <summary>
///
/// </summary>
/// <param name="outputFile"></param>
/// <param name="handler"></param>
/// <returns></returns>
public NSwagRunner GenerateTypeScriptClient(FilePath outputFile, Action <TypeScriptClientGeneratorSettings> handler)
{
var settings = new TypeScriptClientGeneratorSettings();
handler?.Invoke(settings);
return(GenerateTypeScriptClient(outputFile, settings));
}
static async Task Main(string[] args)
{
// var document = OpenApiDocument.FromUrlAsync("https://firefinder.azurewebsites.net/swagger/v1/swagger.json");
var document = OpenApiDocument.FromUrlAsync("https://localhost:5000/swagger/v1/swagger.json");
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
HttpClass = HttpClass.HttpClient,
InjectionTokenType = InjectionTokenType.InjectionToken,
ImportRequiredTypes = true,
Template = TypeScriptTemplate.Angular,
GenerateClientClasses = true,
GenerateClientInterfaces = true
};
var generator = new TypeScriptClientGenerator(await document, settings);
var code = generator.GenerateFile();
string path = "firefinder-api.service.ts";
using (StreamWriter sw = File.CreateText(path))
sw.WriteLine(code);
Console.WriteLine("Done");
}
internal TypeScriptFrameworkModel(TypeScriptClientGeneratorSettings settings)
{
_settings = settings;
RxJs = new TypeScriptFrameworkRxJsModel(this);
Angular = new TypeScriptFrameworkAngularModel(settings);
}
public async Task <IActionResult> GenerateTypeScriptClient(GenerateTypeScriptClientRequest request)
{
try
{
OpenApiDocument document;
try
{
document = await OpenApiDocument.FromUrlAsync(request.SwaggerContractEndpoint.AbsoluteUri);
}
catch (HttpRequestException ex)
{
return(StatusCode(404, ex.Message));
}
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
return(StatusCode(200, code));
}
catch (Exception ex)
{
return(StatusCode(500, new ServerError500Response(ex)
{
Endpoint = request.SwaggerContractEndpoint
}));
}
}
public async Task When_generating_typescript_with_any_inheritance_then_inheritance_is_generated()
{
// Arrange
var json = @"{
""openapi"": ""3.0.0"",
""components"": {
""schemas"": {
""SessionStateResent"": {
""allOf"": [
{
""$ref"": ""#/components/schemas/SportsbookEventBody""
},
{
""type"": ""object"",
""additionalProperties"": false
}
]
},
""SportsbookEventBody"": {
""type"": ""object"",
""additionalProperties"": false
}
}
}
}";
var document = await OpenApiDocument.FromJsonAsync(json);
// Act
var settings = new TypeScriptClientGeneratorSettings();
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
// Assert
Assert.Contains("SessionStateResent extends SportsbookEventBody", code);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptOperationModel" /> class.</summary>
/// <param name="operation">The operation.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptOperationModel(
OpenApiOperation operation,
TypeScriptClientGeneratorSettings settings,
TypeScriptClientGenerator generator,
TypeResolverBase resolver)
: base(null, operation, resolver, generator, settings)
{
_operation = operation;
_settings = settings;
_generator = generator;
var parameters = GetActualParameters();
if (settings.GenerateOptionalParameters)
{
parameters = parameters
.OrderBy(p => p.Position ?? 0)
.OrderBy(p => !p.IsRequired)
.ToList();
}
Parameters = parameters
.Select(parameter =>
new TypeScriptParameterModel(parameter.Name,
GetParameterVariableName(parameter, _operation.Parameters), ResolveParameterType(parameter),
parameter, parameters, _settings, _generator, resolver))
.ToList();
}
static async Task CompileFile(string input, string output, TypeScriptClientGeneratorSettings settings)
{
var doc = await OpenApiDocument.FromFileAsync(input);
var generator = new TypeScriptClientGenerator(doc, settings);
await File.WriteAllTextAsync(output, generator.GenerateFile());
}
/// <summary>
///
/// </summary>
/// <param name="outputFile"></param>
/// <param name="settings"></param>
/// <returns></returns>
public NSwagRunner GenerateTypeScriptClient(FilePath outputFile, TypeScriptClientGeneratorSettings settings = null)
{
settings = settings ?? new TypeScriptClientGeneratorSettings();
var generator = new TypeScriptClientGenerator(Document, settings);
WriteToFile(outputFile, generator.GenerateFile());
return(this);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
public TypeScriptParameterModel(
string parameterName,
string variableName,
string typeName,
OpenApiParameter parameter,
IList <OpenApiParameter> allParameters,
TypeScriptClientGeneratorSettings settings,
TypeScriptClientGenerator generator,
TypeResolverBase typeResolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings.TypeScriptGeneratorSettings, generator, typeResolver)
{
_settings = settings;
}
public string ToTypeScriptCode(OpenApiDocument document)
{
//var document = OpenApiDocument.FromUrl(swaggerSpecUrl);
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
return(code);
}
private static string Generate()
{
const string SwaggerSpecUrl = "https://localhost:44376/swagger/v1/swagger.json";
var document = OpenApiDocument.FromUrlAsync(SwaggerSpecUrl).Result;
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
};
var generator = new TypeScriptClientGenerator(document, settings);
return(generator.GenerateFile());
}
async static Task GenerateTypeScriptClient(string url, string generatePath) =>
await GenerateClient(
document : await OpenApiDocument.FromUrlAsync(url),
generatePath : generatePath,
generateCode : (OpenApiDocument document) =>
{
var settings = new TypeScriptClientGeneratorSettings();
settings.TypeScriptGeneratorSettings.TypeStyle = TypeScriptTypeStyle.Interface;
settings.TypeScriptGeneratorSettings.TypeScriptVersion = 3.5M;
settings.TypeScriptGeneratorSettings.DateTimeType = TypeScriptDateTimeType.String;
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
return(code);
}
);
private static void GenerateTypescript(OpenApiDocument document)
{
var generatorSettings = new TypeScriptClientGeneratorSettings
{
GenerateOptionalParameters = true,
};
generatorSettings.TypeScriptGeneratorSettings.TypeStyle = TypeScriptTypeStyle.Interface;
var codeGenerator = new TypeScriptClientGenerator(document, generatorSettings);
var code = codeGenerator.GenerateFile();
code = code.Replace("file?: FileParameter", "file?: File");
code = code.Replace("file.data, file.fileName ? file.fileName : \"file\"", "file");
File.WriteAllText(@"..\..\..\..\..\..\frontend\src\app\service\service.ts", code);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptClientTemplateModel" /> class.</summary>
/// <param name="controllerName">Name of the controller.</param>
/// <param name="controllerClassName">Name of the controller.</param>
/// <param name="operations">The operations.</param>
/// <param name="extensionCode">The extension code.</param>
/// <param name="document">The Swagger document.</param>
/// <param name="settings">The settings.</param>
public TypeScriptClientTemplateModel(
string controllerName,
string controllerClassName,
IEnumerable <TypeScriptOperationModel> operations,
TypeScriptExtensionCode extensionCode,
OpenApiDocument document,
TypeScriptClientGeneratorSettings settings)
{
_extensionCode = extensionCode;
_settings = settings;
_document = document;
Class = controllerClassName;
Operations = operations;
BaseClass = _settings.ClientBaseClass?.Replace("{controller}", controllerName);
Framework = new TypeScriptFrameworkModel(settings);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptFileTemplateModel" /> class.</summary>
/// <param name="clientTypes">The client types.</param>
/// <param name="dtoTypes">The DTO types.</param>
/// <param name="document">The Swagger document.</param>
/// <param name="extensionCode">The extension code.</param>
/// <param name="settings">The settings.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptFileTemplateModel(
IEnumerable <CodeArtifact> clientTypes,
IEnumerable <CodeArtifact> dtoTypes,
OpenApiDocument document,
TypeScriptExtensionCode extensionCode,
TypeScriptClientGeneratorSettings settings,
TypeScriptTypeResolver resolver)
{
_document = document;
_extensionCode = extensionCode;
_settings = settings;
_resolver = resolver;
_clientCode = clientTypes.OrderByBaseDependency().Concatenate();
_clientTypes = clientTypes;
Types = dtoTypes.OrderByBaseDependency().Concatenate();
ExtensionCodeBottom = GenerateExtensionCodeAfter();
Framework = new TypeScriptFrameworkModel(settings);
}
public SelfTypeScriptGenerator(TypeScriptClientGeneratorSettings clientGeneratorSettings,
OpenApiDocument openApiDocument)
{
_clientGeneratorSettings = clientGeneratorSettings;
if (_clientGeneratorSettings.ExcludedParameterNames == null)
{
_clientGeneratorSettings.ExcludedParameterNames = new string[0];
}
Constant.TsBaseType.AddRange(_clientGeneratorSettings.ExcludedParameterNames);
_resolver = new TypeScriptTypeResolver(clientGeneratorSettings.TypeScriptGeneratorSettings);
_openApiDocument = openApiDocument;
_resolver.RegisterSchemaDefinitions(_openApiDocument.Definitions);
_typeScriptClientGenerator =
new TypeScriptClientGenerator(_openApiDocument, _clientGeneratorSettings, _resolver);
_extensionCode = new TypeScriptExtensionCode(
clientGeneratorSettings.TypeScriptGeneratorSettings.ExtensionCode,
(clientGeneratorSettings.TypeScriptGeneratorSettings.ExtendedClasses ?? new string[] { })
.Concat(new[] { clientGeneratorSettings.ConfigurationClass }).ToArray(),
new[] { clientGeneratorSettings.ClientBaseClass });
}
public async Task When_body_is_xml_then_correct_TypeScript_is_generated()
{
//// Arrange
var generator = new WebApiOpenApiDocumentGenerator(new WebApiOpenApiDocumentGeneratorSettings());
var document = await generator.GenerateForControllerAsync <MyXmlController>();
var settings = new TypeScriptClientGeneratorSettings {
Template = TypeScriptTemplate.JQueryCallbacks
};
settings.TypeScriptGeneratorSettings.TypeScriptVersion = 1.8m;
//// Act
var gen = new TypeScriptClientGenerator(document, settings);
var code = gen.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("(xmlDocument: string, "));
Assert.IsTrue(code.Contains("const content_ = xmlDocument;"));
Assert.IsTrue(code.Contains("\"Content-Type\": \"application/xml\""));
}
public void Generate()
{
var settins = new JsonSchemaGeneratorSettings
{
//SchemaType = SchemaType.Swagger2,
AllowReferencesWithProperties = true
};
var as1 = new Partner().GetType().Assembly;
var documents = OpenApiDocumentGenerator.GetOpenApiDocumentSepareted(settins, as1);
//var json = document.ToJson(SchemaType.Swagger2);
//File.WriteAllText("swagger.json", json);
var tsSettings = new TypeScriptClientGeneratorSettings
{
ClassName = "MyClass",
UseTransformResultMethod = true,
UseTransformOptionsMethod = true,
ClientBaseClass = "MyClassBase",
};
foreach (var doc in documents)
{
var tsGenerator = new TypeScriptClientGenerator(doc, tsSettings);
var tsCode = tsGenerator.GenerateFile();
File.WriteAllText("ts\\" + Guid.NewGuid().ToString("N") + ".ts", tsCode);
}
var document = OpenApiDocumentGenerator.GetOpenApiDocument(settins, as1);
var tsGenerator2 = new TypeScriptClientGenerator(document, tsSettings);
var tsCode2 = tsGenerator2.GenerateFile();
File.WriteAllText("ts\\api.ts", tsCode2);
}
private static async Task <string> GenerateTypeScript()
{
var settings = new TypeScriptClientGeneratorSettings
{
GenerateClientClasses = false,
Template = TypeScriptTemplate.Fetch,
ImportRequiredTypes = false,
TypeScriptGeneratorSettings =
{
TypeScriptVersion = 3.0m,
TypeStyle = TypeScriptTypeStyle.Interface,
DateTimeType = TypeScriptDateTimeType.String,
NullValue = TypeScriptNullValue.Null,
MarkOptionalProperties = false,
}
};
var document = await GenerateSwaggerDocument();
var generator = new TypeScriptClientGenerator(document, settings);
return(generator.GenerateFile());
}
private static async Task GenerateTypeScriptClient(string url, string generatePath)
{
await GenerateClient(
await OpenApiDocument.FromUrlAsync(url),
generatePath,
document =>
{
var settings = new TypeScriptClientGeneratorSettings();
settings.TypeScriptGeneratorSettings.TypeStyle = TypeScriptTypeStyle.Interface;
settings.TypeScriptGeneratorSettings.TypeScriptVersion = 3.5M;
settings.TypeScriptGeneratorSettings.DateTimeType = TypeScriptDateTimeType.String;
settings.Template = TypeScriptTemplate.Angular;
settings.InjectionTokenType = InjectionTokenType.InjectionToken;
settings.TypeScriptGeneratorSettings.ModuleName = "ValantDemoApiClient";
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
return(code);
}
);
}
public static async Task Main(string[] args)
{
var projectFolder = Path.GetFullPath(@"..\..\..\");
// TODO fix path
//var document = {./swaggerServer.json};
var document = OpenApiDocument.FromFileAsync("./swaggerServer.json").Result;
// var document = OpenApiDocument.FromUrlAsync("https://localhost:5001/swagger/v1/swagger.json").Result;
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
// TODO fix path
await File.WriteAllTextAsync("./client.generated.ts", code);
// await File.WriteAllTextAsync(Path.Combine(projectFolder, "/Users/dieterbalis/Documents/App42/Server/app42.server/Pencil42App.TypescriptGenerator/client.generated.ts"), code);
// await File.WriteAllTextAsync(Path.Combine(projectFolder, "/Users/jokeclaeys/Documents/App42/app42.server/Pencil42App.TypescriptGenerator/client.generated.ts"), code);
}
public Task StartAsync(CancellationToken cancellationToken)
{
_ = Task.Run(async() =>
{
while (!cancellationToken.IsCancellationRequested)
{
Logger.LogInformation("Compiling output.ts...");
try
{
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}",
Template = TypeScriptTemplate.Fetch,
UseGetBaseUrlMethod = true,
};
settings.TypeScriptGeneratorSettings.EnumStyle =
NJsonSchema.CodeGeneration.TypeScript.TypeScriptEnumStyle.StringLiteral;
settings.TypeScriptGeneratorSettings.TemplateDirectory = "./Templates";
settings.TypeScriptGeneratorSettings.TypeStyle =
NJsonSchema.CodeGeneration.TypeScript.TypeScriptTypeStyle.Interface;
await CompileFile("./Client/openapi.json", "./Client/output.ts", settings);
}
catch (Exception e)
{
Logger.LogError(e, "Unable to write output");
}
using var fsw = new FileSystemWatcher("Templates");
fsw.WaitForChanged(WatcherChangeTypes.Changed);
}
});
return(Task.CompletedTask);
}
internal TypeScriptFrameworkAngularModel(TypeScriptClientGeneratorSettings settings)
{
_settings = settings;
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptResponseModel" /> class.</summary>
/// <param name="operationModel">The operation model.</param>
/// <param name="operation">The operation.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="isPrimarySuccessResponse">if set to <c>true</c> [is success response].</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
public TypeScriptResponseModel(IOperationModel operationModel, OpenApiOperation operation, string statusCode, OpenApiResponse response, bool isPrimarySuccessResponse,
JsonSchema exceptionSchema, IClientGenerator generator, TypeResolverBase resolver, TypeScriptClientGeneratorSettings settings)
: base(operationModel, operation, statusCode, response, isPrimarySuccessResponse, exceptionSchema, resolver, settings.TypeScriptGeneratorSettings, generator)
{
_settings = settings;
}
public async Task When_parameter_is_array_then_TypeScript_is_correct()
{
//// Arrange
var swagger = @"{
""swagger"" : ""2.0"",
""info"" : {
""version"" : ""1.0.2"",
""title"" : ""Test API""
},
""host"" : ""localhost:8080"",
""basePath"" : ""/"",
""tags"" : [ {
""name"" : ""api""
} ],
""schemes"" : [ ""http"" ],
""paths"" : {
""/removeElement"" : {
""delete"" : {
""tags"" : [ ""api"" ],
""summary"" : ""Removes elements"",
""description"" : ""Removes elements"",
""operationId"" : ""removeElement"",
""consumes"" : [ ""application/json"" ],
""produces"" : [ ""application/json"" ],
""parameters"" : [ {
""name"" : ""X-User"",
""in"" : ""header"",
""description"" : ""User identifier"",
""required"" : true,
""type"" : ""string""
}, {
""name"" : ""elementId"",
""in"" : ""query"",
""description"" : ""The ids of existing elements that should be removed"",
""required"" : false,
""type"" : ""array"",
""items"" : {
""type"" : ""integer"",
""format"" : ""int64""
},
} ],
""responses"" : {
""default"" : {
""description"" : ""successful operation""
}
}
}
}
},
""definitions"" : { }
}
";
var document = await OpenApiDocument.FromJsonAsync(swagger);
//// Act
var settings = new TypeScriptClientGeneratorSettings {
ClassName = "MyClass"
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
//// Assert
Assert.Contains(@"elementId.forEach(item => { url_ += ""elementId="" + encodeURIComponent("""" + item) + ""&""; });", code);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseSession();
app.UseExceptionHandler(appBuilder =>
{
appBuilder.Use(async(context, next) =>
{
IExceptionHandlerFeature error = context.Features[typeof(IExceptionHandlerFeature)] as IExceptionHandlerFeature;
if (error != null && error.Error is SecurityTokenExpiredException)
{
context.Response.StatusCode = 401;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonConvert.SerializeObject(new
{
State = 401,
Message = "Token Expired"
}));
}
else if (error != null && error.Error != null)
{
context.Response.StatusCode = 500;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonConvert.SerializeObject(new
{
State = 500,
Message = error.Error.Message
}));
}
else
{
await next();
}
});
});
app.UseResponseCompression();
app.UseCors(
builder =>
builder
.AllowCredentials()
.AllowAnyHeader().AllowAnyMethod()
.WithOrigins("http://wearereading20200721193701.azurewebsites.net/").Build());
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "WeAreReading V1");
});
app.UseStaticFiles(new StaticFileOptions()
{
ContentTypeProvider = new FileExtensionContentTypeProvider(new Dictionary <string, string>()
{
{ ".xlf", "application/x-msdownload" },
{ ".exe", "application/octect-stream" },
}),
});
app.UseHttpsRedirection();
if (!env.IsDevelopment())
{
app.UseSpaStaticFiles();
}
app.UseStatusCodePages();
// app.UseDefaultFiles(); // so index.html is not required
app.UseFileServer(new FileServerOptions()
{
EnableDirectoryBrowsing = false
});
app.UseAuthentication();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
app.UseSpa(spa =>
{
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseAngularCliServer(npmScript: "start");
spa.Options.StartupTimeout = TimeSpan.FromMinutes(5);
}
});
if (env.IsDevelopment())
{
Task.Run(() =>
{
using HttpClient httpClient = new HttpClient();
string SourceDocumentAbsoluteUrl = Configuration["SwaggerToTypeScriptSettings:SourceDocumentAbsoluteUrl"];
string OutputDocumentRelativePath = Configuration["SwaggerToTypeScriptSettings:OutputDocumentRelativePath"];
using Stream contentStream = httpClient.GetStreamAsync(SourceDocumentAbsoluteUrl).Result;
using StreamReader streamReader = new StreamReader(contentStream);
string json = streamReader.ReadToEnd();
var document = NSwag.OpenApiDocument.FromJsonAsync(json).Result;
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "SwaggerClient",
Template = TypeScriptTemplate.Angular,
RxJsVersion = 6.0M,
HttpClass = HttpClass.HttpClient,
InjectionTokenType = InjectionTokenType.InjectionToken,
BaseUrlTokenName = "API_BASE_URL",
UseSingletonProvider = true
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
new FileInfo(OutputDocumentRelativePath).Directory.Create();
try
{
File.WriteAllText(OutputDocumentRelativePath, code);
}
catch (Exception ex)
{
throw ex;
}
});
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <IdentityOptions>(options =>
{
options.Password.RequireNonAlphanumeric = false;
});
services.AddHangfire(x => x.UseSqlServerStorage(Configuration.GetConnectionString("DefaultConnection")));
services.AddDbContext <UnderSeaDatabaseContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddDefaultIdentity <User>()
.AddEntityFrameworkStores <UnderSeaDatabaseContext>();
services.AddIdentityServer()
.AddCorsPolicyService <IdentityServerCorsPolicyService>()
.AddDeveloperSigningCredential()
.AddInMemoryPersistedGrants()
.AddInMemoryIdentityResources(IdentityServerConfig.GetIdentityResources())
.AddInMemoryApiResources(IdentityServerConfig.GetApiResources(Configuration))
.AddInMemoryClients(IdentityServerConfig.GetClients(Configuration))
.AddAspNetIdentity <User>();
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
options.Authority = Configuration["Authority"];
options.Audience = Configuration["ApiName"];
options.RequireHttpsMetadata = false;
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
{
NameClaimType = JwtClaimTypes.Name
};
});
services.AddCors(options =>
{
options.AddDefaultPolicy(policy =>
{
policy.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
});
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSignalR();
services.AddSwaggerDocument(options =>
{
options.Title = "Undersea API";
options.Version = "1.0";
options.Description = "API for the game called Under sea, which is a turn based online multiplayer strategy game.";
options.PostProcess = document =>
{
var settings = new TypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
Template = TypeScriptTemplate.Axios
};
var generator = new TypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
var path = Directory.GetCurrentDirectory();
var directory = new DirectoryInfo(path + @"\TypeScript");
if (!directory.Exists)
{
directory.Create();
}
var filePath = path + @"\TypeScript\Client.ts";
File.WriteAllText(filePath, code);
};
});
services.AddAutoMapper(typeof(KnownValues).Assembly);
services.AddSingleton(new ModifierParserContainer(new AbstractEffectModifierParser[]
{
new BarrackSpaceEffectParser(),
new CoralProductionEffectParser(),
new PearlProductionEffectParser(),
new HarvestModifierEffectParser(),
new PopulationEffectParser(),
new TaxModifierEffectParser(),
new UnitDefenseEffectParser(),
new UnitAttackEffectParser(),
new AddBuildingEffectParser(),
new IncreaseUnitAttackEffectParser(),
new BuildingCoralProductionEffectParser()
}));
services.AddSingleton <IUserTracker, UserTracker>();
services.AddTransient <ITurnHandlingService, TurnHandlingService>();
services.AddTransient <ICountryService, CountryService>();
services.AddTransient <IResearchService, ResearchService>();
services.AddTransient <IBuildingService, BuildingService>();
services.AddTransient <IUnitService, UnitService>();
services.AddTransient <ICommandService, CommandService>();
services.AddTransient <IExceptionLogger, ExceptionLogger>();
// User ID provider for SignalR Hub
services.AddTransient <IUserIdProvider, UserIdProvider>();
}
