public void CreateCoAdminUser()
{
Thread.Sleep(2000); // give any user deletes time to happen
const string expectedName = "foo bar";
const string expectedLogin = "******";
var user = new EnterpriseUser
{
Name = expectedName,
Login = expectedLogin,
Status = UserStatus.Inactive,
Role = UserRole.CoAdmin,
};
EnterpriseUser actualUser = Client.CreateUser(user);
try
{
Assert.That(actualUser.Name, Is.EqualTo(expectedName));
Assert.That(actualUser.Login, Is.EqualTo(expectedLogin));
Assert.That(actualUser.Role, Is.EqualTo(UserRole.CoAdmin));
Assert.That(actualUser.Status, Is.EqualTo(UserStatus.Inactive));
}
finally
{
Client.Delete(actualUser, false, true);
}
}
public void ConvertToStandaloneUser()
{
var enterpriseUser = new EnterpriseUser
{
Role = UserRole.User,
Login = "******",
Name = "No Body",
};
EnterpriseUser entUser = null;
try
{
entUser = Client.CreateUser(enterpriseUser);
var standaloneUser = Client.ConvertToStandaloneUser(entUser);
Assert.That(standaloneUser, Is.Not.Null);
Assert.That(standaloneUser.Name, Is.EqualTo(entUser.Name));
Assert.That(standaloneUser.Login, Is.EqualTo(entUser.Login));
}
finally
{
if (entUser != null)
{
Client.Delete(entUser);
}
}
}
public void CannotCreateAdminUser()
{
var enterpriseUser = new EnterpriseUser
{
Role = UserRole.Admin,
Login = "******",
Name = "No Body",
};
Client.CreateUser(enterpriseUser);
}
/// <summary>
/// Updates the settings and information about a user. This method only works for enterprise admins
/// </summary>
/// <param name="onSuccess">Action to perform with the updated user</param>
/// <param name="onFailure">Action to perform following a failed User operation</param>
/// <param name="user">The user with udpated information</param>
/// <returns>A user with the updated information</returns>
public void UpdateUser(Action<EnterpriseUser> onSuccess, Action<Error> onFailure, EnterpriseUser user)
{
var request = _requestHelper.UpdateUser(user);
_restClient.ExecuteAsync(request, onSuccess, onFailure);
}
/// <summary>
/// Moves all of the content from within one user’s folder into a new folder in another user’s account. You can move folders across users as long as the you have administrative permissions.
/// </summary>
/// <param name="onSuccess">Action to perform with the moved folder</param>
/// <param name="onFailure">Action to perform following a failed User operation</param>
/// <param name="currentOwner">The user whose files will be moved</param>
/// <param name="newOwner">The user to whom the files will be moved</param>
/// <param name="notify">Whether to notify the currentOwner that their files are being moved</param>
public void MoveRootFolderToAnotherUser(Action<Folder> onSuccess, Action<Error> onFailure, EnterpriseUser currentOwner, EnterpriseUser newOwner, bool notify = true)
{
GuardFromNull(currentOwner, "currentOwner");
GuardFromNull(newOwner, "newOwner");
MoveRootFolderToAnotherUser(onSuccess, onFailure, currentOwner.Id, newOwner.Id, notify);
}
/// <summary>
/// Updates the settings and information about a user. This method only works for enterprise admins
/// </summary>
/// <param name="user">The user with udpated information</param>
/// <returns>A user with the updated information</returns>
public EnterpriseUser UpdateUser(EnterpriseUser user)
{
var request = _requestHelper.UpdateUser(user);
return _restClient.ExecuteAndDeserialize<EnterpriseUser>(request);
}
/// <summary>
/// Moves all of the content from within one user’s folder into a new folder in another user’s account. You can move folders across users as long as the you have administrative permissions.
/// </summary>
/// <param name="currentOwner">The user whose files will be moved</param>
/// <param name="newOwner">The user to whom the files will be moved</param>
/// <param name="notify">Whether to notify the currentOwner that their files are being moved</param>
/// <returns>The folder as it now exists in the newOwner's Box</returns>
public Folder MoveRootFolderToAnotherUser(EnterpriseUser currentOwner, EnterpriseUser newOwner, bool notify = true)
{
GuardFromNull(currentOwner, "currentOwner");
GuardFromNull(newOwner, "newOwner");
return MoveRootFolderToAnotherUser(currentOwner.Id, newOwner.Id, notify);
}
/// <summary>
/// Add a new email alias for a user
/// </summary>
/// <param name="onSuccess">An action to perform with the updated user</param>
/// <param name="onFailure">An action to perform following a failed User operation </param>
/// <param name="user">The user to alias</param>
/// <param name="alias">The email alias to add </param>
public void AddEmailAlias(Action<EmailAlias> onSuccess, Action<Error> onFailure, EnterpriseUser user, string alias)
{
GuardFromNull(user, "user");
AddEmailAlias(onSuccess, onFailure, user.Id, alias);
}
public void TrackingCodes()
{
const string expectedName = "foo bar";
const string expectedLogin = "******";
var expectedTrackingCodes = new List<TrackingCode>
{
new TrackingCode("Foo", "value1"),
new TrackingCode("Bar", "value2"),
};
var managedUser = new EnterpriseUser
{
Name = expectedName,
Login = expectedLogin,
TrackingCodes = expectedTrackingCodes,
};
EnterpriseUser user = Client.CreateUser(managedUser);
try
{
Assert.That(user.Name, Is.EqualTo(expectedName));
Assert.That(user.Login, Is.EqualTo(expectedLogin));
Assert.That(user.TrackingCodes, Is.EquivalentTo(expectedTrackingCodes));
}
finally
{
Client.Delete(user, false, true);
}
}
/// <summary>
/// Used to provision a new user in an enterprise. This method only works for enterprise admins.
/// </summary>
/// <param name="onSuccess">Action to perform with the created user</param>
/// <param name="onFailure">Action to perform following a failed User operation</param>
/// <param name="user">The properties to set for the new user. Name and Login are required. Warning -- Box tracks a user's space amount in GB, so if you choose to specify the SpaceAmount, it must be at least 1 GB (2^30).</param>
/// <param name="fields">The properties that should be set on the returned User. Type and Id are always set. If left null, all properties will be set, which can increase response time.</param>
/// <returns>The new user</returns>
public void CreateUser(Action<EnterpriseUser> onSuccess, Action<Error> onFailure, EnterpriseUser user, EnterpriseUserField[] fields = null)
{
GuardFromNull(user, "user");
GuardFromNull(user.Name, "user.Name");
GuardFromNull(user.Login, "user.Login");
var request = _requestHelper.CreateUser(user);
_restClient.ExecuteAsync(request, onSuccess, onFailure);
}
/// <summary>
/// Retrieves a single user
/// </summary>
/// <param name="user">The user to retrieve</param>
/// <returns>The requested user</returns>
public EnterpriseUser Get(EnterpriseUser user)
{
GuardFromNull(user, "user");
return GetUser(user.Id);
}
public void UpdateEnterpriseUser()
{
Thread.Sleep(2000); // give any user deletes time to happen
var managedUser = new EnterpriseUser
{
Name = "will change",
Login = "******",
Status = UserStatus.Inactive,
Address = "will change street",
SpaceAmount = -1,
IsExemptFromDeviceLimits = false,
IsExemptFromLoginVerification = false,
IsSyncEnabled = false,
CanSeeManagedUsers = false,
Role = UserRole.User,
};
EnterpriseUser user = Client.CreateUser(managedUser);
const string expectedName = "foo bar";
const string expectedAddress = "some address";
long expectedSpaceAmount = 2*(long) Math.Pow(2, 30); // 2 GB
user.Name = expectedName;
user.Address = expectedAddress;
user.Status = UserStatus.Active;
user.SpaceAmount = expectedSpaceAmount;
user.IsExemptFromDeviceLimits = true;
user.IsExemptFromLoginVerification = true;
user.IsSyncEnabled = true;
user.CanSeeManagedUsers = true;
user.Role = UserRole.CoAdmin;
try
{
EnterpriseUser updatedUser = Client.UpdateUser(user);
Assert.That(updatedUser.Name, Is.EqualTo(expectedName));
Assert.That(updatedUser.Address, Is.EqualTo(expectedAddress));
Assert.That(updatedUser.IsExemptFromDeviceLimits, Is.True);
Assert.That(updatedUser.IsExemptFromLoginVerification, Is.True);
Assert.That(updatedUser.IsSyncEnabled, Is.True);
Assert.That(updatedUser.CanSeeManagedUsers, Is.True);
Assert.That(updatedUser.Role, Is.EqualTo(UserRole.CoAdmin));
Assert.That(updatedUser.SpaceAmount, Is.EqualTo(expectedSpaceAmount));
// Assert.That(updatedUser.Status, Is.EqualTo(UserStatus.Active));
}
finally
{
Client.Delete(user, false, true);
}
}
/// <summary>
/// Delete an email alias for a user
/// </summary>
/// <param name="user">The aliased user</param>
/// <param name="alias">The alias to delete </param>
public void Delete(EnterpriseUser user, EmailAlias alias)
{
GuardFromNull(user, "user");
GuardFromNull(alias, "alias");
DeleteEmailAlias(user.Id, alias.Id);
}
/// <summary>
/// Delete an email alias for a user
/// </summary>
/// <param name="onSuccess">An action to perform following a successful delete</param>
/// <param name="onFailure">An action to perform following a failed User operation </param>
/// <param name="user">The aliased user</param>
/// <param name="alias">The alias to delete</param>
public void Delete(Action onSuccess, Action<Error> onFailure, EnterpriseUser user, EmailAlias alias)
{
GuardFromNull(user, "user");
GuardFromNull(alias, "alias");
DeleteEmailAlias(onSuccess, onFailure, user.Id, alias.Id);
}
/// <summary>
/// Add a new email alias for a user
/// </summary>
/// <param name="user">The user to alias</param>
/// <param name="alias">The email alias to add </param>
/// <returns>The updated user</returns>
public EmailAlias AddEmailAlias(EnterpriseUser user, string alias)
{
GuardFromNull(user, "user");
return AddEmailAlias(user.Id, alias);
}
/// <summary>
/// Deletes a user from an enterprise account
/// </summary>
/// <param name="onSuccess">Action to perform following a successful deletion</param>
/// <param name="onFailure">Action to perform following a failed User operation</param>
/// <param name="user">The user to delete</param>
/// <param name="notify">Whether to notify the user by email that their account has been deleted. Default is to notify them.</param>
/// <param name="force">Whether to force the deletion if the user has items in their Box. Default is to not force the deletion.</param>
/// <exception cref="BoxApi.V2.BoxException">Thrown if the 'force' is false and the user has items in their Box</exception>
public void Delete(Action onSuccess, Action<Error> onFailure, EnterpriseUser user, bool notify = true, bool force = false)
{
GuardFromNull(user, "user");
DeleteUser(onSuccess, onFailure, user.Id, notify, force);
}
/// <summary>
/// Deletes a user from an enterprise account
/// </summary>
/// <param name="user">The user to delete</param>
/// <param name="notify">Whether to notify the user by email that their account has been deleted. Default is to notify them.</param>
/// <param name="force">Whether to force the deletion if the user has items in their Box. Default is to not force the deletion.</param>
/// <exception cref="BoxApi.V2.BoxException">Thrown if the 'force' is false and the user has items in their Box</exception>
public void Delete(EnterpriseUser user, bool notify = true, bool force = false)
{
GuardFromNull(user, "user");
DeleteUser(user.Id, notify, force);
}
/// <summary>
/// Changes the primary login email to one of a user's confirmed aliases
/// </summary>
/// <param name="user">The user to update</param>
/// <param name="login">The new login</param>
/// <returns>The updated user</returns>
public EnterpriseUser ChangePrimaryLogin(EnterpriseUser user, string login)
{
GuardFromNull(user, "user");
return ChangePrimaryLogin(user.Id, login);
}
/// <summary>
/// Rolls a user out of an enterprise and converts them to a standalone free user.
/// </summary>
/// <param name="onSuccess">Action to perform with the standalone user</param>
/// <param name="onFailure">Action to perform following failed conversion</param>
/// <param name="user">The enterprise user to convert</param>
public void ConvertToStandaloneUser(Action<User> onSuccess, Action<Error> onFailure, EnterpriseUser user)
{
var restRequest = _requestHelper.RemoveUserFromEnterprise(user.Id);
_restClient.ExecuteAsync(restRequest, onSuccess, onFailure);
}
public void RequirePasswordReset()
{
var enterpriseUser = new EnterpriseUser
{
Role = UserRole.User,
Login = "******",
Name = "No Body",
};
EnterpriseUser entUser = null;
try
{
entUser = Client.CreateUser(enterpriseUser);
Assert.That(entUser.IsPasswordResetRequired, Is.False);
entUser.IsPasswordResetRequired = true;
var updated = Client.UpdateUser(entUser);
Assert.That(updated.IsPasswordResetRequired, Is.True);
// Once set, this can't be unset.
updated.IsPasswordResetRequired = false;
updated = Client.UpdateUser(updated);
Assert.That(updated.IsPasswordResetRequired, Is.True);
}
finally
{
if (entUser != null)
{
Client.Delete(entUser);
}
}
}
/// <summary>
/// converts them to a standalone free user.
/// </summary>
/// <param name="user">The enterprise user to convert</param>
/// <returns>The standalone user</returns>
public User ConvertToStandaloneUser(EnterpriseUser user)
{
var restRequest = _requestHelper.RemoveUserFromEnterprise(user.Id);
return _restClient.ExecuteAndDeserialize<User>(restRequest);
}
/// <summary>
/// Retrieves a single user
/// </summary>
/// <param name="onSuccess">Action to perform with the retrieved user</param>
/// <param name="onFailure">Action to perform following a failed User operation</param>
/// <param name="user">The user to retrieve</param>
public void Get(Action<EnterpriseUser> onSuccess, Action<Error> onFailure, EnterpriseUser user)
{
GuardFromNull(user, "user");
GetUser(onSuccess, onFailure, user.Id);
}
/// <summary>
/// Used to provision a new user in an enterprise. This method only works for enterprise admins.
/// </summary>
/// <param name="user">The properties to set for the new user. Name and Login are required. Warning -- Box tracks a user's space amount in GB, so if you choose to specify the SpaceAmount, it must be at least 1 GB (2^30).</param>
/// <returns>The new user</returns>
public EnterpriseUser CreateUser(EnterpriseUser user)
{
GuardFromNull(user, "user");
GuardFromNull(user.Name, "user.Name");
GuardFromNull(user.Login, "user.Login");
var request = _requestHelper.CreateUser(user);
return _restClient.ExecuteAndDeserialize<EnterpriseUser>(request);
}
/// <summary>
/// Retrieves the email aliases for a user
/// </summary>
/// <param name="user">The user for whom to retrieve the email aliases</param>
/// <returns>A collection of email aliases</returns>
public EmailAliasCollection GetEmailAliases(EnterpriseUser user)
{
GuardFromNull(user, "user");
return GetEmailAliases(user.Id);
}
/// <summary>
/// Retrieves the email aliases for a user
/// </summary>
/// <param name="onSuccess">An action to perfrom with the email aliases</param>
/// <param name="onFailure">An action to perform following a failed User operation</param>
/// <param name="user">The user for whom to retrieve the email aliases</param>
public void GetEmailAliases(Action<EmailAliasCollection> onSuccess, Action<Error> onFailure, EnterpriseUser user)
{
GuardFromNull(user, "user");
GetEmailAliases(onSuccess, onFailure, user.Id);
}
public void CreateEnterpriseUser()
{
Thread.Sleep(2000); // give any user deletes time to happen
const string expectedName = "foo bar";
const string expectedLogin = "******";
const string expectedAddress = "some address";
long expectedSpaceAmount = 2*(long) Math.Pow(2, 30); // 2 GB
var user = new EnterpriseUser
{
Name = expectedName,
Login = expectedLogin,
Status = UserStatus.Active,
Address = expectedAddress,
SpaceAmount = expectedSpaceAmount,
};
EnterpriseUser actualUser = Client.CreateUser(user);
try
{
Assert.That(actualUser.Name, Is.EqualTo(expectedName));
Assert.That(actualUser.Address, Is.EqualTo(expectedAddress));
Assert.That(actualUser.Login, Is.EqualTo(expectedLogin));
Assert.That(actualUser.Role, Is.EqualTo(UserRole.User));
Assert.That(actualUser.Status, Is.EqualTo(UserStatus.Active));
Assert.That(actualUser.SpaceAmount, Is.EqualTo(expectedSpaceAmount));
Assert.That(actualUser.SpaceUsed, Is.EqualTo(0));
}
finally
{
Client.Delete(actualUser, false, true);
}
}
/// <summary>
/// Changes the primary login email to one of a user's confirmed aliases
/// </summary>
/// <param name="onSuccess">An action to perform with the updated user</param>
/// <param name="onFailure">An action to perform following a failed User operation</param>
/// <param name="user">The user to update</param>
/// <param name="login">The new login</param>
public void ChangePrimaryLogin(Action<EnterpriseUser> onSuccess, Action<Error> onFailure, EnterpriseUser user, string login)
{
GuardFromNull(user, "user");
ChangePrimaryLogin(onSuccess, onFailure, user.Id, login);
}
