public async Task <IActionResult> UpdateProfile(UpdateProfileRequestModel updateProfileRequest)
{
var userId = User.GetId();
await _profileService.UpdateProfileAsync(userId, updateProfileRequest);
return(Ok());
}
public async Task UpdateProfileAsync(int userId, UpdateProfileRequestModel updateProfileRequest)
{
var user = await _userRepository.GetById(userId);
user.DisplayName = updateProfileRequest.DisplayName;
_userRepository.Update(user);
}
public async Task <ProfileResponseModel> PutProfile([FromBody] UpdateProfileRequestModel model)
{
await _userService.SaveUserAsync(model.ToUser(_currentContext.User));
var response = new ProfileResponseModel(_currentContext.User);
return(response);
}
public async Task <ProfileResponseModel> PutProfile([FromBody] UpdateProfileRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
await _userService.SaveUserAsync(model.ToUser(user));
var response = new ProfileResponseModel(user, null);
return(response);
}
public ValidationResult UpdateProfile([FromBody] UpdateProfileRequestModel requestModel)
{
var result = new ValidationResult();
var user = Context.Users.FirstOrDefault(r => r.Username.ToUpper() == requestModel.Username.ToUpper());
if (user == null)
{
result.InValidate("", "Username does not exist.");
return(result);
}
if (string.IsNullOrEmpty(requestModel.FirstName))
{
result.InValidate("firstName", "First name required.");
}
if (string.IsNullOrEmpty(requestModel.LastName))
{
result.InValidate("lastName", "Last name required.");
}
if (string.IsNullOrEmpty(requestModel.EmailAddress))
{
result.InValidate("emailAddress", "Email address required.");
}
if (!string.IsNullOrEmpty(requestModel.NewPassword) && requestModel.NewPassword.ToUpper() != requestModel.ConfirmPassword.ToUpper())
{
result.InValidate("password", "New and confirm password do not match.");
}
if (result.IsValid)
{
user.UpdateDate = DateTime.Now;
user.UpdateUser = user.Username;
user.FirstName = requestModel.FirstName;
user.LastName = requestModel.LastName;
user.EmailAddress = requestModel.EmailAddress;
if (!string.IsNullOrEmpty(requestModel.NewPassword))
{
var salt = Context.Salts.First(s => s.Active == true).Value;
user.Password = SecurityHelper.SaltedHashAlgorithm(requestModel.NewPassword, salt);
}
Context.SaveChanges();
}
return(result);
}
public async Task <ProfileResponseModel> PutProfile([FromBody] UpdateProfileRequestModel model)
{
var user = await _userService.GetUserByPrincipalAsync(User);
if (user == null)
{
throw new UnauthorizedAccessException();
}
await _userService.SaveUserAsync(model.ToUser(user));
var response = new ProfileResponseModel(user, null, null, null, await _userService.TwoFactorIsEnabledAsync(user));
return(response);
}
public async Task <ActionResult> Update(UpdateProfileRequestModel model)
{
var result = await this.profiles.Update(
model.Id,
model.Name,
model.MainPhotoUrl,
model.Biography,
model.Gender);
if (result.Failure)
{
return(BadRequest(result.Error));
}
return(Ok());
}
public ProfileResultModel UpdateProfile(UpdateProfileRequestModel param)
{
ProfileResultModel result = new ProfileResultModel();
try
{
int?memberId = IdentityHelper.GetMemberId();
if (!memberId.HasValue)
{
throw new OrgException("Invalid MemberId");
}
MemberBL bl = new MemberBL();
var member = bl.UpdateProfile(memberId.Value, new UpdateMemberModel
{
Email = param.Email,
FirstName = param.FirstName,
LastName = param.LastName,
NickName = param.NickName,
Gender = param.Gender,
Photo = param.Photo
});
result.Status = true;
result.Message = "Updated profile successfully.";
result.Member = member;
}
catch (OrgException oex)
{
result.Status = false;
result.Message = oex.Message;
}
catch (Exception ex)
{
result.Status = false;
result.Message = AppConfigs.InternalErrorMessage;
if (AppConfigs.DebugInternalMessage)
{
result.InternalMessage = ex.Message;
}
}
return(result);
}
public async Task <ActionResult> Update(UpdateProfileRequestModel model)
{
var userId = this.currentUser.GetId();
var result = await this.profileService.Update(
userId,
model.FirstName,
model.LastName,
model.DisplayName,
model.Location,
model.Biography);
if (result.Failure)
{
return(this.BadRequest(result.Error));
}
return(this.Ok());
}
public Profile ConvertToProfile(UpdateProfileRequestModel requestModel)
{
Profile result = new Profile {
Id = requestModel.ProfileId,
IsActive = true,
Name = requestModel.Name,
Monday = requestModel.Monday,
Tuesday = requestModel.Tuesday,
Wednesday = requestModel.Wednesday,
Thursday = requestModel.Thursday,
Friday = requestModel.Friday,
Saturday = requestModel.Saturday,
Sunday = requestModel.Sunday,
StartHour = requestModel.StartHour,
StartMinute = requestModel.StartMinute
};
return(result);
}
public async Task <ActionResult> Update(UpdateProfileRequestModel model)
{
var userId = this.currentUser.GetId();
var result = await this.profiles.Update(
userId,
model.Email,
model.UserName,
model.FurstName,
model.LastName,
model.MainPhotoUrl,
model.IsPrivate);
if (result.Failure)
{
return(BadRequest(result.Error));
}
return(Ok());
}
/// <summary>
/// To Call Save Profile Details Api..
/// </summary>
/// <param name="request"></param>
/// <param name="success"></param>
/// <param name="failed"></param>
/// <returns></returns>
public async Task <ResendTokenResponseModel> ProfileSaveApi(UpdateProfileRequestModel request, Action <object> success, Action <object> failed)
{
ResendTokenResponseModel resmodel = new ResendTokenResponseModel();
try
{
var url = string.Format("{0}/api/appconnect/ProfileSave", WebServiceDetails.BasUri);
string randomGuid = Guid.NewGuid().ToString();
var dic = new Dictionary <string, string>();
dic.Add("randomguid", randomGuid);
dic.Add("hash", randomGuid + WebServiceDetails.AppKey + request.profiletoken + Helpers.LocalStorage.GeneralSecretkey
+ request.displayname + request.emailaddress);
var result = await _apiProvider.Post <ResendTokenResponseModel, UpdateProfileRequestModel>(url, request, dic);
var response = result.RawResult;
resmodel = JsonConvert.DeserializeObject <ResendTokenResponseModel>(response);
if (result.IsSuccessful == true)
{
if (resmodel.responsecode == 100)
{
success.Invoke(resmodel);
}
else
{
failed.Invoke(resmodel);
}
}
else
{
failed.Invoke(resmodel);
}
}
catch (Exception exception)
{
UserDialogs.Instance.HideLoading();
}
return(resmodel);
}
public async Task <ActionResult> Update(UpdateProfileRequestModel model)
{
var userId = this.currentUser.GetId();
var updated = await this.profiles.Update(
userId,
model.Email,
model.UserName,
model.Name,
model.MainPhotoUrl,
model.WebSite,
model.Biography,
model.Gender,
model.IsPrivate);
if (updated.Failure)
{
return(BadRequest(updated.Error));
}
return(Ok());
}
public ProfileResponseModel Update(UpdateProfileRequestModel requestModel)
{
Profile profileItem = ModelBinder.Instance.ConvertToProfile(requestModel);
profileItem = _profileService.Update(profileItem);
IEnumerable <ProfileGroupMapping> existedMappings = _profileGroupMappingService.GetListByGroup(profileItem.Id);
// delete mapping
foreach (ProfileGroupMapping item in existedMappings)
{
if (!requestModel.GroupIdList.Contains(item.GroupId))
{
_profileGroupMappingService.Delete(item.Id);
}
}
// insert mapping
IEnumerable <Group> latesGroups = _groupService.GetListByIds(requestModel.GroupIdList.ToList());
IEnumerable <long> mappedGroupIds = existedMappings.Select(x => x.ProfileId);
foreach (Group item in latesGroups)
{
if (!mappedGroupIds.Contains(item.Id))
{
_profileGroupMappingService.Insert(
new ProfileGroupMapping {
IsActive = true,
ProfileId = profileItem.Id,
GroupId = item.Id
});
}
}
ProfileResponseModel resultModel = ModelBinder.Instance.ConvertToProfileResponseModel(profileItem, latesGroups);
return(resultModel);
}
public ActionResult <ProfileResponseModel> Put([FromBody] UpdateProfileRequestModel requestModel)
{
ProfileResponseModel result = _procedure.Update(requestModel);
return(result);
}
public JsonResult SaveProfile(UpdateProfileRequestModel inputModel)
{
return(Json(WebApiCaller.PostAsync <ValidationResult>("WebApi:Authenticate:SaveProfile", inputModel)));
}
