private async Task SetViewLinkedApps(DropboxTeamClient client)
{
/* sample data */
int totalUserLinkedApps = 8;
if (AccountLinked())
{
var linkedAppsResult = await client.Team.LinkedAppsListTeamLinkedAppsAsync();
/* retrieve distinct set of linked app names */
HashSet <string> linkedAppNames = new HashSet <string>();
foreach (MemberLinkedApps appData in linkedAppsResult.Apps)
{
foreach (var memberLinkedApp in appData.LinkedApiApps)
{
if (memberLinkedApp.Linked != null)
{
linkedAppNames.Add(memberLinkedApp.AppName);
}
}
}
totalUserLinkedApps = linkedAppNames.Count;
}
ViewBag.TotalUserLinkedApps = totalUserLinkedApps;
}
private async Task SetViewActivityData(DropboxTeamClient client)
{
/* sample data */
ulong numDailyActives = 17;
ulong numWeeklySharedFolders = 4;
var activeUsers = new List <ulong?> {
6, 10, 4, 5, 8, 2, 9
};
if (AccountLinked())
{
var activityInfo = await client.Team.ReportsGetActivityAsync();
activeUsers = (List <ulong?>)activityInfo.ActiveUsers1Day;
/* grab the last element in the array, which contains numDailyActives for today */
numDailyActives = activeUsers.Last() == null ? 0 : (ulong)activeUsers.Last();
var sharedFoldersWeekly = (List <ulong?>)activityInfo.ActiveSharedFolders7Day;
/* grab the last element in the array, which contains numWeeklySharedFolders for this week */
numWeeklySharedFolders = sharedFoldersWeekly.Last() == null ? 0 : (ulong)sharedFoldersWeekly.Last();
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
ViewBag.NumDailyActives = numDailyActives;
ViewBag.NumWeeklySharedFolders = numWeeklySharedFolders;
ViewBag.ActiveUsers = serializer.Serialize(activeUsers);
}
static async Task <TeamMemberAccountModel> MapTeamMemberAccountDetail(DropboxTeamClient teamClient, string memberId)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("MapTeamMemberAccountDetail() called...");
}
TeamMemberAccountModel teamMemberAccount = null;
using (DropboxClient userClient = teamClient.AsMember(memberId))
{
FullAccount fullAccount = await userClient.Users.GetCurrentAccountAsync();
teamMemberAccount = new TeamMemberAccountModel()
{
Email = fullAccount.Email,
LastName = CheckValueForComma(fullAccount.Name.Surname),
FirstName = CheckValueForComma(fullAccount.Name.GivenName)
};
}
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"Email : {teamMemberAccount.Email}");
Console.WriteLine($"LastName : {teamMemberAccount.LastName}");
Console.WriteLine($"FirstName : {teamMemberAccount.FirstName}");
Console.WriteLine($"SharedFolders.Count: going to figure that out next...");
}
return(teamMemberAccount);
}
static async Task <List <SharedFolderModel> > GetTeamMemberShares(DropboxTeamClient teamClient, string memberId)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("GetTeamMemberShares() called...");
}
// initialize here so sharedFolders in scope of return statement
List <SharedFolderModel> sharedFolders = new List <SharedFolderModel>();
_sharedFoldersListCount = 0;
using (DropboxClient userClient = teamClient.AsMember(memberId))
{
ListFoldersResult sharedFoldersList = await userClient.Sharing.ListFoldersAsync();
sharedFolders = await ProcessSharedFoldersList(userClient, sharedFoldersList);
if (_debug)
{
// before ...ContinueAsync() count
Console.WriteLine("----------------");
Console.WriteLine($"Total shared folders count: {_sharedFoldersListCount}");
Console.WriteLine($"Any more shared folders? sharedFoldersList.Cursor: {sharedFoldersList.Cursor}");
}
// iterate over pages from userClient.Sharing.ListFoldersContinueAsync if list.Cursor is set
while (sharedFoldersList.Cursor != null)
{
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"sharedFoldersList.Cursor not null: {sharedFoldersList.Cursor}");
Console.WriteLine("Preparing to continue...");
}
// sharedFoldersList.Cursor flips to null once all folders are listed via ListFoldersContinueAsync()
sharedFoldersList = await userClient.Sharing.ListFoldersContinueAsync(sharedFoldersList.Cursor);
List <SharedFolderModel> sharedFoldersCursorList = await ProcessSharedFoldersList(userClient, sharedFoldersList);
sharedFolders.AddRange(sharedFoldersCursorList);
if (_debug)
{
// after ...ContinueAsync() count
Console.WriteLine("----------------");
Console.WriteLine($"Total shared folders count with continue: {_sharedFoldersListCount}");
}
}
}
return(sharedFolders);
}
// GET: /Home
public async Task <ActionResult> IndexAsync()
{
DropboxTeamClient teamClient = GetTeamClient();
/* run asynchronous data retrieval synchronously */
await SetViewTeamInfo(teamClient);
await SetViewLinkedApps(teamClient);
await SetViewActivityData(teamClient);
await SetViewMemberList(teamClient);
return(View());
}
private async Task SetViewMemberList(DropboxTeamClient client)
{
/* sample data */
var memListResult = new MembersListResult(GetMemberListSampleData(), "", true);
if (AccountLinked())
{
memListResult = await client.Team.MembersListAsync();
}
ViewBag.TeamMembers = memListResult.Members;
}
/// <summary>
/// List all members in the team.
/// </summary>
/// <param name="client">The Dropbox team client.</param>
/// <returns>The result from the MembersListAsync call.</returns>
private async Task <MembersListResult> ListTeamMembers(DropboxTeamClient client)
{
var members = await client.Team.MembersListAsync();
foreach (var member in members.Members)
{
Console.WriteLine("Member id : {0}", member.Profile.TeamMemberId);
Console.WriteLine("Name : {0}", member.Profile.Name);
Console.WriteLine("Email : {0}", member.Profile.Email);
}
return(members);
}
public static void Initialize(TestContext context)
{
UserAccessToken = context.Properties["userAccessToken"].ToString();
Client = new DropboxClient(UserAccessToken);
var teamToken = context.Properties["teamAccessToken"].ToString();
TeamClient = new DropboxTeamClient(teamToken);
var appKey = context.Properties["appKey"].ToString();
var appSecret = context.Properties["appSecret"].ToString();
AppClient = new DropboxAppClient(appKey, appSecret);
}
static async Task UpdateTeamMemberAccountList(DropboxTeamClient teamClient, string teamMemberId)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("UpdateTeamMemberAccountList() called...");
}
TeamMemberAccountModel teamMemberAccount = await GetTeamMemberAccountDetails(teamClient, teamMemberId);
OutputTeamMemberCsv(teamMemberAccount);
_teamMemberAccounts.Add(teamMemberAccount);
}
/// <summary>
/// Run tests for team-level operations.
/// </summary>
/// <param name="client">The Dropbox client.</param>
/// <returns>An asynchronous task.</returns>
private async Task RunTeamTests(DropboxTeamClient client)
{
var members = await client.Team.MembersListAsync();
var member = members.Members.FirstOrDefault();
if (member != null)
{
// A team client can perform action on a team member's behalf. To do this,
// just pass in team member id in to AsMember function which returns a user client.
// This client will operates on this team member's Dropbox.
var userClient = client.AsMember(member.Profile.TeamMemberId);
await RunUserTests(userClient);
}
}
static async Task ListTeamName(DropboxTeamClient teamClient)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("ListTeamName() called...");
}
TeamGetInfoResult teamInfo = await teamClient.Team.GetInfoAsync();
if (_debug)
{
Console.WriteLine($"teamInfo.Name: {teamInfo.Name}");
}
}
static async Task EvaluateTeamMemberAccounts(DropboxTeamClient teamClient)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("EvaluateTeamMemberAccounts() called...");
}
MembersListResult teamMembers = await teamClient.Team.MembersListAsync();
// sort team members by email, since name fields are user specified (typos, etc.)
foreach (Dropbox.Api.Team.TeamMemberInfo teamMember in teamMembers.Members.OrderBy(m => m.Profile.Email))
{
_csvString = "";
if (_debug)
{
// // filter on test/validation account
// if (teamMember.Profile.Email == "test_user@your_company.com")
// {
// await UpdateTeamMemberAccountList(teamClient, teamMember.Profile.TeamMemberId);
// }
// filter on account (validate shared folder owner)
if (teamMember.Profile.Email == "shared_folder_owner@your_company.com")
{
await UpdateTeamMemberAccountList(teamClient, teamMember.Profile.TeamMemberId);
}
// // filter on multiple associates
// // - one where ShareIsTeamFolder is true, the other where ShareIsInsideTeamFolder is true
// if (teamMember.Profile.Email == "target_user_1@your_company.com" || teamMember.Profile.Email == "target_user_2@your_company.com")
// {
// await UpdateTeamMemberAccountList(teamClient, teamMember.Profile.TeamMemberId);
// }
}
else
{
await UpdateTeamMemberAccountList(teamClient, teamMember.Profile.TeamMemberId);
}
}
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"_teamMemberAccounts count: {_teamMemberAccounts.Count}");
}
}
static async Task <TeamMemberAccountModel> GetTeamMemberAccountDetails(DropboxTeamClient teamClient, string memberId)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("GetTeamMemberAccountDetails() called...");
}
TeamMemberAccountModel teamMemberAccount = await MapTeamMemberAccountDetail(teamClient, memberId);
List <SharedFolderModel> teamMemberShares = await GetTeamMemberShares(teamClient, memberId);
teamMemberAccount.SharedFolders = teamMemberShares;
return(teamMemberAccount);
}
private async Task SetViewTeamInfo(DropboxTeamClient client)
{
/* sample data */
string teamName = "PlaceholderTeam";
uint numMembers = 26;
if (AccountLinked())
{
var teamInfo = await client.Team.GetInfoAsync();
teamName = teamInfo.Name;
numMembers = teamInfo.NumProvisionedUsers;
}
ViewBag.TeamName = teamName;
ViewBag.NumMembers = numMembers;
}
static async Task Run()
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("Run() called...");
}
using (DropboxTeamClient teamClient = new DropboxTeamClient(_accessToken))
{
await ListTeamName(teamClient);
await ListTeamMembers(teamClient);
await EvaluateTeamMemberAccounts(teamClient);
}
}
static async Task ListTeamMembers(DropboxTeamClient teamClient)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("ListTeamMembers() called...");
}
MembersListResult members = await teamClient.Team.MembersListAsync();
int memberCount = 0;
// no Count or Length, so have to enumerate to get count
foreach (Dropbox.Api.Team.TeamMemberInfo member in members.Members)
{
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"Member ID: {member.Profile.TeamMemberId}");
Console.WriteLine($"Name : {member.Profile.Name.DisplayName}");
Console.WriteLine($"Email : {member.Profile.Email}");
}
memberCount++;
}
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"Total team member count : {memberCount}"); // 252
Console.WriteLine($"Any more members? members.HasMore: {members.HasMore}");
}
while (members.HasMore)
{
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"members.HasMore: {members.HasMore}");
Console.WriteLine("Preparing to continue...");
}
MembersListResult membersContinue = await teamClient.Team.MembersListContinueAsync(members.Cursor);
foreach (Dropbox.Api.Team.TeamMemberInfo member in members.Members)
{
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"Member ID: {member.Profile.TeamMemberId}");
Console.WriteLine($"Name : {member.Profile.Name.DisplayName}");
Console.WriteLine($"Email : {member.Profile.Email}");
}
memberCount++;
}
}
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"Total team member count with continue: {memberCount}"); // 252
}
}
