public ActionResult <PagedObject <Project> > AddProjectPerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string projectId,
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId)
{
var projectGuid = Guid.Parse(projectId);
var project = _projectService.GetProject(projectGuid);
if (project == null)
{
return(ErrorObjectResultFactory.NotFound());
}
var personGuid = Guid.Parse(personId);
var person = _personService.GetPerson(personGuid);
if (person == null)
{
return(ErrorObjectResultFactory.NotFound());
}
_projectService.AddProjectPerson(projectGuid, personGuid);
return(new OkResult());
}
public ActionResult <Project> UpdateProject(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string projectId,
[FromBody] ProjectUpdateRequest request)
{
var projectGuid = Guid.Parse(projectId);
var project = _projectService.GetProject(projectGuid);
if (project == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (request.ProjectCode != null &&
request.ProjectCode != project.ProjectCode &&
_projectQueryService.ExistsProjectCode(request.ProjectCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayProjectProjectCode),
"projectCode"));
}
var dto = _mapper.Map <ProjectUpdateRequest, ProjectUpdateDto>(request);
dto.ProjectId = projectGuid;
var entity = _projectService.UpdateProject(dto);
return(_mapper.Map <Domain.Entities.Project, Project>(entity));
}
public ActionResult <PagedObject <Group> > AddGroupPerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string groupId,
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId,
[FromBody]
GroupPersonAddRequest request)
{
var groupGuid = Guid.Parse(groupId);
var group = _groupService.GetGroup(groupGuid);
if (group == null)
{
return(ErrorObjectResultFactory.NotFound());
}
var personGuid = Guid.Parse(personId);
var person = _personService.GetPerson(personGuid);
if (person == null)
{
return(ErrorObjectResultFactory.NotFound());
}
_groupService.AddGroupPerson(groupGuid, personGuid, request.PositionType);
return(new OkResult());
}
/// <inheritdoc/>
public override void OnException(ExceptionContext context)
{
_logger.LogError(context.Exception, "InternalServerError");
context.Result = ErrorObjectResultFactory.InternalServerError();
context.ExceptionHandled = true;
return;
}
/// <inheritdoc/>
protected override async Task HandleForbiddenAsync(AuthenticationProperties properties)
{
var options = Context.RequestServices.GetService <IOptions <JsonOptions> >();
var result = ErrorObjectResultFactory.Forbidden();
string json = JsonSerializer.Serialize(result.Value, options.Value.JsonSerializerOptions);
Response.Headers["WWW-Authenticate"] = "Bearer error=\"insufficient_scope\"";
Response.StatusCode = result.StatusCode.Value;
Response.ContentType = "application/json";
await Response.BodyWriter.WriteAsync(Encoding.UTF8.GetBytes(json));
}
/// <inheritdoc/>
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
var envSettings = filterContext.HttpContext.RequestServices.GetService <IEnvSettings>();
if (!envSettings.IsDebug)
{
filterContext.Result = ErrorObjectResultFactory.Forbidden();
return;
}
base.OnActionExecuting(filterContext);
}
public ActionResult <Project> CreateProject([FromBody] ProjectCreateRequest request)
{
if (_projectQueryService.ExistsProjectCode(request.ProjectCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayProjectProjectCode),
"projectCode"));
}
var dto = _mapper.Map <ProjectCreateRequest, ProjectCreateDto>(request);
var entity = _projectService.CreateProject(dto);
return(_mapper.Map <Domain.Entities.Project, Project>(entity));
}
public ActionResult <Project> GetProject(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string projectId)
{
var projectGuid = Guid.Parse(projectId);
var entity = _projectService.GetProject(projectGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
return(_mapper.Map <Domain.Entities.Project, Project>(entity));
}
public ActionResult <Group> GetGroup(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string groupId)
{
var groupGuid = Guid.Parse(groupId);
var entity = _groupService.GetGroup(groupGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
return(_mapper.Map <Domain.Entities.Group, Group>(entity));
}
public ActionResult <WorkType> GetWorkType(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string workTypeId)
{
var workTypeGuid = Guid.Parse(workTypeId);
var entity = _workTypeService.GetWorkType(workTypeGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
return(_mapper.Map <Domain.Entities.WorkType, WorkType>(entity));
}
public ActionResult DeleteWorkType(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string workTypeId)
{
var workTypeGuid = Guid.Parse(workTypeId);
var entity = _workTypeService.GetWorkType(workTypeGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
_workTypeService.DeleteWorkType(workTypeGuid);
return(new OkResult());
}
public ActionResult DeletePerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId)
{
var personGuid = Guid.Parse(personId);
var entity = _personService.GetPerson(personGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
_personService.DeletePerson(personGuid);
return(new OkResult());
}
/// <summary>
/// アプリケーション構成処理。
/// </summary>
/// <param name="app"><see cref="IApplicationBuilder"/></param>
/// <param name="env"><see cref="IWebHostEnvironment"/></param>
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseStatusCodePages(async context =>
{
var options = context.HttpContext.RequestServices.GetService <IOptions <JsonOptions> >();
string json;
if (context.HttpContext.Response.StatusCode == 404)
{
json = JsonSerializer.Serialize(ErrorObjectResultFactory.NotFound().Value, options.Value.JsonSerializerOptions);
}
else
{
return;
}
context.HttpContext.Response.ContentType = "application/json";
await context.HttpContext.Response.WriteAsync(json);
});
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseSwagger();
app.UseSwaggerUI(options =>
{
options.RoutePrefix = string.Empty;
options.SwaggerEndpoint("/swagger/v1/swagger.json", "WaterTrans.Scheduler.WebApi v1");
});
app.UseRouting();
app.UseCors();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
endpoints.MapDefaultControllerRoute();
endpoints.MapControllers();
});
}
public ActionResult <Person> CreatePerson([FromBody] PersonCreateRequest request)
{
if (_personQueryService.ExistsPersonCode(request.PersonCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonPersonCode),
"personCode"));
}
if (_personQueryService.ExistsLoginId(request.LoginId))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonLoginId),
"loginId"));
}
var dto = _mapper.Map <PersonCreateRequest, PersonCreateDto>(request);
var entity = _personService.CreatePerson(dto);
return(_mapper.Map <Domain.Entities.Person, Person>(entity));
}
public ActionResult <Group> CreateGroup([FromBody] GroupCreateRequest request)
{
if (_groupQueryService.ExistsGroupCode(request.GroupCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupCode),
"groupCode"));
}
if (_groupQueryService.ExistsGroupTree(request.GroupTree))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupTree),
"groupTree"));
}
var dto = _mapper.Map <GroupCreateRequest, GroupCreateDto>(request);
var entity = _groupService.CreateGroup(dto);
return(_mapper.Map <Domain.Entities.Group, Group>(entity));
}
public ActionResult <WorkType> CreateWorkType([FromBody] WorkTypeCreateRequest request)
{
if (_workTypeQueryService.ExistsWorkTypeCode(request.WorkTypeCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayWorkTypeWorkTypeCode),
"workTypeCode"));
}
if (_workTypeQueryService.ExistsWorkTypeTree(request.WorkTypeTree))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayWorkTypeWorkTypeTree),
"workTypeTree"));
}
var dto = _mapper.Map <WorkTypeCreateRequest, WorkTypeCreateDto>(request);
var entity = _workTypeService.CreateWorkType(dto);
return(_mapper.Map <Domain.Entities.WorkType, WorkType>(entity));
}
public ActionResult <Person> UpdatePerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId,
[FromBody] PersonUpdateRequest request)
{
var personGuid = Guid.Parse(personId);
var person = _personService.GetPerson(personGuid);
if (person == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (request.PersonCode != null &&
request.PersonCode != person.PersonCode &&
_personQueryService.ExistsPersonCode(request.PersonCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonPersonCode),
"personCode"));
}
if (request.LoginId != null &&
request.LoginId != person.LoginId &&
_personQueryService.ExistsLoginId(request.LoginId))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayPersonLoginId),
"loginId"));
}
var dto = _mapper.Map <PersonUpdateRequest, PersonUpdateDto>(request);
dto.PersonId = personGuid;
var entity = _personService.UpdatePerson(dto);
return(_mapper.Map <Domain.Entities.Person, Person>(entity));
}
public ActionResult <Group> UpdateGroup(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string groupId,
[FromBody] GroupUpdateRequest request)
{
var groupGuid = Guid.Parse(groupId);
var group = _groupService.GetGroup(groupGuid);
if (group == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (request.GroupCode != null &&
request.GroupCode != group.GroupCode &&
_groupQueryService.ExistsGroupCode(request.GroupCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupCode),
"groupCode"));
}
if (request.GroupTree != null &&
request.GroupTree != group.GroupTree &&
_groupQueryService.ExistsGroupTree(request.GroupTree))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupTree),
"groupTree"));
}
var dto = _mapper.Map <GroupUpdateRequest, GroupUpdateDto>(request);
dto.GroupId = groupGuid;
var entity = _groupService.UpdateGroup(dto);
return(_mapper.Map <Domain.Entities.Group, Group>(entity));
}
public ActionResult <WorkType> UpdateWorkType(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string workTypeId,
[FromBody] WorkTypeUpdateRequest request)
{
var workTypeGuid = Guid.Parse(workTypeId);
var workType = _workTypeService.GetWorkType(workTypeGuid);
if (workType == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (request.WorkTypeCode != null &&
request.WorkTypeCode != workType.WorkTypeCode &&
_workTypeQueryService.ExistsWorkTypeCode(request.WorkTypeCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayWorkTypeWorkTypeCode),
"workTypeCode"));
}
if (request.WorkTypeTree != null &&
request.WorkTypeTree != workType.WorkTypeTree &&
_workTypeQueryService.ExistsWorkTypeTree(request.WorkTypeTree))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayWorkTypeWorkTypeTree),
"workTypeTree"));
}
var dto = _mapper.Map <WorkTypeUpdateRequest, WorkTypeUpdateDto>(request);
dto.WorkTypeId = workTypeGuid;
var entity = _workTypeService.UpdateWorkType(dto);
return(_mapper.Map <Domain.Entities.WorkType, WorkType>(entity));
}
public ActionResult <PagedObject <Project> > RemoveProjectPerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string projectId,
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId)
{
var projectGuid = Guid.Parse(projectId);
var personGuid = Guid.Parse(personId);
if (!_projectService.ContainsProjectPerson(projectGuid, personGuid))
{
return(ErrorObjectResultFactory.NotFound());
}
_projectService.RemoveProjectPerson(projectGuid, personGuid);
return(new OkResult());
}
public ActionResult <PagedObject <Group> > RemoveGroupPerson(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string groupId,
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string personId)
{
var groupGuid = Guid.Parse(groupId);
var personGuid = Guid.Parse(personId);
if (!_groupService.ContainsGroupPerson(groupGuid, personGuid))
{
return(ErrorObjectResultFactory.NotFound());
}
_groupService.RemoveGroupPerson(groupGuid, personGuid);
return(new OkResult());
}
public ActionResult DeleteGroup(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string groupId)
{
var groupGuid = Guid.Parse(groupId);
var entity = _groupService.GetGroup(groupGuid);
if (entity == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (entity.Persons.Count > 0)
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationHasChildren, ErrorMessages.DisplayPerson),
"groupId"));
}
_groupService.DeleteGroup(groupGuid);
return(new OkResult());
}
public ActionResult <Token> CreateToken([FromForm] TokenCreateRequest request)
{
if (request.GrantType == GrantTypes.AuthorizationCode)
{
if (string.IsNullOrEmpty(request.ClientId))
{
return(ErrorObjectResultFactory.InvalidClient());
}
var application = _authorizeService.GetApplication(request.ClientId);
if (application == null)
{
return(ErrorObjectResultFactory.InvalidClient());
}
if (!application.GrantTypes.Contains(GrantTypes.AuthorizationCode))
{
return(ErrorObjectResultFactory.InvalidGrantType());
}
if (string.IsNullOrEmpty(request.Code))
{
return(ErrorObjectResultFactory.InvalidCode());
}
var authorizationCode = _authorizeService.GetAuthorizationCode(request.Code);
if (authorizationCode == null)
{
return(ErrorObjectResultFactory.InvalidCode());
}
if (application.ApplicationId != authorizationCode.ApplicationId)
{
return(ErrorObjectResultFactory.InvalidCode());
}
var accessToken = _authorizeService.CreateAccessToken(
application.ApplicationId,
authorizationCode.AccountId,
null);
_authorizeService.UseAuthorizationCode(request.Code);
return(new Token
{
AccessToken = accessToken.TokenId,
ExpiresIn = _appSetgings.AccessTokenExpiresIn,
Scope = string.Join(' ', accessToken.Scopes),
TokenType = "Bearer",
});
}
else if (request.GrantType == GrantTypes.ClientCredentials)
{
if (string.IsNullOrEmpty(request.ClientId))
{
return(ErrorObjectResultFactory.InvalidClient());
}
var application = _authorizeService.GetApplication(request.ClientId);
if (application == null || application.ClientSecret != request.ClientSecret)
{
return(ErrorObjectResultFactory.InvalidClient());
}
if (!application.GrantTypes.Contains(GrantTypes.ClientCredentials))
{
return(ErrorObjectResultFactory.InvalidGrantType());
}
IList <string> scopes = new List <string>();
if (!string.IsNullOrEmpty(request.Scope))
{
scopes = request.Scope.Split(' ', ',');
foreach (string scope in scopes)
{
if (!application.Scopes.Contains(scope))
{
return(ErrorObjectResultFactory.InvalidScope());
}
}
}
var accessToken = _authorizeService.CreateAccessToken(application.ApplicationId, scopes);
return(new Token
{
AccessToken = accessToken.TokenId,
ExpiresIn = _appSetgings.AccessTokenExpiresIn,
Scope = string.Join(' ', accessToken.Scopes),
TokenType = "Bearer",
});
}
else
{
throw new NotImplementedException();
}
}
/// <inheritdoc/>
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
return(await Task.Run <AuthenticateResult>(() =>
{
if (!Request.Headers.ContainsKey("Authorization"))
{
_responseHeader = "Bearer realm=\"token_required\"";
_responseResult = ErrorObjectResultFactory.NoAuthorizationHeader();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
if (authHeader.Scheme != "Bearer")
{
_responseHeader = "Bearer error=\"invalid_request\"";
_responseResult = ErrorObjectResultFactory.InvalidAuthorizationScheme();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
try
{
if (authHeader.Parameter == null)
{
_responseHeader = "Bearer error=\"invalid_token\"";
_responseResult = ErrorObjectResultFactory.InvalidAuthorizationToken();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
var accessToken = _authorizeService.GetAccessToken(authHeader.Parameter);
if (accessToken == null)
{
_responseHeader = "Bearer error=\"invalid_token\"";
_responseResult = ErrorObjectResultFactory.InvalidAuthorizationToken();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
if (accessToken.ExpiryTime < DateUtil.Now)
{
_responseHeader = "Bearer error=\"invalid_token\"";
_responseResult = ErrorObjectResultFactory.AuthorizationTokenExpired();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
var result = new List <Claim>();
foreach (var role in accessToken.Roles)
{
result.Add(new Claim(ClaimTypes.Role, role));
}
foreach (var scope in accessToken.Scopes)
{
result.Add(new Claim(Scopes.ClaimType, scope));
}
result.Add(new Claim(ClaimTypes.Name, accessToken.Name));
result.Add(new Claim(ClaimTypes.NameIdentifier, accessToken.PrincipalId.ToString()));
var identity = new ClaimsIdentity(result.ToArray(), Scheme.Name);
var principal = new ClaimsPrincipal(identity);
var ticket = new AuthenticationTicket(principal, Scheme.Name);
return AuthenticateResult.Success(ticket);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
_responseResult = ErrorObjectResultFactory.InternalServerError();
return AuthenticateResult.Fail(_responseResult.Error.Message);
}
}));
}
/// <summary>
/// サービス構成処理。
/// </summary>
/// <param name="services"><see cref="IServiceCollection"/></param>
public void ConfigureServices(IServiceCollection services)
{
services.AddAutoMapper(typeof(Startup));
services.Configure <AppSettings>(Configuration.GetSection("AppSettings"));
services.Configure <EnvSettings>(Configuration.GetSection("EnvSettings"));
services.Configure <DBSettings>(options =>
{
Configuration.GetSection("DBSettings").Bind(options);
options.SqlProviderFactory = SqlClientFactory.Instance;
});
// This is work around. See https://github.com/dotnet/aspnetcore/issues/4853 @zhurinvlad commented on 5 Sep 2018
services.AddSingleton <IValidationAttributeAdapterProvider, CustomValidationAttributeAdapterProvider>();
services.AddSingleton <IConfigureOptions <MvcOptions>, MvcConfiguration>();
services.AddTransient <IAppSettings>(x => x.GetService <IOptionsMonitor <AppSettings> >().CurrentValue);
services.AddTransient <IEnvSettings>(x => x.GetService <IOptionsMonitor <EnvSettings> >().CurrentValue);
services.AddTransient <IDBSettings>(x => x.GetService <IOptionsMonitor <DBSettings> >().CurrentValue);
services.AddTransient <IAccessTokenRepository, AccessTokenRepository>();
services.AddTransient <IAccountQueryService, AccountQueryService>();
services.AddTransient <IAccountRepository, AccountRepository>();
services.AddTransient <IAccountService, AccountService>();
services.AddTransient <IApplicationRepository, ApplicationRepository>();
services.AddTransient <IAuthorizationCodeRepository, AuthorizationCodeRepository>();
services.AddTransient <IAuthorizeService, AuthorizeService>();
services.AddTransient <IGroupPersonRepository, GroupPersonRepository>();
services.AddTransient <IGroupQueryService, GroupQueryService>();
services.AddTransient <IGroupRepository, GroupRepository>();
services.AddTransient <IGroupService, GroupService>();
services.AddTransient <IPersonQueryService, PersonQueryService>();
services.AddTransient <IPersonRepository, PersonRepository>();
services.AddTransient <IPersonService, PersonService>();
services.AddTransient <IProjectPersonRepository, ProjectPersonRepository>();
services.AddTransient <IProjectQueryService, ProjectQueryService>();
services.AddTransient <IProjectRepository, ProjectRepository>();
services.AddTransient <IProjectService, ProjectService>();
services.AddTransient <ITagRepository, TagRepository>();
services.AddTransient <IWorkTypeQueryService, WorkTypeQueryService>();
services.AddTransient <IWorkTypeRepository, WorkTypeRepository>();
services.AddTransient <IWorkTypeService, WorkTypeService>();
if (!WebHostEnvironment.IsProduction())
{
services.AddCors(options =>
{
options.AddDefaultPolicy(builder =>
{
builder.WithOrigins("https://localhost:8443")
.AllowCredentials()
.AllowAnyMethod()
.AllowAnyHeader();
builder.WithOrigins("https://editor.swagger.io")
.AllowCredentials()
.AllowAnyMethod()
.AllowAnyHeader();
builder.WithOrigins("https://watertrans.stoplight.io")
.AllowCredentials()
.AllowAnyMethod()
.AllowAnyHeader();
});
});
}
services.AddAuthentication(BearerAuthenticationHandler.SchemeName)
.AddScheme <AuthenticationSchemeOptions, BearerAuthenticationHandler>(BearerAuthenticationHandler.SchemeName, null);
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(options =>
{
Configuration.Bind("AzureAD", options);
options.Events.OnSignedOutCallbackRedirect = context =>
{
context.Response.Redirect("/");
context.HandleResponse();
return(Task.CompletedTask);
};
options.Events.OnTokenValidated = context =>
{
return(Task.CompletedTask);
};
});
services.AddRazorPages().AddMicrosoftIdentityUI();
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.FullControlScopePolicy, policy =>
{
policy.RequireClaim(Scopes.ClaimType, Scopes.FullControl);
});
options.AddPolicy(Policies.ReadScopePolicy, policy =>
{
policy.RequireClaim(Scopes.ClaimType, Scopes.FullControl, Scopes.Read, Scopes.Write, Scopes.User);
});
options.AddPolicy(Policies.WriteScopePolicy, policy =>
{
policy.RequireClaim(Scopes.ClaimType, Scopes.FullControl, Scopes.Write);
});
});
services.AddApiVersioning();
services.AddVersionedApiExplorer(options =>
{
options.GroupNameFormat = "'v'V";
options.SubstituteApiVersionInUrl = true;
});
services.AddControllers(options =>
{
options.Filters.Add(typeof(CatchAllExceptionFilter));
})
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
options.JsonSerializerOptions.IgnoreNullValues = true;
})
.ConfigureApiBehaviorOptions(options =>
{
options.InvalidModelStateResponseFactory = context =>
{
return(ErrorObjectResultFactory.ValidationError(context.ModelState));
};
})
.AddDataAnnotationsLocalization(options =>
{
options.DataAnnotationLocalizerProvider = (type, factory) => factory.Create(typeof(ErrorMessages));
});
services.AddSwaggerGen(options =>
{
options.EnableAnnotations();
options.SwaggerGeneratorOptions.DescribeAllParametersInCamelCase = true;
options.SwaggerDoc("v1", new OpenApiInfo {
Title = "DailyReport Web Api", Version = "v1"
});
options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "アクセストークンを入力してください。",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.Http,
Scheme = "bearer",
});
options.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer",
},
},
new string[] { }
},
});
});
}