public async Task <IActionResult> Patch(int id, [FromBody] TViewModel viewModel)
{
_logger.LogTrace(LogEventId, AwesomeMethods.ConvertDataForLog(viewModel, _converter));
if (viewModel.Id != id)
{
_logger.LogError(LogEventId, $"INVALID ID : ({id})");
return(BadRequest(_response
.AddError(_localizer["InvalidId"])
.Get()));
}
var model = await _repository.GetById(viewModel.Id);
if (model == null)
{
_logger.LogWarning(LogEventId, $"NOT FOUND : ID ({id})");
return(NotFound(_response
.AddWarning(_localizer["IdNotFound"])
.Get()));
}
Mapper.Map <TViewModel, TModel>(viewModel, model);
return(await ApplyChanges(model));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_logger.LogTrace(LogEvents.AccountController, AwesomeMethods.ConvertDataForLog(model, _converter));
// If user not found act like everything was ok. Do not reveal critical info like that
// no user with that email exists
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(View("ForgotPasswordCheckEmail"));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(
user.Email,
$"{_serverOptions.Value.ProjectName} - {_localizer["ResetPassword"]}",
$"{_localizer["ResetPasswordDetail"]} <a href='{callbackUrl}'>{callbackUrl}</a>");
_logger.LogInformation(LogEvents.AccountController, $"RESET PASSWORD EMAIL SENT FOR USER {user.Email}");
return(View("ForgotPasswordCheckEmail"));
}
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IOptions <ServerOptions> serverOptions,
SeedDbData seeder)
{
// When in development
if (env.IsDevelopment())
{
// Log in Debug Window and in Console using the minimum log level from options
loggerFactory.AddDebug(serverOptions.Value.LogLevel);
loggerFactory.AddConsole(serverOptions.Value.LogLevel);
// Use developer exception pages
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
// When in staging/production
else
{
// Log in files (using the Serilog library) using the minimum log level from options
AwesomeMethods.CreateSerilogLogger(env, serverOptions.Value.LogLevel);
loggerFactory.AddSerilog();
// Use custom exception page
app.UseExceptionHandler("/Home/Error");
}
// Add custom middlware to log exceptions and fall back to the previous exception handlers
app.UseLogExceptionHandler();
// Configure the localization. en-US and el-GR cultures are supported with en-US being
// the default one
ConfigureLocalization(app);
// Enable static files so files in wwwroot can be found and served
app.UseStaticFiles();
// Apply initial data in the database
seeder.EnsureSeedInitialDataAsync().Wait();;
// Enable Identity
app.UseIdentity();
// Enable IdentityServer
app.UseIdentityServer();
// Enable MVC with a default template
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}");
});
}
static ConfigBase()
{
var builder = AwesomeMethods.CreateConfigurationBuilder("hosting");
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddUserSecrets();
}
Configuration = builder.Build();
}
public async Task <IActionResult> Get()
{
var items = await _repository.GetAll();
_logger.LogTrace(LogEventId, AwesomeMethods.ConvertDataForLog(items, _converter));
return(Ok(_response
.AddData(Mapper.Map <IEnumerable <TViewModel> >(items))
.Get()));
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseConfiguration(AwesomeMethods.CreateConfigurationBuilder("hosting").Build())
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>()
.Build();
host.Run();
}
IConfigurationRoot LoadConfiguration(IHostingEnvironment env)
{
var builder = AwesomeMethods.CreateConfigurationBuilder("appsettings")
.AddEnvironmentVariables();
if (env.IsDevelopment())
{
// In development environment we add user secrets
builder.AddUserSecrets();
}
;
return(builder.Build());
}
public void OnActionExecuting(ActionExecutingContext context)
{
if (context.ActionArguments.ContainsKey("viewModel") &&
context.ActionArguments["viewModel"] != null)
{
_logger.LogTrace(LogEvents.ValidateViewModel, AwesomeMethods.ConvertDataForLog(context.ActionArguments["viewModel"], _converter));
}
if (!context.ModelState.IsValid)
{
_logger.LogError(LogEvents.ValidateViewModel, "INVALID MODEL");
_logger.LogError(LogEvents.ValidateViewModel, AwesomeMethods.ConvertDataForLog(context.ModelState, _converter));
context.Result = new BadRequestObjectResult(_response.AddModelState(context.ModelState)
.Get());
}
}
public async Task <IActionResult> Get(int id)
{
var model = await _repository.GetById(id);
if (model == null)
{
_logger.LogWarning(LogEventId, $"NOT FOUND : ID ({id})");
return(NotFound(_response
.AddWarning(_localizer["IdNotFound"])
.Get()));
}
_logger.LogTrace(LogEventId, AwesomeMethods.ConvertDataForLog(model, _converter));
return(Ok(_response
.AddData(Mapper.Map <TViewModel>(model))
.Get()));
}
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IOptions <ApiOptions> apiOptions,
SeedDbData seeder)
{
// When in development
if (env.IsDevelopment())
{
// Log in Debug Window and in Console using the minimum log level from options
loggerFactory.AddDebug(apiOptions.Value.LogLevel);
loggerFactory.AddConsole(apiOptions.Value.LogLevel);
}
// When in staging/production
else
{
// Log in files (using the Serilog library) using the minimum log level from options
AwesomeMethods.CreateSerilogLogger(env, apiOptions.Value.LogLevel);
loggerFactory.AddSerilog();
}
// Custom Middleware for exception handling. This is added first in the pipeline to catch
// unhandled exceptions from the whole request
app.UseApiExceptionHandler();
// Uncomment the line below to raise exception for debugging purposes to test the above handler
// app.UseExceptionRaiser();
// Configure the localization. en-US and el-GR cultures are supported with en-US being
// the default one
ConfigureLocalization(app);
// Configure the field mapping between Models and ViewModels
ConfigureMapping();
// Enable MVC. No routes specified here. We use attribute routing in controllers
app.UseMvc();
// Apply initial data in the database
seeder.EnsureSeedInitialDataAsync().Wait();
}
public async Task <IActionResult> SignIn(SignInViewModel model, string returnUrl)
{
ViewData["ReturnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
return(View(model));
}
_logger.LogTrace(LogEvents.AccountController, AwesomeMethods.ConvertDataForLog(model, _converter));
// If user is already authenticated redirect
if (User.Identity.IsAuthenticated)
{
return(ResolveRedirect(returnUrl));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
_logger.LogWarning(LogEvents.AccountController, $"USER WITH EMAIL {model.Email} NOT FOUND");
ModelState.AddModelError("", _localizer["InvalidUsernameOrPassword"]);
return(View());
}
// Check if user is confirmed to send confirm email again
if (!user.EmailConfirmed)
{
return(await SendRegisterConfirmationEmail(user));
}
// Sign in
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
return(ResolveRedirect(returnUrl));
}
return(View());
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl)
{
ViewData["ReturnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
return(View(model));
}
_logger.LogTrace(LogEvents.AccountController, AwesomeMethods.ConvertDataForLog(model, _converter));
// If user is already authenticated redirect
if (User.Identity.IsAuthenticated)
{
return(ResolveRedirect(returnUrl));
}
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email
};
// Create new user
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation(LogEvents.AccountController, $"USER {user.Email} CREATED");
return(await SendRegisterConfirmationEmail(user));
}
else
{
_logger.LogWarning(LogEvents.AccountController, $"USER {user.Email} CREATION FAILED");
}
return(View());
}
public async Task <IActionResult> Post([FromBody] TViewModel viewModel)
{
_logger.LogTrace(LogEventId, AwesomeMethods.ConvertDataForLog(viewModel, _converter));
var model = Mapper.Map <TModel>(viewModel);
_repository.Add(model);
if (await _repository.Save())
{
_logger.LogInformation(LogEventId, $"SAVED : ID ({model.Id})");
return(CreatedAtAction("Get", new { id = model.Id },
_response
.AddInfo(_localizer["Saved"])
.AddData(Mapper.Map <TViewModel>(model))
.Get()));
}
else
{
_logger.LogWarning(LogEventId, "NOT SAVED");
return(NoContent());
}
}
IConfigurationRoot LoadConfiguration(IHostingEnvironment env)
{
return(AwesomeMethods.CreateConfigurationBuilder("appsettings")
.AddEnvironmentVariables()
.Build());
}
