private async Task AllowPermissionsForGoogleDriveFile(GoogleAuthDTO authDTO, string fileId)
{
//create google drive service for file manipulation
var driveService = await _googleDrive.CreateDriveService(authDTO);
var batch = new BatchRequest(driveService);
//bach service callback for successfull permission set
BatchRequest.OnResponse <Permission> callback = delegate(
Permission permission, RequestError error, int index, HttpResponseMessage message){
if (error != null)
{
// Handle error
throw new ApplicationException($"Problem with Google Drive Permissions: {error.Message}");
}
};
var userPermission = new Permission
{
Type = "user",
Role = "writer",
EmailAddress = CloudConfigurationManager.GetSetting("GoogleMailAccount")
};
var request = driveService.Permissions.Create(userPermission, fileId);
request.Fields = "id";
batch.Queue(request, callback);
await batch.ExecuteAsync();
}
public async Task DeleteAllFiles()
{
var ids = await ListFileIds();
if (ids.Count == 0)
{
return;
}
var batch = new BatchRequest(_service);
void Callback(Permission permission, RequestError error, int index, HttpResponseMessage message)
{
if (error != null)
{
Console.WriteLine(error.Message);
}
}
ids.ForEach(id =>
{
var deleteRequest = _service.Files.Delete(id);
batch.Queue(deleteRequest, (BatchRequest.OnResponse <Permission>)Callback);
});
await batch.ExecuteAsync();
}
public static void SendIndexingRequest(List <string> linksToIndex, string action)
{
try
{
var indexRequest = new BatchRequest(_googleIndexingApiClientService);
var notificationResponses = new List <PublishUrlNotificationResponse>();
foreach (var url in linksToIndex)
{
var urlNotification = new UrlNotification {
Url = url, Type = action
};
indexRequest.Queue <PublishUrlNotificationResponse>(
new UrlNotificationsResource.PublishRequest(_googleIndexingApiClientService, urlNotification), (response, error, i, message) =>
{
notificationResponses.Add(response);
});
}
indexRequest.ExecuteAsync().ConfigureAwait(false);
Log.Info($"{action} request to Google Indexing API for '{string.Join(",", linksToIndex)}' succeeded", linksToIndex);
}
catch (Exception ex)
{
Log.Error($"{action} request to Google Indexing API for '{string.Join(",", linksToIndex)}' failed: {ex.Message}", ex, linksToIndex);
}
}
/// <summary>
/// </summary>
/// <param name="syncMetric"></param>
/// <param name="accountName"></param>
/// <returns>
/// </returns>
public async Task<bool> UploadSyncData(SyncMetric syncMetric, string accountName)
{
try
{
var analyticsService = new AnalyticsService(new BaseClientService.Initializer
{
ApplicationName = ApplicationInfo.ProductName,
ApiKey = "AIzaSyBrpqcL6Nh1vVecfhIbxGVnyGHMZ8-aH6k"
});
var batchRequest = new BatchRequest(analyticsService);
var metric = new CustomMetric
{
Name = "SyncMetric",
Kind = "string"
};
var insertRequest = analyticsService.Management.CustomMetrics.Insert(metric, "", "");
batchRequest.Queue<CustomMetric>(insertRequest, InsertMetricCallback);
await batchRequest.ExecuteAsync();
}
catch (Exception ex)
{
Logger.Error(ex);
return false;
}
return true;
}
/// <summary>
/// Add multiple students in a specified course.
/// </summary>
/// <param name="courseId">Id of the course to add students.</param>
/// <param name="studentEmails">Email address of the students.</param>
public static void ClassroomBatchAddStudents(string courseId,
List <string> studentEmails)
{
try
{
/* Load pre-authorized user credentials from the environment.
* TODO(developer) - See https://developers.google.com/identity for
* guides on implementing OAuth2 for your application. */
GoogleCredential credential = GoogleCredential.GetApplicationDefault()
.CreateScoped(ClassroomService.Scope.ClassroomRosters);
// Create Classroom API service.
var service = new ClassroomService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = "Classroom Snippets"
});
var batch = new BatchRequest(service, "https://classroom.googleapis.com/batch");
BatchRequest.OnResponse <Student> callback = (student, error, i, message) =>
{
if (error != null)
{
Console.WriteLine("Error adding student to the course: {0}", error.Message);
}
else
{
Console.WriteLine("User '{0}' was added as a student to the course.",
student.Profile.Name.FullName);
}
};
foreach (var studentEmail in studentEmails)
{
var student = new Student()
{
UserId = studentEmail
};
var request = service.Courses.Students.Create(student, courseId);
batch.Queue <Student>(request, callback);
}
Task.WaitAll(batch.ExecuteAsync());
}
catch (Exception e)
{
// TODO(developer) - handle error appropriately
if (e is AggregateException)
{
Console.WriteLine("Credential Not found");
}
else if (e is GoogleApiException)
{
Console.WriteLine("Course does not exist.");
}
else
{
throw;
}
}
}
public async Task <TasksWrapper> DeleteReminderTasks(List <ReminderTask> reminderTasks, IDictionary <string, object> taskListSpecificData)
{
var deletedTasks = new TasksWrapper();
if (!reminderTasks.Any())
{
deletedTasks.IsSuccess = true;
return(deletedTasks);
}
CheckTaskListSpecificData(taskListSpecificData);
var errorList = new Dictionary <int, ReminderTask>();
//Get Calendar Service
var calendarService = GetTasksService(AccountName);
if (reminderTasks == null || string.IsNullOrEmpty(TaskListId))
{
deletedTasks.IsSuccess = false;
return(deletedTasks);
}
try
{
if (reminderTasks.Any())
{
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
//Split the list of calendarAppointments by 1000 per list
//Iterate over each appointment to create a event and batch it
for (var i = 0; i < reminderTasks.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = reminderTasks[i];
var deleteRequest = calendarService.Tasks.Delete(TaskListId,
appointment.TaskId);
batchRequest.Queue <Task>(deleteRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message, reminderTasks,
"Error in deleting events", errorList, deletedTasks));
}
await batchRequest.ExecuteAsync();
}
}
catch (Exception exception)
{
Logger.Error(exception);
deletedTasks.IsSuccess = false;
return(deletedTasks);
}
deletedTasks.IsSuccess = true;
return(deletedTasks);
}
public async Task ShareAsync(string itemId, string userEmail)
{
var batch = new BatchRequest(_service);
var userPermission = new Permission
{
Type = "user",
Role = "reader",
EmailAddress = userEmail,
};
var request = _service.Permissions.Create(userPermission, itemId);
request.Fields = "id";
batch.Queue(request, (BatchRequest.OnResponse <Permission>)((permission, error, index, message) =>
{
if (error != null)
{
Console.WriteLine(error.Message);
}
else
{
Console.WriteLine("Permission ID: " + permission.Id);
}
}));
await batch.ExecuteAsync();
}
/// <summary>
/// </summary>
/// <param name="syncMetric"></param>
/// <param name="accountName"></param>
/// <returns>
/// </returns>
public async Task <bool> UploadSyncData(SyncMetric syncMetric, string accountName)
{
try
{
var analyticsService = new AnalyticsService(new BaseClientService.Initializer
{
ApplicationName = ApplicationInfo.ProductName,
ApiKey = "AIzaSyBrpqcL6Nh1vVecfhIbxGVnyGHMZ8-aH6k"
});
var batchRequest = new BatchRequest(analyticsService);
var metric = new CustomMetric
{
Name = "SyncMetric",
Kind = "string"
};
var insertRequest = analyticsService.Management.CustomMetrics.Insert(metric, "", "");
batchRequest.Queue <CustomMetric>(insertRequest, InsertMetricCallback);
await batchRequest.ExecuteAsync();
}
catch (Exception ex)
{
Logger.Error(ex);
return(false);
}
return(true);
}
private async Task <List <ReminderTask> > AddTasksInternal(List <ReminderTask> reminderTasks,
TasksService taskService, Dictionary <int, ReminderTask> errorList)
{
var addedEvents = new List <ReminderTask>();
//Create a Batch Request
var batchRequest = new BatchRequest(taskService);
for (var i = 0; i < reminderTasks.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(taskService);
}
var reminderTask = reminderTasks[i];
var googleTask = CreaterGoogleTask(reminderTask);
var insertRequest = taskService.Tasks.Insert(googleTask,
TaskListId);
batchRequest.Queue <Task>(insertRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message,
reminderTasks, "Error in adding events", errorList,
addedEvents));
}
await batchRequest.ExecuteAsync();
return(addedEvents);
}
/// <summary>
/// Adds several products to the specified account, as a batch.
/// </summary>
/// <returns>The task containing the list of products</returns>
private async Task <List <Product> > InsertProductBatch(ulong merchantId)
{
Console.WriteLine("=================================================================");
Console.WriteLine("Inserting several products");
Console.WriteLine("=================================================================");
// Create a batch request.
BatchRequest request = new BatchRequest(service);
List <Product> products = new List <Product>();
// Add three product insertions to the queue.
for (int i = 0; i < 3; i++)
{
ProductsResource.InsertRequest insertRequest =
service.Products.Insert(shoppingUtil.GenerateProduct(), merchantId);
request.Queue <Product>(
insertRequest,
(content, error, index, message) =>
{
products.Add(content);
Console.WriteLine(String.Format("Product inserted with id {0}", ((Product)content).Id));
});
}
await request.ExecuteAsync(CancellationToken.None);
return(products);
}
/// <summary>
/// Metoda pro hromadny import udalosti do google kalendare
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
async static Task PrijdejHromadneUdalosti(CalendarService service)
{
var request2 = new BatchRequest(service);
foreach (var zaznam in Uzivatel.ZaznamyProGoogleKalendar)
{
request2.Queue <Event>(service.Events.Insert(
new Event
{
Summary = zaznam.Titulek,
Location = zaznam.MistoUrl,
Description = zaznam.Popis,
Start = new EventDateTime()
{
DateTime = zaznam.Start
},
End = new EventDateTime()
{
DateTime = zaznam.Konec
}
}, CalendarId),
(content, error, i, message) =>
{
// Put your callback code here.
Uzivatel.ChybovaHlaska = "Chyba behem importu do google kalendáře.";
});
}
await request2.ExecuteAsync();
}
public void ExecuteAsync_NoCallback_Test()
{
var handler = new BatchMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
using (var service = new MockClientService(initializer, "http://sample.com"))
{
var responses = new List <Tuple <MockResponse, RequestError, HttpResponseMessage> >();
var batch = new BatchRequest(service);
var request1 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"100\"",
Name = "Name1"
});
var request2 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"200\"",
Name = "Name1-1"
});
batch.Queue <MockResponse>(request1, null);
batch.Queue <MockResponse>(request2, null);
batch.ExecuteAsync().Wait();
}
}
public async Task <CalendarUpdateResult> AddStudentGroupSchedule(CalendarService calendarService,
StudentGroupSchedule schedule)
{
var calendarEvents = ResolveEventsFromSchedule(schedule);
try
{
var batchRequest = new BatchRequest(calendarService);
foreach (var calendarEvent in calendarEvents.Take(3)) //TODO: Take all at the end of project
{
batchRequest.Queue(calendarService.Events.Insert(calendarEvent, "primary"),
async(Event content, RequestError error, int index, HttpResponseMessage message) =>
{
var messageContent = await message.Content.ReadAsStringAsync();
if (error is null)
{
return;
}
throw new Exception(error.Message);
});
}
await batchRequest.ExecuteAsync();
return(new CalendarUpdateResult(true));
}
catch (Exception e)
{
return(new CalendarUpdateResult(e.Message));
}
}
private async Task ShareWithAccountsAsync(string fileId, string accounts)
{
if (string.IsNullOrEmpty(accounts))
{
return;
}
var newEmails = accounts.Split(';', StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).Distinct().ToArray();
_logger.LogInformation($"Sharing file {fileId} with {accounts}.");
var folder = await new FilesResource.GetRequest(_driveService, fileId)
{
Fields = "id,permissions", QuotaUser = QuotaUser
}.ExecuteAsync();
var remove = folder.Permissions.Where(x => !newEmails.Contains(x.EmailAddress) && x.EmailAddress != _config.CredentialParameters.ClientEmail).Select(x => _driveService.Permissions.Delete(folder.Id, x.Id)).ToList();
var add = newEmails.Except(folder.Permissions.Select(x => x.EmailAddress))
.Select(x => new PermissionsResource.CreateRequest(_driveService, new Permission {
EmailAddress = x, Type = "user", Role = "reader"
}, folder.Id)
{
QuotaUser = QuotaUser,
SendNotificationEmail = false
}).ToList();
var cb = DefaultBatchCallback <Permission>();
var batch = new BatchRequest(_driveService);
remove.ForEach(x => batch.Queue(x, cb));
add.ForEach(x => batch.Queue(x, cb));
await batch.ExecuteAsync();
}
/// <summary>
/// Metoda wysyła wszystkie zdarzenia do kalendarza jako jeden request.
/// Wykonywana po zaktualizowaniu wszystkich zdarzeń z bazy danych.
/// </summary>
public async Task SendEventsRequest()
{
Logs.WriteErrorLog("SendEventsRequest " + Request.Count.ToString());
await Request.ExecuteAsync();
Request = new BatchRequest(Service);
}
public async void BatchInsertFromTemplate(int UserId, string Timezone, List <WeeklyTemplateEventData> fromTemplateEvents)
{
string AccessToken = oAuthService.GetGoogleAccessToken(UserId);
if (AccessToken != null && fromTemplateEvents.Count != 0)
{
System.Diagnostics.Debug.WriteLine("Calendar has FromTemplate events!... attemping Google batch insert!");
string[] scopes = new string[] { "https://www.googleapis.com/auth/calendar" };
var flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = oAuthService.GoogleClientId,
ClientSecret = oAuthService.GoogleClientSecret
},
Scopes = scopes,
DataStore = new FileDataStore("Store")
});
var token = new TokenResponse
{
AccessToken = AccessToken,
RefreshToken = oAuthService.GetGoogleRefreshToken(UserId)
};
var credential = new UserCredential(flow, UserId.ToString(), token);
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = oAuthService.GoogleApplicationName,
});
var request = new BatchRequest(service);
foreach (WeeklyTemplateEventData template in fromTemplateEvents)
{
request.Queue <Event>(service.Events.Insert(
new Event
{
Summary = template.Title,
Start = new EventDateTime()
{
DateTimeRaw = template.StartDateTime, TimeZone = Timezone
},
End = new EventDateTime()
{
DateTimeRaw = template.EndDateTime, TimeZone = Timezone
},
ColorId = exCalHelperService.GetGoogleColor(template.CategoryId)
}, "primary"),
(content, error, i, message) =>
{
exCalHelperService.StoreExternalEventId(UserId, template.LocalId, content.Id, 1, content.ETag);
});
}
await request.ExecuteAsync();
}
}
private static void SafeExecuteSync(BatchRequest batchRequest, int attemptOrderNumber)
{
// Attempt to execute provided request.
try { Task.Run(async() => { await batchRequest.ExecuteAsync(); }).Wait(); }
// On request operation canceled
catch (OperationCanceledException ex)
{
// Increase attempt order number by one.
attemptOrderNumber++;
// Validate whether request reattempt limit hasn't been exceeded
if (RequestsExecutor._cancellationErrorAttemptsLimit < attemptOrderNumber)
{
// ... and throw appropriate exception if has. attempt
throw new BatchRequestExecutionUnexpectedException(batchRequest, ex);
}
// Await appropriate cooldown period.
Thread.Sleep(RequestsExecutor._cancellationErrorCooldown);
// Reattempt.
RequestsExecutor.SafeExecuteSync(batchRequest, attemptOrderNumber);
}
// On google internal error encounter, retry
catch (Google.GoogleApiException ex) when(ex.Message.Contains("Internal error encountered. [500]"))
{
// Increase attempt order number by one.
attemptOrderNumber++;
// Validate whether request reattempt limit hasn't been exceeded
if (RequestsExecutor._internalErrorAttemptsLimit < attemptOrderNumber)
{
// ... and throw appropriate exception if has. attempt
throw new BatchRequestExecutionUnexpectedException(batchRequest, ex);
}
// Await appropriate cooldown period.
Thread.Sleep(RequestsExecutor._internalErrorCooldown);
// Reattempt.
RequestsExecutor.SafeExecuteSync(batchRequest, attemptOrderNumber);
}
// On used all available requests quota
catch (Google.GoogleApiException ex) when(ex.Message.Contains("Quota exceeded for quota group"))
{
// Set session request limiter state to indicate no available google requests quota at this time.
SessionRequestsLimiter.Instance.ClearAvailableQuota();
// Reattempt.
RequestsExecutor.SafeExecuteSync(batchRequest, attemptOrderNumber);
}
// On any other unexpected database error
catch (Google.GoogleApiException ex) { throw new BatchRequestExecutionUnexpectedException(batchRequest, ex); }
}
// GET: Selection
public async Task <ActionResult> Index(CancellationToken cancellationToken)
{
var result = await new AuthorizationCodeMvcApp(this, new AppFlowMetadata()).AuthorizeAsync(cancellationToken);
if (result.Credential != null)
{
var service = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = result.Credential,
ApplicationName = ApplicationName
});
try
{
var selectionViewModel = new SelectionViewModel();
var examLinksList = new List <ExamLink>();
var request = new BatchRequest(service);
var selectedPaperIds = string.Join(",", ((List <int>)Session["SelectedIds"]).ToArray());
var examPapers = HttpDataProvider.GetData <List <dynamic> >(string.Format("exam/forids?examIds={0}", selectedPaperIds));
examPapers.ForEach(delegate(dynamic examPaper) {
string fileId = examPaper.FileStoreId;
request.Queue <Google.Apis.Drive.v2.Data.File>(service.Files.Get(fileId),
(file, error, x, message) =>
{
if (error != null)
{
throw new Exception("error");
}
else
{
examLinksList.Add(new ExamLink {
PaperName = examPaper.PaperName, PaperUrl = file.WebContentLink, FileId = fileId
});
}
});
});
await request.ExecuteAsync();
selectionViewModel.ExamLinks = examLinksList;
Session.Remove("SelectedIds");
return(View(selectionViewModel));
}
catch (Exception ex)
{
// Todo: Log errors and show friendly error
throw ex;
}
}
else
{
return(new RedirectResult(result.RedirectUri));
}
}
public bool shareFile(CommonDescriptor fileToShare, string role, string email, string optionalMessage)
{
try {
Console.WriteLine("STARTED SHARING");
var _googleDriveService = InitializeAPI.googleDriveService;
var batch = new BatchRequest(_googleDriveService);
BatchRequest.OnResponse <Permission> callback = delegate(
Permission permission,
RequestError error,
int index,
System.Net.Http.HttpResponseMessage message)
{
if (error != null)
{
// Handle error
Console.WriteLine(error.Message);
}
else
{
Console.WriteLine("Permission ID: " + permission.Id);
}
};
//TODO: launch the share window view, get the email address
//shareWindow window = new shareWindow();
//window.Show();
//get the informaiton
//TODO: replace these permissions with the permissions entered on the shareWindow
Permission userPermission = new Permission();
userPermission.Type = "user";
userPermission.Role = role; //TODO. pick the correct role
userPermission.EmailAddress = email; //TODO, enter the email address
var request = _googleDriveService.Permissions.Create(userPermission, fileToShare.FileID);
request.Fields = "id";
request.EmailMessage = optionalMessage; //TODO enter message
batch.Queue(request, callback);
var task = batch.ExecuteAsync();
}
catch (Exception e)
{
//caught a bug
Console.WriteLine(e.Message);
}
return(true);
}
private async Task Run()
{
var privatekey = "private key";
var accountEmailAddress = "email address";
var credentials = new ServiceAccountCredential(
new ServiceAccountCredential.Initializer(accountEmailAddress)
{
Scopes = new[] { AnalyticsService.Scope.AnalyticsReadonly }
}.FromPrivateKey(privatekey));
var service = new AnalyticsService(new BaseClientService.Initializer()
{
HttpClientInitializer = credentials,
ApplicationName = "Test"
});
var request = new BatchRequest(service);
BatchRequest.OnResponse <GaData> callback = (content, error, i, message) =>
{
if (error != null)
{
Console.WriteLine("Error: {0}", error.Message);
}
else
{
if (content.Rows != null)
{
foreach (var item in content.Rows)
{
foreach (var item1 in item)
{
Console.WriteLine(item1);
}
}
}
else
{
Console.WriteLine("Not Found");
}
}
};
int counter = 0;
while (counter < 5)
{
var req = service.Data.Ga.Get("ga:XXXXX", "30daysAgo", "yesterday", "ga:sessions");
req.Filters = "ga:pagePath==/page" + counter + ".html";
request.Queue <GaData>(req, callback);
counter++;
}
await request.ExecuteAsync();
}
public static void FileSharing(string fileId, DriveService driveService)
{
try
{
fileId = "1XY2zomDP2qYZJ-aTAPLHSMEu-v7RVjii";
var batch = new BatchRequest(driveService);
BatchRequest.OnResponse <Permission> callback = delegate(
Permission permission,
RequestError error,
int index,
System.Net.Http.HttpResponseMessage message)
{
if (error != null)
{
// Handle error
Console.WriteLine(error.Message);
}
else
{
Console.WriteLine("Permission ID: " + permission.Id);
}
};
Permission userPermission = new Permission()
{
Type = "user",
Role = "writer",
EmailAddress = "*****@*****.**",
};
var request = driveService.Permissions.Create(userPermission, fileId);
request.Fields = "id";
batch.Queue(request, callback);
//Permission domainPermission = new Permission()
//{
// Type = "user",
// Role = "reader",
// Domain = "gmail.com"
//};
//request = driveService.Permissions.Create(domainPermission, fileId);
//request.Fields = "id";
//batch.Queue(request, callback);
var task = batch.ExecuteAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult> SendEmailAsync(CancellationToken cancellaionToken, SelectionViewModel model)
{
var result = await new AuthorizationCodeMvcApp(this, new AppFlowMetadata()).AuthorizeAsync(cancellaionToken);
if (result.Credential != null)
{
var service = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = result.Credential,
ApplicationName = ApplicationName
});
var request = new BatchRequest(service);
try
{
Google.Apis.Drive.v2.Data.Permission newPermission = new Google.Apis.Drive.v2.Data.Permission();
newPermission.Value = model.EmailAddress;
newPermission.Type = "user";
newPermission.Role = "reader";
//service.Permissions.Insert()
model.ExamLinks.ForEach(delegate(ExamLink examLink) {
request.Queue <Google.Apis.Drive.v2.Data.Permission>(service.Permissions.Insert(newPermission, examLink.FileId),
(permission, error, x, message) =>
{
if (error != null)
{
throw new Exception("error");
}
});
});
await request.ExecuteAsync();
//sendEmail(model);
return(View("Index", model));
}
catch (Exception ex)
{
throw ex;
}
}
else
{
return(new RedirectResult(result.RedirectUri));
}
}
public async Task FileSharing(DriveService driveService, string fileId, string email)
{
try
{
var batch = new BatchRequest(driveService);
BatchRequest.OnResponse <Permission> callback = delegate(
Permission permission,
RequestError error,
int index,
HttpResponseMessage message)
{
if (error != null)
{
// Handle error
foreach (var singleError in error.Errors)
{
_logger.LogError($"Message: {singleError.Message}");
_logger.LogError($"Domain: {singleError.Domain}");
_logger.LogError($"Location: {singleError.Location}");
_logger.LogError($"LocationType: {singleError.LocationType}");
_logger.LogError($"Reason: {singleError.Reason}");
}
}
else
{
_logger.LogInformation("Permission ID: " + permission.Id);
}
};
var userPermission = new Permission
{
Type = "user",
Role = "writer",
EmailAddress = email,
};
var request = driveService.Permissions.Create(userPermission, fileId);
request.Fields = "id";
batch.Queue(request, callback);
await batch.ExecuteAsync();
}
catch (Exception e)
{
_logger.LogError(default(EventId), e, e.Message);
throw;
}
}
public async void BatchDeleteFromTemplateEvents(int UserId, List <ExternalEventIds> externalEventIds)
{
string AccessToken = oAuthService.GetGoogleAccessToken(UserId);
if (AccessToken != null && externalEventIds.Count != 0)
{
string[] scopes = new string[] { "https://www.googleapis.com/auth/calendar" };
var flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = new ClientSecrets
{
ClientId = oAuthService.GoogleClientId,
ClientSecret = oAuthService.GoogleClientSecret
},
Scopes = scopes,
DataStore = new FileDataStore("Store")
});
var token = new TokenResponse
{
AccessToken = AccessToken,
RefreshToken = oAuthService.GetGoogleRefreshToken(UserId)
};
var credential = new UserCredential(flow, UserId.ToString(), token);
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = oAuthService.GoogleApplicationName,
});
var request = new BatchRequest(service);
foreach (ExternalEventIds template in externalEventIds)
{
if (template.GoogleId != null)
{
request.Queue <Event>(service.Events.Delete("primary", template.GoogleId),
(content, error, i, message) =>
{
exCalHelperService.DeleteExternalEvent(template.GoogleId);
});
}
}
await request.ExecuteAsync();
}
}
/// <summary>
/// Delete Events from the Google Calendar
/// </summary>
/// <param name="owner">calendar owner</param>
/// <param name="calendarId">calendar id</param>
/// <param name="events">events to remove</param>
/// <returns>async task for the background Api tasks</returns>
private static async Task DeleteGoogleEventsAsync(string owner, string calendarId, List <GCalEventItem> events)
{
try
{
int batchCount = 1;
// Create a batch request.
var request = new BatchRequest(GetCalendarService(owner));
foreach (GCalEventItem e in events)
{
if (batchCount < 900)
{
request.Queue <Event>(
GetCalendarService(owner).Events.Delete(calendarId, e.EventId), (content, error, i, message) =>
{
// Put your callback code here.
if (error != null)
{
log.Error("Error deleting removed appointments from Google Calendar: " + error.Message);
}
});
batchCount++;
}
else
{
// Execute the batch request and create a new batch as cannot send more than 1000
await request.ExecuteAsync();
batchCount = 1;
request = new BatchRequest(GetCalendarService(owner));
}
}
// Execute the batch request
await request.ExecuteAsync();
googleCalEvents = (List <GCalEventItem>)googleCalEvents.Except(events).ToList();
}
catch (Exception e)
{
log.Error("Error deleting Google Events : " + e.Message);
}
}
public async Task DeleteContainerAsync(string containerName)
{
try
{
var batch = new BatchRequest(_storageService);
foreach (var blob in await ListBlobsAsync(containerName))
{
batch.Queue <string>(_storageService.Objects.Delete(_bucket, $"{blob.Container}/{blob.Name}"),
(content, error, i, message) => { });
}
await batch.ExecuteAsync();
}
catch (GoogleApiException gae)
{
throw Error(gae);
}
}
public static List <UrlNotificationMetadata> VerifySubmissionStatus(List <string> urls)
{
var metadataRequest = new BatchRequest(_googleIndexingApiClientService);
var metadataResponses = new List <UrlNotificationMetadata>();
foreach (var url in urls)
{
metadataRequest.Queue <UrlNotificationMetadata>(
new UrlNotificationsResource.GetMetadataRequest(_googleIndexingApiClientService)
{
Url = url
}, (response, error, i, message) =>
{
metadataResponses.Add(response);
});
}
metadataRequest.ExecuteAsync().ConfigureAwait(false);
return(metadataResponses);
}
public void DeleteContainer(string containerName)
{
try
{
var batch = new BatchRequest(_storageService);
foreach (var blob in ListBlobs(containerName))
{
batch.Queue <string>(_storageService.Objects.Delete(_bucket, $"{blob.Container}/{blob.Name}"),
(content, error, i, message) => { });
}
AsyncHelpers.RunSync(() => batch.ExecuteAsync());
}
catch (GoogleApiException gae)
{
throw Error(gae);
}
}
private static void ShareFileById(string fileId, string filename, string recipientEmail, string senderName, RoleType roleType)
{
var batch = new BatchRequest(DriveService);
BatchRequest.OnResponse <Permission> callback = delegate(
Permission permission,
RequestError error,
int index,
System.Net.Http.HttpResponseMessage message)
{
if (error != null)
{
MessageBox.Show("Could not share the file with " + recipientEmail + "!\nReason: " + error.Message, "Drive Crypt", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
};
Permission userPermission = new Permission();
userPermission.Type = "user";
userPermission.Role = roleType.ToString();
userPermission.EmailAddress = recipientEmail;
var request = DriveService.Permissions.Create(userPermission, fileId);
request.Fields = "id";
if (Path.GetExtension(filename) == FileCryptor.DRIVE_CRYPT_EXTENSTION)
{
request.SendNotificationEmail = true;
request.EmailMessage = string.Format("{0} has shared the following encoded file with you:\n{1}\nwhich you can view under http://drive.google.com/file/d/{2} \nbut it can only be readable after decoding, using DriveCrypt application.", senderName, filename, fileId);
}
else
{
request.SendNotificationEmail = false;
}
batch.Queue(request, callback);
batch.ExecuteAsync();
}
/// <summary>
/// Deletes several products from the specified account, as a batch.
/// </summary>
private async Task DeleteProductsBatch(ulong merchantId, List <Product> newProductsBatch)
{
Console.WriteLine("=================================================================");
Console.WriteLine("Deleting several products");
Console.WriteLine("=================================================================");
// Create a batch request.
BatchRequest request = new BatchRequest(service);
foreach (Product product in newProductsBatch)
{
ProductsResource.DeleteRequest deleteRequest = service.Products.Delete(merchantId, product.Id);
request.Queue <Product>(
deleteRequest,
(content, error, i, message) =>
{
Console.WriteLine("Product deleted.");
});
}
await request.ExecuteAsync(CancellationToken.None);
}
private async Task <List <Appointment> > AddCalendarEventsInternal(List <Appointment> calendarAppointments,
bool addDescription, bool addReminder,
bool addAttendees,
bool attendeesToDescription, CalendarService calendarService,
Dictionary <int, Appointment> errorList)
{
var addedEvents = new List <Appointment>();
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
for (var i = 0; i < calendarAppointments.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = calendarAppointments[i];
var calendarEvent = CreateGoogleCalendarEvent(appointment, addDescription, addReminder,
addAttendees,
attendeesToDescription);
var insertRequest = calendarService.Events.Insert(calendarEvent,
CalendarId);
insertRequest.SendNotifications = false;
insertRequest.MaxAttendees = 10000;
batchRequest.Queue <Event>(insertRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message,
calendarAppointments, "Error in adding events", errorList,
addedEvents));
}
await batchRequest.ExecuteAsync();
return(addedEvents);
}
/// <summary>
/// Deletes several products from the specified account, as a batch.
/// </summary>
private async Task DeleteProductsBatch(ulong merchantId, List<Product> newProductsBatch)
{
Console.WriteLine("=================================================================");
Console.WriteLine("Deleting several products");
Console.WriteLine("=================================================================");
// Create a batch request.
BatchRequest request = new BatchRequest(service);
foreach (Product product in newProductsBatch) {
ProductsResource.DeleteRequest deleteRequest = service.Products.Delete(merchantId, product.Id);
request.Queue<Product>(
deleteRequest,
(content, error, i, message) =>
{
Console.WriteLine("Product deleted.");
});
}
await request.ExecuteAsync(CancellationToken.None);
}
public async Task<AppointmentsWrapper> UpdateCalendarEvents(List<Appointment> calendarAppointments, bool addDescription,
bool addReminder, bool addAttendees, bool attendeesToDescription,
IDictionary<string, object> calendarSpecificData)
{
var updatedAppointments = new AppointmentsWrapper();
if (!calendarAppointments.Any())
{
updatedAppointments.IsSuccess = true;
return updatedAppointments;
}
CheckCalendarSpecificData(calendarSpecificData);
var errorList = new Dictionary<int, Appointment>();
//Get Calendar Service
var calendarService = GetCalendarService(AccountName);
if (calendarAppointments == null || string.IsNullOrEmpty(CalendarId))
{
updatedAppointments.IsSuccess = false;
return updatedAppointments;
}
try
{
if (calendarAppointments.Any())
{
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
//Split the list of calendarAppointments by 1000 per list
//Iterate over each appointment to create a event and batch it
for (var i = 0; i < calendarAppointments.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = calendarAppointments[i];
var calendarEvent = CreateUpdatedGoogleCalendarEvent(appointment, addDescription, addReminder,
addAttendees, attendeesToDescription);
var updateRequest = calendarService.Events.Update(calendarEvent,
CalendarId, calendarEvent.Id);
batchRequest.Queue<Event>(updateRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message, calendarAppointments, "Error in updating event",errorList,updatedAppointments));
}
await batchRequest.ExecuteAsync();
}
}
catch (Exception exception)
{
Logger.Error(exception);
updatedAppointments.IsSuccess = false;
return updatedAppointments;
}
updatedAppointments.IsSuccess = true;
return updatedAppointments;
}
private async Task<List<Appointment>> AddCalendarEventsInternal(List<Appointment> calendarAppointments,
bool addDescription, bool addReminder,
bool addAttendees,
bool attendeesToDescription, CalendarService calendarService,
Dictionary<int, Appointment> errorList)
{
var addedEvents = new List<Appointment>();
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
for (var i = 0; i < calendarAppointments.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = calendarAppointments[i];
var calendarEvent = CreateGoogleCalendarEvent(appointment, addDescription, addReminder,
addAttendees,
attendeesToDescription);
var insertRequest = calendarService.Events.Insert(calendarEvent,
CalendarId);
insertRequest.MaxAttendees = 10000;
batchRequest.Queue<Event>(insertRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message,
calendarAppointments, "Error in adding events",errorList,
addedEvents));
}
await batchRequest.ExecuteAsync();
return addedEvents;
}
public async Task<CalendarAppointments> DeleteCalendarEvents(List<Appointment> calendarAppointments,
IDictionary<string, object> calendarSpecificData)
{
var deletedAppointments = new CalendarAppointments();
if (!calendarAppointments.Any())
{
deletedAppointments.IsSuccess = true;
return deletedAppointments;
}
CheckCalendarSpecificData(calendarSpecificData);
var errorList = new Dictionary<int, Appointment>();
//Get Calendar Service
var calendarService = GetCalendarService(AccountName);
if (calendarAppointments == null || string.IsNullOrEmpty(CalendarId))
{
deletedAppointments.IsSuccess = false;
return deletedAppointments;
}
try
{
if (calendarAppointments.Any())
{
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
//Split the list of calendarAppointments by 1000 per list
//Iterate over each appointment to create a event and batch it
for (var i = 0; i < calendarAppointments.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = calendarAppointments[i];
var deleteRequest = calendarService.Events.Delete(CalendarId,
appointment.AppointmentId);
batchRequest.Queue<Event>(deleteRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message, calendarAppointments,
"Error in deleting events",errorList,deletedAppointments));
}
await batchRequest.ExecuteAsync();
}
}
catch (Exception exception)
{
Logger.Error(exception);
deletedAppointments.IsSuccess = false;
return deletedAppointments;
}
deletedAppointments.IsSuccess = true;
return deletedAppointments;
}
public async Task<ActionResult> Index(CancellationToken cancellationToken, string q = null)
{
var result = await new AuthorizationCodeMvcApp(this, new MyMailFlowMetadata()).AuthorizeAsync(cancellationToken);
if (result.Credential != null)
{
List<Message> messages = new List<Message>();
List<Label> labels = new List<Label>();
var service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = result.Credential,
ApplicationName = ApplicationName
});
UsersResource.LabelsResource.ListRequest labelsRequest = service.Users.Labels.List("me");
UsersResource.MessagesResource.ListRequest messagesRequest = service.Users.Messages.List("me");
messagesRequest.Q = q ?? "label:inbox ";
ListLabelsResponse labelsResponse = null;
ListMessagesResponse messagesResponse = null;
var batchRequests = new BatchRequest(service);
batchRequests.Queue<ListLabelsResponse>(labelsRequest,
(content, error, i, message) =>
{
labelsResponse = content;
});
batchRequests.Queue<ListMessagesResponse>(messagesRequest,
(content, error, i, message) =>
{
messagesResponse = content;
});
await batchRequests.ExecuteAsync();
batchRequests = new BatchRequest(service);
foreach (var label in labelsResponse.Labels)
{
batchRequests.Queue<Label>(service.Users.Labels.Get("me", label.Id),
(content, error, i, label2) =>
{
labels.Add(content);
});
}
foreach (var message in messagesResponse.Messages)
{
batchRequests.Queue<Message>(service.Users.Messages.Get("me", message.Id),
(content, error, i, message2) =>
{
messages.Add(content);
});
}
await batchRequests.ExecuteAsync();
ViewBag.Labels = labels;
ViewBag.Messages = messages;
return View();
}
else
{
return new RedirectResult(result.RedirectUri);
}
}
public async System.Threading.Tasks.Task UploadResults()
{
var request = new BatchRequest(Service);
foreach (WorkDay day in Schedule)
{
// Setup request for current events.
EventsResource.ListRequest listrequest = Service.Events.List(Calendarid);
listrequest.TimeMin = DateTime.Today.AddDays(-6);
listrequest.TimeMax = DateTime.Today.AddDays(15);
listrequest.ShowDeleted = false;
listrequest.SingleEvents = true;
listrequest.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime;
// Check to see if work events are already in place on the schedule, if they are,
// setup a batch request to delete them.
// Not the best implementation, but takes care of duplicates without tracking
// eventIds to update existing events.
String workevent = "Wegmans: ";
Events eventslist = listrequest.Execute();
if (eventslist.Items != null && eventslist.Items.Count > 0)
{
foreach (Event eventItem in eventslist.Items)
{
if(eventItem.Start.DateTime != null)
{
DateTime eventcontainer = (DateTime)eventItem.Start.DateTime; // Typecast to use ToShortDateString() method for comparison.
if (((eventcontainer.ToShortDateString()) == (day.Date.ToShortDateString())) && (eventItem.Summary.Contains(workevent)))
{
request.Queue<Event>(Service.Events.Delete(Calendarid, eventItem.Id),
(content, error, i, message) =>
{
if (error != null)
{
throw new Exception(error.ToString());
}
});
}
}
}
}
// Setup a batch request to upload the work events.
request.Queue<Event>(Service.Events.Insert(
new Event
{
Summary = workevent + day.Activity,
Description = day.Comments,
Location = day.Location,
Start = new EventDateTime()
{
DateTime = day.StartDateTime,
TimeZone = "America/New_York",
},
End = new EventDateTime()
{
DateTime = day.EndDateTime,
TimeZone = "America/New_York",
},
Reminders = new Event.RemindersData()
{
UseDefault = true,
},
}, Calendarid),
(content, error, i, message) =>
{
if (error != null)
{
throw new Exception(error.ToString());
}
});
}
// Execute batch request.
await request.ExecuteAsync();
}
/// <summary>
/// Adds several products to the specified account, as a batch.
/// </summary>
/// <returns>The task containing the list of products</returns>
private async Task<List<Product>> InsertProductBatch(ulong merchantId)
{
Console.WriteLine("=================================================================");
Console.WriteLine("Inserting several products");
Console.WriteLine("=================================================================");
// Create a batch request.
BatchRequest request = new BatchRequest(service);
List<Product> products = new List<Product>();
// Add three product insertions to the queue.
for (int i = 0; i < 3; i++)
{
ProductsResource.InsertRequest insertRequest =
service.Products.Insert(shoppingUtil.GenerateProduct(), merchantId);
request.Queue<Product>(
insertRequest,
(content, error, index, message) =>
{
products.Add(content);
Console.WriteLine(String.Format("Product inserted with id {0}", ((Product)content).Id));
});
}
await request.ExecuteAsync(CancellationToken.None);
return products;
}
public async Task<TasksWrapper> UpdateReminderTasks(List<ReminderTask> reminderTasks, IDictionary<string, object> taskListSpecificData)
{
var updatedAppointments = new TasksWrapper();
if (!reminderTasks.Any())
{
updatedAppointments.IsSuccess = true;
return updatedAppointments;
}
CheckTaskListSpecificData(taskListSpecificData);
var errorList = new Dictionary<int, ReminderTask>();
//Get Calendar Service
var calendarService = GetTasksService(AccountName);
if (reminderTasks == null || string.IsNullOrEmpty(TaskListId))
{
updatedAppointments.IsSuccess = false;
return updatedAppointments;
}
try
{
if (reminderTasks.Any())
{
//Create a Batch Request
var batchRequest = new BatchRequest(calendarService);
//Split the list of calendarAppointments by 1000 per list
//Iterate over each appointment to create a event and batch it
for (var i = 0; i < reminderTasks.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(calendarService);
}
var appointment = reminderTasks[i];
var task = CreateUpdatedGoogleTask(appointment);
var updateRequest = calendarService.Tasks.Update(task,
TaskListId, task.Id);
batchRequest.Queue<Task>(updateRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message, reminderTasks,
"Error in updating event", errorList, updatedAppointments));
}
await batchRequest.ExecuteAsync();
}
}
catch (Exception exception)
{
Logger.Error(exception);
updatedAppointments.IsSuccess = false;
return updatedAppointments;
}
updatedAppointments.IsSuccess = reminderTasks.Count == updatedAppointments.Count;
return updatedAppointments;
}
private async Task<List<ReminderTask>> AddTasksInternal(List<ReminderTask> reminderTasks,
TasksService taskService, Dictionary<int, ReminderTask> errorList)
{
var addedEvents = new List<ReminderTask>();
//Create a Batch Request
var batchRequest = new BatchRequest(taskService);
for (var i = 0; i < reminderTasks.Count; i++)
{
if (i != 0 && i % 999 == 0)
{
await batchRequest.ExecuteAsync();
batchRequest = new BatchRequest(taskService);
}
var reminderTask = reminderTasks[i];
var googleTask = CreaterGoogleTask(reminderTask);
var insertRequest = taskService.Tasks.Insert(googleTask,
TaskListId);
batchRequest.Queue<Task>(insertRequest,
(content, error, index, message) =>
CallbackEventErrorMessage(content, error, index, message,
reminderTasks, "Error in adding events", errorList,
addedEvents));
}
await batchRequest.ExecuteAsync();
return addedEvents;
}