public async Task <IActionResult> EditUser([FromBody] EditUserRequest editUser)
{
(bool succeed, string message, EditUserResponse userResponse) = await Mediator.Send(editUser);
if (succeed)
{
return(Ok(userResponse.ToResponse()));
}
return(BadRequest(message.ToResponse()));
}
public ActionResult Edit(EditUserView model)
{
var req = new EditUserRequest {
UserId = model.UserId, UserStateId = model.UserStateId
};
var resp = _adminUserService.ModifyUser(req);
var message = resp.Message;
var color = resp.Succeed ? StyleConstants.GreenColor : StyleConstants.RedColor;
return(Json(new { color, message }));
}
public void ChangeEmail()
{
EditUserRequest request = new EditUserRequest(connection, testToken, testUser);
request.Email = "*****@*****.**";
request.Password = "******";
EditUserResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
}
public async Task <IActionResult> Update([FromRoute] long groupUserId, [FromBody] EditUserRequest editUserRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Result editResult = await _manageUserService.EditUser(groupUserId, editUserRequest);
return(editResult.ToApiResult());
}
public bool Validate(EditUserRequest requestToValidate)
{
return(!(string.IsNullOrEmpty(requestToValidate.FireBaseUid) ||
string.IsNullOrEmpty(requestToValidate.FirstName) ||
string.IsNullOrEmpty(requestToValidate.LastName) ||
string.IsNullOrEmpty(requestToValidate.Street1) ||
string.IsNullOrEmpty(requestToValidate.State) ||
string.IsNullOrEmpty(requestToValidate.City) ||
string.IsNullOrEmpty(requestToValidate.Zipcode) ||
string.IsNullOrEmpty(requestToValidate.Email)));
}
private async Task <HttpResponseMessage> EditUser(int id, EditUserRequest data)
{
var request = new HttpRequestMessage(HttpMethod.Patch, $"api/users/{id}")
{
Content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json")
};
var response = await client.SendAsync(request);
return(response);
}
public bool EditUser(EditUserRequest request)
{
try
{
return(_userLogic.EditUser(request.Id, request.Name, request.Email, request.Password, request.Phone,
request.RoleId));
}
catch (Exception e)
{
throw new FaultException("Sikertelen módosítás");
}
}
public static bool EditProfile(EditUserRequest request)
{
bool CheckLogInAuthentication = false;
try
{
var Client = new HttpClient();
string url = ServiceAPIInfo.serviceAPI + ServiceAPIInfo.EditUser;
string Json = JsonConvert.SerializeObject(request, Formatting.Indented);
var contentjson = new StringContent(Json, Encoding.UTF8, ServiceAPIInfo.ContentMediaType);
//Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Client.BaseAddress = new Uri(url);
HttpResponseMessage responseAPI = Client.PostAsync(url, contentjson).Result;
if (responseAPI.IsSuccessStatusCode == true)
{
var test = responseAPI.Content.ReadAsStringAsync();
var stringmsg = (object)test.Result;
var result = JsonConvert.DeserializeObject <ProfileResponse>(test.Result);
if (!string.IsNullOrWhiteSpace(result.ToString()))
{
//SaveData(responseData.data.email);
CheckLogInAuthentication = true;
}
else
{
CheckLogInAuthentication = false;
}
CheckLogInAuthentication = true;
}
else
{
Console.WriteLine("Unauthorized User !");
CheckLogInAuthentication = false;
}
return(CheckLogInAuthentication);
}
catch (WebException ex)
{
Console.WriteLine(ex.ToString());
}
catch (ProtocolViolationException ex)
{
Console.WriteLine(ex.ToString());
}
catch (AggregateException ex)
{
Console.WriteLine("Server is not responding..");
Console.WriteLine(ex.InnerException.Message);
}
return(CheckLogInAuthentication);
}
public void EditUser()
{
EditUserRequest request = new EditUserRequest(connection, testToken, testUser);
request.FirstName = "Knar2";
request.LastName = "Lhe";
request.Nicknane = "Knar66";
EditUserResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
}
public string Edit(User user)
{
string response = "";
var result = new EditUserRequest(user).Execute(Api.Client);
if (result.Status == 200)
{
response = result.Data;
user.Clean();
}
return(response);
}
public async Task <IActionResult> EditUser(string id)
{
if (id == null)
{
return(NotFound());
}
var request = new EditUserRequest(id);
var response = await _mediator.Send(request);
return(View(response));
}
public ActionResult EditInfo(EditInfo model)
{
if (ModelState.IsValid)
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
var ctx = Request.GetOwinContext();
ClaimsIdentity identity = new ClaimsIdentity(Request.GetOwinContext().Authentication.User.Identity);
string accessToken = identity.FindFirst("AccessToken").Value;
Guid userID = new Guid(identity.FindFirst(ClaimTypes.NameIdentifier).Value);
string currentUserName = identity.FindFirst(ClaimTypes.Name).Value;
EditUserRequest request = new EditUserRequest(connection, accessToken, userID);
request.FirstName = model.FirstName;
request.LastName = model.LastName;
request.Nicknane = model.Nicknane;
EditUserResponse response = request.Send();
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
//TODO: If Nickname is changed, change it in the user claim
if (request.Nicknane != currentUserName)
{
identity.RemoveClaim(identity.FindFirst(ClaimTypes.Name));
identity.AddClaim(new Claim(ClaimTypes.Name, request.Nicknane));
var authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut();
AuthenticationProperties properties = new AuthenticationProperties {
IsPersistent = Convert.ToBoolean(identity.FindFirst(ClaimTypes.IsPersistent).Value)
};
authenticationManager.SignIn(properties, identity);
ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(identity);
HttpContext.User = claimsPrincipal;
}
TempData["Success"] = "You have successfully updated your info";
return(RedirectToAction("Index", "Account"));
}
else
{
TempData["Errors"] = "There was an error processing your request. Please try again.";
return(View(model));
}
}
else
{
return(View(model));
}
}
public async Task <IActionResult> Edit(string Id, [FromBody] EditUserRequest Request, [FromHeader] string Authorization)
{
var User = _authService.Authorize(Authorization);
if (Id != User)
{
throw new ChatAuthException("Editing another user");
}
await _userService.Edit(Id, Request.User);
return(Ok(await _userService.Get(Id, Id)));
}
public async Task <bool> OldPasswordIsCorrect(int userId, EditUserRequest request)
{
string encryptedPassword = EncrypterUtility.StringToSHA256String(value: request.Password);
var userFound = await _context.UserDrive.Where(user => user.Id == userId)
.AsNoTracking().FirstOrDefaultAsync();
if (userFound == null)
{
return(false);
}
return(userFound.Password == request.Password);
}
public EditUserRequest UpdateUser(EditUserRequest updatedUserObj)
{
// Handle the deleted user field sa we set it to Null in the DB if not set. Dot Net will pass in 1/1/0001 if set to null and SQL do not like
if (updatedUserObj.IsPartner == false)
{
updatedUserObj.PartnerId = null;
}
// Validate our dates to check that they are valid ranges of dates for SQL server
if (!_sqlDateValidator.IsValidSqlDateTime(updatedUserObj.DateDeleted))
{
// Value is not valid or null so set to a valid SQL date
// Struggled with setting this to Null so this will work for now
updatedUserObj.DateDeleted = DateTime.Parse("1800-01-01T00:00:00");
//0001-01-01T00: 00:00
}
using (var db = new SqlConnection(_connectionString))
{
var editUserQuery = @"
UPDATE
[User]
SET
[FireBaseUid] = @firebaseUid,
[FirstName] = @firstName,
[LastName] = @lastName,
[Street1] = @street1,
[Street2] = @street2,
[City] = @city,
[State] = @state,
[ZipCode] = @zipCode,
[Email] = @email,
[IsPartner] = @isPartner,
[PartnerID] = @partnerId,
[IsAdmin] = @isAdmin,
[DateCreated] = @dateCreated,
[DateDeleted] = @dateDeleted,
[IsDeleted] = @isDeleted
WHERE
id = @id";
var rowsAffected = db.Execute(editUserQuery, updatedUserObj);
if (rowsAffected == 1)
{
return(updatedUserObj);
}
throw new Exception("Could not update user");
}
}
public EditUserResponse EditUser(EditUserRequest request)
{
EditUserResponse response = new EditUserResponse();
AuthToken authToken = null;
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AuthToken, "Auth Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AntiForgeryToken, "Anti Forgery Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "Username");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.FirstName, "First Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.LastName, "Last Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "User Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.EmailAddress, "Email Address");
Common.Helpers.ValidationHelper.ValidateStringLength(request.FirstName, "First Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.LastName, "Last Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.Username, "User Name", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.EmailAddress, "Email Address", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateEmailAddress(request.EmailAddress);
if (!UserController.ValidateSession(request.AuthToken, out authToken))
{
throw new AuthenticationException("Authentication failed.");
}
UserController.ValidateAntiForgeryToken(request.AntiForgeryToken, authToken);
UserController.UpdateUser(request.Username, request.FirstName, request.LastName, request.EmailAddress, authToken);
}
catch (AuthenticationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException <string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, authToken == null ? null : authToken.Username);
throw new WebFaultException <string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return(response);
}
//User
public Task <EditUserResponse> EditUser(string currentPassword = "",
string username = null, string email = null, string password = null,
ImageType avatarType = ImageType.Png, byte[] avatar = null)
{
if (currentPassword == null)
{
throw new ArgumentNullException(nameof(currentPassword));
}
var request = new EditUserRequest {
CurrentPassword = currentPassword, Username = username, Email = email, Password = password, Avatar = Base64Picture(avatarType, avatar)
};
return(_rest.Patch <EditUserResponse>(Endpoints.UserMe, request));
}
public async Task <IActionResult> Edit([FromRoute] int id, [FromBody] EditUserRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var response = await _userService.EditAsync(id, request);
if (!response.IsValid)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <BaseResponse> EditAsync(int id, EditUserRequest request)
{
var user = await _userRepository.GetByIdAsync(id);
if (user == null)
{
return(new BaseResponse("User is not found"));
}
user.Email = request.Email;
user.FirstName = request.FirstName;
user.LastName = request.LastName;
_userRepository.Update(user);
await _unitOfWork.SaveChangesAsync();
return(new BaseResponse());
}
public async Task <Result <string> > EditAsync(EditUserRequest request, string origin)
{
var id = _authenticatedUserService.UserId;
var user = await _userManager.FindByIdAsync(id);
CultureInfo provider = CultureInfo.InvariantCulture;
DateTime?dateOfBirth = user.DateOfBirth;
try
{
//dateOfBirth = DateTime.ParseExact(request.DateOfBirth, "dd/MM/yyyy", provider);
dateOfBirth = DateTime.Parse(request.DateOfBirth);
}
catch { }
DateTime?identityDateOfIssue = user.IdentityDateOfIssue;
try
{ /*identityDateOfIssue = DateTime.ParseExact(request.identityDateOfIssue, "dd/MM/yyyy", provider); */
identityDateOfIssue = DateTime.Parse(request.IdentityDateOfIssue);
}
catch { }
{
user.FirstName = request.FirstName ?? user.FirstName;
user.LastName = request.LastName ?? user.LastName;
//user.PhoneNumber = request.PhoneNumber ?? user.PhoneNumber;
user.GenderId = request.GenderId ?? user.GenderId;
user.DateOfBirth = dateOfBirth ?? user.DateOfBirth;
user.IdentityTypeId = request.IdentityTypeId ?? user.IdentityTypeId;
user.IdentityNumber = request.IdentityNumber ?? user.IdentityNumber;
user.IdentityPlace = request.IdentityPlace ?? user.IdentityPlace;
user.IdentityDateOfIssue = identityDateOfIssue ?? user.IdentityDateOfIssue;
user.Nationality = request.Nationality ?? user.Nationality;
user.ProvinceId = request.ProvinceId ?? user.ProvinceId;
user.DistrictId = request.DistrictId ?? user.DistrictId;
user.CommuneId = request.CommuneId ?? user.CommuneId;
user.Address = request.Address ?? user.Address;
user.MaritalStatusId = request.MaritalStatusId ?? user.MaritalStatusId;
};
//var userWithSameEmail = await _userManager.FindByEmailAsync(request.Email);
await _userManager.UpdateAsync(user);
return(Result <string> .Success("True"));
}
public async Task <ActionResult <HttpResponse> > Edit(int id, EditUserRequest request)
{
var userDto = _mapper.Map <EditUserRequest, UserDto>(request);
userDto.Id = id;
try
{
await _userService.Edit(userDto);
return(new HttpResponse("Done"));
}
catch (EntityNotExistsException e)
{
ModelState.TryAddModelError(EntityNotExistsException.ModelStateKeyText, e.Message);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> UpdateUserData(EditUserRequest user)
{
var userReq = _mapper.Map <User>(user);
var validationResult = UserRequestValidator.Instance.ValidateRequest(userReq);
if (validationResult != null)
{
return(ValidationProblem(validationResult));
}
await _userService.Edit(userReq);
await _addressService.Edit(userReq.ResidentialAddress);
return(Ok());
}
public async Task <bool> CheckValidation()
{
try
{
if (string.IsNullOrEmpty(DisplayName))
{
UserDialogs.Instance.Alert("Profile", "Can't blank User Name!.", "OK");
}
else if (string.IsNullOrEmpty(emailID))
{
UserDialogs.Instance.Alert("Profile", "Can't blank Email-ID!.", "OK");
}
else if (string.IsNullOrEmpty(MobileNo))
{
UserDialogs.Instance.Alert("Profile", "Can't blank Mobile No.!.", "OK");
}
else
{
EMobileEditUser _ProfileRequest = new EMobileEditUser()
{
Address1 = Address,
Email = emailID,
Mobile = MobileNo,
Name = DisplayName,
Image = null
};
EditUserRequest rootObject = new EditUserRequest();
rootObject.EditUser = new EMobileEditUser();
rootObject.EditUser = _ProfileRequest;
rootObject.UserID = CrossSettings.Current.GetValueOrDefault("FacultyId", 0);
rootObject.UserType = (int)UserType.currentUserType;
var result = GeneralMethod.EditProfile(rootObject);
if (result)
{
return(true);
}
}
}
catch (Exception ex)
{
return(false);
}
return(false);
}
public async Task <bool> EditUser(EditUserRequest request, string id)
{
var userFromDb = await _userManager.FindByIdAsync(id);
if (userFromDb == null)
{
return(false);
}
// maping
userFromDb.FirstName = request.FirstName;
userFromDb.LastName = request.LastName;
userFromDb.Age = request.Age;
userFromDb.Sex = request.Sex;
var isEditted = await _userManager.UpdateAsync(userFromDb);
return(isEditted.Succeeded);
}
ResponseBase IAdminUserService.ModifyUser(EditUserRequest model)
{
var resp = new ResponseBase();
try
{
var user = _userDAL.FindBy(m => m.Id == model.UserId).SingleOrDefault();
user.StateId = model.UserStateId;
_userDAL.Save(user);
resp.Message = "保存成功";
resp.Succeed = true;
}
catch (Exception ex)
{
resp.Message = "编辑用户信息失败";
Log(ex);
}
return(resp);
}
public ActionResult <EditUserRequest> UpdateUser(string id, [FromBody] EditUserRequest updatedUserObj)
{
//var jwtFirebaseId = UserId;
//User submittingUser = _repo.GetUserById(id);
//if (updatedUserObj.FireBaseUid != jwtFirebaseId == false)
//{
// // return 401 as the User they are passing in is not the same as the one making the request
// return Unauthorized();
//}
if (!_editUserValidator.Validate(updatedUserObj))
{
return(BadRequest(new { error = "NESVault User Object Validation Failed " }));
}
//return null;
var updatedUser = _repo.UpdateUser(updatedUserObj);
return(Ok(updatedUser));
}
public async Task <IActionResult> PutUser(int id, EditUserRequest request)
{
if (!HasPermission(id))
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
request = Util.ProcessEditRequest(request);
if (request is null)
{
return(BadRequest());
}
User user = await context.Users.FindAsync(id);
if (user is null)
{
return(NotFound());
}
if (user.Username != request.Username &&
await context.Users.AnyAsync(e => e.Username == request.Username))
{
return(Conflict());
}
user.Name = request.Name;
user.Username = request.Username;
user.About = request.About;
context.Entry(user).State = EntityState.Modified;
try
{
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
return(Ok());
}
public async Task <SurveyUserDTO> UpdateUser(EditUserRequest request, int userId)
{
var user = await _context.SurveyUsers.Where(x => x.Id == userId).FirstOrDefaultAsync();
if (user == null)
{
throw new Exception("User not found ! ");
}
user.FirstName = request.FirstName;
user.LastName = request.LastName;
user.Gender = request.Gender;
user.DoB = request.DoB;
user.Country = request.Country;
await _context.SaveChangesAsync();
return(_mapper.Map <SurveyUserDTO>(user));
}
public async Task <IActionResult> Edit(string id, EditUserRequest model)
{
if (!ModelState.IsValid)
{
return(NotFoundView());
}
Result editResult = await _manageUserService.EditUser(id, model, GetUserId());
if (editResult.Failure)
{
SaveTempData(TEMP_DATA_STATUS_ALERT_KEY, StatusAlertViewExtension.Get(editResult));
}
else
{
SaveTempData(TEMP_DATA_STATUS_ALERT_KEY, StatusAlertViewExtension.Get("User updated"));
}
return(RedirectToAction(nameof(Details), new { id }));
}
public async Task <CommonUtils.Result.Result> EditUser(long groupUserId, EditUserRequest editUserRequest)
{
IBaseSpecification <GroupUserEntity, GroupUserEntity> specification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.Id == groupUserId)
.Include(x => x.User)
.Build();
CommonUtils.Result.Result <GroupUserEntity> getGroupUserResult = await _groupUserStore.SingleOrDefault(specification);
if (getGroupUserResult.Failure)
{
return(CommonUtils.Result.Result.Fail(getGroupUserResult));
}
//TODO: change so that Edit takes AppUserEntity as parameter
Core.Models.Result.Result updateResult = await EditUser(getGroupUserResult.Value.UserId, editUserRequest, "");
return(updateResult.ToNewResult());
}
