public bool ActivateUser(int userId, string userEmail)
{
if (!userEmail.IsValidEmail() || string.IsNullOrEmpty(userEmail) || userId <= 0)
{
return(false);
}
return(_userService.ActivateUser(userId, userEmail, null, true));
}
public async Task <IActionResult> Activate([FromRoute] int id)
{
if (id <= 0)
{
return(BadRequest());
}
try
{
await _userService.ActivateUser(id);
}
catch (NullReferenceException ex)
{
if (!(await _userService.UserExists(id)))
{
return(NotFound(ex));
}
}
catch (DbUpdateException ex)
{
return(BadRequest(ex));
}
return(Ok());
}
public async Task <IActionResult> ActivateUser(string userId)
{
var result = await _userService.ActivateUser(userId);
if (result.Success)
{
return(NoContent());
}
return(BadRequest(result));
}
public async Task ActivateUser_WithNonExistedId_ShouldThrowExceptionActivateUser()
{
var context = MdmsDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
_userService = new UserService(new FakeUserManager(), context);
await Assert.ThrowsAsync <NullReferenceException>(() => _userService.ActivateUser("idzzzzzz"));
}
public async Task <IActionResult> ActivateUser(string id)
{
var result = await _userService.ActivateUser(id);
if (result)
{
return(RedirectToAction("UsersList", "Admin", new { activ = false }));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> ActivateAccount(string guid)
{
var result = await _userService.ActivateUser(guid);
if (result.ErrorOccured)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> ConfirmEmail(string email, string token)
{
var result = await _userService.ActivateUser(email, token);
if (result)
{
return(Ok());
}
return(BadRequest());
}
public ActionResult Active(int ticket)
{
try
{
UserService.ActivateUser(ticket);
return(View("Activated"));
}
catch
{
return(View("ActivationError"));
}
}
public IActionResult ConfirmEmail(string token)
{
bool emailConfirmation = _emailService.CheckEmailToken(token);
if (emailConfirmation)
{
JwtSecurityToken tokenJwt = _emailService.DecodeJwtToken(token);
string email = tokenJwt.Payload.FirstOrDefault(x => x.Key == "email").Value.ToString();
_userService.ActivateUser(email);
}
return(null);
}
public async Task <IActionResult> ActivateAccount(string id)
{
var user = await userService.GetUserByEmailActiveCode(id);
if (user != null)
{
userService.ActivateUser(user);
return(JsonResponseStatus.Success());
}
return(JsonResponseStatus.NotFound());
}
public IActionResult ActivateUser([FromRoute] Guid id)
{
var result = _userService.ActivateUser(id);
if (result.Equals("User has been activated"))
{
return StatusCode(400, result);
}
if (result.Equals("User does not exist"))
{
return StatusCode(404, result);
}
return StatusCode(201, result);
}
public IHttpActionResult ActivateUser(string IdUser)
{
try
{
int decryptedUserId = Convert.ToInt32(EncryptionService.Decrypt(IdUser));
int result = _userService.ActivateUser(decryptedUserId);
return(Ok(result));
}
catch (Exception)
{
return(Unauthorized());
}
}
public IActionResult ActivateUser(string code, string email)
{
string result;
if (code == null || code.Equals(string.Empty) || email == null || email.Equals(string.Empty))
{
result = "参数错误！";
}
code = code.Trim();
email = email.Trim();
userService.ActivateUser(code, email, out result);
return(View("ActivateUser", result));
}
public async Task <IActionResult> ActivateUser(string id)
{
try
{
await _userService.ActivateUser(id);
return(StatusCode(200));
}
catch (Exception ex)
{
return(StatusCode(400, ex.Message));
}
}
public async Task <ActionResult> ActivateUser([FromRoute] int id)
{
UserDto userDto = await _userService.GetUser(id);
if (userDto == null)
{
return(NotFound("No such user"));
}
await _userService.ActivateUser(id);
return(Ok());
}
public bool ActivateUser(Guid id)
{
try
{
_userService.ActivateUser(id);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> Activate([FromRoute] string id)
{
try
{
await _userService.ActivateUser(id, User.GetUserId());
return(Ok());
}
catch (Exception x)
{
Log.Error($"ERROR User/Activate/{id}", x);
return(StatusCode(500));
}
}
public async Task <string> ActivateAccount(string code)
{
var item = await _service.ActivateUser(code);
var model = _mapper.Map <UserModel>(item);
if (model != null)
{
return("User Activated Successfully");
}
else
{
return("Error Occured");
}
}
public ActionResult Activate(Guid code)
{
User user = _userService.GetUserByCode(code);
if (user != null)
{
_userService.ActivateUser(user);
ViewBag.Result = "Üyeliğiniz aktifleştirilmiştir.";
}
else
{
ViewBag.Result = "Böyle bir kullanıcı bulunamadı";
}
return(View());
}
public ActionResult Activate(Guid code)
{
User user = _userService.GetUserByCode(code);
if (user != null)
{
_userService.ActivateUser(user);
ViewBag.Result = "Üyeliğiniz aktifleştirilmiştir";
return(RedirectToAction("UserLogin", "Login"));
}
else
{
ViewBag.Result = "Böyle bir kullanıcı bulunamadı!";
return(RedirectToAction("USerRegister"));
}
}
public IActionResult ActivateUser(int userId)
{
try
{
ContextUserViewModel _user = authService.GetLoggedUser();
if (_user == null || !UtilsService.IsAdmin(_user.Profile))
{
return(Unauthorized());
}
return(Ok(service.ActivateUser(userId)));
}
catch (Exception)
{
throw;
}
}
public ServiceResponse <bool> ActivateUser([FromBody] JObject jObject)
{
var id = (int)jObject["Id"];
var response = new ServiceResponse <bool>();
try
{
response.Model = _userService.ActivateUser(id);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = GetErrorMessageDetail(ex);
}
return(response);
}
public IActionResult ActivateUser(DeactivateUserViewModel model)
{
this.ViewData["InitialState"] = "Inactive";
if (ModelState.IsValid)
{
if (userService.ActivateUser(model))
{
return(RedirectToAction("ActSuccess", new DeactivateUserViewModel()
{
UserName = model?.UserName, IsActive = true
}));
}
}
return(RedirectToAction("ActFail", new DeactivateUserViewModel()
{
UserName = model?.UserName, IsActive = false
}));
}
public async Task <IActionResult> Activate([HttpTrigger(AuthorizationLevel.Function, "get", Route = "v1/user/activate")] HttpRequest req, ILogger log)
{
if (req.Query.ContainsKey("code"))
{
var activationCode = req.Query["code"];
var user = userService.GetUserByActivationCode(activationCode);
if (user != null)
{
userService.ActivateUser(user.Id);
return(new OkResult());
}
}
return(new BadRequestResult());
}
public IActionResult ActivateUser([FromBody] ActivationKeyRequest activation)
{
if (activation == null)
{
return(BadRequest());
}
if (string.IsNullOrEmpty(activation.ActivationKey))
{
return(BadRequest());
}
try
{
var user = _userService.ActivateUser(activation.ActivationKey);
if (user == null)
{
return(NotFound(new { message = "Bu aktivasyon anahtarıyla kayıtlı bir kullanıcı bulunmamaktadır." }));
}
var tokenString = _tokenService.GetToken(user.Id, _appSettings);
// return basic user info (without password) and token to store client side
return(Ok(new
{
Id = user.Id,
Name = user.Name,
Surname = user.Surname,
Email = user.Email,
IsActive = user.IsActive,
Token = tokenString
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
//[Authorize]
//[HttpPost]
//public ActionResult ChangePassword(ChangePasswordModel model)
//{
// if (ModelState.IsValid)
// {
// bool changePasswordSucceeded;
// try
// {
// changePasswordSucceeded = _userService.ChangeUserPassword(User.Identity.DisplayName, model.OldPassword, model.NewPassword);
// }
// catch (Exception)
// {
// changePasswordSucceeded = false;
// }
// if (changePasswordSucceeded)
// {
// return RedirectToAction("ChangePasswordSuccess");
// }
// else
// {
// ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
// }
// }
// // If we got this far, something failed, redisplay form
// return View(model);
//}
//public ActionResult ChangePasswordSuccess()
//{
// return View();
//}
public ActionResult Activate(string email, string key = "")
{
var user = _userService.GetByEmail(email);
if (user == null)
{
//TODO: redirect / add modelState error
}
if (string.IsNullOrEmpty(key) && !user.IsActivated)
{
return(RedirectToAction("NotActivated", new { email = user.Email }));
}
if (user.NewEmailKey == key)
{
_userService.ActivateUser(user);
return(RedirectToAction("Activated"));
}
else
{
throw new NotImplementedException();
}
}
public HttpResponseMessage Signup([FromBody] SignupViewModel viewModel)
{
if (viewModel == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unknown error"));
}
try
{
_userService.ActivateUser(viewModel.Email, viewModel.Password, viewModel.Invite);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (UserAlreadyExistException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> ActivateUser([FromBody] ActivateUserDto userDto)
{
try
{
var user = await userService.ActivateUser(userDto);
return(Ok(user));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new ResponseDto <UserDto>
{
Errors = new List <ErrorDto>
{
new ErrorDto
{
ErrorCode = 1, ErrorMessage = ex.Message
}
}
}));
}
}
public IActionResult ActivateUser(ActivateOrDesactivateUserDto model)
{
_service.ActivateUser(model.UserName);
return(Ok());
}
public async Task <IActionResult> ActivateUser(Guid id)
{
await _userService.ActivateUser(id);
return(Ok());
}
