public ActionResult UpdateUser([FromBody] UpdateUserData data)
{
try
{
var quser = QuantApp.Kernel.User.FindUser(data.UserID);
if (quser == null)
{
return(BadRequest(new { Data = "User not found" }));
}
if (!string.IsNullOrWhiteSpace(data.FirstName))
{
quser.FirstName = data.FirstName;
}
if (!string.IsNullOrWhiteSpace(data.LastName))
{
quser.LastName = data.LastName;
}
if (!string.IsNullOrWhiteSpace(data.MetaData))
{
quser.MetaData = data.MetaData;
}
return(Ok(new { Data = "ok" }));
}
catch
{
return(BadRequest(new { Data = "error" }));
}
}
public void Update(UpdateUserData model, IValidationErrors errors)
{
if (!model.Validate(errors))
{
return;
}
var user = UnitOfWork.Users.Include(x => x.UserModules).FirstOrDefault(x => x.Id == model.UserId);
if (user == null)
{
throw new Exception("User not found");
}
model.MapTo(user);
foreach (var userModule in user.UserModules)
{
var modelUserModule = model.Modules.FirstOrDefault(x => x.Id == userModule.ModuleId);
if (modelUserModule == null)
{
continue;
}
if (modelUserModule.Permission == userModule.Permission)
{
continue;
}
modelUserModule.MapTo(userModule);
}
UnitOfWork.SaveChanges();
}
public void Put_Always_SetsModuleGrantrIdToCurrentUser()
{
const string currentUserId = "currentUserId";
var mockUserService = A.Fake <IUserService>();
A.CallTo(() => mockUserService.GetByName(A <string> ._)).Returns(new User()
{
Id = currentUserId
});
var controller = CreateController(mockUserService);
var model = new UpdateUserData();
model.Modules.Add(new UpdateUserData.UserModule()
{
GranterId = "fake"
});
Helper.Suppress(() => controller.Put("", model));
A.CallTo(() => mockUserService.Update(A <UpdateUserData> ._, A <IValidationErrors> ._)).WhenArgumentsMatch(
(x) =>
{
var mdl = x.Get <UpdateUserData>(0);
return(mdl.Modules.Any(y => y.GranterId != currentUserId));
});
}
public async Task <IActionResult> UpdateUserAsync(int id, [FromBody] UpdateUserData command)
{
if (id != AccountID)
{
return(Forbid());
}
await _userService.UpdateAsync(id, command);
return(NoContent());
}
public static void UpdateUserDataItem(UserDataUpdateRequest model)
{
DataProvider.ExecuteNonQuery(GetConnection, "dbo.UserData_Update"
, inputParamMapper : delegate(SqlParameterCollection UpdateUserData)
{
UpdateUserData.AddWithValue("@Id", model.Id);
UpdateUserData.AddWithValue("@FirstName", model.FirstName);
UpdateUserData.AddWithValue("@LastName", model.LastName);
UpdateUserData.AddWithValue("@PhoneNumber", model.PhoneNumber);
});
}
void Awake()
{
if (_instance == null)
{
_instance = this;
}
else if (_instance != this)
{
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
}
public UpdateUserResponse UpdateUser(UpdateUserData data)
{
UpdateUserRequest request = new UpdateUserRequest
{
UserNr = GetUserAuthenticationData().UserNr,
Email = data.Email
};
UpdateUserResponse response = _client.UpdateUser(request);
return(response);
}
/// <summary>
/// 修改密码按钮事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void updateUserButton_Click(object sender, EventArgs e)
{
lockButton();
string oldPassword = oldPasswordBox.Text.Trim();
string newPassword = newPasswordBox.Text.Trim();
//输入密码格式错误
if (!UserUitls.IsOkPassword(oldPassword) || !UserUitls.IsOkPassword(newPassword))
{
addAlter(EnumExtend.GetDisplayText(LoginEnum.ERRORPWD), CxFlatAlertBox.AlertType.Error);
unlockButton();
}
//发送HTTP请求访问服务器
try
{
User user = new User();
user.username = LoginInfo.CurrentUser.data.user.username;
user.password = oldPassword;
UpdateUserData updateUserData = new UpdateUserData();
updateUserData.user = user;
updateUserData.newPassword = newPassword;
SessionData <UpdateUserData> sessionData = new SessionData <UpdateUserData>();
sessionData.sessionId = LoginInfo.CurrentUser.sessionId;
sessionData.data = updateUserData;
string url = Resources.Server + Resources.UpdateUserUrl;
string data = JsonConvert.SerializeObject(sessionData);
string response = HttpUitls.POST(url, data);
OkeResult <string> okeResult = JsonConvert.DeserializeObject <OkeResult <string> >(response);
if (okeResult.success)
{
addAlter(EnumExtend.GetDisplayText(LoginEnum.SUCC_UPDATE), CxFlatAlertBox.AlertType.Success);
timer.Stop();
timer.Tick += formClose_Tick;
timer.Start();
}
else
{
addAlter(okeResult.error, CxFlatAlertBox.AlertType.Error);
unlockButton();
}
}
catch (Exception)
{
addAlter(Resources.ExceptionTip, CxFlatAlertBox.AlertType.Error);
unlockButton();
}
return;
}
internal Result UpdateUser(string customerId, string userId, UpdateUserParams data)
{
var loggerManager = new LoggerManager();
var operationGuid = Guid.NewGuid().ToString();
try
{
loggerManager.InsertLogoRecord(nameof(UpdateUser), nameof(LogLevel.Info), null, data.TransactionId, JsonConvert.SerializeObject(data));
var orderDemandManager = new OrderDemandManager();
var updateUser = new UpdateUserData
{
Address = data.Address,
OrderDemandGuid = operationGuid,
ContactInfo = data.ContactInfo,
ExternalId = userId,
Email = data.Email,
FirstName = data.FirstName,
LastName = data.LastName
};
var validator = new UpdateUserValidator();
var valResults = validator.Validate(updateUser);
var validationSucceeded = valResults.IsValid;
if (!validationSucceeded)
{
var failures = valResults.Errors;
var message = failures.Aggregate(string.Empty, (current, failure) => current + (failure.ErrorMessage + "<br />"));
return(new Result {
IsCompleted = false, Success = false, Message = message
});
}
orderDemandManager.SaveOrderDemand(null, operationGuid, 0, (int)ProvisionType.UpdateUser, (int)OrderDemandStates.Created, (int)OrderDemandType.Integrated, JsonConvert.SerializeObject(updateUser), data.TransactionId);
return(new Result {
IsCompleted = false, Success = true
});
}
catch (Exception ex)
{
loggerManager.InsertLogoRecord(nameof(UpdateUser), nameof(LogLevel.Error), ex.Message + " " + ex.StackTrace, operationGuid, JsonConvert.SerializeObject(data));
return(new Result {
IsCompleted = true, Success = false, Message = ex.Message
});
};
}
public void UpdateUser(UpdateUserData data)
{
using (var context = Context)
{
var user = context.Users.FirstOrDefault(u => u.ExternalId == data.ExternalId);
user.Address = data.Address;
user.ContactInfo = data.ContactInfo;
user.Email = data.Email;
user.ExternalId = data.ExternalId;
user.FirstName = data.FirstName;
user.LastName = data.LastName;
user.LastChangeDate = DateTime.Now;
context.Users.Update(user);
context.SaveChanges();
}
}
public async Task UpdateAsync(int id, UpdateUserData command)
{
if (await _context.Users.ExistsInDatabaseAsync(id) == false)
{
throw new CorruptedOperationException("User doesn't exist.");
}
var loginHash = _hashManager.CalculateDataHash(command.Login);
var emailHash = _hashManager.CalculateDataHash(command.UserEmail);
var user = await _context.Users.GetById(id).SingleOrDefaultAsync();
user.Update(loginHash, emailHash);
_context.Users.Update(user);
await _context.SaveChangesAsync();
}
public async Task <UserDto> UpdateUser(long userId, UpdateUserData userData)
{
await using var tmp = await connectionController.OpenConnectionAsync();
var user = await repo.GetUser(userId);
if (user.Email != userData.Email)
{
user.EmailVerified = false;
}
userData.MapTo(user, mapper);
user = await repo.UpdateUser(user);
return(user.ToDto(mapper));
}
public IHttpActionResult Put(string id, [FromBody] UpdateUserData model)
{
model.UserId = id;
foreach (var module in model.Modules)
{
module.GranterId = User.Identity.GetUserId();
}
var errors = new List <string>();
UserService.Update(model, new ValidationErrors(errors));
if (errors.Count != 0)
{
return(new ServiceErrorsResult(errors));
}
else
{
return(this.StatusCode(HttpStatusCode.NoContent));
}
}
public override void DoJob(dynamic data)
{
var operationGuid = string.Empty;
try
{
UpdateUserData json = JsonConvert.DeserializeObject <UpdateUserData>(data);
operationGuid = json.OrderDemandGuid;
_userRepository.UpdateUser(json);
_orderDemandRepository.ChangeOrderDemandState(operationGuid, (int)OrderDemandStates.Finished);
}
catch (Exception ex)
{
_orderDemandRepository.ChangeOrderDemandState(operationGuid, (int)OrderDemandStates.FinishedError);
_logRepository.InsertLogoRecord(nameof(Create), nameof(LogLevel.Error), ex.Message + " " + ex.StackTrace, operationGuid, data);
}
}
public async Task <IActionResult> UpdateUser(string userId, UpdateUserData data)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
user.FirstName = data.FirstName;
user.LastName = data.LastName;
user.BirthDate = data.BirthDate;
await userManager.UpdateAsync(user);
return(Ok(new
{
UserId = user.Id,
user.Email,
user.FirstName,
user.LastName,
user.BirthDate,
}));
}
public async Task <ActionResult <UserDto> > UpdateAccount(
[FromBody]
UpdateUserData updateData)
{
return(await usersSvc.UpdateUser(User.GetId(), updateData));
}
