private void btnUpdate_Click(object sender, RoutedEventArgs e)
{
Event newEvent = createEventBody();
addAttendees(newEvent);
if (newEvent != null && selEvent != null)
{
try
{
EventsResource.UpdateRequest upReq = new EventsResource.UpdateRequest(myService, newEvent, "primary", selEvent.Id);
upReq.SendNotifications = false;
upReq.Execute();
selEvent = null;
EventListBox.SelectedItem = null;
MessageBox.Show("The selected event has been updated.");
}
catch (Google.GoogleApiException)
{
MessageBox.Show("An invalid time range has been entered. Please make sure your start date occurs before your end date.");
}
setReadRequest();
EventListBox.DataContext = request.Execute();
}
}
public async Task <GoogleEventModel> UpdateEvent(GoogleEventModel eventModel, string calendarID)
{
if (!eventModel.Start.HasValue)
{
return(null);
}
var start = eventModel.Start.Value;
var service = GetCalendarService();
var calendartimeZone = GetCurrentCalendar(service).TimeZone;
var simpleStartDate = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second);
Event gEvent = new Event
{
Id = eventModel.EventId,
Summary = eventModel.Summary,
Location = eventModel.Location,
Description = eventModel.Description,
Start = new EventDateTime()
{
DateTime = TimeZoneInfo.ConvertTimeBySystemTimeZoneId(simpleStartDate, TZConvert.IanaToWindows(calendartimeZone)),
},
End = new EventDateTime()
{
DateTime = TimeZoneInfo.ConvertTimeBySystemTimeZoneId(simpleStartDate.AddMinutes(15), TZConvert.IanaToWindows(calendartimeZone)),
}
};
//gEvent.Start.DateTimeRaw = gEvent.Start.DateTime.Value.ToLongDateString();
//gEvent.End.DateTimeRaw = gEvent.End.DateTime.Value.ToLongDateString();
EventsResource.UpdateRequest request = service.Events.Update(gEvent, calendarID, gEvent.Id);
Event UpdatedEvent = await request.ExecuteAsync();
return(UpdatedEvent.MapToGoogleEventModel());
}
static void Main(string[] args)
{
UserCredential credential;
using (var stream = new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Google Calendar API service.
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
EventsResource.ListRequest request = service.Events.List("primary");
request.TimeMin = DateTime.Now.AddYears(-1); //DateTime.Now.AddYears(-7);
request.TimeMax = DateTime.Now;
request.ShowDeleted = false;
request.SingleEvents = true;
request.MaxResults = 1000; //{Default:25, Max:2500}
request.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime;
// List events.
Events events = request.Execute();
Console.WriteLine(String.Format("Event Count: {0}", events.Items.Count));
if (events.Items != null && events.Items.Count > 0)
{
foreach (var eventItem in events.Items)
{
Thread.Sleep(200);
eventItem.Visibility = "private";
eventItem.Transparency = "transparent";
EventsResource.UpdateRequest updateReq = service.Events.Update(eventItem, "primary", eventItem.Id);
Event updatedEvent = updateReq.Execute();
Console.WriteLine("Event Updated: " + updatedEvent.Id + " " + updatedEvent.Visibility + " " + updatedEvent.Description);
}
}
else
{
Console.WriteLine("No events found.");
}
Console.Read();
Console.Read();
}
public async Task UpdateEvent(Event e, string calendar = "primary")
{
if (calService == null)
{
await Auth(EditScopes);
}
EventsResource.UpdateRequest req = calService.Events.Update(e, calendar, e.Id);
await req.ExecuteAsync();
}
public void UpdateItems(List <KalenderItem> myItems)
{
foreach (KalenderItem myItem in myItems)
{
try
{
EventsResource.UpdateRequest myUpdateRequest = new EventsResource.UpdateRequest(m_Service, myItem.Event, m_Entry.Id, myItem.Event.Id);
myUpdateRequest.Fetch();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
/// <summary>
/// Edit Event with the same ID
/// </summary>
/// <param name="event1">Event with changes</param>
public void EditEvent(TCGSync.Entities.Event event1)
{
EventsResource.GetRequest getRequest = new EventsResource.GetRequest(GService, user.googleCalendarId, event1.GoogleId);
Google.Apis.Calendar.v3.Data.Event googleEvent = getRequest.Execute();
googleEvent.Start = new EventDateTime()
{
DateTime = event1.Start
};
googleEvent.End = new EventDateTime()
{
DateTime = event1.End
};
googleEvent.Summary = event1.Description;
EventsResource.UpdateRequest updateRequest = new EventsResource.UpdateRequest(GService, googleEvent, user.googleCalendarId, event1.GoogleId);
updateRequest.Execute();
}
/// <summary>
/// Обновление записи календаря
/// </summary>
/// <param name="new_event">Новая запись</param>
/// <param name="calendar">Календарь</param>
/// <param name="source_event">Исходная запись</param>
public void UpdateEvent(Event new_event, string sourceCalendarId, string newCalendarId = null)
{
if (isConnect)
{
EventsResource.UpdateRequest request = new EventsResource.UpdateRequest(Service, new_event, sourceCalendarId, new_event.Id);
Event resource = request.Execute();
WorkBD.Execution_query($"delete from Events_calendar where Id_Event = N'{resource.Id}'");
if (newCalendarId != null)
{
MoveEvent(resource.Id, sourceCalendarId, newCalendarId);
}
}
else
{
WorkBD.Execution_query($"if exists(select Id from Events_calendar where Id_Event = N'{new_event.Id}') if exists(select Id from Mod_Event where Id_Mod_Event = N'{new_event.Id}') update Mod_Event set New_Event = N'{JsonConvert.SerializeObject(new_event)}', New_Calendar = (select Id from Name_Calendar where Id_Calendar = N'{newCalendarId}' and Id_User = (select Id from Users where UserName = N'{User}')) where Id_Mod_Event = N'{new_event.Id}' else insert into Mod_Event (RecordId, New_Event, New_Calendar, Id_Mod_Event) values ((select Id from Activity where EvendId = (select Id from Events_calendar where Id_Event = N'{new_event.Id}')), N'{JsonConvert.SerializeObject(new_event)}', (select Id from Name_Calendar where Id_Calendar = N'{newCalendarId}' and Id_User = (select Id from Users where UserName = N'{User}')), N'{new_event.Id}') else update Ins_Event set New_Ev = N'{JsonConvert.SerializeObject(new_event)}', Cal_Id = (select Id from Name_Calendar where Id_Calendar = N'{newCalendarId ?? sourceCalendarId}' and Id_User = (select Id from Users where UserName = N'{User}')) where Id_New_Ev = N'{new_event.Id}'");
WorkBD.Execution_query($"if exists(select me.Id from Mod_Event me, Events_calendar ec where me.New_Event = ec.Calendar_event and me.Id_Mod_Event = N'{new_event.Id}' and ec.Id_Event = N'{new_event.Id}' and me.New_Calendar = (select ac.NameId from Activity ac where ac.EvendId = (select Id from Events_calendar where Id_Event = N'{new_event.Id}'))) delete from Mod_Event where Id_Mod_Event = N'{new_event.Id}'");
}
}
private async Task <ILoadedAppointment> UpdateAppointmentAsync(string id, int?sequence, IAppointment appointmentData, bool force)
{
EventsResource.UpdateRequest request = _service.Events.Update(appointmentData.ToGoogleEvent(sequence + 1), CalendarId, id);
Event updatedEvent = await request.ExecuteAsync().ConfigureAwait(false);
string description = updatedEvent.RecurringEventId != null
? "instance of a recurring event"
: updatedEvent.Recurrence != null
? "recurring event"
: "event";
Logger.Verbose($"Updated {description} \"{appointmentData}\" on {appointmentData.Schedule?.Start:d}");
if (appointmentData.Schedule?.Recurrence?.Exceptions != null)
{
await UpdateExceptionsAsync(updatedEvent.Id, appointmentData.Schedule, force).ConfigureAwait(false);
}
return(new GoogleCalendarAppointment(updatedEvent));
}
public async Task ApproveVacation(UserVacationViewModel model, int vacationId)
{
var userEvent = await _db.UserVacations.FirstOrDefaultAsync(u => u.Id == vacationId);
var userToken = await _db.UserGoogleToken.FirstOrDefaultAsync(u => u.UserId == userEvent.UserId);
if (userEvent != null && userToken != null)
{
UserCredential credential = await GetCredential(userToken.AccessToken, userToken.RefreshToken, userToken.IssuedAt, clientId, clientSecret);
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "Futurify Vacation",
});
// Define parameters of request.
var newEvent = new Event
{
Summary = "Day Off: Approved",
Description = model.Title,
Start = new EventDateTime
{
DateTime = model.Start
},
End = new EventDateTime
{
DateTime = model.End
},
ColorId = "10",
};
EventsResource.UpdateRequest approveEvent = service.Events.Update(newEvent, calendarId, userEvent.GoogleCalendarId); //"primary"
approveEvent.SendNotifications = true;
var approve = await approveEvent.ExecuteAsync();
}
}
public Boolean EditEvent(Event evento)
{
try
{
EventsResource.UpdateRequest request = service.Events.Update(evento, "primary", evento.Id);
var respuesta = request.Execute();
int a = 0;
return(true);
}
catch (Exception e)
{
if (ConfiguracionAplicacion.Default.Idioma.Equals("ES"))
{
MessageBox.Show("Hubo un error " + e);
}
else
{
MessageBox.Show("There was an error " + e);
}
return(false);
throw;
}
}
public Event UpdateEvent(Event eventToUpdate, string calendarId, bool sendNotifications = false)
{
EventsResource.UpdateRequest eventUpdateRequest = service.Events.Update(eventToUpdate, calendarId, eventToUpdate.Id);
eventUpdateRequest.SendNotifications = sendNotifications;
return(DoActionWithExponentialBackoff(eventUpdateRequest));
}
public void UpdateAppointment(string id, Event _event)
{
EventsResource.UpdateRequest updateRequest = service.Events.Update(_event, "primary", id);
updateRequest.Execute();
}
private async void updateevent()
{
UserCredential credential;
using (var stream =
new FileStream(Server.MapPath("client_secret.json"), FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);;
credPath = Path.Combine(credPath, ".credentials/calendarupdate-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets, Scopes, "user", CancellationToken.None, new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Google Calendar API service.
var service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
CalendarService cs = service;
DateTime d = Convert.ToDateTime(txtdoe.Value);
DateTimeOffset t = DateTimeOffset.Parse(txttime.Value);
dt = new DateTime(d.Year, d.Month, d.Day, t.Hour, t.Minute, t.Second);
Event old = service.Events.Get("primary", eID).Execute();
old.Summary = txtesummary.Value;
old.Location = txteLocation.Value;
old.Description = txtedesc.Value;
old.Start.DateTime = DateTime.Parse(XmlConvert.ToString(dt, XmlDateTimeSerializationMode.Utc));
old.Start.TimeZone = TimeZone.CurrentTimeZone.ToString();
old.End.DateTime = DateTime.Parse(XmlConvert.ToString(dt, XmlDateTimeSerializationMode.Utc));
old.End.TimeZone = TimeZone.CurrentTimeZone.ToString();
Event newEvent = new Event()
{
Summary = txtesummary.Value,
Location = txteLocation.Value,
Description = txtedesc.Value,
Start = new EventDateTime()
{
DateTime = DateTime.Parse(dt.ToString()),//DateTime.pr dt.ToUniversalTime().ToString("YYYY-MM-DD'T'HH:mm:ssZ"),
TimeZone = "Europe/Paris",
},
End = new EventDateTime()
{
DateTime = DateTime.Parse(dt.ToString()),
// DateTime = DateTime.Parse(datetimepicker1.Value),
TimeZone = "Europe/Paris",
},
};
String calendarId = "primary";
EventsResource.UpdateRequest request = service.Events.Update(newEvent, calendarId, eID);
Event newevent = await request.ExecuteAsync();
UserData user = (UserData)Session["User"];
Dataservice.DatamanagementClient findata = new Dataservice.DatamanagementClient();
findata.Open();
eID = Request.QueryString.Get("eid");
object[] eventdetails = findata.getevent(eID, user.getID());
int getnum = findata.updateevent(dt, txtesummary.Value, txteLocation.Value, txtedesc.Value, newevent.Id.ToString(), (string)eventdetails[0]);
findata.Close();
}
private static void UpdateNewEvent(CalendarService service, string calendarId, SmEmployee employee, CrmActivityDto activity, List <EventAttendee> eventAttendees, string eventId, ILog logger, string notes)
{
var overrides = new List <EventReminder>();
if (GetEventReminderEmail())
{
overrides.Add(new EventReminder {
Method = "email", Minutes = GetEventReminderEmailMinutes()
});
}
if (GetEventReminderSMS())
{
overrides.Add(new EventReminder {
Method = "sms", Minutes = GetEventReminderSMSMinutes()
});
}
string summary = $"{activity.Topic} [ความสำคัญ:{activity.PriorityEnumName}][สถานะ:{activity.StatusEnumName}] ".Replace(System.Environment.NewLine, string.Empty);
var endDateTime = activity.EndDateTime == null ? activity.StartDateTime : activity.EndDateTime.Value;
Event newEvent = new Event()
{
ICalUID = activity.ActivityId,
Summary = summary,
Location = activity.RelateActName,
Description = activity.Detail,
Created = activity.ModifiedDate,
ColorId = GetPriorityColor(activity.PriorityEnumName),
Status = GetStatus(activity.StatusEnumName),
Start = new EventDateTime()
{
DateTime = activity.StartDateTime,
TimeZone = GetTimeZone(),
},
End = new EventDateTime()
{
DateTime = endDateTime,
TimeZone = GetTimeZone(),
},
Updated = DateTime.Now,
Attendees = eventAttendees,
Visibility = "default",
Organizer = new Event.OrganizerData
{
Email = employee.Facebook,
DisplayName = $"{employee.EmpFirstName} {employee.EmpLastName}",
},
Reminders = new Event.RemindersData()
{
UseDefault = false,
Overrides = overrides
},
ConferenceData = new ConferenceData
{
Notes = notes
}
};
EventsResource.UpdateRequest updateRequest = service.Events.Update(newEvent, calendarId, eventId);
try
{
Event updatedEvent = updateRequest.Execute();
logger.Info($"CalendarId:{calendarId} Event Id:{newEvent.ICalUID} has been updated successful.");
}
catch (Exception e)
{
logger.Error($"Update Event Id:{newEvent.ICalUID} CalendarId:{calendarId} Error:{e.Message}{e.StackTrace}");
}
}
public static void Main()
{
CalendarService service = GetCalendarService();
CalendarListEntry calendarListEntry = GetCalendarListEntry(service);
if (calendarListEntry == null)
{
Console.WriteLine("Der Kalender konnte nicht gefunden werden.");
return;
}
// Define parameters of request.
// Alternative KalenderId für den "Haupt"-Kalender: "primary"
EventsResource.ListRequest request = service.Events.List(calendarListEntry.Id);
request.TimeMin = DateTime.Now;
request.ShowDeleted = false;
request.SingleEvents = true;
request.MaxResults = 100;
request.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime;
// List events.
Events events = request.Execute();
if (events?.Items?.Any() != true)
{
Console.WriteLine("No upcoming events found.");
return;
}
int updateCounter = 0;
int skippedCounter = 0;
foreach (Event eventItem in events.Items)
{
bool eventWasUpdated = false;
bool isMuellKalenderEvent = EventIsMuellKalenderEvent(eventItem);
// Korrigiert den Zeitraum des Events
if (isMuellKalenderEvent && DateFixIsRequired(eventItem))
{
var oldDateTime = eventItem.Start.DateTime.Value;
eventItem.Start.DateTime = new DateTime(oldDateTime.Year, oldDateTime.Month, oldDateTime.Day);
eventItem.End.DateTime = eventItem.Start.DateTime.Value.AddDays(1);
eventWasUpdated = true;
}
// Setzt die Erinnerung auf 12 Stunden vor dem Termin
if (isMuellKalenderEvent && eventItem.Reminders?.UseDefault != false)
{
if (eventItem.Reminders == null)
{
eventItem.Reminders = new Event.RemindersData();
}
eventItem.Reminders.UseDefault = false;
eventItem.Reminders.Overrides = new List <EventReminder>();
// Reminder per popup (nicht per email) 12 Stunden vor dem Event
eventItem.Reminders.Overrides.Add(new EventReminder {
Method = "popup", Minutes = 12 * 60
});
eventWasUpdated = true;
}
if (!eventWasUpdated)
{
skippedCounter++;
Console.WriteLine($"Skipped #{skippedCounter}: {eventItem.Summary ?? eventItem.Id} ({eventItem.Start.DateTime})");
continue;
}
EventsResource.UpdateRequest updateRequest = service.Events.Update(eventItem, calendarListEntry.Id, eventItem.Id);
Event updateResult = updateRequest.Execute();
updateCounter++;
Console.WriteLine($"Updated #{updateCounter}: {eventItem.Summary ?? eventItem.Id} ({eventItem.Start.DateTime})");
}
}
public Event updateToGoogleCalendar(Event googleAppointment)
{
EventsResource.UpdateRequest request = service.Events.Update(googleAppointment, calendarId, googleAppointment.Id);
return(request.Execute());
}
public async Task <string> UpdateEvent(GoogleEvent i, Guid OwnerGuid)
{
Event eventoEsistente = null;
//verifica se fare update o insert
var IsUpdate = (string.IsNullOrWhiteSpace(i.ID) == false);
if (i.ID == "null")
{
IsUpdate = false;
}
if (IsUpdate == false)
{
EventsResource.GetRequest request = Generic.Calendar.Events.Get(MainClass.StudentsCalendar, i.ID);
try { eventoEsistente = await request.ExecuteAsync(); } catch { }
IsUpdate = eventoEsistente != null;
}
GoogleEvent.UpdateResponse output = new GoogleEvent.UpdateResponse();
try
{
eventoEsistente = EventMixedFromGoogle(i, eventoEsistente);
if (IsUpdate)
{
EventsResource.UpdateRequest request = Generic.Calendar.Events.Update(
eventoEsistente, MainClass.StudentsCalendar, eventoEsistente.Id
);
eventoEsistente = await request.ExecuteAsync();
}
else
{
eventoEsistente.Id = null;
EventsResource.InsertRequest request = Generic.Calendar.Events.Insert(
eventoEsistente, MainClass.StudentsCalendar
);
eventoEsistente = await request.ExecuteAsync();
}
if (eventoEsistente != null)
{
output.item = eventoEsistente.ToGoogleEvent();
output.state = Visual1993.Data.WebServiceV2.WebRequestState.Ok;
}
}
catch (Exception ex) {
output.state = Visual1993.Data.WebServiceV2.WebRequestState.GenericError;
output.errorMessage = ex.Message;
}
//manda la mail al Loft team
//prendi le info dell'utente per la mail
//var internalEvent = (await InternalEvent.getAllFromGoogleID(i.ID)).items.FirstOrDefault();
//if (internalEvent == null) { output.errorMessage = "Impossibile trovare l'evento correlato"; return JsonConvert.SerializeObject(output);}
var utente = (await User.GetOne(OwnerGuid)).items.FirstOrDefault();
if (utente == null)
{
output.errorMessage = "Impossibile trovare l'utente che ha inserito l'evento"; return(JsonConvert.SerializeObject(output));
}
try {
var msgStr = "<html><body>" +
"<p>Nome: " + i.Name + "</p>" +
"<p>Inizio: " + i.StartDate.ToString() + "</p>" +
"<p>Fine: " + i.EndDate.ToString() + "</p>" +
"<p>Owner: " + i.OwnerName + "</p>" +
"<p>Luogo: " + i.Luogo + "</p>" +
"<p>Descrizione: " + i.Description + "</p>" +
"<p><a href=\"" + MainClass.ExternalAccessBaseUri + MainClass.LoftPrefix + "event/" + i.InternalEventGuid + "/accept\">Accetta</a></p>" +
"<p><a href=\"" + MainClass.ExternalAccessBaseUri + MainClass.LoftPrefix + "event/" + i.InternalEventGuid + "/deny\">Rifiuta</a></p>" +
"</body></html>"
;
var mail = new MailRESTRequest {
From = utente?.data?.Email ?? null,
To = MainClass.StaffMail,
Cc = MainClass.StaffCcMail,
IsBodyHtml = true,
SmtpProvider = MailRESTRequest.SmtpProviderEnum.Luiss,
Body = msgStr,
Subject = "Prenotazione evento Loft"
};
var web = new Visual1993.Data.WebServiceV2();
var config = new WebServiceV2.UrlToStringConfiguration
{
url = MainClass.Visual1993RestServer + "visual1993/mail/send",
Type = WebServiceV2.UrlToStringConfiguration.RequestType.JsonRaw,
Verb = WebServiceV2.UrlToStringConfiguration.RequestVerb.POST,
RawContent = JsonConvert.SerializeObject(mail)
};
var res = await web.UrlToString(config);
var resAsObj = JsonConvert.DeserializeObject <WebServiceV2.DefaultResponse>(res);
if (resAsObj.state != WebServiceV2.WebRequestState.Ok)
{
output.errorMessage = "mail not sent. Error: " + resAsObj.errorMessage;
}
//ma non impostare lo stato a !=Ok perchè la richiesta in se è andata a buon fine
}
catch (Exception ex)
{
output.errorMessage = ex.Message;
}
return(JsonConvert.SerializeObject(output));
}
public void Update(IDirectResponseSchema newCalendarEvent, string calendarId, string oldEventId)
{
var _newCalendarEvent = newCalendarEvent as Event;
EventsResource.UpdateRequest request = service.Events.Update(_newCalendarEvent, calendarId, oldEventId);
}
