private static async Task SubmitBatchContent(IBaseClient client, Dictionary <string, Func <BatchRequestStep> > requests, bool ignoreNotFound, bool ignoreRefAlreadyExists, CancellationToken token, int attemptCount = 1)
{
BatchRequestContent content = GraphHelper.BuildBatchRequest(requests);
BatchResponseContent response = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Batch.Request().PostAsync(content, token), token, content.BatchRequestSteps.Count + 1);
List <GraphBatchResult> results = await GetBatchResults(await response.GetResponsesAsync(), ignoreNotFound, ignoreRefAlreadyExists, attemptCount <= MaxRetry);
GraphHelper.ThrowOnExceptions(results);
int retryInterval = 8 * attemptCount;
Dictionary <string, Func <BatchRequestStep> > stepsToRetry = new Dictionary <string, Func <BatchRequestStep> >();
foreach (var result in results.Where(t => t.IsRetryable))
{
retryInterval = Math.Max(result.RetryInterval, retryInterval);
stepsToRetry.Add(result.ID, requests[result.ID]);
}
if (stepsToRetry.Count > 0)
{
logger.Info($"Sleeping for {retryInterval} before retrying after attempt {attemptCount}");
await Task.Delay(TimeSpan.FromSeconds(retryInterval), token);
await GraphHelper.SubmitBatchContent(client, stepsToRetry, ignoreNotFound, ignoreRefAlreadyExists, token, ++attemptCount);
}
}
private static async Task <string> GetGroups(IGroupDeltaCollectionPage page, ITargetBlock <Group> target, CancellationToken token)
{
Group lastGroup = null;
if (page.Count > 0)
{
foreach (Group group in page.CurrentPage)
{
if (lastGroup?.Id == group.Id)
{
logger.Trace($"Merging group {group.Id}");
MergeGroup(lastGroup, group);
}
else
{
if (lastGroup != null)
{
logger.Trace($"posting group {lastGroup.Id}. next group {group.Id}");
target.Post(lastGroup);
}
}
lastGroup = group;
}
}
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
foreach (Group group in page.CurrentPage)
{
if (lastGroup?.Id == group.Id)
{
logger.Trace($"Merging group {group.Id}");
MergeGroup(lastGroup, group);
}
else
{
if (lastGroup != null)
{
logger.Trace($"posting group {lastGroup.Id}. next group {group.Id}");
target.Post(lastGroup);
}
}
lastGroup = group;
}
}
if (lastGroup != null)
{
target.Post(lastGroup);
}
page.AdditionalData.TryGetValue("@odata.deltaLink", out object link);
return(link as string);
}
private static async Task <string> GetUsersWithDelta(IUserDeltaRequest request, ITargetBlock <User> target, CancellationToken token)
{
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await request.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
target.Post(user);
}
return(await GraphHelperUsers.GetUsersWithDelta(page, target, token));
}
private static async Task <TeamsAsyncOperation> SubmitTeamCreateRequestAndWait(Beta.GraphServiceClient client, Beta.Team team, CancellationToken token)
{
string location = await GraphHelper.ExecuteWithRetryAndRateLimit(async() =>
{
var message = client.Teams.Request().GetHttpRequestMessage();
message.Method = HttpMethod.Post;
message.Content = new StringContent(JsonConvert.SerializeObject(team), Encoding.UTF8, "application/json");
return(await AsyncRequestSubmit(client, message, token));
}, token, 1);
return(await AsyncRequestWait(client, token, location));
}
private static async Task <TeamsAsyncOperation> SubmitTeamUnarchiveRequestAndWait(Beta.GraphServiceClient client, string teamid, CancellationToken token)
{
string location = await GraphHelper.ExecuteWithRetryAndRateLimit(async() =>
{
var message = new HttpRequestMessage();
message.Method = HttpMethod.Post;
message.RequestUri = new Uri(client.Teams[teamid].RequestUrl + "/unarchive");
message.Content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
return(await AsyncRequestSubmit(client, message, token));
}, token, 1);
return(await AsyncRequestWait(client, token, location));
}
public static async Task <string> GetGroupIdByMailNickname(GraphServiceClient client, string mailNickname, CancellationToken token)
{
var collectionPage = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Groups.Request().Filter($"mailNickname eq '{mailNickname}'").Select("id").GetAsync(token), token, 0);
if (collectionPage.Count == 0)
{
return(null);
}
if (collectionPage.Count > 1)
{
throw new InvalidOperationException();
}
return(collectionPage[0].Id);
}
private static async Task <string> GetUsersWithDelta(IUserDeltaCollectionPage page, ITargetBlock <User> target, CancellationToken token)
{
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
target.Post(user);
}
}
page.AdditionalData.TryGetValue("@odata.deltaLink", out object link);
return(link as string);
}
private static async Task <List <DirectoryObject> > GetOwners(IGroupOwnersCollectionWithReferencesPage page, CancellationToken token)
{
List <DirectoryObject> members = new List <DirectoryObject>();
if (page?.Count > 0)
{
members.AddRange(page.CurrentPage);
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
members.AddRange(page.CurrentPage);
}
}
return(members);
}
private static async Task GetGroups(Beta.IGraphServiceGroupsCollectionRequest request, ITargetBlock <Beta.Group> target, CancellationToken token)
{
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await request.GetAsync(token), token, 0);
foreach (Beta.Group group in page.CurrentPage)
{
target.Post(group);
}
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
foreach (Beta.Group group in page.CurrentPage)
{
target.Post(group);
}
}
}
private static async Task GetUsers(IGraphServiceUsersCollectionRequest request, ITargetBlock <User> target, CancellationToken token)
{
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await request.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
target.Post(user);
}
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
target.Post(user);
}
}
}
private static async Task <TeamsAsyncOperation> AsyncRequestWait(Beta.GraphServiceClient client, CancellationToken token, string location)
{
TeamsAsyncOperation result;
int waitCount = 1;
do
{
await Task.Delay(TimeSpan.FromSeconds(3 * waitCount), token);
var b = new TeamsAsyncOperationRequestBuilder($"{client.BaseUrl}{location}", client);
// GetAsyncOperation API sometimes returns 'bad request'. Possibly a replication issue. So we create a custom IsRetryable handler for this call only
result = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await b.Request().GetAsync(token), token, 1, GraphHelperTeams.IsGetAsyncOperationRetryable);
GraphHelperTeams.logger.Trace($"Result of async operation is {result.Status}: Count : {waitCount}");
waitCount++;
} while (result.Status == TeamsAsyncOperationStatus.InProgress || result.Status == TeamsAsyncOperationStatus.NotStarted);
return(result);
}
public static async Task <List <Beta.Channel> > GetChannels(Beta.GraphServiceClient client, string teamid, CancellationToken token)
{
List <Beta.Channel> channels = new List <Beta.Channel>();
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[teamid].Channels.Request().GetAsync(token), token, 0);
if (page?.Count > 0)
{
channels.AddRange(page.CurrentPage);
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
channels.AddRange(page.CurrentPage);
}
}
return(channels);
}
public static async Task <List <Beta.AadUserConversationMember> > GetChannelMembers(Beta.GraphServiceClient client, string groupId, string channelId, CancellationToken token)
{
List <Beta.AadUserConversationMember> members = new List <Beta.AadUserConversationMember>();
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[groupId].Channels[channelId].Members.Request().GetAsync(token), token, 0);
if (page?.Count > 0)
{
members.AddRange(page.CurrentPage.Where(t => t is Beta.AadUserConversationMember && (t.Roles == null || t.Roles.Any(u => !string.Equals(u, "guest", StringComparison.OrdinalIgnoreCase)))).Cast <Beta.AadUserConversationMember>());
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
members.AddRange(page.CurrentPage.Where(t => t is Beta.AadUserConversationMember && (t.Roles == null || t.Roles.Any(u => !string.Equals(u, "guest", StringComparison.OrdinalIgnoreCase)))).Cast <Beta.AadUserConversationMember>());
}
}
return(members);
}
private static async Task <TeamsAsyncOperation> SubmitTeamArchiveRequestAndWait(Beta.GraphServiceClient client, string teamid, bool?setSpoSiteReadOnly, CancellationToken token)
{
string location = await GraphHelper.ExecuteWithRetryAndRateLimit(async() =>
{
var message = new HttpRequestMessage();
message.Method = HttpMethod.Post;
message.RequestUri = new Uri(client.Teams[teamid].RequestUrl + "/archive");
if (setSpoSiteReadOnly.HasValue && setSpoSiteReadOnly.Value)
{
message.Content = new StringContent("{\"shouldSetSpoSiteReadOnlyForMembers\": true}", Encoding.UTF8, "application/json");
}
else
{
message.Content = new StringContent("{\"shouldSetSpoSiteReadOnlyForMembers\": false}", Encoding.UTF8, "application/json");;
}
return(await AsyncRequestSubmit(client, message, token));
}, token, 1);
return(await AsyncRequestWait(client, token, location));
}
public static async Task <List <string> > GetGuestUsers(GraphServiceClient client, CancellationToken token)
{
var request = client.Users.Request().Filter("userType eq 'guest'");
List <string> guests = new List <string>();
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await request.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
guests.Add(user.Id);
}
while (page.NextPageRequest != null)
{
page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await page.NextPageRequest.GetAsync(token), token, 0);
foreach (User user in page.CurrentPage)
{
guests.Add(user.Id);
}
}
return(guests);
}
public static async Task <Group> CreateGroup(GraphServiceClient client, Group group, CancellationToken token)
{
return(await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Groups.Request().AddAsync(group, token), token, 1));
}
public static async Task <List <DirectoryObject> > GetGroupOwners(GraphServiceClient client, string groupid, CancellationToken token)
{
IGroupOwnersCollectionWithReferencesPage result = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Groups[groupid].Owners.Request().GetAsync(token), token, 0);
return(await GetOwners(result, token));
}
public static async Task DeleteGroup(GraphServiceClient client, string id, CancellationToken token)
{
await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Groups[id].Request().DeleteAsync(token), token, 1);
}
public static async Task DeleteChannel(Beta.GraphServiceClient client, string teamid, string channelid, CancellationToken token)
{
await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[teamid].Channels[channelid].Request().DeleteAsync(token), token, 1);
}
//public static async Task<Team> GetTeam(GraphServiceClient client, string teamid, CancellationToken token)
//{
// return await GraphHelper.ExecuteWithRetryAndRateLimit(async () => await client.Teams[teamid].Request().GetAsync(token), token, 0);
//}
public static async Task <Beta.Team> GetTeam(Beta.GraphServiceClient client, string teamid, CancellationToken token)
{
return(await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[teamid].Request().GetAsync(token), token, 0));
}
private static async Task <string> GetGroups(IGroupDeltaRequest request, ITargetBlock <Group> target, CancellationToken token)
{
var page = await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await request.GetAsync(token), token, 0);
return(await GetGroups(page, target, token));
}
public static async Task <Beta.Team> CreateTeamFromGroup(Beta.GraphServiceClient client, string groupid, Beta.Team team, CancellationToken token)
{
return(await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Groups[groupid].Team.Request().PutAsync(team, token), token, 1));
}
public static async Task <Beta.Channel> UpdateChannel(Beta.GraphServiceClient client, string teamid, string channelid, Beta.Channel channel, CancellationToken token)
{
return(await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[teamid].Channels[channelid].Request().UpdateAsync(channel, token), token, 1));
}
public static async Task UpdateTeam(Beta.GraphServiceClient client, string teamid, Beta.Team team, CancellationToken token)
{
await GraphHelper.ExecuteWithRetryAndRateLimit(async() => await client.Teams[teamid].Request().UpdateAsync(team, token), token, 1);
}
