public UserController(IAuthTokenRepo authTokenRepo, IUserRepo userRepo, GoogleCalendarService googleCalendarApi) { _authTokenRepo = authTokenRepo; _googleCalendarApi = googleCalendarApi; _userRepo = userRepo; }
public async Task CreateCalendarWithEventsShouldReturnOperationalResultCalendarFailure() { var messages = new Dictionary <string, HttpResponseMessage>() { [this._googleCalendarSettings.CalendarsEndpoint] = new HttpResponseMessage() { StatusCode = HttpStatusCode.BadRequest, }, [this._googleCalendarSettings.EventsEndpoint] = new HttpResponseMessage() { StatusCode = HttpStatusCode.BadRequest, } }; using var testMessageHandler = new TestMessageHandler(messages); using (var httpClient = new HttpClient(testMessageHandler)) { var googleCalendarService = new GoogleCalendarService( httpClient, this._adventSettings, this._testSettings, this._googleCalendarSettings); // Act var createdCalendar = await googleCalendarService.CreateNewCalendarWithEvents().ConfigureAwait(false); // Assert Assert.IsType <OperationalResult>(createdCalendar); Assert.Equal(OperationalResultStatus.CalendarFailure, createdCalendar.Status); } }
private async Task CleanGoogleCalendarInternal() { if (SelectedProfile.GoogleSettings.GoogleAccount == null || SelectedProfile.GoogleSettings.GoogleCalendar == null) { MessageService.ShowMessageAsync("Please select a Google calendar to wipe"); return; } var task = await MessageService.ShowConfirmMessage( "Are you sure you want to reset events from 10 year past and 10 year future?"); if (task != MessageDialogResult.Affirmative) { return; } var calendarSpecificData = new Dictionary <string, object> { { "CalendarId", SelectedProfile.GoogleSettings.GoogleCalendar.Id }, { "AccountName", SelectedProfile.GoogleSettings.GoogleAccount.Name } }; var result = await GoogleCalendarService.ClearCalendar(calendarSpecificData); if (!result) { MessageService.ShowMessageAsync("Reset calendar failed."); } }
private async Task GetGoogleCalendarInternal() { try { if (SelectedProfile.GoogleSettings.GoogleAccount == null || SelectedProfile.GoogleSettings.GoogleAccount.Name == null) { return; } var calendars = await GoogleCalendarService.GetAvailableCalendars( SelectedProfile.GoogleSettings.GoogleAccount.Name); if (calendars.Any()) { if (SelectedProfile.GoogleSettings.GoogleCalendar != null) { SelectedProfile.GoogleSettings.GoogleCalendar = calendars.FirstOrDefault(t => t.Id.Equals(SelectedProfile.GoogleSettings.GoogleCalendar.Id)); } if (SelectedProfile.GoogleSettings.GoogleCalendar == null) { SelectedProfile.GoogleSettings.GoogleCalendar = calendars.First(); } } SelectedProfile.GoogleSettings.GoogleCalendars = calendars; } catch (Exception exception) { MessageService.ShowMessageAsync("Unable to get Google calendars."); Logger.Error(exception); } }
public IndexModel(ILogger <IndexModel> logger, BackgroundImageService backgroundImageService, GoogleCalendarService calendarService, WeatherService weatherService) { this._logger = logger; this._backgroundImageService = backgroundImageService; this._calendarService = calendarService; this._weatherService = weatherService; this.NextDays = new CalendarDay[0]; }
public static void Main(string[] args) { DesktopPlatform.Start(); GoogleCalendarService google = new GoogleCalendarService(new TestConfig()); DesktopPlatform.Finish(); }
public async Task DoWork() // Add new gmail account and sync with db { var service = new GoogleCalendarService(); var range = (int)AppDomain.CurrentDomain.GetData("EventViewableYearRange"); var timeMax = new DateTime(DateTime.Today.Year + range - 1, 12, 31, 23, 59, 59); var accounts = _dbs.GetAvailableAccounts(); try { var events = await service.GetEvents(timeMax); if (events != null && !events.Items.IsNullOrEmpty()) { var email = events.Items[0].Creator.Email; var foundAcc = accounts.Find(a => a.Email == email); List <GXEvent> newEvents = null; int targetAccountId = 0; // Email exists within db, add new events from last sync timestamp if (foundAcc != null) { targetAccountId = foundAcc.AccId; var fromLastSync = events.Items.Where(e => e.Updated >= foundAcc.LastSync); newEvents = fromLastSync.ToGXEvents(targetAccountId); } // New email else { targetAccountId = accounts.Max(a => a.AccId) + 1; await _dbs.AddAccount(email); newEvents = events.Items.ToGXEvents(targetAccountId); } // Add new events to db await _dbs.AddEvents(newEvents, targetAccountId); await _dbs.UpdateLastSync(targetAccountId); } } catch (Newtonsoft.Json.JsonException) { throw new FormatException("Incorrect oauth token file format. Restore or delete it and try again"); } catch (DataException) { throw new DataException("Failed to modify database. Verify the connection and try again"); } finally { if (Events.Count < viewableEventsNum) { RefreshEvents(viewableEventsNum); } } }
public CalendarController(ICalendarService calendarService, IAuthenticationService authenticationService, ExternalCalendarHelperService exCalHelperService, OAuthService oAuthService, GoogleCalendarService googleCalendarService, MicrosoftOAuthService msOAuthService, MicrosoftCalendarService msCalService) { this.calendarService = calendarService; this.authenticationService = authenticationService; this.exCalHelperService = exCalHelperService; this.oAuthService = oAuthService; this.googleCalendarService = googleCalendarService; this.msOAuthService = msOAuthService; this.msCalService = msCalService; }
private async Task <List <Appointment> > GetEqualAppointments(GoogleCalendarService googleCalenderService, OutlookCalendarService outlookCalendarService, string calenderId) { List <Appointment> googleAppointments = await googleCalenderService.GetCalendarEventsInRangeAsync(0, 2, calenderId); List <Appointment> outLookAppointments = await outlookCalendarService.GetOutlookAppointmentsAsync(0, 2); return((from lookAppointment in outLookAppointments let isAvailable = googleAppointments.Any(appointment => appointment.Equals(lookAppointment)) where isAvailable select lookAppointment).ToList()); }
public async Task CalendarService_SucessfullyDeleteAddedEvent(GoogleCalendarService service, string eventId) { try { await service.DeleteEvent(eventId); } catch (Exception ex) { Assert.Fail("Failed to delete event: " + ex.Message); } }
private void StartAuthentication(TaskScheduler taskScheduler) { //// Authenticate Oauth2 string clientId = "68932173233-e7nf2hlqhl9o16knj0iatg82bmgdkvom.apps.googleusercontent.com"; string clientSecret = "QRDGYelWPnCOsCiWlXVl6Cc3"; string redirectUri = "urn:ietf:wg:oauth:2.0:oob"; string userName = "******"; // A string used to identify a user (locally). var calenderService = (new AccountAuthentication()).AuthenticateCalenderOauth(clientId, clientSecret, userName, "OutlookGoogleSyncRefresh.Auth.Store", "OutlookGoogleSyncRefresh"); var googleCalenderService = new GoogleCalendarService(calenderService); googleCalenderService.GetAvailableCalendars() .ContinueWith(task => ContinuationActionGoogle(task, googleCalenderService, taskScheduler)); }
public async Task <string> CalendarService_SucessfullyAddEvent(GoogleCalendarService service) { var dummyEvent = CreateDummyEvent().ToEvent(); string dummyId = ""; try { dummyId = await service.AddEvent(dummyEvent); } catch (Exception ex) { Assert.Fail("Failed to add event: " + ex.Message); } return(dummyId); }
private void ContinuationActionGoogle(Task <List <Calendar> > task, GoogleCalendarService googleCalenderService, TaskScheduler taskScheduler) { string calenderId = string.Empty; var calender = task.Result.FirstOrDefault(calendar => calendar.Name.Contains("Test")); if (calender != null) { calenderId = calender.Id; } googleCalenderService.GetCalendarEventsInRangeAsync(0, 1, calenderId) .ContinueWith(ContinuationActionGoogleAppointments, taskScheduler); }
private void Button_Clicked(object sender, EventArgs e) { var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "mycalendar_credentials.json"); var googleCalendar = new GoogleCalendarService(path); var eventTitle = EntryEventTitle.Text; var participants = EntryParticipants.Text.Split(';'); var eventDateTime = new DateTime(DatePickerMeeting.Date.Year, DatePickerMeeting.Date.Month, DatePickerMeeting.Date.Day, TimePickerMeeting.Time.Hours, TimePickerMeeting.Time.Minutes, TimePickerMeeting.Time.Seconds ); googleCalendar.CreateEvent(eventTitle, participants, eventDateTime, eventDateTime.AddHours(1)); }
public async Task CalendarService_SucessfullyRetrieveAddedEvent(GoogleCalendarService service, string eventId) { try { var dummyRetrieved = await service.GetEvent(eventId); if (dummyRetrieved == null || dummyRetrieved.Summary != "dummy event") { Assert.Fail("Incorrect dummy event retrieved"); } } catch (Exception ex) { Assert.Fail("Failed to get event: " + ex.Message); } }
public async Task TestGoogleCalendarServiceSample() { // arrange var service = new GoogleCalendarService( googleToken: new TokenEntity() { TokenType = "Bearer", AccessToken = TestContext.Parameters["GOOGLE_TEST_TOKEN"] }, calendarId: TestContext.Parameters["GOOGLE_CALENDAR_ID"] ); // act var result = await service.GetEventsSample(); // assert Assert.IsNotNull(result); }
public static async Task <System.Collections.Generic.List <Models.CalendarEntry> > GetCalendars(TokenEntity msaToken, TokenEntity googleToken, ILogger logger) { var start = DateTime.Now.Date.AddDays(-7); var end = DateTime.Now.Date.AddDays(Constants.CalendarWeeks * 7); var events = new System.Collections.Generic.List <CalendarEntry>(); try { var holidays = new System.Collections.Generic.List <CalendarEntry>(); // combine public and school holidays var publicHolidaysService = new PublicHolidaysService(); var schoolHolidaysService = new SchoolHolidaysService(); holidays.AddRange(await publicHolidaysService.GetEvents(start, end)); holidays.AddRange(await schoolHolidaysService.GetEvents(start, end, logger)); var deduplicatedHolidays = holidays.GroupBy(x => x.Date).Select(y => y.First()).ToList <CalendarEntry>(); events.AddRange(deduplicatedHolidays); var googleCalendarService = new GoogleCalendarService( googleToken, calendarId: Util.GetEnvironmentVariable("GOOGLE_CALENDAR_ID"), timeZone: Util.GetEnvironmentVariable("CALENDAR_TIMEZONE")); var googleEvents = await googleCalendarService.GetEvents(start, end, isPrimary : true); events.AddRange(googleEvents); var outlookCalendarService = new OutlookCalendarService(msaToken, timeZone: Util.GetEnvironmentVariable("CALENDAR_TIMEZONE")); var outlookEvents = await outlookCalendarService.GetEvents(start, end, isSecondary : true); events.AddRange(outlookEvents); } catch (Exception ex) { throw ex; } return(events); }
private void Button_Click_Selected(object sender, RoutedEventArgs e) { MyGrid.IsEnabled = false; //// Authenticate Oauth2 string clientId = "68932173233-e7nf2hlqhl9o16knj0iatg82bmgdkvom.apps.googleusercontent.com"; string clientSecret = "QRDGYelWPnCOsCiWlXVl6Cc3"; string redirectUri = "urn:ietf:wg:oauth:2.0:oob"; string userName = "******"; // A string used to identify a user (locally). var calenderService = (new AccountAuthenticationService(new ApplicationLogger(), new MessageService())).AuthenticateCalenderOauth(clientId, clientSecret, userName, "OutlookGoogleSyncRefresh.Auth.Store", "OutlookGoogleSyncRefresh"); var googleCalenderService = new GoogleCalendarService(calenderService, new ApplicationLogger()); var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); googleCalenderService.GetAvailableCalendars() .ContinueWith( task => GetInformation(task.Result, scheduler, googleCalenderService)); }
public async Task TestGoogleCalendarService1Week() { // arrange var service = new GoogleCalendarService( googleToken: new TokenEntity() { TokenType = "Bearer", AccessToken = TestContext.Parameters["GOOGLE_TEST_TOKEN"] }, calendarId: TestContext.Parameters["GOOGLE_CALENDAR_ID"] ); var start = DateTime.Now.Date; var end = DateTime.Now.Date.AddDays(7); // act var result = await service.GetEvents(start, end); // assert Assert.IsNotNull(result); Assert.Greater(result.Count, 0); }
public async Task CreateCalendarWithEventsShouldReturnOperationalResultSuccess() { // Arrange var newCalendarId = "1"; var eventsUrl = this.GetEventsUrl(newCalendarId); var messages = new Dictionary <string, HttpResponseMessage>() { [this._googleCalendarSettings.CalendarsEndpoint] = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StringContent( JsonConvert.SerializeObject(new CalendarDto() { Id = newCalendarId }), Encoding.UTF8, MediaTypeNames.Application.Json) }, [eventsUrl] = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, } }; using var testMessageHandler = new TestMessageHandler(messages); using var httpClient = new HttpClient(testMessageHandler); var googleCalendarService = new GoogleCalendarService( httpClient, this._adventSettings, this._testSettings, this._googleCalendarSettings); // Act var createdCalendar = await googleCalendarService.CreateNewCalendarWithEvents().ConfigureAwait(false); // Assert Assert.IsType <OperationalResult>(createdCalendar); Assert.Equal(OperationalResultStatus.Success, createdCalendar.Status); }
public async Task CalendarService_TestAddGetDelete() { // Path for credential and token const string credPath = @"auth\credentials.json"; const string tokenPath = @"auth\token.json"; var currentDir = Directory.GetCurrentDirectory(); AppDomain.CurrentDomain.SetData("GoogleCalendarCredentialPath", Path.Combine(currentDir, credPath)); AppDomain.CurrentDomain.SetData("GoogleCalendarTokenPath", Path.Combine(currentDir, tokenPath)); // Actual test var service = new GoogleCalendarService(); var eventId = await CalendarService_SucessfullyAddEvent(service); if (eventId.IsNullOrEmpty()) { Assert.Fail("Empty google event id retrieved"); } await CalendarService_SucessfullyRetrieveAddedEvent(service, eventId); await CalendarService_SucessfullyDeleteAddedEvent(service, eventId); // Clean up used token Directory.Delete(Path.Combine(currentDir, tokenPath), true); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Admin, "get", Route = null)] HttpRequest req, [Table(Constants.TOKEN_TABLE, partitionKey: Constants.TOKEN_PARTITIONKEY, rowKey: Constants.MSATOKEN_ROWKEY)] TokenEntity msaToken, [Table(Constants.TOKEN_TABLE, partitionKey: Constants.TOKEN_PARTITIONKEY, rowKey: Constants.GOOGLETOKEN_ROWKEY)] TokenEntity googleToken, ILogger log) { string googleCalendarResult; string outlookCalendarResult; int statusCode = StatusCodes.Status200OK; // check Google calendar try { var calendarService = new GoogleCalendarService( googleToken, calendarId: Util.GetEnvironmentVariable("GOOGLE_CALENDAR_ID"), timeZone: Util.GetEnvironmentVariable("CALENDAR_TIMEZONE")); var result = await calendarService.GetEventsSample(); googleCalendarResult = result?.Count.ToString() ?? "empty resultset"; log.LogInformation(googleCalendarResult); } catch (Exception ex) { googleCalendarResult = ex.Message; log.LogError(ex, nameof(GoogleCalendarService)); statusCode = StatusCodes.Status424FailedDependency; } // check Outlook calender try { var calendarService = new OutlookCalendarService(msaToken, timeZone: Util.GetEnvironmentVariable("CALENDAR_TIMEZONE")); var result = await calendarService.GetEventsSample(); outlookCalendarResult = result?.Count.ToString() ?? "empty resultset"; log.LogInformation(googleCalendarResult); } catch (Exception ex) { outlookCalendarResult = ex.Message; log.LogError(ex, nameof(OutlookCalendarService)); statusCode = StatusCodes.Status424FailedDependency; } // check MSA Token if (msaToken == null) { statusCode = StatusCodes.Status424FailedDependency; } // check Google Token if (googleToken == null) { statusCode = StatusCodes.Status424FailedDependency; } // assemble service info return(statusCode == StatusCodes.Status200OK ? (ActionResult) new OkObjectResult(new { home = Environment.GetEnvironmentVariable("HOME", EnvironmentVariableTarget.Process), webSiteName = Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME", EnvironmentVariableTarget.Process), appRoot = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().CodeBase), staticFilesRoot = Util.GetApplicationRoot(), googleCalendarResult, outlookCalendarResult, msaToken, googleToken }) : (ActionResult) new StatusCodeResult(statusCode)); }
/// <summary> /// Get events from current user his/her google calendar /// </summary> /// <returns>A list of events in GoogleCalenderModel</returns> public List<GoogleCalendarModel> GetEventsUser() { var googleCalendarService = new GoogleCalendarService(_credential); googleCalendarService.CreateService(); return googleCalendarService.GetData(); }
public async Task RequestGoogleCalendarData() { await _googleAuthenticator.LoginGoogle(_testUsername); var calendarService = new GoogleCalendarService(_googleAuthenticator.GetCurrentCredentials()); calendarService.CreateService(); }
// Save received event (already validated by edit view model) to db // If SaveEventMsg.SaveChangeOnline true, then also save event to / delete event from google calendar private async void OnModifyEventReceived(ModifyEventMsg m) { var eventToModify = m.Event; var service = new GoogleCalendarService(); try { // Modify local db and possiblely google calendar based on action switch (m.Action) { case EventModifyAction.Add: string googleCalendarEventId = null; var targetAccountId = eventToModify.AID; // Apply changes online first so any failure will prevent changes from being saved locally if (LoggedIn && m.SaveChangeOnline) { googleCalendarEventId = await service.AddEvent(eventToModify.ToEvent()); } // Event was successfully persisted on Google Calendar, update account and id if (!googleCalendarEventId.IsNullOrEmpty()) { var accounts = _dbs.GetAvailableAccounts(); var lastSyncAccount = accounts.Where(a => a.AccId > 1) .OrderByDescending(a => a.LastSync) .FirstOrDefault(); if (lastSyncAccount == null) { throw new DataException("Couldn't find target Google Calendar account"); } targetAccountId = lastSyncAccount.AccId; eventToModify.GID = googleCalendarEventId; } // Save changes locally await _dbs.AddEvent(eventToModify, targetAccountId); // Switch view to edit just created event Messenger.Base.Send(eventToModify); break; case EventModifyAction.Update: if (LoggedIn && m.SaveChangeOnline) { await service.UpdateEvent(eventToModify.ToEvent()); } await _dbs.UpdateEvent(eventToModify, eventToModify.EID); break; case EventModifyAction.Delete: if (LoggedIn && m.SaveChangeOnline) { await service.DeleteEvent(eventToModify.GID); } _dbs.DeleteEvent(eventToModify.EID); break; default: SendModifyEventStatus(success: false, msg: "Unknown action received"); return; } } catch (DataException ex) { SendModifyEventStatus(success: false, msg: ex.Message); return; } catch (Google.GoogleApiException) { SendModifyEventStatus(success: false, msg: "Unable to apply changes online. If error persists, consider modifying event locally"); return; } SendModifyEventStatus(success: true, deleted: m.Action == EventModifyAction.Delete); RefreshEvents(viewableEventsNum); // Update tree view if opened Messenger.Base.Send(new UpdateTreeViewMsg { ModifiedEvent = m.Event, Action = m.Action }); }
public CalendarViewModel() { var cs = new GoogleCalendarService(); Events = cs.GetListedEvents(cs._googleCalendarService); }
public static async Task Main(string[] args) { // NLog: setup the logger first to catch all errors LogFactory nlog = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config"); #if DEBUG DebugLoggingConfig.ActivateDebugLogging(); #endif var logger = nlog.GetCurrentClassLogger(); logger.Info("Startup..."); try { // 1) read private config file (not on github) string secretsFilename = "Secrets/DashboardConfig.json"; if (File.Exists(secretsFilename)) { using (var r = File.OpenRead(secretsFilename)) { Config = await JsonSerializer.DeserializeAsync <DashboardConfig>(r); } } else { Config = new DashboardConfig(); Directory.CreateDirectory("Secrets/"); using (var w = File.Create(secretsFilename)) { var options = new JsonSerializerOptions { WriteIndented = true }; await JsonSerializer.SerializeAsync(w, Config, options); } } #if DEBUG // this UNC path doesn't work on raspbian! Config.BackgroundImagesPath = @"\\SynologyDS218j\photo\DashboardBackgrounds"; #endif // 2) this one is complex, async, and long. We can't properly call this during ConfigureServices... GoogleService = await GoogleCalendarService.GoogleCalendarAuthAsync(); // Want to know, which calendar IDs you have? // foreach (var kvp in await CalendarListService.QueryCalendarIdsAsync(GoogleService)) // { // Console.WriteLine($"CalendarID;Summary: {kvp.Key};{kvp.Value}"); // } #if RELEASE // 3) PIR sensor to control the monitor PirSensorService = new PirSensorService(Config, new MonitorService()); PirSensorService.Start(); #endif logger.Info("Build WebHost..."); var host = CreateWebHostBuilder(args).Build(); logger.Info("Run WebHost!"); await host.RunAsync(); } catch (Exception ex) { logger.Error(ex, "Stopped program because of exception"); throw; } finally { // Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux) NLog.LogManager.Shutdown(); } }
private void GetInformation(IEnumerable <Calendar> list, TaskScheduler currentSynchronizationContext, GoogleCalendarService googleCalenderService) { string calenderId = string.Empty; var calender = list.FirstOrDefault(calendar => calendar.Name.Contains("Office")); if (calender != null) { calenderId = calender.Id; } var outlookService = new OutlookCalendarService(); GetEqualAppointments(googleCalenderService, outlookService, calenderId).ContinueWith(ContinuationActionGoogleAppointments, currentSynchronizationContext); }