public async Task GetFolderCollaborators_ValidResponse_ValidCollaborators()
{
/*** Arrange ***/
_handler.Setup(h => h.ExecuteAsync <BoxCollection <BoxCollaboration> >(It.IsAny <IBoxRequest>()))
.Returns(() => Task.FromResult <IBoxResponse <BoxCollection <BoxCollaboration> > >(new BoxResponse <BoxCollection <BoxCollaboration> >()
{
Status = ResponseStatus.Success,
ContentString = "{ \"total_count\": 1, \"entries\": [ { \"type\": \"collaboration\", \"id\": \"14176246\", \"created_by\": { \"type\": \"user\", \"id\": \"4276790\", \"name\": \"David Lee\", \"login\": \"[email protected]\" }, \"created_at\": \"2011-11-29T12:56:35-08:00\", \"modified_at\": \"2012-09-11T15:12:32-07:00\", \"expires_at\": null, \"status\": \"accepted\", \"accessible_by\": { \"type\": \"user\", \"id\": \"755492\", \"name\": \"Simon Tan\", \"login\": \"[email protected]\" }, \"role\": \"editor\", \"acknowledged_at\": \"2011-11-29T12:59:40-08:00\", \"item\": null } ] }"
}));
/*** Act ***/
BoxCollection <BoxCollaboration> c = await _foldersManager.GetCollaborationsAsync("fakeId");
BoxCollaboration collab = c.Entries.FirstOrDefault();
/*** Assert ***/
Assert.AreEqual(1, c.TotalCount);
Assert.AreEqual("collaboration", collab.Type);
Assert.AreEqual("14176246", collab.Id);
Assert.AreEqual("David Lee", collab.CreatedBy.Name);
Assert.AreEqual("*****@*****.**", collab.CreatedBy.Login);
var user = collab.AccessibleBy as BoxUser;
Assert.AreEqual("Simon Tan", user.Name);
Assert.AreEqual("*****@*****.**", user.Login);
}
public async Task EditCollaboration_ValidResponse_ValidCollaboration()
{
/*** Arrange ***/
string responseString = "{\"type\":\"collaboration\",\"id\":\"791293\",\"created_by\":{\"type\":\"user\",\"id\":\"17738362\",\"name\":\"sean rose\",\"login\":\"[email protected]\"},\"created_at\":\"2012-12-12T10:54:37-08:00\",\"modified_at\":\"2012-12-12T11:30:43-08:00\",\"expires_at\":null,\"status\":\"accepted\",\"accessible_by\":{\"type\":\"user\",\"id\":\"18203124\",\"name\":\"sean\",\"login\":\"[email protected]\"},\"role\":\"viewer\",\"acknowledged_at\":\"2012-12-12T11:30:43-08:00\",\"item\":{\"type\":\"folder\",\"id\":\"11446500\",\"sequence_id\":\"0\",\"etag\":\"0\",\"name\":\"Shared Pictures\"}}";
Handler.Setup(h => h.ExecuteAsync <BoxCollaboration>(It.IsAny <IBoxRequest>()))
.Returns(Task.FromResult <IBoxResponse <BoxCollaboration> >(new BoxResponse <BoxCollaboration>()
{
Status = ResponseStatus.Success,
ContentString = responseString
}));
/*** Act ***/
BoxCollaborationRequest request = new BoxCollaborationRequest()
{
Id = "fakeId"
};
BoxCollaboration collab = await _collaborationsManager.EditCollaborationAsync(request);
/*** Assert ***/
Assert.AreEqual("791293", collab.Id);
Assert.AreEqual("collaboration", collab.Type);
Assert.AreEqual("user", collab.CreatedBy.Type);
Assert.AreEqual("17738362", collab.CreatedBy.Id);
Assert.AreEqual("*****@*****.**", collab.CreatedBy.Login);
}
public async Task CollaborationsOnFolderWorkflow_LiveSession_ValidResponse()
{
const string folderId = "1927307787";
// Add Collaboration
BoxCollaborationRequest addRequest = new BoxCollaborationRequest()
{
Item = new BoxRequestEntity()
{
Id = folderId,
Type = BoxType.folder
},
AccessibleBy = new BoxCollaborationUserRequest()
{
Login = "******"
},
Role = "viewer"
};
BoxCollaboration collab = await _client.CollaborationsManager.AddCollaborationAsync(addRequest, notify : false);
Assert.AreEqual(folderId, collab.Item.Id, "Folder and collaboration folder id do not match");
Assert.AreEqual(BoxCollaborationRoles.Viewer, collab.Role, "Incorrect collaboration role");
// Edit Collaboration
BoxCollaborationRequest editRequest = new BoxCollaborationRequest()
{
Id = collab.Id,
Role = BoxCollaborationRoles.Editor,
CanViewPath = true
};
BoxCollaboration editCollab = await _client.CollaborationsManager.EditCollaborationAsync(editRequest);
Assert.AreEqual(collab.Id, editCollab.Id, "Id of original collaboration and updated collaboration do not match");
Assert.AreEqual(BoxCollaborationRoles.Editor, editCollab.Role, "Incorrect updated role");
// get existing collaboration
var existingCollab = await _client.CollaborationsManager.GetCollaborationAsync(collab.Id, fields : new List <string>()
{
"can_view_path"
});
Assert.IsTrue(existingCollab.CanViewPath.Value, "failed to retrieve existing collab with specific fields");
// test getting list of collaborations on folder
var collabs = await _client.FoldersManager.GetCollaborationsAsync(folderId);
Assert.AreEqual(4, collabs.Entries.Count, "Failed to get correct number of folder collabs.");
// Test Remove Collaboration
bool success = await _client.CollaborationsManager.RemoveCollaborationAsync(collab.Id);
Assert.IsTrue(success, "Collaboration deletion was unsucessful");
}
protected virtual void PrintCollaboration(BoxCollaboration c, bool json = false)
{
if (json)
{
this.OutputJson(c);
return;
}
else
{
this.PrintCollaboration(c);
}
}
public async Task CollaborationsOnFileWorkflow_LiveSession_ValidResponse()
{
const string fileId = "100699285359";
// Add Collaboration
BoxCollaborationRequest addRequest = new BoxCollaborationRequest()
{
Item = new BoxRequestEntity()
{
Id = fileId,
Type = BoxType.file
},
AccessibleBy = new BoxCollaborationUserRequest()
{
Login = "******"
},
Role = "viewer"
};
BoxCollaboration collab = await _client.CollaborationsManager.AddCollaborationAsync(addRequest, notify : false);
Assert.AreEqual(fileId, collab.Item.Id, "File and collaboration file id do not match");
Assert.AreEqual(BoxCollaborationRoles.Viewer, collab.Role, "Incorrect collaboration role");
// TODO: Edit Collaboration
BoxCollaborationRequest editRequest = new BoxCollaborationRequest()
{
Id = collab.Id,
Role = BoxCollaborationRoles.Editor
};
BoxCollaboration editCollab = await _client.CollaborationsManager.EditCollaborationAsync(editRequest);
Assert.AreEqual(collab.Id, editCollab.Id, "Id of original collaboration and updated collaboration do not match");
Assert.AreEqual(BoxCollaborationRoles.Editor, editCollab.Role, "Incorrect updated role");
// get existing collaboration
var existingCollab = await _client.CollaborationsManager.GetCollaborationAsync(collab.Id);
Assert.IsTrue(existingCollab.Item.Id == fileId, "failed to retrieve existing collab");
// test getting list of collaborations on file
var collabs = await _client.FilesManager.GetCollaborationsAsync(fileId);
Assert.AreEqual(4, collabs.Entries.Count, "Failed to get correct number of file collabs.");
// Test Remove Collaboration
bool success = await _client.CollaborationsManager.RemoveCollaborationAsync(collab.Id);
Assert.IsTrue(success, "Collaboration deletion was unsucessful");
}
protected virtual void PrintCollaboration(BoxCollaboration c)
{
Reporter.WriteInformation($"Collaboration ID: {c.Id}");
if (c.Item != null)
{
Reporter.WriteInformation("Collaboration Item: ");
this.PrintItem(c.Item);
}
Reporter.WriteInformation($"Collaboration Role: {c.Role}");
Reporter.WriteInformation($"Collaboration Status: {c.Status}");
if (c.CreatedBy != null)
{
Reporter.WriteInformation("Created by: ");
this.PrintMiniUser(c.CreatedBy);
}
}
public async Task CollaborationsWorkflow_LiveSession_ValidResponse()
{
const string folderId = "1927307787";
// Add Collaboration
BoxCollaborationRequest addRequest = new BoxCollaborationRequest()
{
Item = new BoxRequestEntity()
{
Id = folderId,
Type = BoxType.folder
},
AccessibleBy = new BoxCollaborationUserRequest()
{
Login = "******"
},
Role = "viewer"
};
BoxCollaboration collab = await _client.CollaborationsManager.AddCollaborationAsync(addRequest, notify : false);
Assert.AreEqual(folderId, collab.Item.Id, "Folder and collaboration folder id do not match");
Assert.AreEqual(BoxCollaborationRoles.Viewer, collab.Role, "Incorrect collaboration role");
// Edit Collaboration
BoxCollaborationRequest editRequest = new BoxCollaborationRequest()
{
Id = collab.Id,
Role = BoxCollaborationRoles.Editor
};
BoxCollaboration editCollab = await _client.CollaborationsManager.EditCollaborationAsync(editRequest);
Assert.AreEqual(collab.Id, editCollab.Id, "Id of original collaboration and updated collaboration do not match");
Assert.AreEqual(BoxCollaborationRoles.Editor, editCollab.Role, "Incorrect updated role");
// Test Remove Collaboration
bool success = await _client.CollaborationsManager.RemoveCollaborationAsync(collab.Id);
Assert.IsTrue(success, "Collaboration deletion was unsucessful");
}
public async Task CollaborationsWorkflow_LiveSession_ValidResponse()
{
// Test Add Collaboration
BoxCollaborationRequest addRequest = new BoxCollaborationRequest()
{
Item = new BoxRequestEntity()
{
Id = folderId,
Type = BoxType.folder
},
AccessibleBy = new BoxCollaborationUserRequest()
{
Login = "******"
},
Role = "viewer"
};
BoxCollaboration collab = await _client.CollaborationsManager.AddCollaborationAsync(addRequest);
Assert.AreEqual(folderId, collab.Item.Id);
Assert.AreEqual(BoxCollaborationRoles.Viewer, collab.Role);
// Test Edit Collaboration
BoxCollaborationRequest editRequest = new BoxCollaborationRequest()
{
Id = collab.Id,
Role = BoxCollaborationRoles.Editor
};
BoxCollaboration editCollab = await _client.CollaborationsManager.EditCollaborationAsync(editRequest);
Assert.AreEqual(collab.Id, editCollab.Id);
Assert.AreEqual(BoxCollaborationRoles.Editor, editCollab.Role);
// Test Remove Collaboration
await _client.CollaborationsManager.RemoveCollaborationAsync(collab.Id);
}
public async Task GroupMembershipWorkflow_ValidRequest()
{
// Get current user
var user = await _client.UsersManager.GetCurrentUserInformationAsync();
// Get all the current memberships for this user
var current_memberships = await _client.GroupsManager.GetAllGroupMembershipsForUserAsync(user.Id);
// Create a new group
string groupName = GetUniqueName();
BoxGroupRequest groupReq = new BoxGroupRequest()
{
Name = groupName,
};
var newGroup = await _client.GroupsManager.CreateAsync(groupReq);
// Create a membership
BoxGroupMembershipRequest request = new BoxGroupMembershipRequest()
{
User = new BoxRequestEntity()
{
Id = user.Id
},
Group = new BoxGroupRequest()
{
Id = newGroup.Id
}
};
var responseMembership = await _client.GroupsManager.AddMemberToGroupAsync(request);
Assert.AreEqual("group_membership", responseMembership.Type, "The type is not group_membership");
Assert.AreEqual("member", responseMembership.Role, "Membership role is not set correctly");
Assert.AreEqual(user.Id, responseMembership.User.Id, "User id not set correctly for membership");
Assert.AreEqual(newGroup.Id, responseMembership.Group.Id, "Group id not set correctly for membership");
// Get the created group membership
var membership = await _client.GroupsManager.GetGroupMembershipAsync(responseMembership.Id);
Assert.AreEqual("group_membership", membership.Type, "The type is not group_membership");
Assert.AreEqual("member", membership.Role, "Membership role is not set correctly");
Assert.AreEqual(user.Id, membership.User.Id, "User id not set correctly for membership");
Assert.AreEqual(newGroup.Id, membership.Group.Id, "Group id not set correctly for membership");
// Update the group membership's role
request = new BoxGroupMembershipRequest()
{
Role = "admin"
};
var updatedMembership = await _client.GroupsManager.UpdateGroupMembershipAsync(responseMembership.Id, request);
Assert.AreEqual("admin", updatedMembership.Role, "Membership role was not updated correctly");
// Get all memberships for the given groups
var memberships = await _client.GroupsManager.GetAllGroupMembershipsForGroupAsync(newGroup.Id);
Assert.AreEqual(1, memberships.Entries.Count, "Wrong count of memberships");
Assert.AreEqual(1, memberships.TotalCount, "Wrong total count of memberships");
Assert.AreEqual("group_membership", memberships.Entries[0].Type, "Wrong type");
Assert.AreEqual(newGroup.Id, memberships.Entries[0].Group.Id, "Wrong Group id");
Assert.AreEqual(user.Id, memberships.Entries[0].User.Id, "Wrong User id");
// Add this group to a folder
const string folderId = "1927307787";
// Add Collaboration
BoxCollaborationRequest addRequest = new BoxCollaborationRequest()
{
Item = new BoxRequestEntity()
{
Id = folderId,
Type = BoxType.folder
},
AccessibleBy = new BoxCollaborationUserRequest()
{
Type = BoxType.group,
Id = newGroup.Id
},
Role = "viewer"
};
BoxCollaboration collab = await _client.CollaborationsManager.AddCollaborationAsync(addRequest, notify : false);
Assert.AreEqual(folderId, collab.Item.Id, "Folder and collaboration folder id do not match");
Assert.AreEqual(BoxCollaborationRoles.Viewer, collab.Role, "Incorrect collaboration role");
// Get all collaborations for the give group
var collabs = await _client.GroupsManager.GetCollaborationsForGroupAsync(newGroup.Id);
Assert.AreEqual(1, collabs.Entries.Count, "Wrong count of collaborations");
Assert.AreEqual(1, collabs.TotalCount, "Wrong total count of collaborations");
collab = collabs.Entries[0];
Assert.AreEqual <string>(newGroup.Id, collab.AccessibleBy.Id, "Wrong Group Id");
Assert.AreEqual <string>("viewer", collab.Role, "Wrong Role Type");
// Get memberships for the user
memberships = await _client.GroupsManager.GetAllGroupMembershipsForUserAsync(user.Id);
Assert.AreEqual(current_memberships.TotalCount + 1, memberships.TotalCount, "The total count of memberships for user did not increase");
Assert.IsTrue(memberships.Entries.Exists(m => m.Id.Equals(membership.Id)), "Newly created group membership does not exist in this users list of memberships");
// Delete the group membership
bool success = await _client.GroupsManager.DeleteGroupMembershipAsync(membership.Id);
memberships = await _client.GroupsManager.GetAllGroupMembershipsForGroupAsync(newGroup.Id);
Assert.AreEqual(0, memberships.Entries.Count, "Count should be 0");
Assert.AreEqual(0, memberships.TotalCount, "Total count should be 0");
// Clean up - delete group
var delResult = await _client.GroupsManager.DeleteAsync(newGroup.Id);
}
protected async Task ProcessAddCollaborationsFromFile(string path, BoxType t,
string command, List <string> fields,
bool save = false, string overrideSavePath = "",
string overrideSaveFileFormat = "", bool json = false)
{
var boxClient = base.ConfigureBoxClient(oneCallAsUserId: this._asUser.Value(), oneCallWithToken: base._oneUseToken.Value());
var processedCollaborations = new List <BoxCollaboration>();
if (!string.IsNullOrEmpty(path))
{
path = GeneralUtilities.TranslatePath(path);
}
try
{
var collaborationRequests = new List <BoxCollaborationRequest>();
if (command.ToLower() == CollaborationAddCommand.commandName)
{
collaborationRequests = base.ReadFile <BoxCollaborationRequest, BoxCollaborationRequestMap>(path);
}
else if (command.ToLower() == CollaborationUpdateCommand.commandName)
{
collaborationRequests = base.ReadFile <BoxCollaborationRequest, BoxCollaborationUpdateRequestMap>(path);
}
else
{
throw new Exception("Cannot use bulk-file-path with this command.");
}
foreach (var collaborationRequest in collaborationRequests)
{
try
{
var createdCollaboration = new BoxCollaboration();
if (command.ToLower() == CollaborationAddCommand.commandName)
{
Reporter.WriteInformation($"Processing collaboration for item ID: {collaborationRequest.Item.Id}");
Reporter.WriteInformation($"Processing collaboration for item type: {collaborationRequest.Item.Type}");
createdCollaboration = await boxClient.CollaborationsManager.AddCollaborationAsync(collaborationRequest, fields : fields);
}
else if (command.ToLower() == CollaborationUpdateCommand.commandName)
{
Reporter.WriteInformation($"Processing update on collaboration ID: {collaborationRequest.Id}");
createdCollaboration = await boxClient.CollaborationsManager.EditCollaborationAsync(collaborationRequest, fields : fields);
}
else
{
throw new Exception("Cannot use bulk-file-path with this command.");
}
if (createdCollaboration != null)
{
this.PrintCollaboration(createdCollaboration, json);
if (save || !string.IsNullOrEmpty(overrideSavePath) || base._settings.GetAutoSaveSetting())
{
processedCollaborations.Add(createdCollaboration);
}
}
}
catch (BoxException e)
{
var errorMessage = JObject.Parse(e.Message);
var code = errorMessage.GetValue("code").ToString();
if (code == "user_already_collaborator" || code == "conflict")
{
Reporter.WriteWarning("Collaboration already exists...");
var existingCollaborations = new BoxCollection <BoxCollaboration>();
var itemId = collaborationRequest.Item.Id;
if (collaborationRequest.Item.Type == BoxType.folder)
{
existingCollaborations = await boxClient.FoldersManager.GetCollaborationsAsync(itemId, fields : fields);
}
else if (collaborationRequest.Item.Type == BoxType.file)
{
existingCollaborations = await boxClient.FilesManager.GetCollaborationsAsync(itemId, fields : fields);
}
else
{
throw e;
}
var existingCollab = new BoxCollaboration();
if (!string.IsNullOrEmpty(collaborationRequest.AccessibleBy.Id))
{
existingCollab = existingCollaborations.Entries.Find((collaboration) =>
{
return(collaboration.AccessibleBy.Id == collaborationRequest.AccessibleBy.Id);
});
}
else if (!string.IsNullOrEmpty(collaborationRequest.AccessibleBy.Login))
{
var user = (await boxClient.UsersManager.GetEnterpriseUsersAsync(filterTerm: collaborationRequest.AccessibleBy.Login)).Entries.FirstOrDefault();
if (user != null)
{
existingCollab = existingCollaborations.Entries.Find((collaboration) =>
{
return(collaboration.AccessibleBy.Id == user.Id);
});
}
else
{
throw e;
}
}
if (existingCollab != null)
{
processedCollaborations.Add(existingCollab);
}
else
{
throw e;
}
}
else
{
Reporter.WriteError("Failed processing on collaboration:");
if (!String.IsNullOrEmpty(collaborationRequest.Id))
{
Reporter.WriteError($"Collaboration ID: {collaborationRequest.Id}");
}
Reporter.WriteError($"Role: {collaborationRequest.Role}");
if (!String.IsNullOrEmpty(collaborationRequest.Status))
{
Reporter.WriteError($"Status: {collaborationRequest.Status}");
}
if (collaborationRequest.Item != null)
{
Reporter.WriteError($"Item ID: {collaborationRequest.Item.Id}");
Reporter.WriteError($"Item type: {collaborationRequest.Item.Type}");
}
if (collaborationRequest.AccessibleBy != null)
{
Reporter.WriteError($"Accessible by ID: {collaborationRequest.AccessibleBy.Id}");
Reporter.WriteError($"Accessible by type: {collaborationRequest.AccessibleBy.Type}");
}
Reporter.WriteError("Reason:");
Reporter.WriteError(e.Message);
}
}
catch (Exception e)
{
Reporter.WriteError("Failed processing on collaboration:");
if (!String.IsNullOrEmpty(collaborationRequest.Id))
{
Reporter.WriteError($"Collaboration ID: {collaborationRequest.Id}");
}
Reporter.WriteError($"Role: {collaborationRequest.Role}");
if (!String.IsNullOrEmpty(collaborationRequest.Status))
{
Reporter.WriteError($"Status: {collaborationRequest.Status}");
}
if (collaborationRequest.Item != null)
{
Reporter.WriteError($"Item ID: {collaborationRequest.Item.Id}");
Reporter.WriteError($"Item type: {collaborationRequest.Item.Type}");
}
if (collaborationRequest.AccessibleBy != null)
{
Reporter.WriteError($"Accessible by ID: {collaborationRequest.AccessibleBy.Id}");
Reporter.WriteError($"Accessible by type: {collaborationRequest.AccessibleBy.Type}");
}
Reporter.WriteError("Reason:");
Reporter.WriteError(e.Message);
}
}
}
catch (Exception e)
{
Reporter.WriteError(e.Message);
}
if (save || !string.IsNullOrEmpty(overrideSavePath) || base._settings.GetAutoSaveSetting())
{
var fileFormat = base._settings.GetBoxReportsFileFormatSetting();
if (!string.IsNullOrEmpty(overrideSaveFileFormat))
{
fileFormat = overrideSaveFileFormat;
}
var savePath = base._settings.GetBoxReportsFolderPath();
if (!string.IsNullOrEmpty(overrideSavePath))
{
savePath = overrideSavePath;
}
var fileName = String.Empty;
if (command.ToLower() == CollaborationAddCommand.commandName)
{
fileName = $"{base._names.CommandNames.Collaborations}-{base._names.SubCommandNames.Add}-{DateTime.Now.ToString(GeneralUtilities.GetDateFormatString())}";
}
else if (command.ToLower() == CollaborationUpdateCommand.commandName)
{
fileName = $"{base._names.CommandNames.Collaborations}-{base._names.SubCommandNames.Update}-{DateTime.Now.ToString(GeneralUtilities.GetDateFormatString())}";
}
if (!String.IsNullOrEmpty(fileName))
{
base.WriteListResultsToReport <BoxCollaboration, BoxCollaborationMap>(processedCollaborations, fileName, savePath, fileFormat);
}
}
}
