public void TestUpdateUser()
{
var newEmailAddress = $"updated+{m_timestampSuffix}@cloudinary.com";
const string newName = "updated";
var updateUserParams = new UpdateUserParams(m_userId1)
{
Email = newEmailAddress,
Name = newName
};
var updateUserResult = AccountProvisioning.UpdateUser(updateUserParams);
Assert.AreEqual(newName, updateUserResult.Name);
Assert.AreEqual(newEmailAddress, updateUserResult.Email);
var getUserResult = AccountProvisioning.User(m_userId1);
Assert.AreEqual(m_userId1, getUserResult.Id);
Assert.AreEqual(newEmailAddress, getUserResult.Email);
var listUsersResult = AccountProvisioning.Users(new ListUsersParams());
var foundUser = listUsersResult.Users.FirstOrDefault(user => user.Id == m_userId1);
Assert.NotNull(foundUser);
Assert.AreEqual(newEmailAddress, foundUser.Email);
}
public void TestUpdateUserParamsCheck()
{
var parameters = new UpdateUserParams(TestId);
parameters.UserId = string.Empty;
AssertCheck(parameters, "UserId must not be empty");
}
public async Task TestUpdateUser()
{
var newEmailAddress = $"updated-async+{m_timestampSuffix}@cloudinary.com";
const string newName = "updated-async";
var updateUserParams = new UpdateUserParams(m_userId1)
{
Email = newEmailAddress,
Name = newName,
SubAccountIds = new List <string> {
m_cloudId1, m_cloudId2
}
};
var updateUserResult = await AccountProvisioning.UpdateUserAsync(updateUserParams);
Assert.AreEqual(newName, updateUserResult.Name);
Assert.AreEqual(newEmailAddress, updateUserResult.Email);
Assert.AreEqual(2, updateUserResult.SubAccountIds.Length);
Assert.That(new[] { m_cloudId1, m_cloudId2 }, Is.EquivalentTo(updateUserResult.SubAccountIds));
var getUserResult = await AccountProvisioning.UserAsync(m_userId1);
Assert.AreEqual(m_userId1, getUserResult.Id);
Assert.AreEqual(newEmailAddress, getUserResult.Email);
var listUsersResult = await AccountProvisioning.UsersAsync(new ListUsersParams());
var foundUser = listUsersResult.Users.FirstOrDefault(user => user.Id == m_userId1);
Assert.NotNull(foundUser);
Assert.AreEqual(newEmailAddress, foundUser.Email);
}
public void UpdateUser(UpdateUserParams param)
{
var user = UserManager.FindByName(param.userName);
AssertAccessRights(user.client_id);
user.Update(ApplicationUser, param);
var identityResult = UserManager.Update(user);
//--in client users keine anpassung der userauth!
//var identityResult = user.UpdateUserAuth(ApplicationUser, param, rolesOfUserGroup, UserManager, RoleManager);
//return identityResult;
}
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 TestUpdateUserParamsDictionary()
{
var parameters = new UpdateUserParams(TestId)
{
Name = TestName,
Email = Email,
Role = Role,
SubAccountIds = idList
};
Assert.DoesNotThrow(() => parameters.Check());
var dictionary = parameters.ToParamsDictionary();
Assert.AreEqual(TestName, dictionary["name"]);
Assert.AreEqual(Email, dictionary["email"]);
Assert.AreEqual("admin", dictionary["role"]);
Assert.AreEqual(idList, dictionary["sub_account_ids"]);
}
public IdentityResult UpdateUser(UpdateUserParams param)
{
var user = UserManager.FindByName(param.userName);
AssertAccessRights(user.client_id);
user.Update(ApplicationUser, param);
var identityResult = UserManager.Update(user);
//--------------
if (identityResult.Succeeded)
{
var userGroups = uow.UserGroup.GetSelectForClient(ApplicationUserClient_Id).Where(ug => param.userGroupIds.Contains(ug.id));
identityResult = user.UpdateUserAuth(ApplicationUser, userGroups, UserManager);
if (identityResult.Succeeded)
{
identityResult = UserManager.Update(user);
}
}
return(identityResult);
}
public async Task <Result> UpdateUserAsync(string customerId, string userId, UpdateUserParams data)
{
try
{
var user = await _dataService.UserService.ExternalGetAsync(userId);
user.FirstName = data.FirstName;
user.LastName = data.LastName;
user.Address = data.Address;
user.Email = data.Email;
user.ContactInfo = data.ContactInfo;
_dataService.UserService.Update(user);
await _dataService.SaveChangesAsync();
return(new Result(true, null));
}
catch (Exception ex)
{
await _dataService.LogDataService.InsertLogoRecordAsync(nameof(UpdateUserAsync), nameof(Enums.LogLevel.Error), ex.Message, data.TransactionId, JsonConvert.SerializeObject(data));
return(new Result(false, ex.Message));
}
}
/// <summary>
/// Updates the details of the specified user asynchronously.
/// </summary>
/// <param name="parameters">Parameters to update user.</param>
/// <param name="cancellationToken">(Optional) Cancellation token.</param>
/// <returns>Parsed information about updated user.</returns>
public Task <UserResult> UpdateUserAsync(UpdateUserParams parameters, CancellationToken?cancellationToken = null)
{
var url = GetUsersUrl(parameters.UserId);
return(CallAccountApiAsync <UserResult>(HttpMethod.PUT, url, cancellationToken, parameters));
}
/// <summary>
/// Updates the details of the specified user.
/// </summary>
/// <param name="parameters">Parameters to update user.</param>
/// <returns>Parsed information about updated user.</returns>
public UserResult UpdateUser(UpdateUserParams parameters)
{
var url = GetUsersUrl(parameters.UserId);
return(CallAccountApi <UserResult>(HttpMethod.PUT, url, parameters));
}
