//[FieldSetter(Field.Reminder)]
private void SetReminder(Event googleItem, Outlook.AppointmentItem outlookItem, Target target)
{
if (target == Target.Google)
{
if (outlookItem.ReminderSet)
{
if (outlookItem.ReminderOverrideDefault)
{
var reminder = new EventReminder
{
Minutes = outlookItem.ReminderMinutesBeforeStart,
Method = "popup"
};
googleItem.Reminders.Overrides = new[] { reminder };
}
else
{
googleItem.Reminders.Overrides = null;
}
googleItem.Reminders.UseDefault = !outlookItem.ReminderOverrideDefault;
}
else
{
googleItem.Reminders = null;
}
}
else if (googleItem.Reminders == null)
{
((Outlook.AppointmentItem)outlookItem).ReminderSet = false;
}
else
{
if (googleItem.Reminders.UseDefault.GetValueOrDefault())
{
if (this._defaultReminders.Any())
{
((Outlook.AppointmentItem)outlookItem).ReminderSet = true;
((Outlook.AppointmentItem)outlookItem).ReminderOverrideDefault = true;
((Outlook.AppointmentItem)outlookItem).ReminderMinutesBeforeStart = this._defaultReminders.First().Minutes.GetValueOrDefault();
}
else
{
((Outlook.AppointmentItem)outlookItem).ReminderSet = false;
}
}
else
{
if (googleItem.Reminders.Overrides != null && googleItem.Reminders.Overrides.Count > 0)
{
((Outlook.AppointmentItem)outlookItem).ReminderSet = true;
((Outlook.AppointmentItem)outlookItem).ReminderOverrideDefault = true;
((Outlook.AppointmentItem)outlookItem).ReminderMinutesBeforeStart = googleItem.Reminders.Overrides.First().Minutes.GetValueOrDefault();
}
else
{
((Outlook.AppointmentItem)outlookItem).ReminderSet = false;
}
}
}
}
public JsonResult GetEvents()
{
List <EventReminder> events = new List <EventReminder>();
using (SqlConnection con = new SqlConnection(Connectionstring))
{
string userid = Session["UserID"].ToString();
con.Open();
string query = "Select * from tblEvents where UserID=" + userid;
SqlCommand cmd = new SqlCommand(query, con);
SqlDataReader sdr = cmd.ExecuteReader();
DataTable datatable = new DataTable();
datatable.Load(sdr);
con.Close();
foreach (DataRow row in datatable.Rows)
{
EventReminder listevents = new EventReminder();
listevents.EventID = Convert.ToInt32(row.ItemArray[0]);
listevents.UserID = Convert.ToInt32(row.ItemArray[1]);
listevents.Subject = row.ItemArray[2].ToString();
listevents.Description = row.ItemArray[3].ToString();
listevents.StartDate = row.ItemArray[4].ToString();
listevents.EndDate = row.ItemArray[5].ToString();
events.Add(listevents);
}
}
return(new JsonResult {
Data = events, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public ActionResult Create(EventReminder events)
{
string userid = Session["UserID"].ToString();
eventRepository.AddEditEvent(events, userid);
return(RedirectToAction("Calenderlist", "Account"));
}
public void ReadXml(XmlReader reader)
{
if ((reader.MoveToContent() == XmlNodeType.Element) && (reader.LocalName == "Calendar"))
{
Name = reader["Name"];
ID = reader["Url"];
Enabled = Boolean.Parse(reader["Enabled"]);
Color = Color.FromArgb(Int32.Parse(reader["Color"]));
if (reader.ReadToDescendant("Event"))
{
while ((reader.MoveToContent() == XmlNodeType.Element) && (reader.LocalName == "Event"))
{
var gvent = new Gvent(this);
gvent.ReadXml(reader);
Add(gvent);
}
}
this.DefaultReminders = new List <EventReminder>();
while ((reader.MoveToContent() == XmlNodeType.Element) && (reader.LocalName == "DefaultReminder"))
{
int minutes;
EventReminder defaultReminder = new EventReminder()
{
Method = reader["Method"],
Minutes = (Int32.TryParse(reader["Minutes"], out minutes) ? minutes : (int?)null)
};
this.DefaultReminders.Add(defaultReminder);
reader.Read();
}
reader.Read();
}
}
public ActionResult Edit(EventReminder events)
{
string userid = Session["UserID"].ToString();
eventRepository.AddEditEvent(events, userid);
ViewBag.pageload = "edit";
return(RedirectToAction("ListEvents", "Account"));
}
public GVentMinder(EventReminder reminder)
{
if (reminder == null)
{
throw new ArgumentNullException("entry");
}
_HowEarly = TimeSpan.FromMinutes((double)reminder.Minutes);
}
public bool Update(EventReminder reminder)
{
if (_HowEarly != TimeSpan.FromMinutes((double)reminder.Minutes))
{
return(false);
}
Processed = true;
return(true);
}
public string AddEvent(DateTime startDate, DateTime endDate, string summary, string description)
{
var service = GetCalendarService();
Event ev = new Event()
{
Summary = summary,
Location = location,
Description = description,
Start = new EventDateTime()
{
DateTime = startDate
},
End = new EventDateTime()
{
DateTime = endDate
},
};
ev.Transparency = "transparent";
EventReminder remPopup = new EventReminder();
remPopup.Method = "popup";
remPopup.Minutes = 15;
EventReminder remMail = new EventReminder();
remMail.Method = "email";
remMail.Minutes = 15;
Event.RemindersData rd = new Event.RemindersData();
rd.UseDefault = false;
IList <EventReminder> list = new List <EventReminder>();
list.Add(remPopup);
list.Add(remMail);
rd.Overrides = list;
ev.Reminders = rd;
var calendarId = "primary";
Event recurringEvent = service.Events.Insert(ev, calendarId).Execute();
string eidWord = "eid=";
var index = recurringEvent.HtmlLink.IndexOf(eidWord, 0);
var eid = recurringEvent.HtmlLink.Substring(index + eidWord.Length, recurringEvent.HtmlLink.Length - (index + eidWord.Length));
//var calendarEditLink = string.Format(@"https://calendar.google.com/calendar/u/2/r/eventedit/{0}?sf=true", eid);
return(eid);
}
/// <summary>
/// Sets the goolge reminder.
/// </summary>
/// <param name="eventItem">The event item.</param>
private void SetGoogleReminder(Event eventItem)
{
eventItem.Reminders.UseDefault = false;
eventItem.Reminders.Overrides = eventItem.Reminders.Overrides ?? new List <EventReminder>();
EventReminder reminder = eventItem.Reminders.Overrides.FirstOrDefault() ?? new EventReminder();
reminder.Minutes = Math.Min(Minutes, MaxGoogleMinutes);
reminder.Method = ReminderMethod.ToString().ToLowerInvariant();
eventItem.Reminders.Overrides.Clear();
eventItem.Reminders.Overrides.Add(reminder);
}
public static List <EventReminder> GetReminderList()
{
var reminder = new EventReminder
{
Method = "popup",
Minutes = 30
};
var reminderList = new List <EventReminder> {
reminder
};
return(reminderList);
}
public ActionResult Edit(EventReminder events)
{
using (SqlConnection con = new SqlConnection(Connectionstring))
{
string userid = Session["UserID"].ToString();
con.Open();
string qry = string.Empty;
qry = "Update tblEvents set UserID = '" + userid + "', Subject = '" + events.Subject + "', Description = '" + events.Description +
"', StartDate= '" + events.StartDate + "',EndDate= '" + events.EndDate + "' where EventID=" + events.EventID;
this.AddUpdateDeleteSQL(qry);
}
return(RedirectToAction("ListEvents", "Account"));
}
private void CancelCommandExecuted()
{
_eventDataUnit.RevertChanges();
if (_isEditMode)
{
EventReminder.Refresh();
}
else
{
EventReminder.AssignedToUser = null;
EventReminder = null;
}
}
public JsonResult DeleteEvent(int eventID)
{
var status = false;
using (SqlConnection con = new SqlConnection(Connectionstring))
{
con.Open();
EventReminder events = new EventReminder();
string qry = "delete from tblEvents where EventID=" + eventID;
eventRepository.AddUpdateDeleteSQL(qry);
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
public ActionResult Create(EventReminder events)
{
using (SqlConnection con = new SqlConnection(Connectionstring))
{
string userid = Session["UserID"].ToString();
con.Open();
string qry = string.Empty;
var startDate = Convert.ToDateTime(events.StartDate);
var endDate = Convert.ToDateTime(events.EndDate);
qry = "insert into tblEvents(UserID,Subject,Description,StartDate,EndDate)" +
" values('" + userid + "','" + events.Subject + "','" + events.Description + "','" + startDate + "','" + endDate + "')";
this.AddUpdateDeleteSQL(qry);
}
return(RedirectToAction("Calenderlist", "Account"));
}
public void AddEditEvent(EventReminder events, string userid)
{
string qry = string.Empty;
var startDate = Convert.ToDateTime(events.StartDate);
var endDate = Convert.ToDateTime(events.EndDate);
if (events.EventID > 0)
{
qry = "Update tblEvents set Subject = '" + events.Subject + "', Description = '" + events.Description +
"', StartDate= '" + startDate + "',EndDate= '" + endDate + "' where EventID= '" + events.EventID + "' and UserID= " + userid;
}
else
{
qry = "insert into tblEvents(UserID,Subject,Description,StartDate,EndDate)" +
" values('" + userid + "','" + events.Subject + "','" + events.Description + "','" + startDate + "','" + endDate + "')";
}
this.AddUpdateDeleteSQL(qry);
}
public JsonResult SaveEvent(EventReminder events)
{
var status = false;
using (SqlConnection con = new SqlConnection(Connectionstring))
{
string userid = Session["UserID"].ToString();
con.Open();
string qry = string.Empty;
qry = "Update tblEvents set Subject = '" + events.Subject + "', Description = '" + events.Description +
"', StartDate= '" + events.StartDate + "',EndDate= '" + events.EndDate + "' where EventID= '" + events.EventID + "' and UserID= " + userid;
eventRepository.AddUpdateDeleteSQL(qry);
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
public void AddEventToCalendar(List <Lesson> lessons, int reminderMinutes = 15)
{
try
{
if (lessons != null && lessons.Count > 0)
{
foreach (var lesson in lessons)
{
var ev = new Event();
var startLessonTime = DateTime.Parse(lesson.Date + " " + lesson.StartTime);
var endLessonTime = DateTime.Parse(lesson.Date + " " + lesson.EndTime);
EventDateTime start = new EventDateTime {
DateTime = startLessonTime
};
EventDateTime end = new EventDateTime {
DateTime = endLessonTime
};
var reminder1 = new EventReminder {
Method = "popup", Minutes = reminderMinutes
};
var eventReminderData = new Event.RemindersData {
UseDefault = false, Overrides = new[] { reminder1 }
};
ev.Start = start;
ev.End = end;
ev.Summary = lesson.LessonName + " " + lesson.ClassRoom;
ev.Description = lesson.TeacherName + " " + lesson.Group;
ev.Reminders = eventReminderData;
var calendarId = "primary";
Event recurringEvent = _service.Events.Insert(ev, calendarId).Execute();
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
throw;
}
}
public void EventInsert(string name, DateTime start)
{
var e = new Event();
e.Summary = name + "DDD event1";
e.Description = "My DDD1";
e.Start = new EventDateTime();
e.Start.DateTime = new DateTime(2020, 06, 14, 11, 30, 00);
e.End = new EventDateTime();
e.End.DateTime = new DateTime(2020, 06, 14, 11, 45, 00);
var reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = 30;
e.Reminders = new Event.RemindersData();
e.Reminders.UseDefault = true;
//e.Reminders.Overrides =new List<EventReminder> { reminder };
_service.Events.Insert(e, "primary").Execute();
}
/// <summary>
/// Создает и добавляет новое событие в календарь
/// </summary>
/// <param name="title"></param>
/// <param name="location"></param>
/// <param name="description"></param>
/// <param name="startdate"></param>
/// <param name="enddate"></param>
/// <returns></returns>
public static bool CreateNewEvent(DateTime startdate, DateTime enddate, string title, bool remind, string location = "", string description = "")
{
if (startdate == null || enddate == null)
throw new ArgumentNullException("Аргументы startdate и enddate не могут быть null");
if (startdate < DateTime.Today || enddate < DateTime.Today || enddate < startdate)
throw new ArgumentOutOfRangeException("Даты события не могут быть меньше сегодняшней. Дата окончания события не может быть меньше даты начала события");
if (String.IsNullOrEmpty(title))
throw new ArgumentException("Аргумент title не может быть пустым или null");
Event eventdata = new Event();
eventdata.Summary = title;
eventdata.Location = location;
eventdata.Description = description;
EventDateTime start = new EventDateTime();
start.DateTime = startdate;
eventdata.Start = start;
EventDateTime end = new EventDateTime();
end.DateTime = enddate;
eventdata.End = end;
eventdata.Transparency = "transparent";
if(remind)
{
EventReminder rem = new EventReminder();
rem.Method = "popup";
rem.Minutes = 15;
Event.RemindersData rd = new Event.RemindersData();
rd.UseDefault = false;
IList<EventReminder> list = new List<EventReminder>();
list.Add(rem);
rd.Overrides = list;
eventdata.Reminders = rd;
}
// k06n3almls6oo2f3grmdtt4kh4 @group.calendar.google.com
//[email protected]
var insertevent = _calService.Events.Insert(eventdata, "*****@*****.**");
Event createdevent = insertevent.Execute();
return true;
}
public List <EventReminder> EventsList(string userid)
{
string query = "Select * from tblEvents where UserID=" + userid;
DataTable datatable = GetSQLList(query);
List <EventReminder> eventList = new List <EventReminder>();
foreach (DataRow row in datatable.Rows)
{
EventReminder eventModel = new EventReminder();
eventModel.EventID = Convert.ToInt32(row.ItemArray[0]);
eventModel.UserID = Convert.ToInt32(row.ItemArray[1]);
eventModel.Subject = row.ItemArray[2].ToString();
eventModel.Description = row.ItemArray[3].ToString();
eventModel.StartDate = row.ItemArray[4].ToString();
eventModel.EndDate = row.ItemArray[5].ToString();
eventList.Add(eventModel);
}
return(eventList);
}
public EventReminder GetEventReminder(int eventid)
{
var eventreminders = db.All <EventReminder>();
var events = db.All <Event>();
if (eventreminders.Count() != events.Count())
{
foreach (var ev in events)
{
if (!eventreminders.Any(x => x.EventId == ev.EventId))
{
db.Write(() =>
{
var evrem = new EventReminder(ev.EventId, false);
db.Add(evrem);
});
}
}
}
return(db.All <EventReminder>().FirstOrDefault(x => x.EventId == eventid));
}
/// <summary>
/// Creates a GoogleCalendarEvent from internal Data
/// </summary>
/// <returns></returns>
public Event ToGoogleCalendarEvent()
{
Event googleCalendarEvent = new Event();
googleCalendarEvent.Start = new EventDateTime();
googleCalendarEvent.End = new EventDateTime();
if (AllDay)
{
googleCalendarEvent.Start.Date = Start.ToString("yyyy-MM-dd");
googleCalendarEvent.End.Date = End.ToString("yyyy-MM-dd");
}
else
{
googleCalendarEvent.Start.DateTime = Start;
googleCalendarEvent.End.DateTime = End;
}
googleCalendarEvent.Summary = Subject;
googleCalendarEvent.Description = Description;
googleCalendarEvent.Location = Location;
//Erinnerung setzen
googleCalendarEvent.Reminders = new Event.RemindersData();
googleCalendarEvent.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = RemainterMinutesBefore;
googleCalendarEvent.Reminders.Overrides = new List <EventReminder>();
googleCalendarEvent.Reminders.Overrides.Add(reminder);
//Teilnehmer
googleCalendarEvent.Attendees = Attendees.Select(att => att.ToGoogleAttendee()).ToList();
return(googleCalendarEvent);
}
public void AddEvent(ProgramItem item)
{
const string GoogleDateFormatString = "yyyy-MM-ddTHH:mm:00Z";
//service.Key = Key;
var list = service.Events.List("primary");
var fetch = list.Fetch();
var start = new EventDateTime();
start.DateTime = "2013-03-05T10:30:00Z";
start.TimeZone = "+0000";
var end = new EventDateTime();
end.DateTime = "2013-03-05T10:35:00Z";
end.TimeZone = "+0000";
var e = new Event();
e.End = end;
e.Kind = "calendar#event";
e.Start = start;
e.Summary = "Summary";
e.Id = null;
e.ICalUID = null;
e.Location = "";
var eventReminder = new EventReminder();
eventReminder.Method = "sms";
eventReminder.Minutes = 15;
e.Reminders = new Event.RemindersData();
e.Reminders.UseDefault = false;
e.Reminders.Overrides = new List<EventReminder>();
e.Reminders.Overrides.Add(eventReminder);
// Recurrence:
var recur = "RRULE:FREQ=DAILY;COUNT=20;INTERVAL=1;WKST=SU";
e.Recurrence = new List<string>();
e.Recurrence.Add(recur);
e.RecurringEventId = "12345";
e.OriginalStartTime = start;
AddEvent(e);
}
public Event UpdateCalendarEntry(AppointmentItem ai, Event ev, ref int itemModified, Boolean forceCompare = false)
{
if (!Settings.Instance.APIlimit_inEffect && GetOGCSproperty(ev, Program.APIlimitHit)) {
log.Fine("Back processing Event affected by attendee API limit.");
} else {
if (!(MainForm.Instance.ManualForceCompare || forceCompare)) { //Needed if the exception has just been created, but now needs updating
if (Settings.Instance.SyncDirection != SyncDirection.Bidirectional) {
if (DateTime.Parse(ev.Updated) > ai.LastModificationTime)
return null;
} else {
if (OutlookCalendar.GetOGCSlastModified(ai).AddSeconds(5) >= ai.LastModificationTime)
//Outlook last modified by OGCS
return null;
if (DateTime.Parse(ev.Updated) > DateTime.Parse(GoogleCalendar.GoogleTimeFrom(ai.LastModificationTime)))
return null;
}
}
}
String aiSummary = OutlookCalendar.GetEventSummary(ai);
log.Debug("Processing >> " + aiSummary);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine(aiSummary);
//Handle an event's all-day attribute being toggled
String evStart = ev.Start.Date ?? ev.Start.DateTime;
String evEnd = ev.End.Date ?? ev.End.DateTime;
if (ai.AllDayEvent) {
ev.Start.DateTime = null;
ev.End.DateTime = null;
if (MainForm.CompareAttribute("Start time", SyncDirection.OutlookToGoogle, evStart, ai.Start.ToString("yyyy-MM-dd"), sb, ref itemModified)) {
ev.Start.Date = ai.Start.ToString("yyyy-MM-dd");
}
if (MainForm.CompareAttribute("End time", SyncDirection.OutlookToGoogle, evEnd, ai.End.ToString("yyyy-MM-dd"), sb, ref itemModified)) {
ev.End.Date = ai.End.ToString("yyyy-MM-dd");
}
} else {
//Handle: Google = all-day; Outlook = not all day, but midnight values (so effectively all day!)
if (ev.Start.Date != null &&
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(evStart)) == GoogleCalendar.GoogleTimeFrom(ai.Start) &&
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(evEnd)) == GoogleCalendar.GoogleTimeFrom(ai.End))
{
sb.AppendLine("All-Day: true => false");
ev.Start.DateTime = GoogleCalendar.GoogleTimeFrom(ai.Start);
ev.End.DateTime = GoogleCalendar.GoogleTimeFrom(ai.End);
itemModified++;
}
ev.Start.Date = null;
ev.End.Date = null;
if (MainForm.CompareAttribute("Start time", SyncDirection.OutlookToGoogle,
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(evStart)), GoogleCalendar.GoogleTimeFrom(ai.Start), sb, ref itemModified)) {
ev.Start.DateTime = GoogleCalendar.GoogleTimeFrom(ai.Start);
}
if (MainForm.CompareAttribute("End time", SyncDirection.OutlookToGoogle,
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(evEnd)), GoogleCalendar.GoogleTimeFrom(ai.End), sb, ref itemModified)) {
ev.End.DateTime = GoogleCalendar.GoogleTimeFrom(ai.End);
}
}
List<String> oRrules = Recurrence.Instance.BuildGooglePattern(ai, ev);
if (ev.Recurrence != null) {
for (int r = 0; r < ev.Recurrence.Count; r++) {
String rrule = ev.Recurrence[r];
if (rrule.StartsWith("RRULE:")) {
if (oRrules != null) {
String[] oRrule_bits = oRrules.First().TrimStart("RRULE:".ToCharArray()).Split(';');
foreach (String oRrule_bit in oRrule_bits) {
if (!rrule.Contains(oRrule_bit)) {
if (MainForm.CompareAttribute("Recurrence", SyncDirection.OutlookToGoogle, rrule, oRrules.First(), sb, ref itemModified)) {
ev.Recurrence[r] = oRrules.First();
}
}
}
} else {
log.Debug("Converting to non-recurring event.");
MainForm.CompareAttribute("Recurrence", SyncDirection.OutlookToGoogle, rrule, null, sb, ref itemModified);
ev.Recurrence[r] = null;
}
break;
}
}
} else {
if (oRrules != null && ev.RecurringEventId == null) {
log.Debug("Converting to recurring event.");
MainForm.CompareAttribute("Recurrence", SyncDirection.OutlookToGoogle, null, oRrules.First(), sb, ref itemModified);
ev.Recurrence = oRrules;
}
}
if (ev.Recurrence != null && ev.RecurringEventId == null) {
ev = OutlookCalendar.Instance.IOutlook.IANAtimezone_set(ev, ai);
}
String subjectObfuscated = Obfuscate.ApplyRegex(ai.Subject, SyncDirection.OutlookToGoogle);
if (MainForm.CompareAttribute("Subject", SyncDirection.OutlookToGoogle, ev.Summary, subjectObfuscated, sb, ref itemModified)) {
ev.Summary = subjectObfuscated;
}
if (!Settings.Instance.AddDescription) ai.Body = "";
String outlookBody = ai.Body;
//Check for Google description truncated @ 8Kb
if (!string.IsNullOrEmpty(ai.Body) && !string.IsNullOrEmpty(ev.Description)
&& ev.Description.Length == 8 * 1024
&& ai.Body.Length > 8 * 1024) {
outlookBody = ai.Body.Substring(0, 8 * 1024);
}
if (MainForm.CompareAttribute("Description", SyncDirection.OutlookToGoogle, ev.Description, outlookBody, sb, ref itemModified))
ev.Description = outlookBody;
if (MainForm.CompareAttribute("Location", SyncDirection.OutlookToGoogle, ev.Location, ai.Location, sb, ref itemModified))
ev.Location = ai.Location;
String oPrivacy = (ai.Sensitivity == OlSensitivity.olNormal) ? "default" : "private";
String gPrivacy = ev.Visibility ?? "default";
if (MainForm.CompareAttribute("Private", SyncDirection.OutlookToGoogle, gPrivacy, oPrivacy, sb, ref itemModified)) {
ev.Visibility = oPrivacy;
}
String oFreeBusy = (ai.BusyStatus == OlBusyStatus.olFree) ? "transparent" : "opaque";
String gFreeBusy = ev.Transparency ?? "opaque";
if (MainForm.CompareAttribute("Free/Busy", SyncDirection.OutlookToGoogle, gFreeBusy, oFreeBusy, sb, ref itemModified)) {
ev.Transparency = oFreeBusy;
}
if (Settings.Instance.AddAttendees && ai.Recipients.Count > 1 && !APIlimitReached_attendee) {
if (ai.Recipients.Count >= 200) {
MainForm.Instance.Logboxout("ALERT: Attendees will not be synced for this meeting as it has " +
"more than 200, which Google does not allow.");
ev.Attendees = new List<EventAttendee>();
} else {
try {
CompareRecipientsToAttendees(ai, ev, sb, ref itemModified);
} catch (System.Exception ex) {
if (OutlookCalendar.Instance.IOutlook.ExchangeConnectionMode().ToString().Contains("Disconnected")) {
MainForm.Instance.Logboxout("Outlook is currently disconnected from Exchange, so it's not possible to sync attendees.");
MainForm.Instance.Logboxout("Please reconnect or do not sync attendees.");
throw new System.Exception("Outlook has disconnected from Exchange.");
} else {
MainForm.Instance.Logboxout("WARNING: Unable to sync attendees.\r\n" + ex.Message);
}
}
}
}
//Reminders
if (Settings.Instance.AddReminders) {
Boolean OKtoSyncReminder = OutlookCalendar.Instance.IsOKtoSyncReminder(ai);
if (ev.Reminders.Overrides != null) {
//Find the popup reminder in Google
for (int r = ev.Reminders.Overrides.Count - 1; r >= 0; r--) {
EventReminder reminder = ev.Reminders.Overrides[r];
if (reminder.Method == "popup") {
if (OKtoSyncReminder) {
if (ai.ReminderSet) {
if (MainForm.CompareAttribute("Reminder", SyncDirection.OutlookToGoogle, reminder.Minutes.ToString(), ai.ReminderMinutesBeforeStart.ToString(), sb, ref itemModified)) {
reminder.Minutes = ai.ReminderMinutesBeforeStart;
}
} else {
sb.AppendLine("Reminder: " + reminder.Minutes + " => removed");
ev.Reminders.Overrides.Remove(reminder);
if (ev.Reminders.Overrides == null || ev.Reminders.Overrides.Count == 0) {
ev.Reminders.UseDefault = Settings.Instance.UseGoogleDefaultReminder;
}
itemModified++;
} //if Outlook reminders set
} else {
sb.AppendLine("Reminder: " + reminder.Minutes + " => removed");
ev.Reminders.Overrides.Remove(reminder);
ev.Reminders.UseDefault = false;
itemModified++;
}
} //if google reminder found
} //foreach reminder
} else { //no google reminders set
if (ai.ReminderSet && OKtoSyncReminder) {
sb.AppendLine("Reminder: nothing => " + ai.ReminderMinutesBeforeStart);
ev.Reminders.UseDefault = false;
EventReminder newReminder = new EventReminder();
newReminder.Method = "popup";
newReminder.Minutes = ai.ReminderMinutesBeforeStart;
ev.Reminders.Overrides = new List<EventReminder>();
ev.Reminders.Overrides.Add(newReminder);
itemModified++;
} else {
if (MainForm.CompareAttribute("Reminder Default", SyncDirection.OutlookToGoogle, ev.Reminders.UseDefault.ToString(), OKtoSyncReminder ? Settings.Instance.UseGoogleDefaultReminder.ToString() : "False", sb, ref itemModified)) {
ev.Reminders.UseDefault = OKtoSyncReminder ? Settings.Instance.UseGoogleDefaultReminder : false;
}
}
}
}
if (itemModified > 0) {
MainForm.Instance.Logboxout(sb.ToString(), false, verbose: true);
MainForm.Instance.Logboxout(itemModified + " attributes updated.", verbose: true);
System.Windows.Forms.Application.DoEvents();
}
return ev;
}
/// <summary>
/// Inserts events.
/// </summary>
/// <param name="events">The events.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
public bool InsertEvents(Event[] events)
{
try
{
if (!UseGoogleCalendar)
return false;
if (!Authorized)
{
Mail.SendEmail(EmailTo, MailResource.Calendar_InsertEvents_Subject,
MailResource.Calendar_InsertEvents_TextBody, UseMail, true);
return false;
}
if (String.IsNullOrEmpty(GoogleCalendarId))
{
GoogleCalendarId = DefaultGoogleCalendarId;
}
foreach (Event @event in events)
{
if (String.IsNullOrEmpty(ReminderTime))
{
var remindersData = new Event.RemindersData { UseDefault = false };
@event.Reminders = remindersData;
}
else
{
TimeSpan reminderTimeSpan;
if (TimeSpan.TryParse(ReminderTime, out reminderTimeSpan))
{
var emailEventReminder = new EventReminder
{
Method = EmailMethod,
Minutes = 0
};
var popupEventReminder = new EventReminder
{
Method = PopupMethod,
Minutes = 0
};
var remindersData = new Event.RemindersData
{
Overrides = new List<EventReminder>
{
emailEventReminder,
popupEventReminder
},
UseDefault = false
};
@event.Reminders = remindersData;
@event.Start.DateTime = @event.Start.DateTime.GetValueOrDefault().Add(reminderTimeSpan);
}
}
@event.Visibility = IsEventsPrivate ? PrivateEventVisibility : DefaultEventVisibility;
_calendarService.Events.Insert(@event, GoogleCalendarId).Execute();
}
}
catch (Exception e)
{
Mail.SendEmail(EmailTo, MailResource.Calendar_InsertEvents_Subject,
MailResource.Calendar_InsertEvents_TextBody, UseMail, true);
Logger.SetLog(e);
return false;
}
return true;
}
public static void UpdateAppointmentReminders(Outlook.AppointmentItem master, Event slave)
{
if (master.ReminderSet)
{
if (slave.Reminders == null)
{
slave.Reminders = new Event.RemindersData();
slave.Reminders.Overrides = new List<EventReminder>();
}
slave.Reminders.UseDefault = false;
if (slave.Reminders.Overrides != null)
{
slave.Reminders.Overrides.Clear();
}
else
{
slave.Reminders.Overrides = new List<EventReminder>();
}
var reminder = new EventReminder();
reminder.Minutes = master.ReminderMinutesBeforeStart;
if (reminder.Minutes > 40300)
{
//ToDo: Check real limit, currently 40300
Logger.Log("Reminder Minutes to big (" + reminder.Minutes + "), set to maximum of 40300 minutes for appointment: " + master.Subject + " - " + master.Start, EventType.Warning);
reminder.Minutes = 40300;
}
reminder.Method = "popup";
slave.Reminders.Overrides.Add(reminder);
}
}
private Event createCalendarEntry(AppointmentItem ai)
{
string itemSummary = OutlookCalendar.GetEventSummary(ai);
log.Debug("Processing >> " + itemSummary);
MainForm.Instance.Logboxout(itemSummary, verbose: true);
Event ev = new Event();
//Add the Outlook appointment ID into Google event
AddOutlookID(ref ev, ai);
ev.Start = new EventDateTime();
ev.End = new EventDateTime();
ev.Recurrence = Recurrence.Instance.BuildGooglePattern(ai, ev);
if (ev.Recurrence != null) {
ev = OutlookCalendar.Instance.IOutlook.IANAtimezone_set(ev, ai);
}
if (ai.AllDayEvent) {
ev.Start.Date = ai.Start.ToString("yyyy-MM-dd");
ev.End.Date = ai.End.ToString("yyyy-MM-dd");
} else {
ev.Start.DateTime = GoogleCalendar.GoogleTimeFrom(ai.Start);
ev.End.DateTime = GoogleCalendar.GoogleTimeFrom(ai.End);
}
ev.Summary = Obfuscate.ApplyRegex(ai.Subject, SyncDirection.OutlookToGoogle);
if (Settings.Instance.AddDescription) ev.Description = ai.Body;
ev.Location = ai.Location;
ev.Visibility = (ai.Sensitivity == OlSensitivity.olNormal) ? "default" : "private";
ev.Transparency = (ai.BusyStatus == OlBusyStatus.olFree) ? "transparent" : "opaque";
ev.Attendees = new List<EventAttendee>();
if (Settings.Instance.AddAttendees && ai.Recipients.Count > 1 && !APIlimitReached_attendee) { //Don't add attendees if there's only 1 (me)
if (ai.Recipients.Count >= 200) {
MainForm.Instance.Logboxout("ALERT: Attendees will not be synced for this meeting as it has " +
"more than 200, which Google does not allow.");
} else {
foreach (Microsoft.Office.Interop.Outlook.Recipient recipient in ai.Recipients) {
EventAttendee ea = GoogleCalendar.CreateAttendee(recipient);
ev.Attendees.Add(ea);
}
}
}
//Reminder alert
if (Settings.Instance.AddReminders) {
ev.Reminders = new Event.RemindersData();
if (OutlookCalendar.Instance.IsOKtoSyncReminder(ai)) {
if (ai.ReminderSet) {
ev.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = ai.ReminderMinutesBeforeStart;
ev.Reminders.Overrides = new List<EventReminder>();
ev.Reminders.Overrides.Add(reminder);
} else {
ev.Reminders.UseDefault = Settings.Instance.UseGoogleDefaultReminder;
}
} else {
ev.Reminders.UseDefault = false;
}
}
return ev;
}
static void Main(string[] args)
{
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/calendar_creds.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.
service = new CalendarService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define parameters of request.
EventsResource.ListRequest request = service.Events.List(MasterCalendarId);
request.TimeMin = DateTime.Now;
request.ShowDeleted = false;
request.SingleEvents = true;
request.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime;
// List events.
Events events = request.Execute();
foreach (String day in new String[] { "A", "B", "C", "D", "E", "F" })
{
RotationDates.Add(day, new List <DateTime>());
}
foreach (var eventItem in events.Items)
{
Console.WriteLine("Examining: {0}", eventItem.Summary);
foreach (String day in new String[] { "A", "B", "C", "D", "E", "F" })
{
if (eventItem.Summary.Contains(String.Format("\"{0}\" Day", day)))
{
RotationDates[day].Add(DateTime.Parse(eventItem.Start.Date));
Console.WriteLine("{0} is an {1} day.", eventItem.Start.Date, day);
}
}
}
using (ScheduleDatabaseEntities db = new ScheduleDatabaseEntities())
{
int evtId = db.Events.Count() <= 0 ? 1 : db.Events.OrderBy(e => e.Id).ToList().Last().Id + 1;
foreach (ClassSchedule schedule in db.ClassSchedules.ToList())
{
foreach (DateTime date in RotationDates["A"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.A.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.A.Hours, schedule.A.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "*****@*****.**");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
foreach (DateTime date in RotationDates["B"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.B.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.B.Hours, schedule.B.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "primary");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
foreach (DateTime date in RotationDates["C"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.C.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.C.Hours, schedule.C.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "primary");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
foreach (DateTime date in RotationDates["D"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.D.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.D.Hours, schedule.D.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "primary");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
foreach (DateTime date in RotationDates["E"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.E.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.E.Hours, schedule.E.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "primary");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
foreach (DateTime date in RotationDates["F"])
{
// only create an event, if it hasn't already been logged.
if (schedule.Events.Where(e => e.Date.Equals(date.Date)).Count() <= 0 && schedule.F.Hours > 0)
{
DateTime st = new DateTime(date.Year, date.Month, date.Day, schedule.F.Hours, schedule.F.Minutes, 0);
DateTime et = st.AddMinutes(50);
Google.Apis.Calendar.v3.Data.Event evt = new Google.Apis.Calendar.v3.Data.Event()
{
Start = new EventDateTime()
{
DateTime = st
},
End = new EventDateTime()
{
DateTime = et
},
Summary = schedule.ClassName
};
EventReminder reminder = new EventReminder()
{
Method = "sms", Minutes = 10
};
evt.Reminders = new Google.Apis.Calendar.v3.Data.Event.RemindersData()
{
Overrides = new List <EventReminder>()
{
reminder
}, UseDefault = false
};
EventsResource.InsertRequest insReq = new EventsResource.InsertRequest(service, evt, "primary");
Google.Apis.Calendar.v3.Data.Event newEvt = insReq.Execute();
Event dbEvent = new Event()
{
ClassScheduleId = schedule.Id, Date = date, CalendarEventURI = newEvt.Id, Id = evtId++
};
db.Events.Add(dbEvent);
db.SaveChanges();
}
}
}
}
Console.WriteLine("I'm Done!");
Console.Read();
}
public AppointmentItem UpdateCalendarEntry(AppointmentItem ai, Event ev, ref int itemModified, Boolean forceCompare = false)
{
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster) //The exception child objects might have changed
{
log.Debug("Processing recurring master appointment.");
}
else
{
if (!forceCompare) //Needed if the exception has just been created, but now needs updating
{
if (Settings.Instance.SyncDirection != SyncDirection.Bidirectional)
{
if (DateTime.Parse(GoogleCalendar.GoogleTimeFrom(ai.LastModificationTime)) > DateTime.Parse(ev.Updated))
{
return(null);
}
}
else
{
if (GoogleCalendar.OGCSlastModified(ev).AddSeconds(5) >= DateTime.Parse(ev.Updated))
{
//Google last modified by OGCS
return(null);
}
if (DateTime.Parse(GoogleCalendar.GoogleTimeFrom(ai.LastModificationTime)) > DateTime.Parse(ev.Updated))
{
return(null);
}
}
}
}
String evSummary = GoogleCalendar.GetEventSummary(ev);
log.Debug("Processing >> " + evSummary);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.AppendLine(evSummary);
RecurrencePattern oPattern = (ai.RecurrenceState == OlRecurrenceState.olApptNotRecurring) ? null : ai.GetRecurrencePattern();
if (ev.Start.Date != null)
{
if (ai.RecurrenceState != OlRecurrenceState.olApptMaster)
{
ai.AllDayEvent = true;
}
if (MainForm.CompareAttribute("Start time", SyncDirection.GoogleToOutlook, ev.Start.Date, ai.Start.ToString("yyyy-MM-dd"), sb, ref itemModified))
{
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster)
{
oPattern.PatternStartDate = DateTime.Parse(ev.Start.Date);
}
else
{
ai.Start = DateTime.Parse(ev.Start.Date);
}
}
if (MainForm.CompareAttribute("End time", SyncDirection.GoogleToOutlook, ev.End.Date, ai.End.ToString("yyyy-MM-dd"), sb, ref itemModified))
{
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster)
{
oPattern.PatternEndDate = DateTime.Parse(ev.End.Date);
}
else
{
ai.End = DateTime.Parse(ev.End.Date);
}
}
}
else
{
if (ai.RecurrenceState != OlRecurrenceState.olApptMaster)
{
ai.AllDayEvent = false;
}
if (MainForm.CompareAttribute("Start time",
SyncDirection.GoogleToOutlook,
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(ev.Start.DateTime)),
GoogleCalendar.GoogleTimeFrom(ai.Start), sb, ref itemModified))
{
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster)
{
oPattern.PatternStartDate = DateTime.Parse(ev.Start.DateTime);
}
else
{
ai.Start = DateTime.Parse(ev.Start.DateTime);
}
}
if (MainForm.CompareAttribute("End time",
SyncDirection.GoogleToOutlook,
GoogleCalendar.GoogleTimeFrom(DateTime.Parse(ev.End.DateTime)),
GoogleCalendar.GoogleTimeFrom(ai.End), sb, ref itemModified))
{
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster)
{
oPattern.PatternEndDate = DateTime.Parse(ev.End.DateTime);
}
else
{
ai.End = DateTime.Parse(ev.End.DateTime);
}
}
}
oPattern = (RecurrencePattern)ReleaseObject(oPattern);
if (ai.RecurrenceState == OlRecurrenceState.olApptMaster)
{
if (ev.Recurrence == null || ev.RecurringEventId != null)
{
log.Debug("Converting to non-recurring events.");
ai.ClearRecurrencePattern();
itemModified++;
}
else
{
Recurrence.Instance.CompareOutlookPattern(ev, ai, sb, ref itemModified);
Recurrence.Instance.UpdateOutlookExceptions(ai, ev);
}
}
else if (ai.RecurrenceState == OlRecurrenceState.olApptNotRecurring)
{
if (!ai.IsRecurring && ev.Recurrence != null && ev.RecurringEventId == null)
{
log.Debug("Converting to recurring appointment.");
Recurrence.Instance.CreateOutlookExceptions(ai, ev);
itemModified++;
}
}
String summaryObfuscated = Obfuscate.ApplyRegex(ev.Summary, SyncDirection.GoogleToOutlook);
if (MainForm.CompareAttribute("Subject", SyncDirection.GoogleToOutlook, summaryObfuscated, ai.Subject, sb, ref itemModified))
{
ai.Subject = summaryObfuscated;
}
if (!Settings.Instance.AddDescription)
{
ev.Description = "";
}
if (Settings.Instance.SyncDirection == SyncDirection.GoogleToOutlook || !Settings.Instance.AddDescription_OnlyToGoogle)
{
if (MainForm.CompareAttribute("Description", SyncDirection.GoogleToOutlook, ev.Description, ai.Body, sb, ref itemModified))
{
ai.Body = ev.Description;
}
}
if (MainForm.CompareAttribute("Location", SyncDirection.GoogleToOutlook, ev.Location, ai.Location, sb, ref itemModified))
{
ai.Location = ev.Location;
}
String oPrivacy = (ai.Sensitivity == OlSensitivity.olNormal) ? "default" : "private";
String gPrivacy = (ev.Visibility == null ? "default" : ev.Visibility);
if (MainForm.CompareAttribute("Private", SyncDirection.GoogleToOutlook, gPrivacy, oPrivacy, sb, ref itemModified))
{
ai.Sensitivity = (ev.Visibility != null && ev.Visibility == "private") ? OlSensitivity.olPrivate : OlSensitivity.olNormal;
}
String oFreeBusy = (ai.BusyStatus == OlBusyStatus.olFree) ? "transparent" : "opaque";
String gFreeBusy = (ev.Transparency == null ? "opaque" : ev.Transparency);
if (MainForm.CompareAttribute("Free/Busy", SyncDirection.GoogleToOutlook, gFreeBusy, oFreeBusy, sb, ref itemModified))
{
ai.BusyStatus = (ev.Transparency != null && ev.Transparency == "transparent") ? OlBusyStatus.olFree : OlBusyStatus.olBusy;
}
if (Settings.Instance.AddAttendees)
{
if (ev.Description != null && ev.Description.Contains("===--- Attendees ---==="))
{
//Protect against <v1.2.4 where attendees were stored as text
log.Info("This event still has attendee information in the description - cannot sync them.");
}
else if (Settings.Instance.SyncDirection == SyncDirection.Bidirectional &&
ev.Attendees != null && ev.Attendees.Count == 0 && ai.Recipients.Count > 150)
{
log.Info("Attendees not being synced - there are too many (" + ai.Recipients.Count + ") for Google.");
}
else
{
//Build a list of Outlook attendees. Any remaining at the end of the diff must be deleted.
List <Recipient> removeRecipient = new List <Recipient>();
if (ai.Recipients != null)
{
foreach (Recipient recipient in ai.Recipients)
{
if (recipient.Name != ai.Organizer)
{
removeRecipient.Add(recipient);
}
}
}
if (ev.Attendees != null)
{
for (int g = ev.Attendees.Count - 1; g >= 0; g--)
{
bool foundRecipient = false;
EventAttendee attendee = ev.Attendees[g];
foreach (Recipient recipient in ai.Recipients)
{
if (!recipient.Resolved)
{
recipient.Resolve();
}
String recipientSMTP = IOutlook.GetRecipientEmail(recipient);
if (recipientSMTP.ToLower() == attendee.Email.ToLower())
{
foundRecipient = true;
removeRecipient.Remove(recipient);
//Optional attendee
bool oOptional = (ai.OptionalAttendees != null && ai.OptionalAttendees.Contains(attendee.DisplayName ?? attendee.Email));
bool gOptional = (attendee.Optional == null) ? false : (bool)attendee.Optional;
if (MainForm.CompareAttribute("Recipient " + recipient.Name + " - Optional Check",
SyncDirection.GoogleToOutlook, gOptional, oOptional, sb, ref itemModified))
{
if (gOptional)
{
recipient.Type = (int)OlMeetingRecipientType.olOptional;
}
else
{
recipient.Type = (int)OlMeetingRecipientType.olRequired;
}
}
//Response is readonly in Outlook :(
break;
}
}
if (!foundRecipient &&
(attendee.DisplayName != ai.Organizer)) //Attendee in Google is owner in Outlook, so can't also be added as a recipient)
{
sb.AppendLine("Recipient added: " + (attendee.DisplayName ?? attendee.Email));
createRecipient(attendee, ai);
itemModified++;
}
}
}
foreach (Recipient recipient in removeRecipient)
{
sb.AppendLine("Recipient removed: " + recipient.Name);
recipient.Delete();
itemModified++;
}
}
}
//Reminders
if (Settings.Instance.AddReminders)
{
if (ev.Reminders.Overrides != null)
{
//Find the popup reminder in Google
for (int r = ev.Reminders.Overrides.Count - 1; r >= 0; r--)
{
EventReminder reminder = ev.Reminders.Overrides[r];
if (reminder.Method == "popup")
{
if (ai.ReminderSet)
{
if (MainForm.CompareAttribute("Reminder", SyncDirection.GoogleToOutlook, reminder.Minutes.ToString(), ai.ReminderMinutesBeforeStart.ToString(), sb, ref itemModified))
{
ai.ReminderMinutesBeforeStart = (int)reminder.Minutes;
}
}
else
{
sb.AppendLine("Reminder: nothing => " + reminder.Minutes);
ai.ReminderSet = true;
ai.ReminderMinutesBeforeStart = (int)reminder.Minutes;
itemModified++;
} //if Outlook reminders set
} //if google reminder found
} //foreach reminder
}
else //no google reminders set
{
if (ai.ReminderSet)
{
sb.AppendLine("Reminder: " + ai.ReminderMinutesBeforeStart + " => removed");
ai.ReminderSet = false;
itemModified++;
}
}
}
if (itemModified > 0)
{
MainForm.Instance.Logboxout(sb.ToString(), false, verbose: true);
MainForm.Instance.Logboxout(itemModified + " attributes updated.", verbose: true);
System.Windows.Forms.Application.DoEvents();
}
return(ai);
}
private void ModifyEvent(Event e, AppointmentItem ai, bool add_description, bool add_reminders, bool add_attendees)
{
e.Start = new EventDateTime();
e.End = new EventDateTime();
if (ai.AllDayEvent)
{
e.Start.Date = ai.Start.ToString("yyyy-MM-dd");
e.End.Date = ai.End.ToString("yyyy-MM-dd");
// nullify the DateTime; otherwise, google rejects
e.Start.DateTime = null;
e.Start.DateTime = null;
}
else
{
e.Start.DateTime = ai.Start;
e.End.DateTime = ai.End;
e.Start.TimeZone = ai.StartTimeZone.Name;
e.End.TimeZone = ai.EndTimeZone.Name;
}
e.Summary = ai.Subject;
if (add_description)
{
e.Description = OutlookGoogleSync.Utilities.ObtainUserBodyData(ai.Body);
}
e.Location = ai.Location;
// determine how to set the status based on the outlook event
OutlookGoogleSync.Utilities.SetEventStatus(e, ai);
// consider the reminder set in Outlook
if (add_reminders && ai.ReminderSet)
{
e.Reminders = new Event.RemindersData();
e.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = ai.ReminderMinutesBeforeStart;
e.Reminders.Overrides = new List <EventReminder>();
e.Reminders.Overrides.Add(reminder);
}
if (add_attendees)
{
e.Description += Environment.NewLine + Environment.NewLine;
e.Description += OutlookGoogleSync.Utilities.BODY_SEPARATOR;
e.Description += Environment.NewLine + Environment.NewLine;
e.Description += Environment.NewLine + "==============================================";
e.Description += Environment.NewLine + "Added by OutlookGoogleSync Bidirectional:" + Environment.NewLine;
e.Description += Environment.NewLine + "ORGANIZER: " + Environment.NewLine + ai.Organizer + Environment.NewLine;
e.Description += Environment.NewLine + "REQUIRED: " + Environment.NewLine + splitAttendees(ai.RequiredAttendees) + Environment.NewLine;
e.Description += Environment.NewLine + "OPTIONAL: " + Environment.NewLine + splitAttendees(ai.OptionalAttendees);
e.Description += Environment.NewLine + "==============================================";
}
// update the property ids that tie the two events together
UpdatePropertyIDs(e, ai);
}
private async void SubmitCommandExecuted()
{
if (!IsEditMode)
{
if (AreEventsVisible)
{
EventReminder.EventReminder.EventID = SelectedEvent.Event.ID;
EventReminder.EventReminder.Event = SelectedEvent.Event;
}
else
{
_event.EventReminders.Add(EventReminder);
}
_eventDataUnit.EventRemindersRepository.Add(EventReminder.EventReminder);
var primaryContact = EventReminder.EventReminder.Event != null ? EventReminder.EventReminder.Event.Contact == null ? String.Empty : "Primary Contact: " + EventReminder.EventReminder.Event.Contact.FirstName + " "
+ EventReminder.EventReminder.Event.Contact.LastName : String.Empty;
var msg = "Event-Reminder" + "\n" + "Created by " + EventReminder.CreatedByUser.FirstName + " " +
EventReminder.CreatedByUser.LastName + " at " + DateTime.Now + "\n" +
"Event Name: " + EventReminder.EventName + "\n" + primaryContact + "\n" + EventReminder.WhatToDo;
var email = new CorrespondenceModel(new Corresponcence()
{
ID = Guid.NewGuid(),
Date = DateTime.Now,
FromAddress = EventReminder.CreatedByUser.EmailAddress,
ToAddress = EventReminder.AssignedToUser.EmailAddress,
Subject = "Event-Reminder",
Message = msg,
});
await EmailService.SendEmail(email, null, null);
if (AreEventsVisible)
{
_originalEvent = SelectedEvent.Clone();
SelectedEvent.EventReminders.Add(EventReminder);
var eventUpdates = LoggingService.FindDifference(_originalEvent, SelectedEvent);
if (!SelectedEvent.EventUpdates.Any())
{
var updates = await _eventDataUnit.EventUpdatesRepository.GetAllAsync(x => x.EventID == SelectedEvent.Event.ID);
SelectedEvent.EventUpdates = new ObservableCollection <EventUpdate>(updates.OrderByDescending(x => x.Date));
}
ProcessUpdates(SelectedEvent, eventUpdates);
await _eventDataUnit.SaveChanges();
}
}
else
{
_eventReminder.AssignedToUser = AssignedToUser;
_eventReminder.EventReminder.AssignedToUserID = AssignedToUser.ID;
EventReminder.EventReminder.LastEditDate = DateTime.Now;
if (AreEventsVisible)
{
if (_originalEvent.Event.ID != _selectedEvent.Event.ID)
{
_originalEvent = _selectedEvent.Clone();
}
EventReminder.EventReminder.Event = SelectedEvent.Event;
SelectedEvent.EventReminders.Where(x => x.EventReminder == _eventReminder.EventReminder).FirstOrDefault().AssignedToUser = AssignedToUser;
var eventUpdates = LoggingService.FindDifference(_originalEvent, SelectedEvent);
if (!SelectedEvent.EventUpdates.Any())
{
var updates = await _eventDataUnit.EventUpdatesRepository.GetAllAsync(x => x.EventID == SelectedEvent.Event.ID);
SelectedEvent.EventUpdates = new ObservableCollection <EventUpdate>(updates.OrderByDescending(x => x.Date));
}
ProcessUpdates(_selectedEvent, eventUpdates);
await _eventDataUnit.SaveChanges();
}
else
{
_eventDataUnit.EventRemindersRepository.SetEntityModified(_eventReminder.EventReminder);
}
EventReminder.Refresh();
}
}
private void SaveEvent(object sender, RoutedEventArgs e)
{
var start = new EventDateTime();
start.DateTime = App.ViewModel.DateTimeConvert(Estart_date.Text,Estart_time.Text);
start.TimeZone = "+0400";
var end = new EventDateTime();
end.DateTime = App.ViewModel.DateTimeConvert(Eend_date.Text, Eend_time.Text);
end.TimeZone = "+0400";
var ev = new Event();
ev.End = end;
ev.Kind = "calendar#event";
ev.Start = start;
ev.Summary = Etitle.Text;
ev.Description = Edescription.Text;
ev.Id = null;
ev.ICalUID = null;
ev.Location = Ewhere.Text;
var eventReminder = new EventReminder();
switch (Enotifytype.Text)
{
case "sms": eventReminder.Method = "sms"; break;
case "email": eventReminder.Method = "email"; break;
}
switch (Enotifytime.Text)
{
case "minutes": eventReminder.Minutes = Convert.ToInt32(Enotifyvalue.Text); break;
case "hours": eventReminder.Minutes = (Convert.ToInt32(Enotifyvalue.Text)*60); break;
case "days": eventReminder.Minutes = (Convert.ToInt32(Enotifyvalue.Text) * 60 * 24); break;
}
ev.Reminders = new Event.RemindersData();
ev.Reminders.UseDefault = false;
ev.Reminders.Overrides = new List<EventReminder>();
ev.Reminders.Overrides.Add(eventReminder);
ev.OriginalStartTime = start;
App.ViewModel.AddEvent(ev);
Close();
}
public ActionResult Edit(int id)
{
EventReminder events = GetEventId(id);
return(View("Create", events));
}
private void SyncNow_Click(object sender, EventArgs e)
{
if (Settings.Instance.UseGoogleCalendar.Id == "")
{
MessageBox.Show("You need to select a Google Calendar first on the 'Settings' tab.");
return;
}
bSyncNow.Enabled = false;
LogBox.Clear();
DateTime syncStarted = DateTime.Now;
logboxout("Sync started at " + syncStarted.ToString());
logboxout("--------------------------------------------------");
logboxout("Reading Outlook Calendar Entries...");
List<OutlookAppointment> outlookEntries;
try
{
var officeCalendar = CreateOfficeCalendar();
outlookEntries = officeCalendar.GetCalendarEntriesInRange();
}
catch (System.Exception ex)
{
bSyncNow.Enabled = true;
notifyIcon1.ShowBalloonTip(5, "outlook issue", "an error while reading from outlook: " + ex.Message, ToolTipIcon.Error);
logboxout("an error while reading from outlook: " + ex.Message + "\n" + ex.StackTrace);
return;
}
if (cbCreateFiles.Checked)
{
using(TextWriter tw = new StreamWriter("export_found_in_outlook.txt"))
{
foreach (OutlookAppointment ai in outlookEntries)
{
tw.WriteLine(Signature(ai));
}
tw.Close();
}
}
logboxout("Found " + outlookEntries.Count + " Outlook Calendar Entries.");
logboxout("--------------------------------------------------");
logboxout("Reading Google Calendar Entries...");
List<Event> GoogleEntries = new List<Event>();
try
{
GoogleEntries = GoogleCalendar.Instance.getCalendarEntriesInRange();
}
catch (System.Exception ex)
{
bSyncNow.Enabled = true;
notifyIcon1.ShowBalloonTip(5, "google issue", "an error while reading from google: " + ex.Message, ToolTipIcon.Error);
logboxout("an error while reading from google: " + ex.Message + "\n" + ex.StackTrace);
return;
}
if (cbCreateFiles.Checked)
{
using(TextWriter tw = new StreamWriter("export_found_in_google.txt"))
{
foreach (Event ev in GoogleEntries)
{
tw.WriteLine(Signature(ev));
}
tw.Close();
}
}
logboxout("Found " + GoogleEntries.Count + " Google Calendar Entries.");
logboxout("--------------------------------------------------");
// Make copies of each list of events (Not strictly needed)
List<Event> GoogleEntriesToBeDeleted = new List<Event>(GoogleEntries);
List<OutlookAppointment> OutlookEntriesToBeCreated = new List<OutlookAppointment>(outlookEntries);
IdentifyGoogleAddDeletes(OutlookEntriesToBeCreated, GoogleEntriesToBeDeleted);
//List<Event> GoogleEntriesToBeDeleted = IdentifyGoogleEntriesToBeDeleted(OutlookEntries, GoogleEntries);
if (cbCreateFiles.Checked)
{
using(TextWriter tw = new StreamWriter("export_to_be_deleted.txt"))
{
foreach (Event ev in GoogleEntriesToBeDeleted)
{
tw.WriteLine(Signature(ev));
}
tw.Close();
}
}
logboxout(GoogleEntriesToBeDeleted.Count + " Google Calendar Entries to be deleted.");
//OutlookEntriesToBeCreated ...in Google!
//List<OutlookAppointment> OutlookEntriesToBeCreated = IdentifyOutlookEntriesToBeCreated(OutlookEntries, GoogleEntries);
if (cbCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_to_be_created.txt"))
{
foreach (OutlookAppointment ai in OutlookEntriesToBeCreated)
{
tw.WriteLine(Signature(ai));
}
tw.Close();
}
}
logboxout(OutlookEntriesToBeCreated.Count + " Entries to be created in Google.");
logboxout("--------------------------------------------------");
if (GoogleEntriesToBeDeleted.Count > 0)
{
logboxout("Deleting " + GoogleEntriesToBeDeleted.Count + " Google Calendar Entries...");
foreach (Event ev in GoogleEntriesToBeDeleted) GoogleCalendar.Instance.deleteCalendarEntry(ev);
logboxout("Done.");
logboxout("--------------------------------------------------");
}
if (OutlookEntriesToBeCreated.Count > 0)
{
logboxout("Creating " + OutlookEntriesToBeCreated.Count + " Entries in Google...");
foreach (OutlookAppointment ai in OutlookEntriesToBeCreated)
{
Event ev = new Event
{
Start = new EventDateTime(),
End = new EventDateTime()
};
if (ai.AllDayEvent)
{
ev.Start.Date = ai.Start.ToString("yyyy-MM-dd");
ev.End.Date = ai.End.ToString("yyyy-MM-dd");
}
else
{
//ev.Start.DateTime = ai.Start;
//ev.End.DateTime = ai.End;
ev.Start.DateTime = GoogleCalendar.Instance.GoogleTimeFrom(ai.Start);
ev.End.DateTime = GoogleCalendar.Instance.GoogleTimeFrom(ai.End);
}
ev.Summary = ai.Subject;
if (cbAddDescription.Checked)
{
ev.Description = ai.Body;
}
ev.Location = ai.Location;
//consider the reminder set in Outlook
if (cbAddReminders.Checked && ai.ReminderSet)
{
ev.Reminders = new Event.RemindersData();
ev.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = ai.ReminderMinutesBeforeStart;
ev.Reminders.Overrides = new List<EventReminder>();
ev.Reminders.Overrides.Add(reminder);
}
ev.Description = ai.Body;
// Set Attendees
if (cbAddAttendees.Checked)
{
var footer = new StringBuilder();
footer.Append(Environment.NewLine);
footer.Append(Environment.NewLine + "==============================================");
footer.Append(Environment.NewLine + "Added by OutlookGoogleSync:" + Environment.NewLine);
footer.Append(Environment.NewLine + "ORGANIZER: " + Environment.NewLine + ai.Organizer + Environment.NewLine);
footer.Append(Environment.NewLine + "REQUIRED: " + Environment.NewLine + splitAttendees(ai.RequiredAttendees) + Environment.NewLine);
footer.Append(Environment.NewLine + "OPTIONAL: " + Environment.NewLine + splitAttendees(ai.OptionalAttendees));
footer.Append(Environment.NewLine + "==============================================");
ev.Description = ev.Description + footer;
}
GoogleCalendar.Instance.addEntry(ev);
}
logboxout("Done.");
logboxout("--------------------------------------------------");
}
DateTime SyncFinished = DateTime.Now;
TimeSpan Elapsed = SyncFinished - syncStarted;
logboxout("Sync finished at " + SyncFinished.ToString());
logboxout("Time needed: " + Elapsed.Minutes + " min " + Elapsed.Seconds + " s");
bSyncNow.Enabled = true;
}
private void syncWorker_DoWork(object sender, DoWorkEventArgs e)
{
if (e.Argument is string &&
"DELETE".Equals((string)e.Argument))
{
deleteAllSyncItems();
return;
}
AppointmentItemCache appointmentItemCache = new AppointmentItemCache();
EventCache eventCache = new EventCache();
DateTime syncStarted = DateTime.Now;
OutlookCalendar ocal = null;
try
{
logboxout("Sync started at " + syncStarted.ToString());
logboxout("--------------------------------------------------");
logboxout("Reading Outlook Calendar Entries...");
ocal = new OutlookCalendar();
List <AppointmentItemCacheEntry> OutlookEntries = new List <AppointmentItemCacheEntry>();
foreach (AppointmentItem a in ocal.getCalendarEntriesInRange(syncStarted))
{
OutlookEntries.Add(appointmentItemCache.GetAppointmentItemCacheEntry(a, ocal.AccountName));
}
if (checkBoxCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_found_in_outlook.txt"))
{
foreach (AppointmentItemCacheEntry ai in OutlookEntries)
{
tw.WriteLine(ai.Signature);
}
}
}
logboxout("Found " + OutlookEntries.Count + " Outlook Calendar Entries.");
logboxout("--------------------------------------------------");
logboxout("Reading Google Calendar Entries...");
string accountName = "(Empty)";
if (ocal != null || !string.IsNullOrEmpty(ocal.AccountName))
{
accountName = ocal.AccountName;
}
GoogleCalendar gcal = new GoogleCalendar();
List <EventCacheEntry> GoogleEntries = new List <EventCacheEntry>();
foreach (Event ev in gcal.getCalendarEntriesInRange(syncStarted))
{
GoogleEntries.Add(eventCache.GetEventCacheEntry(ev, accountName));
}
if (checkBoxCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_found_in_google.txt"))
{
foreach (EventCacheEntry ev in GoogleEntries)
{
tw.WriteLine(ev.Signature);
}
}
}
logboxout("Found " + GoogleEntries.Count + " Google Calendar Entries.");
logboxout("--------------------------------------------------");
List <EventCacheEntry> GoogleEntriesToBeDeleted = identifyGoogleEntriesToBeDeleted(OutlookEntries, GoogleEntries, accountName);
if (checkBoxCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_to_be_deleted.txt"))
{
foreach (EventCacheEntry ev in GoogleEntriesToBeDeleted)
{
tw.WriteLine(ev.Signature);
}
}
}
logboxout(GoogleEntriesToBeDeleted.Count + " Google Calendar Entries to be deleted.");
//OutlookEntriesToBeCreated ...in Google!
List <AppointmentItemCacheEntry> OutlookEntriesToBeCreated = identifyOutlookEntriesToBeCreated(OutlookEntries, GoogleEntries);
if (checkBoxCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_to_be_created.txt"))
{
foreach (AppointmentItemCacheEntry ai in OutlookEntriesToBeCreated)
{
tw.WriteLine(ai.Signature);
}
}
}
logboxout(OutlookEntriesToBeCreated.Count + " Entries to be created in Google.");
logboxout("--------------------------------------------------");
if (GoogleEntriesToBeDeleted.Count > 0)
{
logboxout("Deleting " + GoogleEntriesToBeDeleted.Count + " Google Calendar Entries...");
foreach (EventCacheEntry ev in GoogleEntriesToBeDeleted)
{
gcal.deleteCalendarEntry(ev.Event);
}
logboxout("Done.");
logboxout("--------------------------------------------------");
}
if (OutlookEntriesToBeCreated.Count > 0)
{
logboxout("Creating " + OutlookEntriesToBeCreated.Count + " Entries in Google...");
foreach (AppointmentItemCacheEntry aice in OutlookEntriesToBeCreated)
{
AppointmentItem ai = aice.AppointmentItem;
Event ev = new Event();
ev.Start = new EventDateTime();
ev.End = new EventDateTime();
if (ai.AllDayEvent)
{
ev.Start.Date = ai.Start.ToString("yyyy-MM-dd");
ev.End.Date = ai.End.ToString("yyyy-MM-dd");
}
else
{
ev.Start.DateTime = GoogleCalendar.GoogleTimeFrom(ai.Start);
ev.End.DateTime = GoogleCalendar.GoogleTimeFrom(ai.End);
}
ev.Summary = ai.Subject;
if (checkBoxAddDescription.Checked)
{
try
{
ev.Description = ai.Body;
}
catch (System.Exception ex)
{
string startDt = ai.AllDayEvent ? ai.Start.ToShortDateString() : ai.Start.ToString();
string endDt = ai.AllDayEvent ? ai.End.ToShortDateString() : ai.End.ToString();
logboxout("Error accessing the body of Outlook item. Body will be empty.\r\n Subject: [" + ev.Summary + "]\r\n Start: [" + startDt + "]\r\n End: [" + endDt + "]\r\n Error: " + ex.Message);
}
}
ev.Location = ai.Location;
//consider the reminder set in Outlook
if (checkBoxAddReminders.Checked && ai.ReminderSet)
{
ev.Reminders = new Event.RemindersData();
ev.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = ai.ReminderMinutesBeforeStart;
ev.Reminders.Overrides = new List <EventReminder>();
ev.Reminders.Overrides.Add(reminder);
}
else
{
ev.Reminders = new Event.RemindersData();
ev.Reminders.UseDefault = false;
}
if (checkBoxAddAttendees.Checked)
{
ev.Description += Environment.NewLine;
ev.Description += Environment.NewLine + "==============================================";
ev.Description += Environment.NewLine + "Added by OutlookGoogleSync (" + accountName + "):" + Environment.NewLine;
ev.Description += Environment.NewLine + "ORGANIZER: " + Environment.NewLine + ai.Organizer + Environment.NewLine;
ev.Description += Environment.NewLine + "REQUIRED: " + Environment.NewLine + splitAttendees(ai.RequiredAttendees) + Environment.NewLine;
if (ai.OptionalAttendees != null)
{
ev.Description += Environment.NewLine + "OPTIONAL: " + Environment.NewLine + splitAttendees(ai.OptionalAttendees);
}
ev.Description += Environment.NewLine + "==============================================";
}
gcal.addEntry(ev);
}
logboxout("Done.");
logboxout("--------------------------------------------------");
}
DateTime syncFinished = DateTime.Now;
TimeSpan elapsed = syncFinished - syncStarted;
logboxout("Sync finished at " + syncFinished.ToString());
logboxout("Time needed: " + elapsed.Minutes + " min " + elapsed.Seconds + " s");
}
catch (System.Exception ex)
{
logboxout("Error Syncing:\r\n" + ex.ToString());
}
eventCache.Clear();
freeCOMResources(ocal, appointmentItemCache);
}
public ActionResult Edit(int id)
{
EventReminder events = eventRepository.GetEventById(id);
return(View("Create", events));
}
private void SyncNow_Click(object sender, EventArgs e)
{
if (Settings.Instance.UseGoogleCalendar.Id == "")
{
MessageBox.Show("You need to select a Google Calendar first on the 'Settings' tab.");
return;
}
bSyncNow.Enabled = false;
LogBox.Clear();
DateTime syncStarted = DateTime.Now;
logboxout("Sync started at " + syncStarted.ToString());
logboxout("--------------------------------------------------");
logboxout("Reading Outlook Calendar Entries...");
List <OutlookAppointment> outlookEntries;
try
{
var officeCalendar = CreateOfficeCalendar();
outlookEntries = officeCalendar.GetCalendarEntriesInRange();
}
catch (System.Exception ex)
{
bSyncNow.Enabled = true;
notifyIcon1.ShowBalloonTip(5, "outlook issue", "an error while reading from outlook: " + ex.Message, ToolTipIcon.Error);
logboxout("an error while reading from outlook: " + ex.Message + "\n" + ex.StackTrace);
return;
}
if (cbCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_found_in_outlook.txt"))
{
foreach (OutlookAppointment ai in outlookEntries)
{
tw.WriteLine(Signature(ai));
}
tw.Close();
}
}
logboxout("Found " + outlookEntries.Count + " Outlook Calendar Entries.");
logboxout("--------------------------------------------------");
logboxout("Reading Google Calendar Entries...");
List <Event> GoogleEntries = new List <Event>();
try
{
GoogleEntries = GoogleCalendar.Instance.getCalendarEntriesInRange();
}
catch (System.Exception ex)
{
bSyncNow.Enabled = true;
notifyIcon1.ShowBalloonTip(5, "google issue", "an error while reading from google: " + ex.Message, ToolTipIcon.Error);
logboxout("an error while reading from google: " + ex.Message + "\n" + ex.StackTrace);
return;
}
if (cbCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_found_in_google.txt"))
{
foreach (Event ev in GoogleEntries)
{
tw.WriteLine(Signature(ev));
}
tw.Close();
}
}
logboxout("Found " + GoogleEntries.Count + " Google Calendar Entries.");
logboxout("--------------------------------------------------");
// Make copies of each list of events (Not strictly needed)
List <Event> GoogleEntriesToBeDeleted = new List <Event>(GoogleEntries);
List <OutlookAppointment> OutlookEntriesToBeCreated = new List <OutlookAppointment>(outlookEntries);
IdentifyGoogleAddDeletes(OutlookEntriesToBeCreated, GoogleEntriesToBeDeleted);
//List<Event> GoogleEntriesToBeDeleted = IdentifyGoogleEntriesToBeDeleted(OutlookEntries, GoogleEntries);
if (cbCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_to_be_deleted.txt"))
{
foreach (Event ev in GoogleEntriesToBeDeleted)
{
tw.WriteLine(Signature(ev));
}
tw.Close();
}
}
logboxout(GoogleEntriesToBeDeleted.Count + " Google Calendar Entries to be deleted.");
//OutlookEntriesToBeCreated ...in Google!
//List<OutlookAppointment> OutlookEntriesToBeCreated = IdentifyOutlookEntriesToBeCreated(OutlookEntries, GoogleEntries);
if (cbCreateFiles.Checked)
{
using (TextWriter tw = new StreamWriter("export_to_be_created.txt"))
{
foreach (OutlookAppointment ai in OutlookEntriesToBeCreated)
{
tw.WriteLine(Signature(ai));
}
tw.Close();
}
}
logboxout(OutlookEntriesToBeCreated.Count + " Entries to be created in Google.");
logboxout("--------------------------------------------------");
if (GoogleEntriesToBeDeleted.Count > 0)
{
logboxout("Deleting " + GoogleEntriesToBeDeleted.Count + " Google Calendar Entries...");
foreach (Event ev in GoogleEntriesToBeDeleted)
{
GoogleCalendar.Instance.deleteCalendarEntry(ev);
}
logboxout("Done.");
logboxout("--------------------------------------------------");
}
if (OutlookEntriesToBeCreated.Count > 0)
{
logboxout("Creating " + OutlookEntriesToBeCreated.Count + " Entries in Google...");
foreach (OutlookAppointment ai in OutlookEntriesToBeCreated)
{
Event ev = new Event
{
Start = new EventDateTime(),
End = new EventDateTime()
};
if (ai.AllDayEvent)
{
ev.Start.Date = ai.Start.ToString("yyyy-MM-dd");
ev.End.Date = ai.End.ToString("yyyy-MM-dd");
}
else
{
//ev.Start.DateTime = ai.Start;
//ev.End.DateTime = ai.End;
ev.Start.DateTime = GoogleCalendar.Instance.GoogleTimeFrom(ai.Start);
ev.End.DateTime = GoogleCalendar.Instance.GoogleTimeFrom(ai.End);
}
ev.Summary = ai.Subject;
if (cbAddDescription.Checked)
{
ev.Description = ai.Body;
}
ev.Location = ai.Location;
//consider the reminder set in Outlook
if (cbAddReminders.Checked && ai.ReminderSet)
{
ev.Reminders = new Event.RemindersData();
ev.Reminders.UseDefault = false;
EventReminder reminder = new EventReminder();
reminder.Method = "popup";
reminder.Minutes = ai.ReminderMinutesBeforeStart;
ev.Reminders.Overrides = new List <EventReminder>();
ev.Reminders.Overrides.Add(reminder);
}
ev.Description = ai.Body;
// Set Attendees
if (cbAddAttendees.Checked)
{
var footer = new StringBuilder();
footer.Append(Environment.NewLine);
footer.Append(Environment.NewLine + "==============================================");
footer.Append(Environment.NewLine + "Added by OutlookGoogleSync:" + Environment.NewLine);
footer.Append(Environment.NewLine + "ORGANIZER: " + Environment.NewLine + ai.Organizer + Environment.NewLine);
footer.Append(Environment.NewLine + "REQUIRED: " + Environment.NewLine + splitAttendees(ai.RequiredAttendees) + Environment.NewLine);
footer.Append(Environment.NewLine + "OPTIONAL: " + Environment.NewLine + splitAttendees(ai.OptionalAttendees));
footer.Append(Environment.NewLine + "==============================================");
ev.Description = ev.Description + footer;
}
GoogleCalendar.Instance.addEntry(ev);
}
logboxout("Done.");
logboxout("--------------------------------------------------");
}
DateTime SyncFinished = DateTime.Now;
TimeSpan Elapsed = SyncFinished - syncStarted;
logboxout("Sync finished at " + SyncFinished.ToString());
logboxout("Time needed: " + Elapsed.Minutes + " min " + Elapsed.Seconds + " s");
bSyncNow.Enabled = true;
}
public EventReminderModel(EventReminder eventReminder)
{
_eventReminder = eventReminder;
LoadedTime = DateTime.Now;
}
