public IActionResult Profile(EditProfileRequest request)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Profile)));
}
Result editResult = _manageUserService.EditUser(GetUserId(), request);
Result <ProfileViewModel> getResult = _manageDataService.GetProfile(GetUserId());
if (getResult.Failure)
{
ModelState.AddErrors(getResult.Errors);
return(View());
}
if (editResult.Failure)
{
getResult.Value.StatusAlert = StatusAlertViewExtension.Get(editResult);
ModelState.AddErrors(editResult.Errors);
return(View());
}
getResult.Value.StatusAlert = StatusAlertViewExtension.Get("Profile updated");
return(View(getResult.Value));
}
public async Task <ActionResult> EditProfile([FromBody] EditProfileRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var accessToken = await HttpContext.GetTokenAsync("Bearer", "access_token");
try
{
_userService.EditProfile(request.NewFullName, request.NewEmail, request.NewPhoneNumber, request.NewProfileImage, request.NewPassword, request.OldPassword, accessToken);
return(NoContent());
}
catch (Exception error)
{
if (error.Message == "Unauthoried!")
{
return(Unauthorized());
}
else if (error.Message == "InvalidCredential!")
{
return(Forbid());
}
else
{
return(BadRequest());
}
}
}
public async Task <EditProfileResponse> EditProfile(EditProfileRequest request)
{
var toUpdate = _users.Users.FirstOrDefault(uu => uu.UserId == request.UserId);
/*if(request.Name != )*/
toUpdate.Name = request.Name;
toUpdate.PhoneNumber = request.PhoneNumber;
toUpdate.UserImgUrl = request.UserImage;
toUpdate.UserDescription = request.UserDescription;
toUpdate.OfficeLocation = request.OfficeLocation;
_users.Entry(toUpdate).State = EntityState.Modified;
try
{
await _users.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw new DbUpdateException("Error when updating user" + request.Name);
}
var response = new EditProfileResponse(HttpStatusCode.Accepted);
return(response);
}
public async Task <IActionResult> UpdateProfile([FromBody] EditProfileRequest request)
{
var userId = Guid.Parse(this.User.Claims.First(x => x.Type == "sub").Value);
var result = await this.mediator.Send(new UpdateProfile(userId, request.Bio, request.ImageUrl, request.DisplayName));
return(this.Ok(result));
}
public IActionResult EditProfile([FromBody] EditProfileRequest request)
{
var userId = Request.GetUserId();
_userEditFacade.EditProfile(userId, request.Name, request.AboutUser, request.Gender, request.AvatarLink,
request.Contacts, request.BirthYear);
return(Ok());
}
private async void LoadUserProfileData()
{
try
{
_objHeaderModel.TokenCode = Settings.TokenCode;
_objEditProfileRequest = new EditProfileRequest
{
UserId = Convert.ToInt32(Settings.UserID)
};
//int UserId = Convert.ToInt32(Settings.UserID);
EditProfileResponse objEditProfileResponse = new EditProfileResponse();
_objEditProfileResponse = await _apiService.EditProfilePostAsync(new Get_API_Url().CommonBaseApi(_baseUrlEdit), true, _objHeaderModel, _objEditProfileRequest);
//string s = JsonConvert.SerializeObject(_objEditProfileRequest);
//HttpResponseMessage response = null;
//string uri = "http://180.151.232.92:130/api/User/EditProfile";
//using (var stringContent = new StringContent(s, System.Text.Encoding.UTF8, "application/json"))
//{
//HttpClient client = new HttpClient();
//client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Settings.TokenCode);
//var geet = await client.PostAsync(uri, stringContent);
//if (response.IsSuccessStatusCode)
//{
// var SucessResponse = await response.Content.ReadAsStringAsync();
// objEditProfileResponse = JsonConvert.DeserializeObject<EditProfileResponse>(SucessResponse);
// /return objEditProfileResponse;
//}
//else
//{
// var ErrorResponse = await response.Content.ReadAsStringAsync();
// objEditProfileResponse = JsonConvert.DeserializeObject<EditProfileResponse>(ErrorResponse);
// return objEditProfileResponse;
//}
//}
ProfileResponse result = _objEditProfileResponse.Response;
if (result.StatusCode == 200)
{
this.BindingContext = result.details;
}
else
{
DependencyService.Get <IToast>().Show("No Data!!");
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
}
public Task <EditProfileResponse> EditProfile(EditProfileRequest request)
{
if (request == null)
{
throw new InvalidUserRequest("Request object cannot be null");
}
if (request.UserId <= 0)
{
throw new InvalidUserIdException("UserID is invalid");
}
return(_userRepository.EditProfile(request));
}
public async Task <IActionResult> Edit([FromBody] EditProfileRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var response = await _profileService.EditAsync(request);
if (!response.IsValid)
{
return(BadRequest(response.Message));
}
return(Ok(response));
}
public async Task <BaseResponse> EditAsync(EditProfileRequest request)
{
var loggedUser = await _authenticationService.GetLoggedUserAsync();
var user = loggedUser.User;
user.Email = request.Email;
user.FirstName = request.FirstName;
user.LastName = request.LastName;
_userRepository.Update(user);
await _unitOfWork.SaveChangesAsync();
return(new BaseResponse());
}
public async Task <ResultResponse <ProfileDto> > EditAsync(EditProfileRequest request)
{
var loggedUser = (User)_httpContext.Items.GetOrDefault("User");
loggedUser.Email = request.Email;
loggedUser.FirstName = request.FirstName;
loggedUser.LastName = request.LastName;
_userRepository.Update(loggedUser);
await _unitOfWork.SaveChangesAsync();
var profileDto = _mapper.Map <User, ProfileDto>(loggedUser);
return(new ResultResponse <ProfileDto>(profileDto));
}
public HttpResponseMessage Editstudentdetail([FromBody] EditProfileRequest epr)
{
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["con"].ConnectionString))
{
using (SqlCommand cmd = new SqlCommand("usp_api_EditContactDetails", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@studentcode", epr.studentcode);
cmd.Parameters.AddWithValue("@Correspondance", epr.correspondance);
cmd.Parameters.AddWithValue("@HomeAddress1", epr.homeaddress1);
cmd.Parameters.AddWithValue("@HomeAddress2", epr.homeaddress2);
cmd.Parameters.AddWithValue("@HomeAddress3", epr.homeaddress3);
cmd.Parameters.AddWithValue("@HomeAddress4", epr.homeaddress4);
cmd.Parameters.AddWithValue("@HomePincode", epr.homepincode);
cmd.Parameters.AddWithValue("@HomeCity", epr.homecity);
cmd.Parameters.AddWithValue("@HomeStateCode", epr.homestatecode);
cmd.Parameters.AddWithValue("@HomeCountryCode", epr.homecountrycode);
cmd.Parameters.AddWithValue("@HomeTelNo", epr.hometelno);
cmd.Parameters.AddWithValue("@HomeMobileNo", epr.homemobileno);
cmd.Parameters.AddWithValue("@HomeEMail", epr.homeemail);
cmd.Parameters.AddWithValue("@OfficeAddress1", epr.officeaddress1);
cmd.Parameters.AddWithValue("@OfficeAddress2", epr.officeaddress2);
cmd.Parameters.AddWithValue("@OfficeAddress3", epr.officeaddress3);
cmd.Parameters.AddWithValue("@OfficeAddress4", epr.officeaddress4);
cmd.Parameters.AddWithValue("@OfficeCity", epr.officecity);
cmd.Parameters.AddWithValue("@OfficePincode", epr.officepincode);
cmd.Parameters.AddWithValue("@OfficeStateCode", epr.officestatecode);
cmd.Parameters.AddWithValue("@OfficeCountryCode", epr.officecountrycode);
cmd.Parameters.AddWithValue("@OfficeTelNo", epr.officetelno);
cmd.Parameters.AddWithValue("@OfficeMobileNo", epr.officemobileno);
cmd.Parameters.AddWithValue("@OfficeEMail", epr.officeemail);
cmd.Parameters.AddWithValue("@fb", epr.fb);
cmd.Parameters.AddWithValue("@linkedin", epr.linkedin);
cmd.Parameters.AddWithValue("@twitter ", epr.twitter);
SqlDataAdapter sda = new SqlDataAdapter(cmd);
DataTable dt = new DataTable();
sda.Fill(dt);
if (Convert.ToInt16(dt.Rows[0]["Msg"]) == 1)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
else
{
return(new HttpResponseMessage(HttpStatusCode.NotModified));
}
}
}
}
// EditProfile
public MonetaSdkResult sdkMonetaEditProfile(long unitId, long profileId)
{
MonetaSdkResult result = new MonetaSdkResult();
try
{
EditProfileRequest request = new EditProfileRequest();
List <KeyValueApprovedAttribute> mntAttributes = new List <KeyValueApprovedAttribute>();
KeyValueApprovedAttribute monetaAtribute = new KeyValueApprovedAttribute();
monetaAtribute.key = "kpp";
monetaAtribute.value = "1111";
mntAttributes.Add(monetaAtribute);
monetaAtribute = new KeyValueApprovedAttribute();
monetaAtribute.key = "ogrn";
monetaAtribute.value = "2222";
mntAttributes.Add(monetaAtribute);
monetaAtribute = new KeyValueApprovedAttribute();
monetaAtribute.key = "ogrnip";
monetaAtribute.value = "3333";
mntAttributes.Add(monetaAtribute);
monetaAtribute = new KeyValueApprovedAttribute();
monetaAtribute.key = "okpo";
monetaAtribute.value = "4444";
mntAttributes.Add(monetaAtribute);
monetaAtribute = new KeyValueApprovedAttribute();
monetaAtribute.key = "okved";
monetaAtribute.value = "5555";
mntAttributes.Add(monetaAtribute);
request.profile = mntAttributes.ToArray();
request.unitId = unitId;
request.profileId = profileId;
request.profileIdSpecified = true;
response = client.EditProfile(request);
result = prepareResult();
}
catch (Exception e)
{
result.error = true;
result.errorMessage = e.Message;
}
return(result);
}
public HttpResponseMessage EditProfile(EditProfileRequest request)
{
var result = new EditProfileResult();
try
{
result = service.EditProfile(request);
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.Success = false;
return(Request.CreateResponse(HttpStatusCode.InternalServerError, result));
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public async Task EditProfile_ExceptionOnInvalidUserID()
{
var requestDto = new EditProfileRequest(
0,
"name",
"0833611023",
"image.png",
"user Description",
false,
4,
UserRoles.Administrator,
OfficeLocation.Braamfontein
);
var exception = await Assert.ThrowsAsync <InvalidUserIdException>(() => _sut.EditProfile(requestDto));
Assert.Equal("UserID is invalid", exception.Message);
}
public async Task EditUserProfile_ExpectedReturnStatus()
{
var requestDto = new EditProfileRequest(
1,
"name",
"0833611023",
"image.png",
"user Description",
false,
4,
UserRoles.Administrator,
OfficeLocation.Braamfontein
);
var responseDto = new EditProfileResponse(HttpStatusCode.Accepted);
_userRepoMock.Setup(n => n.EditProfile(requestDto)).ReturnsAsync(responseDto);
var editedUserProfile = await _sut.EditProfile(requestDto);
Assert.Equal(responseDto, editedUserProfile);
}
public Result EditUser(string id, EditProfileRequest editProfileRequest)
{
ValidationResult validationResult = _editProfileValidator.Validate(editProfileRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invlid EditProfileRequest. UserId {id}");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == id);
AppUserEntity appUser = _userRepository.SingleOrDefault(userSpecification);
if (appUser == null)
{
_logger.LogWarning($"No User. UserId {id}");
return(Result.Fail("no_user", "No user"));
}
appUser.FirstName = editProfileRequest.FirstName;
appUser.LastName = editProfileRequest.LastName;
if (appUser.PhoneNumber != editProfileRequest.PhoneNumber)
{
appUser.PhoneNumber = editProfileRequest.PhoneNumber;
appUser.PhoneNumberConfirmed = false;
}
bool updateResult = _userRepository.Update(appUser);
if (!updateResult)
{
_logger.LogError($"Faild to update user. UserId {id}");
return(Result.Fail("error", "Error"));
}
return(Result.Ok());
}
public void onSave()
{
Debug.Log("Clicked on Save Profile");
string testbio = bioInput.GetComponent <InputField>().text; // Get user input text
string testusername = screenNameInput.GetComponent <InputField>().text; // Get user input text
if (!String.IsNullOrWhiteSpace(testbio))
{
bio = testbio;
Global.bio = bio; // update on global
}
if (!String.IsNullOrWhiteSpace(testusername))
{
screenname = testusername;
Global.username = screenname; // update on global
}
Debug.Log("This is the new bio: " + bio);
Debug.Log("This is the new screenname: " + screenname);
picnum = temppicnum;
Global.avatar = picnum;
Debug.Log("This is the new profilepicnum: " + picnum);
// Sending request to server to update bio, screen name, & profile pic
EditProfileRequest req = new EditProfileRequest("editProfile", Global.getID(), Global.getToken(), bio, picnum, screenname);
string json = JsonConvert.SerializeObject(req);
Byte[] data = System.Text.Encoding.ASCII.GetBytes(json);
Global.stream.Write(data, 0, data.Length);
data = new Byte[256];
string responseData = string.Empty;
Int32 bytes = Global.stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
PlayerPrefs.SetString(EMAIL_PREF_KEY, Global.email); // Get the user email from PLAYER PREFS;
SceneManager.LoadScene("ProfileScene"); // Don't save profile changes and go back to Lobby
}
public EditProfileResult EditProfile(EditProfileRequest request)
{
var result = new EditProfileResult();
result.newUserName = request.UserName;
try
{
var user = _cache.RefreshAndGet(
Users,
request.UserName,
new UserNotFoundException(string.Format("user id: {0} not found, please re-login", request.UserName))
);
UserManager.SecurityCheck(request.SecurityKey, user);
// call domain action - if null don't update (?? operator)
UserManager.EditProfile(
user,
request.NewUserName ?? request.UserName,
request.NewPassword ?? request.Password,
request.NewAvatar ?? user.Avatar);
// update result
// parse byte[] to JSON (using int[] as a cleaver KOMBINA)
result.newAvatar = request.NewAvatar?.Select(b => (int)b).ToArray();
result.newPassword = request.NewPassword;
result.newUserName = request.NewUserName;
result.Success = true;
}
catch (PokerException e)
{
result.Success = false;
result.ErrorMessage = e.Message;
Logger.Error(e, this);
}
return(result);
}
public void EditProfileTest()
{
//Arrange
var request = new EditProfileRequest()
{
UserName = user.UserName,
NewUserName = "******",
NewPassword = "******",
NewAvatar = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
SecurityKey = _seqkey,
};
var exStatus = HttpStatusCode.OK;
var exResult = new EditProfileResult()
{
ErrorMessage = "",
Success = true,
newUserName = "******",
newAvatar = (new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }).Select(b => (int)b).ToArray(),
newPassword = "******"
};
//Act
var act = ctrl.EditProfile(request);
EditProfileResult actContent;
var hasContent = act.TryGetContentValue(out actContent);
//Assert
Assert.AreEqual(exStatus, act.StatusCode, "status code");
Assert.IsTrue(hasContent, "has content");
Assert.AreEqual(exResult.ErrorMessage, actContent.ErrorMessage, "error message");
Assert.AreEqual(exResult.Success, actContent.Success, "success bool");
Assert.AreEqual(exResult.newUserName, actContent.newUserName, "user not default");
Assert.AreEqual(exResult.newPassword, actContent.newPassword, "user not default");
CollectionAssert.AreEquivalent(exResult.newAvatar, actContent.newAvatar, "user not default");
}
public async Task <IActionResult> Edit(EditProfileRequest model)
{
if (!ModelState.IsValid)
{
ViewBag.Response = new EditProfileResult {
Succeeded = false,
Description = "Request does not contain the required information to update your profile."
};
return(View(model));
}
var user = await _userManager.GetUserAsync(HttpContext.User);
var claims = new List <Claim>();
if (!string.IsNullOrEmpty(model.PhotoName))
{
claims.Add(new Claim(ClaimTypes.Uri, model.PhotoName));
}
if (!string.IsNullOrEmpty(model.Address))
{
claims.Add(new Claim(ClaimTypes.StreetAddress, model.Address));
}
if (!string.IsNullOrEmpty(model.FirstName))
{
claims.Add(new Claim(ClaimTypes.GivenName, model.FirstName));
}
if (!string.IsNullOrEmpty(model.LastName))
{
claims.Add(new Claim(ClaimTypes.Surname, model.LastName));
}
user.PhoneNumber = model.PhoneNumber;
// Built-in UserManager internally calls UpdateAsync so no need to call it explicitly.
// https://github.com/aspnet/Identity/blob/master/src/Core/UserManager.cs#L1044
var result = await _userManager.AddClaimsAsync(user, claims);
if (!result.Succeeded)
{
ViewBag.Response = new EditProfileResult {
Succeeded = false,
Description = "The was a problem updating your profile. Please try again."
};
return(View(model));
}
// We need to sign out and re-sign in the user in the background in case he changed his photo url. Photo url exists
// in a user claim. Claims are updated when the sign in cookie is generated.
await _signInManager.SignOutAsync();
await _signInManager.SignInAsync(user, true);
ViewBag.Response = new EditProfileResult {
Succeeded = true,
Description = "Your profile was updated successfully."
};
model.PhotoUrl = !string.IsNullOrEmpty(model.PhotoName)
? $"{_appSettings.Domain}/{_appSettings.UploadsFolder}/{user.Id}/{model.PhotoName}"
: $"{_appSettings.Domain}/img/default_profile.png";
return(View(model));
}
public async Task <EditProfileResponse> EditProfile([FromBody] EditProfileRequest request)
{
return(await _service.EditProfile(request));
}
