public async Task <IActionResult> Add()
{
try
{
var model = new AddressEntityViewModel();
if (model != null)
{
ViewBag.CountryList = await _iAddressManager.GetCountryEntitysAsync();
ViewBag.StateList = await _iAddressManager.GetStateEntitysAsync();
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Add[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
public async Task <IActionResult> DeleteAddress(int id)
{
Result result = new Result();
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("DeleteAddress[POST]"));
if (id > 0)
{
result = await _iAddressManager.DeleteAddressEntityAsync(id);
}
else
{
result = Result.Fail(MessageHelper.DeleteFail);
}
if (result.Success)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "DeleteAddress[POST]"));
result = Result.Fail(MessageHelper.UnhandelledError);
return(BadRequest(result));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Details(int id)
{
try
{
var addressTypeViewModel = await _iAddressManager.GetAddressEntityAsync(id);
var model = _iMapper.Map <AddressEntityViewModel, AddressEntityViewModel>(addressTypeViewModel);
if (model != null)
{
return(View("Details", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Details[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
public async Task <IActionResult> Delete(int id)
{
try
{
if (id > 0)
{
_result = await _iAddressManager.DeleteAddressEntityAsync(id);
}
else
{
_result = Result.Fail(MessageHelper.DeleteFail);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Delete, "AddressMessage");
}
else
{
this.FlashError(_result.Error, "AddressMessage");
}
return(JsonResult(_result));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Delete[POST]"));
_result = Result.Fail(MessageHelper.UnhandelledError);
return(JsonResult(_result));
}
}
internal IActionResult ErrorPartialView(Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ErrorPartialView"));
var errorPageViewModel = new ErrorPageViewModel();
errorPageViewModel = ExceptionHelper.ExceptionErrorMessageFormat(ex);
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
internal IActionResult ErrorNullPartialView()
{
ErrorPageViewModel errorPageViewModel = new ErrorPageViewModel();
errorPageViewModel.ErrorMessage = MessageHelper.NullError;
errorPageViewModel.ErrorType = MessageHelper.MessageTypeDanger;
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("ResetPassword[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
bool isValid = true;
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
isValid = false;
// Don't reveal that the user does not exist
ModelState.AddModelError(string.Empty, "Invalid email.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ResetPassword[POST]", $"Invalid email, UserEmail: {model.Email}"));
return(View(model));
}
//var isEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
//if (!isEmailConfirmed)
//{
// isValid = false;
// // Don't reveal that the user email is not confirmed
// ModelState.AddModelError(string.Empty, "Email is not confirmed.");
// _log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ResetPassword[POST]", $"Email is not confirmed, UserEmail: {model.Email}"));
// return View(model);
//}
if (isValid)
{
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(View("ResetPasswordConfirmation"));
}
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ResetPassword[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("ForgotPassword[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
bool isValid = true;
var user = await _userManager.FindByNameAsync(model.Email);
if (user == null)
{
isValid = false;
// Don't reveal that the user does not exist
ModelState.AddModelError(string.Empty, "Invalid email.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ForgotPassword[POST]", $"Invalid email, UserEmail: {model.Email}"));
return(View(model));
}
//var isEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
//if (!isEmailConfirmed)
//{
// isValid = false;
// // Don't reveal that the user email is not confirmed
// ModelState.AddModelError(string.Empty, "Email is not confirmed.");
// _log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("ForgotPassword[POST]", $"Email is not confirmed, UserEmail: {model.Email}"));
// return View(model);
//}
if (isValid)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
var message = await GenareteForgotPasswordEmailTemplateAsync(user);
//await _emailSender.SendEmailBySendGridAsync(user.Id, model.Email, "Reset Password", message);
return(View("ForgotPasswordConfirmation"));
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "ForgotPassword[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Logout()
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("LogOff", $"User:{User.Identity.Name}"));
await _signInManager.SignOutAsync();
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("LogOff", $"User logged out"));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "LogOff"));
}
return(RedirectToAction("Login", "Account"));
}
public async Task <IActionResult> GetAddress(int id)
{
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("GetAddress[GET]"));
var response = await _iAddressManager.GetAddressEntityAsync(id);
return(Ok(response));
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "GetAddress[GET]"));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Save(AddressEntityViewModel viewModel)
{
try
{
ViewBag.CountryList = await _iAddressApiService.GetAllCountryAsync();
ViewBag.StateList = await _iAddressApiService.GetAllStateAsync();
if (ModelState.IsValid)
{
//add
if (viewModel.AddressId == 0)
{
_result = await _iAddressManager.InsertAddressEntityAsync(viewModel);
}
else if (viewModel.AddressId > 0) //edit
{
_result = await _iAddressManager.UpdateAddressEntityAsync(viewModel);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Save, "AddressMessage");
return(RedirectToAction("Index", "Address"));
}
else
{
this.FlashError(_result.Error, "AddressMessage");
return(View("AddOrEdit", viewModel));
}
}
else
{
this.FlashError(ExceptionHelper.ModelStateErrorFirstFormat(ModelState), "AddressMessage");
return(View("AddOrEdit", viewModel));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Save[POST]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressMessage");
return(View("AddOrEdit", viewModel));
}
public async Task <IActionResult> SaveAddress(AddressEntityViewModel viewModel)
{
Result result = new Result();
try
{
_log.Info(LogMessageHelper.FormateMessageForStart("AddAddress[POST]"));
if (ModelState.IsValid)
{
//add
if (viewModel.AddressId == 0)
{
result = await _iAddressManager.InsertAddressEntityAsync(viewModel);
}
else if (viewModel.AddressId > 0) //edit
{
result = await _iAddressManager.UpdateAddressEntityAsync(viewModel);
}
if (result.Success)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
else
{
var modelStateError = ExceptionHelper.ModelStateErrorFirstFormat(ModelState);
result = Result.Fail(modelStateError);
return(BadRequest(result));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "AddAddress[POST]"));
}
return(BadRequest(MessageHelper.NullReferenceExceptionError));
}
public async Task <IActionResult> Save(AddressTypeViewModel viewModel)
{
try
{
if (ModelState.IsValid)
{
//add
if (viewModel.TypeId == 0)
{
_result = await _iAddressTypeManager.InsertAddressTypeAsync(viewModel);
}
else if (viewModel.TypeId > 0) //edit
{
_result = await _iAddressTypeManager.UpdateAddressTypeAsync(viewModel);
}
if (_result.Success)
{
this.FlashSuccess(MessageHelper.Save, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
else
{
this.FlashError(_result.Error, "AddressTypeMessage");
return(View(viewModel));
}
}
else
{
this.FlashError(ExceptionHelper.ModelStateErrorFirstFormat(ModelState), "AddressTypeMessage");
return(View(viewModel));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Save[POST]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(View(viewModel));
}
public IActionResult Add()
{
try
{
var model = new AddressTypeViewModel();
if (model != null)
{
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Add[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
private async Task <Result> IsEmailExists(ApplicationUser user)
{
try
{
var isExists = await _userManager.FindByEmailAsync(user.Email);
if (isExists != null)
{
string isEmailExistsMessage = string.Format(MessageHelper.IsEmailExists, user.Email);
return(Result.Fail(isEmailExistsMessage));
}
else
{
return(Result.Ok());
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "IsEmailExists"));
return(Result.Fail(MessageHelper.Error));
}
}
public async Task <IActionResult> Edit(int id)
{
try
{
var model = await _iAddressTypeManager.GetAddressTypeAsync(id);
if (model != null)
{
return(View("AddOrEdit", model));
}
else
{
this.FlashError(ExceptionHelper.ExceptionErrorMessageForNullObject(), "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
}
catch (Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Edit[GET]"));
}
this.FlashError(MessageHelper.UnhandelledError, "AddressTypeMessage");
return(RedirectToAction("Index", "AddressType"));
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("Register[POST]"));
if (ModelState.IsValid)
{
string userName = ((model.Email).Split('@')[0]).Trim(); // you are get here username.
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email
};
_result = await IsEmailExists(user);
if (!_result.Success)
{
ModelState.AddModelError(string.Empty, _result.Error);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", _result.Error));
return(View(model));
}
var role = new ApplicationRole
{
Id = model.RoleName,
Name = model.RoleName,
IsActive = true
};
IdentityResult resultRole = await _roleManager.CreateAsync(role);
if (resultRole.Succeeded)
{
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, model.RoleName);
await _signInManager.SignInAsync(user, isPersistent : false);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", $"User created a new account with password, UserEmail:{model.Email}"));
var isAdmin = await _userManager.IsInRoleAsync(user, AppConstants.AppUserRole.Admin);
if (isAdmin)
{
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(RedirectToAction("Index", "Admin"));
}
return(Redirect(model.ReturnUrl));
}
else
{
return(RedirectToLocal(model.ReturnUrl));
}
}
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Register[POST]", $"User creation failed, UserEmail:{model.Email}"));
AddErrors(result);
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Register[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
internal IActionResult ErrorPartialView(ErrorPageViewModel errorPageViewModel)
{
_log.Error(LogMessageHelper.FormateMessageForException(errorPageViewModel.ErrorMessage, "Error"));
return(PartialView("_ErrorModal", errorPageViewModel));
}
internal IActionResult JsonResult(Result result)
{
_log.Error(LogMessageHelper.FormateMessageForException(result.Error, "JsonResult"));
return(ModalHelper.Json(result));
}
internal IActionResult JsonResult(Exception ex)
{
_log.Error(LogMessageHelper.FormateMessageForException(ex, "JsonResult"));
return(ModalHelper.JsonError(ex));
}
public async Task <IActionResult> Login(LoginViewModel model)
{
try
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestStart("Login[POST]", $"UserEmail: {model.Email}"));
if (ModelState.IsValid)
{
ApplicationUser user = await _userManager.FindByNameAsync(model.Email);
if (user != null)
{
await _signInManager.SignOutAsync();
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
//var data = await GetUserSignInOutHistoryLocal(model);
//await _userLogInOutHistoryManager.CreateLogInOutHistoryAsync(data);
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"User logged in, UserEmail: {model.Email}"));
var isAdmin = await _userManager.IsInRoleAsync(user, AppConstants.AppUserRole.Admin);
if (isAdmin)
{
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(RedirectToAction("Index", "Admin"));
}
return(Redirect(model.ReturnUrl));
}
else
{
return(RedirectToLocal(model.ReturnUrl));
}
}
if (result.IsLockedOut)
{
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"User account locked out, UserEmail: {model.Email}"));
return(View("Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
_log.Info(LogMessageHelper.LogFormattedMessageForRequestSuccess("Login[POST]", $"Invalid login attempt, UserEmail: {model.Email}"));
return(View(model));
}
}
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, MessageHelper.Error);
_log.Error(LogMessageHelper.FormateMessageForException(ex, "Login[POST]"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}