public async Task <IActionResult> SetPropertyAsync(string subject, string type)
{
if (IsNullOrWhiteSpace(subject))
{
ModelState["subject.String"].Errors.Clear();
ModelState.AddModelError("", Messages.SubjectRequired);
}
type = type.FromBase64UrlEncoded();
var value = await Request.Body.ReadAsStringAsync();
var meta = await GetMetadataAsync();
ValidateUpdateProperty(meta.UserMetadata, type, value);
if (ModelState.IsValid)
{
var result = await service.SetUserPropertyAsync(subject, type, value);
if (result.IsSuccess)
{
return(NoContent());
}
ModelState.AddErrors(result);
}
return(BadRequest(ModelState.ToError()));
}
public IActionResult AddExisting([FromRoute] string groupId, [FromBody] AddExistingUserRequest addExistingUserRequest)
{
Core.Models.Result.Result result = _groupUserService.AddExisting(groupId, addExistingUserRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult Profile()
{
Core.Models.Result.Result <ProfileViewModel> result = _manageDataService.GetProfile(GetUserId());
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
return(View("Profile"));
}
return(View("Profile", result.Value));
}
public IActionResult Remove([FromRoute] long groupUserId)
{
Core.Models.Result.Result result = _groupUserService.Remove(groupUserId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult ChangeRole([FromRoute] string groupId, [FromRoute] long groupUserId, [FromQuery] string roleId)
{
Core.Models.Result.Result result = _groupUserService.ChangeRole(groupUserId, roleId, User.GetUserId(_identityUIClaimOptions));
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> ProfileImage([FromForm] UploadProfileImageRequest uploadImageRequest)
{
Result result = await _profileImageService.UpdateProfileImage(GetUserId(), uploadImageRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public ActionResult <TransactionGetDto> Post([FromBody][Required] TransactionPostDto value)
{
// Validate
var validateResult = _dtoValidationService.ValidateTransferDto(value);
if (validateResult.HasErrors())
{
ModelState.AddErrors(validateResult);
}
if (!ModelState.IsValid)
{
_logger.LogStateWarning("This model is invalid.", ModelState);
return(BadRequest(ModelState));
}
// Work
var user = _userRepository.GetUser(User.Identity.Name);
if (user == null)
{
return(Forbid());
}
var(transaction, transferResult) = _bankService.TryTransferMoney(
user,
value.Sum,
value.From,
value.To);
if (transferResult.HasErrors())
{
ModelState.AddErrors(transferResult);
_logger.LogStateError("Transferring was unsuccessfully.", ModelState);
return(BadRequest(ModelState));
}
var cardFromNumber = value.From.ToNormalizedCardNumber();
var dto = _dtoFactory.Map(transaction, TryValidateModel);
switch (dto)
{
// Validate
case null:
_logger.LogError("Transferring was unsuccessfully.");
return(BadRequest("Transferring error"));
default:
return(Created($"/transactions/{cardFromNumber}", dto));
}
}
public async Task <IActionResult> Remove([FromRoute] string userId, [FromRoute] long attributeId)
{
Result result = await _userAttributeService.Remove(userId, attributeId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> Add([FromRoute] string userId, [FromBody] AddUserAttributeModel addUserAttribute)
{
Result result = await _userAttributeService.Add(userId, addUserAttribute);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> Get([FromRoute] string userId, [FromQuery] DataTableRequest dataTableRequest)
{
Result <DataTableResult <UserAttributeTableModel> > result = await _userAttributeDataService.Get(userId, dataTableRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(result));
}
return(Ok(result.Value));
}
public async Task <IActionResult> ResetPassword(ResetPasswordDto dto)
{
var result = await _mediator.Send(new ResetPasswordRequest(dto));
if (!result.Succeeded)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new ResponseViewModel("Your password has been reset.")));
}
public async Task <IActionResult> ChangePassword(ChangePasswordDto dto)
{
var result = await _mediator.Send(new ChangePasswordRequest(User.Identity.Name, dto));
if (!result.Succeeded)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new ResponseViewModel("Your password has been changed!")));
}
public async Task <IActionResult> Register([FromBody] RegisterDto dto)
{
var result = await _mediator.Send(new RegisterUserRequest(dto, Request.Scheme));
if (!result.Succeeded)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new ResponseViewModel("Your account has been created; please check your inbox!")));
}
public IActionResult Leave([FromRoute] string groupId)
{
//TODO: change for impersonation
Core.Models.Result.Result result = _groupUserService.Leave(User.GetUserId(_identityUIClaimOptions), groupId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public ActionResult <CardGetDto> Post([FromBody] CardPostDto value)
{
// Validate
var validateResult = _dtoValidationService.ValidateOpenCardDto(value);
if (validateResult.HasErrors())
{
ModelState.AddErrors(validateResult);
}
if (!ModelState.IsValid)
{
_logger.LogStateWarning("This model is invalid.", ModelState);
return(BadRequest(ModelState));
}
// Select
var user = _userRepository.GetUser(User.Identity.Name, false);
if (user == null)
{
return(Forbid());
}
var(card, openResult) = _bankService.TryOpenNewCard(
user,
value.Name,
(Currency)value.Currency,
(CardType)value.Type);
if (openResult.HasErrors())
{
ModelState.AddErrors(openResult);
_logger.LogStateError("Opening card was unsuccessfully.", ModelState);
return(BadRequest(ModelState));
}
// Mapping
var dto = _dtoFactory.Map(card, TryValidateModel);
switch (dto)
{
// Validate
case null:
_logger.LogError("Opening card was unsuccessfully.");
return(BadRequest("Не удалось выпустить карту"));
default:
return(Created($"/api/cards/{dto.Number}", dto));
}
}
public async Task <IActionResult> Index()
{
CredentailsViewModel credentailsViewModel = await _credentialsDataService.GetViewModel();
StatusAlertViewModel statusAlert = GetTempData <StatusAlertViewModel>(STATUS_ALERT_TEMP_DATA_KEY);
if (statusAlert != null)
{
ModelState.AddErrors(statusAlert.ValidationErrors);
credentailsViewModel.StatusAlert = statusAlert;
}
return(View(credentailsViewModel));
}
public IActionResult CreateInitialUser(RegisterViewModel model, string returnUrl = null)
{
var users = _identityService.GetUsersInRole(Constants.Roles.Administrator);
if (users.Result.Any())
{
return(RedirectToActionPermanent(nameof(LoginController.Index), "Login", new { returnUrl }));
}
if (ModelState.IsValid)
{
var result = _identityService.CreateUser(model);
if (result.Result.Result.Succeeded)
{
var roleResult = _identityService.AddUserToRole(result.Result.CreatedUser, Constants.Roles.Administrator);
if (roleResult.Result.Succeeded)
{
var signInResult = _identityService.SignInUser(new SignInViewModel
{
Email = model.Email,
Password = model.Password
});
if (signInResult.Result.Succeeded)
{
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction(nameof(CmsController.Index), "Cms"));
}
return(Redirect(returnUrl));
}
return(RedirectToAction(nameof(LoginController.Index), "Login", new { returnUrl }));
}
ModelState.AddErrors(roleResult.Result);
}
else
{
ModelState.AddErrors(result.Result.Result);
}
}
ViewData[Constants.ViewData.ReturnUrl] = returnUrl;
return(View(model));
}
public async Task <ActionResult> ExternalLoginConfirmation(
ExternalLoginConfirmationViewModel model)
{
if (User.Identity?.IsAuthenticated == true)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var loginInfo = await SignInManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
return(View("ExternalLoginFailure"));
}
var email = loginInfo.Principal.FindFirstValue(ClaimTypes.Email);
var user = new JoinIdentityUser()
{
UserName = email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user, loginInfo);
if (result.Succeeded)
{
var token = await UserManager.GenerateEmailConfirmationTokenAsync(user);
_ = await UserManager.ConfirmEmailAsync(user, token);
await SignInManager.SignInAsync(user, isPersistent : true);
await externalLoginProfileExtractor.TryExtractProfile(user, loginInfo);
return(RedirectToLocal(model.ReturnUrl));
}
}
ModelState.AddErrors(result);
}
return(View(model));
}
public async Task <IActionResult> Edit(ChangePasswordEditViewModel viewModel)
{
var user = await _userManager.GetUserAsync(User);
var result = await _userManager.ChangePasswordAsync(user, viewModel.OldPassword, viewModel.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction(nameof(Edit)));
}
ModelState.AddErrors(result.Errors);
return(View(viewModel));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var currentUser = await UserManager.FindByNameAsync(model.Email);
if (currentUser != null)
{
ModelState.AddModelError("",
"Вы уже зарегистрировались. Если пароль не подходит, нажмите «Забыли пароль?»");
return(View("Login", new LoginViewModel()
{
Email = model.Email
}));
}
var passValidateResult =
await UserManager.PasswordValidator.ValidateAsync(model.Password);
if (!passValidateResult.Succeeded)
{
ModelState.AddErrors(passValidateResult);
return(View(model));
}
var user = new JoinIdentityUser {
UserName = model.Email
};
var result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
ModelState.AddErrors(result);
return(View(model));
}
//We don't want to sign in user until he has email confirmed
//await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
await UserManager.SetPasswordWithoutValidationAsync(user.Id, model.Password);
await SendConfirmationEmail(user);
return(View("RegisterSuccess"));
}
public async Task<IActionResult> AcceptInvite(AcceptInviteRequest acceptInvite)
{
if (!ModelState.IsValid)
{
return View();
}
Result result = await _addUserService.AcceptInvite(acceptInvite);
if (result.Failure)
{
ModelState.AddErrors(result);
return View();
}
return RedirectToAction(nameof(RegisterSuccess));
}
public async Task<IActionResult> ConfirmEmail(string id, string code)
{
if(!ModelState.IsValid)
{
return View();
}
Result result = await _emailConfirmationService.ConfirmEmail(id, code);
if(result.Failure)
{
ModelState.AddErrors(result.Errors);
return View();
}
return View();
}
public async Task<IActionResult> LoginWithRecoveryCode(LoginWithRecoveryCodeRequest loginWithRecoveryCode, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return View(new LoginWithRecoveryCodeViewModel(returnUrl));
}
Result result = await _loginService.LoginWithRecoveryCode(loginWithRecoveryCode);
if (result.Failure)
{
ModelState.AddErrors(result);
return View(new LoginWithRecoveryCodeViewModel(returnUrl));
}
return LocalRedirect(returnUrl);
}
public async Task <IActionResult> SignUp(SignUpViewModel form, string returnUrl)
{
if (ModelState.IsValid)
{
var userCreation = await UserManager.CreateAsync(new User { UserName = form.UserName }, form.Password);
if (userCreation.Succeeded)
{
return(await SignIn(form, returnUrl));
}
ModelState.AddErrors(userCreation.Errors, e => e.Description);
}
return(View());
}
public IActionResult Remove([FromRoute] string groupId, [FromRoute] string inviteId)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Result result = _inviteService.Remove(inviteId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> Invite([FromRoute] string groupId, [FromBody] InviteToGroupRequest inviteToGroupRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Result result = await _inviteService.InviteToGroup(groupId, inviteToGroupRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult Get([FromRoute] string groupId, [FromQuery] DataTableRequest dataTableRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Result <DataTableResult <GroupInviteTableModel> > result = _groupInviteDataService.Get(groupId, dataTableRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(result.Value));
}
public IActionResult Remove([FromRoute] string roleId, [FromRoute] string roleAssignmentId)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Result result = _roleAssignmentService.Remove(roleId, roleAssignmentId);
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult GetUnassigned([FromRoute] string roleId, [FromQuery] Select2Request select2Request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Result <Select2Result <Select2ItemBase> > result = _roleAssignmentDataService.GetUnassigned(roleId, select2Request);
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
return(BadRequest(ModelState));
}
return(Ok(result.Value));
}
public IActionResult Get([FromRoute] string roleId, [FromQuery] DataTableRequest dataTableRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Result <DataTableResult <RoleAssignmentTableModel> > result = _roleAssignmentDataService.Get(roleId, dataTableRequest);
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
return(BadRequest(ModelState));
}
return(Ok(result.Value));
}