public GVentMinder(Reminder reminder)
{
if (reminder == null)
throw new ArgumentNullException("entry");
_HowEarly = new TimeSpan(reminder.Days, reminder.Hours, reminder.Minutes, 0);
}
/// <summary>
/// Gets the minutes.
/// </summary>
/// <param name="reminder">The reminder.</param>
/// <returns>The Minutes.</returns>
public static int GetMinutes(this Google.GData.Extensions.Reminder reminder)
{
int result = reminder.Minutes;
result += reminder.Hours * 60;
result += reminder.Days * 24 * 60;
return(result);
}
/// <summary>
/// Adds a reminder to a calendar event.
/// </summary>
/// <param name="entry">The event to update.</param>
/// <param name="numMinutes">Reminder time, in minutes.</param>
/// <returns>The updated EventEntry object.</returns>
static EventEntry AddReminder(EventEntry entry, int numMinutes)
{
Reminder reminder = new Reminder();
reminder.Minutes = numMinutes;
entry.Reminder = reminder;
return (EventEntry)entry.Update();
}
/// <summary>
/// Merges the with.
/// </summary>
/// <param name="googleCalendarItem">The google calendar item.</param>
/// <param name="outlookCalendarItem">The outlook calendar item.</param>
/// <returns>True if Changed.</returns>
public static bool MergeWith(this EventEntry googleCalendarItem, AppointmentItem outlookCalendarItem)
{
var result = false;
result |= googleCalendarItem.Title.ApplyProperty(g => g.Text, outlookCalendarItem.Subject);
result |= googleCalendarItem.Content.ApplyProperty(g => g.Content, outlookCalendarItem.Body);
if (googleCalendarItem.EventTransparency == null)
{
googleCalendarItem.EventTransparency = new EventEntry.Transparency();
}
result |= googleCalendarItem.EventTransparency.ApplyProperty(g => g.Value, outlookCalendarItem.BusyStatus.GetStatus());
if (googleCalendarItem.EventVisibility == null)
{
googleCalendarItem.EventVisibility = new EventEntry.Visibility();
}
result |= googleCalendarItem.EventVisibility.ApplyProperty(g => g.Value, outlookCalendarItem.Sensitivity.GetStatus());
result |= googleCalendarItem.Locations.Merge(outlookCalendarItem.Location);
result |= googleCalendarItem.Participants.Merge(outlookCalendarItem);
if (outlookCalendarItem.RecurrenceState == OlRecurrenceState.olApptNotRecurring)
{
When time = googleCalendarItem.Times.FirstOrInstance();
if (!googleCalendarItem.Times.Any())
{
googleCalendarItem.Times.Add(time);
}
result |= time.ApplyProperty(t => t.AllDay, outlookCalendarItem.AllDayEvent);
result |= time.ApplyProperty(t => t.StartTime, outlookCalendarItem.Start);
result |= time.ApplyProperty(t => t.EndTime, outlookCalendarItem.End);
if (outlookCalendarItem.ReminderSet)
{
Google.GData.Extensions.Reminder reminder = time.Reminders.FirstOrInstance(t => t.Method == Google.GData.Extensions.Reminder.ReminderMethod.alert);
var timespan = TimeSpan.FromMinutes(outlookCalendarItem.ReminderMinutesBeforeStart);
result |= reminder.ApplyProperty(r => r.Method, Google.GData.Extensions.Reminder.ReminderMethod.alert);
result |= reminder.ApplyProperty(r => r.Minutes, timespan.Minutes);
result |= reminder.ApplyProperty(r => r.Hours, timespan.Hours);
result |= reminder.ApplyProperty(r => r.Days, timespan.Days);
}
}
else
{
if (googleCalendarItem.Recurrence == null)
{
googleCalendarItem.Recurrence = new Recurrence();
}
result |= googleCalendarItem.Recurrence.ApplyProperty(r => r.Value, RecurrenceSerializer.Serialize(outlookCalendarItem.GetRecurrencePattern(), outlookCalendarItem.Start, outlookCalendarItem.AllDayEvent));
}
return(result);
}
public EventEntry 创建活动(string 标题, string 说明, string 地点, DateTime 开始时间, DateTime 结束时间, Reminder.ReminderMethod 提醒方式, TimeSpan 提前提醒时间)
{
if (提醒方式 != Reminder.ReminderMethod.none && 提前提醒时间.TotalMinutes < 1) throw new Exception("提前提醒时间不得小于1分钟，因为低于分钟的单位将被忽略");
var q = new EventEntry(标题, 说明, 地点);
q.Times.Add(new When(开始时间, 结束时间));
q.Reminder = new Reminder { Minutes = 提前提醒时间.Minutes, Days = 提前提醒时间.Days, Hours = 提前提醒时间.Hours, Method = Reminder.ReminderMethod.all };
if (操作日历名称 == null)
{
return 日历服务.Insert(new Uri(访问网址), q) as EventEntry;
}
else
{
var query = new CalendarQuery(访问网址);
CalendarEntry c = null;
foreach (CalendarEntry f in 日历服务.Query(query).Entries)
{
if (f.Title.Text == 操作日历名称) c = f;
}
return 日历服务.Insert(new Uri(c.Content.AbsoluteUri), q) as EventEntry;
}
}
public void send(string info)
{
EventEntry entry = new EventEntry();
entry.Title.Text = "iPhone4 开卖状况改变";
entry.Content.Content = info;
Where eventLocation = new Where();
eventLocation.ValueString = "Apple Store";
entry.Locations.Add(eventLocation);
When eventTime = new When(DateTime.Now.AddMinutes(2), DateTime.Now.AddMinutes(30));
entry.Times.Add(eventTime);
Reminder reminder = new Reminder();
reminder.Minutes = 1;
reminder.Method = Reminder.ReminderMethod.all;
entry.Reminders.Add(reminder);
Uri postUri = new Uri("https://www.google.com/calendar/feeds/default/private/full");
AtomEntry insertedEntry = svc.Insert(postUri, entry);
}
public void googlecalendarSMSreminder(string sendstring)
{
CalendarService service = new CalendarService("exampleCo-exampleApp-1");
service.setUserCredentials(UserName.Text, Password.Text);
EventEntry entry = new EventEntry();
// Set the title and content of the entry.
entry.Title.Text = sendstring;
entry.Content.Content = "Nadpis Test SMS.";
// Set a location for the event.
Where eventLocation = new Where();
eventLocation.ValueString = "Test sms";
entry.Locations.Add(eventLocation);
When eventTime = new When(DateTime.Now.AddMinutes(3), DateTime.Now.AddHours(1));
entry.Times.Add(eventTime);
//Add SMS Reminder
Reminder fiftyMinReminder = new Reminder();
fiftyMinReminder.Minutes = 1;
fiftyMinReminder.Method = Reminder.ReminderMethod.sms;
entry.Reminders.Add(fiftyMinReminder);
Uri postUri = new Uri("http://www.google.com/calendar/feeds/default/private/full");
// Send the request and receive the response:
AtomEntry insertedEntry = service.Insert(postUri, entry);
}
//////////////////////////////////////////////////////////////////////
/// <summary>Parses an xml node to create a Reminder object.</summary>
/// <param name="node">the node to parse node</param>
/// <param name="parser">the xml parser to use if we need to dive deeper</param>
/// <returns>the created Reminder object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
Reminder reminder = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return null;
}
}
reminder = new Reminder();
if (node != null && node.Attributes != null)
{
if (node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime] != null)
{
try
{
reminder.AbsoluteTime =
DateTime.Parse(node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@absoluteTime.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeDays] != null)
{
try
{
reminder.Days = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeDays].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@days.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeHours] != null)
{
try
{
reminder.Hours = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeHours].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@hours.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeMinutes] != null)
{
try
{
reminder.Minutes = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeMinutes].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@minutes.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeMethod] != null)
{
try
{
reminder.Method = (ReminderMethod)Enum.Parse(typeof(ReminderMethod),
node.Attributes[GDataParserNameTable.XmlAttributeMethod].Value,
true);
}
catch (Exception e)
{
throw new ArgumentException("Invalid g:reminder/@method.", e);
}
}
}
return reminder;
}
public bool Update(Reminder reminder)
{
if (_HowEarly != new TimeSpan(reminder.Days, reminder.Hours, reminder.Minutes, 0))
return false;
Processed = true;
return true;
}
/////////////////////////////////////////////////////////////////////////////
///
/// tests the reminder object
///
[Test] public void ReminderTest()
{
String xml = "<reminder xmlns=\"http://schemas.google.com/g/2005\" minutes=\"0\" method=\"email\"/>";
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
XmlNode reminderNode = doc.FirstChild;
Reminder f = new Reminder();
Reminder r;
r = f.CreateInstance(reminderNode, new AtomFeedParser()) as Reminder;
Assert.IsTrue(r.Method == Reminder.ReminderMethod.email);
Assert.IsTrue(r.Minutes == 0);
xml = "<reminder xmlns=\"http://schemas.google.com/g/2005\" minutes=\"5\" method=\"sms\"/>";
doc = new XmlDocument();
doc.LoadXml(xml);
reminderNode = doc.FirstChild;
r = new Reminder();
r = f.CreateInstance(reminderNode, new AtomFeedParser()) as Reminder;
Assert.IsTrue(r.Method == Reminder.ReminderMethod.sms);
Assert.IsTrue(r.Minutes == 5);
}
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>Tests the reminder method property</summary>
//////////////////////////////////////////////////////////////////////
[Test] public void CalendarReminderMethodTest()
{
Tracing.TraceMsg("Entering CalendarReminderMethodTest");
EventQuery query = new EventQuery();
CalendarService service = new CalendarService(this.ApplicationName);
if (this.defaultCalendarUri != null)
{
if (this.userName != null)
{
service.Credentials = new GDataCredentials(this.userName, this.passWord);
}
service.RequestFactory = this.factory;
query.Uri = new Uri(this.defaultCalendarUri);
EventFeed calFeed = service.Query(query) as EventFeed;
String strTitle = "Dinner & time" + Guid.NewGuid().ToString();
if (calFeed != null)
{
// get the first entry
EventEntry entry = ObjectModelHelper.CreateEventEntry(1);
entry.Title.Text = strTitle;
entry.Reminders.Clear();
Reminder r1 = new Reminder();
r1.Method = Reminder.ReminderMethod.email;
r1.Minutes = 30;
Reminder r2 = new Reminder();
r2.Method = Reminder.ReminderMethod.alert;
r2.Minutes = 60;
entry.Reminders.Add(r1);
entry.Reminders.Add(r2);
EventEntry newEntry = (EventEntry) calFeed.Insert(entry);
Assert.AreEqual(2, newEntry.Reminders.Count, "There should be two reminders");
Reminder r3 = newEntry.Reminders[0] as Reminder;
Reminder r4 = newEntry.Reminders[1] as Reminder;
Reminder r1a;
Reminder r2a;
if (r3.Method == Reminder.ReminderMethod.email)
{
r1a = r3;
r2a = r4;
}
else
{
r1a = r4;
r2a = r3;
}
Assert.AreEqual(r1.Minutes, r1a.Minutes, "Reminder time should be identical");
Assert.AreEqual(r1.Method, r1a.Method, "Reminder method should be identical");
Assert.AreEqual(r2.Minutes, r2a.Minutes, "Reminder time should be identical");
Assert.AreEqual(r2.Method, r2a.Method, "Reminder method should be identical");
Tracing.TraceMsg("Created calendar entry");
}
service.Credentials = null;
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>Parses an xml node to create a Where object.</summary>
/// <param name="node">the node to parse node</param>
/// <param name="parser">the xml parser to use if we need to dive deeper</param>
/// <returns>the created Where object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
When when = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return(null);
}
}
bool startTimeFlag = false, endTimeFlag = false;
when = new When();
if (node != null)
{
if (node.Attributes != null)
{
String value = node.Attributes[GDataParserNameTable.XmlAttributeStartTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeStartTime].Value : null;
if (value != null)
{
startTimeFlag = true;
when.startTime = DateTime.Parse(value);
when.AllDay = (value.IndexOf('T') == -1);
}
value = node.Attributes[GDataParserNameTable.XmlAttributeEndTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeEndTime].Value : null;
if (value != null)
{
endTimeFlag = true;
when.endTime = DateTime.Parse(value);
when.AllDay = when.AllDay && (value.IndexOf('T') == -1);
}
if (node.Attributes[GDataParserNameTable.XmlAttributeValueString] != null)
{
when.valueString = node.Attributes[GDataParserNameTable.XmlAttributeValueString].Value;
}
}
// single event, g:reminder is inside g:when
if (node.HasChildNodes)
{
XmlNode whenChildNode = node.FirstChild;
IExtensionElementFactory f = new Reminder() as IExtensionElementFactory;
while (whenChildNode != null && whenChildNode is XmlElement)
{
if (String.Compare(whenChildNode.NamespaceURI, f.XmlNameSpace, true, CultureInfo.InvariantCulture) == 0)
{
if (String.Compare(whenChildNode.LocalName, f.XmlName, true, CultureInfo.InvariantCulture) == 0)
{
Reminder r = f.CreateInstance(whenChildNode, null) as Reminder;
when.Reminders.Add(r);
}
}
whenChildNode = whenChildNode.NextSibling;
}
}
}
if (!startTimeFlag)
{
throw new ClientFeedException("g:when/@startTime is required.");
}
if (endTimeFlag && when.startTime.CompareTo(when.endTime) > 0)
{
throw new ClientFeedException("g:when/@startTime must be less than or equal to g:when/@endTime.");
}
return(when);
}
public void googlecalendarSMSreminder(string sendstring)
{
CalendarService service = new CalendarService("exampleCo-exampleApp-1");
service.setUserCredentials("*****@*****.**", "joneson55");
EventEntry entry = new EventEntry();
// Set the title and content of the entry.
entry.Title.Text = sendstring;
entry.Content.Content = "Lockerz Login Page Check.";
// Set a location for the event.
Where eventLocation = new Where();
eventLocation.ValueString = "Lockerz Login";
entry.Locations.Add(eventLocation);
When eventTime = new When(DateTime.Now.AddMinutes(3), DateTime.Now.AddHours(1));
entry.Times.Add(eventTime);
if (checkBox1.Checked == true) //Reminder ON/OFF
{
//Add SMS Reminder
Reminder fiftyMinReminder = new Reminder();
fiftyMinReminder.Minutes = 1;
fiftyMinReminder.Method = Reminder.ReminderMethod.sms;
entry.Reminders.Add(fiftyMinReminder);
}
else
{
}
Uri postUri = new Uri("http://www.google.com/calendar/feeds/default/private/full");
// Send the request and receive the response:
AtomEntry insertedEntry = service.Insert(postUri, entry);
}
public EventEntry 创建活动(string 标题, string 说明, string 地点, DateTime 开始时间, TimeSpan 持续时间, Reminder.ReminderMethod 提醒方式, TimeSpan 提前提醒时间)
{
return 创建活动(标题, 说明, 地点, 开始时间, 开始时间.Add(持续时间), 提醒方式, 提前提醒时间);
}
//////////////////////////////////////////////////////////////////////
/// <summary>Parses an xml node to create a Where object.</summary>
/// <param name="node">the node to parse node</param>
/// <param name="parser">the xml parser to use if we need to dive deeper</param>
/// <returns>the created Where object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
When when = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return null;
}
}
bool startTimeFlag = false, endTimeFlag = false;
when = new When();
if (node != null)
{
if (node.Attributes != null)
{
String value = node.Attributes[GDataParserNameTable.XmlAttributeStartTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeStartTime].Value : null;
if (value != null)
{
startTimeFlag = true;
when.startTime = DateTime.Parse(value);
when.AllDay = (value.IndexOf('T') == -1);
}
value = node.Attributes[GDataParserNameTable.XmlAttributeEndTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeEndTime].Value : null;
if (value != null)
{
endTimeFlag = true;
when.endTime = DateTime.Parse(value);
when.AllDay = when.AllDay && (value.IndexOf('T') == -1);
}
if (node.Attributes[GDataParserNameTable.XmlAttributeValueString] != null)
{
when.valueString = node.Attributes[GDataParserNameTable.XmlAttributeValueString].Value;
}
}
// single event, g:reminder is inside g:when
if (node.HasChildNodes)
{
XmlNode whenChildNode = node.FirstChild;
IExtensionElementFactory f = new Reminder() as IExtensionElementFactory;
while (whenChildNode != null && whenChildNode is XmlElement)
{
if (String.Compare(whenChildNode.NamespaceURI, f.XmlNameSpace, true, CultureInfo.InvariantCulture) == 0)
{
if (String.Compare(whenChildNode.LocalName, f.XmlName, true, CultureInfo.InvariantCulture) == 0)
{
Reminder r = f.CreateInstance(whenChildNode, null) as Reminder;
when.Reminders.Add(r);
}
}
whenChildNode = whenChildNode.NextSibling;
}
}
}
if (!startTimeFlag)
{
throw new ClientFeedException("g:when/@startTime is required.");
}
if (endTimeFlag && when.startTime.CompareTo(when.endTime) > 0)
{
throw new ClientFeedException("g:when/@startTime must be less than or equal to g:when/@endTime.");
}
return when;
}
private void _setEventEntryToCurrent()
{
// create the entry if needed
if (_entry == null)
{
_entry = new EventEntry();
}
// Set the title
_entry.Title.Text = this.Title;
// Set the contents
_entry.Content.Content = this.Contents;
// Set a location for the event.
_entry.Locations.Clear();
_entry.Locations.Add(new Where()
{
ValueString = this.Location
});
// Set the event time
_entry.Times.Clear();
_entry.Times.Add(new When(this.StartTime, this.EndTime));
// reminders clear first so we can update it
_entry.Reminders.Clear();
foreach (var item in Reminders)
{
var newReminder = new Reminder();
newReminder.Method = item.Type;
newReminder.Minutes = item.Minutes;
newReminder.Hours = item.Hours;
newReminder.Days = item.Days;
_entry.Reminders.Add(newReminder);
}
// participants clear first so we can update it
_entry.Participants.Clear();
foreach (var item in Invitees)
{
var newInvitee = new Who();
newInvitee.Email = item.Email;
newInvitee.ValueString = item.Name;
_entry.Participants.Add(newInvitee);
}
}
//////////////////////////////////////////////////////////////////////
/// <summary>Parses an xml node to create a Reminder object.</summary>
/// <param name="node">the node to parse node</param>
/// <param name="parser">the xml parser to use if we need to dive deeper</param>
/// <returns>the created Reminder object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
Reminder reminder = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return(null);
}
}
reminder = new Reminder();
if (node != null && node.Attributes != null)
{
if (node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime] != null)
{
try
{
reminder.AbsoluteTime =
DateTime.Parse(node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@absoluteTime.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeDays] != null)
{
try
{
reminder.Days = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeDays].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@days.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeHours] != null)
{
try
{
reminder.Hours = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeHours].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@hours.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeMinutes] != null)
{
try
{
reminder.Minutes = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeMinutes].Value);
}
catch (FormatException fe)
{
throw new ArgumentException("Invalid g:reminder/@minutes.", fe);
}
}
if (node.Attributes[GDataParserNameTable.XmlAttributeMethod] != null)
{
try
{
reminder.Method = (ReminderMethod)Enum.Parse(typeof(ReminderMethod),
node.Attributes[GDataParserNameTable.XmlAttributeMethod].Value,
true);
}
catch (Exception e)
{
throw new ArgumentException("Invalid g:reminder/@method.", e);
}
}
}
return(reminder);
}
/// <summary>
/// Add a local event to Google Calendar
/// </summary>
/// <param name="GGService">Google calendar service object</param>
/// <param name="GGCalendar">GG calendar object</param>
/// <param name="myGGItem">GGItem object to be added to GG calendar</param>
/// <returns>Google event's ID</returns>
private string AddGGEvent(CalendarService GGService, CalendarEntry GGCalendar, GGItem myGGItem)
{
// Create a event object
EventEntry entry = new EventEntry();
// Use description as event title (necessary)
entry.Title.Text = myGGItem.GetDescription();
// Use tag as event content (optional)
entry.Content.Content = myGGItem.GetTag() + " | " + myGGItem.GetPath();
// Set event start and end time
if (myGGItem.GetEndDate().CompareTo(GGItem.DEFAULT_ENDDATE) != 0)
{ // Specified endDate
// Use endDate - 2hours as start time and endDate as end time
When eventTime = new When(myGGItem.GetEndDate().AddHours(-2), myGGItem.GetEndDate());
entry.Times.Add(eventTime);
}
else
{ // Default endDate
// Treat as tasks, set due date as 3 days later
When eventTime = new When(DateTime.Today, DateTime.Today.AddDays(3));
entry.Times.Add(eventTime);
}
// Log(entry.Updated.ToLongDateString());
// Set email reminder: 15 minutes before end time
Reminder GGReminder = new Reminder();
GGReminder.Minutes = 15;
GGReminder.Method = Reminder.ReminderMethod.email;
entry.Reminders.Add(GGReminder);
// Create the event on Google Calendar
Uri postUri = new Uri("https://www.google.com/calendar/feeds/" + GGCalendar.Id.AbsoluteUri.Substring(63) + "/private/full");
AtomEntry insertedEntry = GGService.Insert(postUri, entry);
// Return the event's ID
return insertedEntry.Id.AbsoluteUri;
}
private void CreateReminder(CalendarService calendarService, String reminderText, DateTime reminderTime)
{
EventEntry newEvent = new EventEntry();
newEvent.Title.Text = reminderText;
newEvent.Content.Content = reminderText + " (Reminder added by RemGen from " + Environment.MachineName + " by " + Environment.UserName + " " + Environment.UserDomainName + ")";
//Where eventLocation = new Where();
//eventLocation.ValueString = "Test event location 2";
//newEvent.Locations.Add(eventLocation);
When eventTime = new When(reminderTime, reminderTime);
newEvent.Times.Add(eventTime);
Reminder reminder = new Reminder();
reminder.Method = Reminder.ReminderMethod.sms;
reminder.AbsoluteTime = reminderTime;
newEvent.Reminders.Add(reminder);
Uri postUri = new Uri(calendarApiUri);
try
{
AtomEntry insertedEntry = calendarService.Insert(postUri, newEvent);
MessageBox.Show("Reminder added successfully");
}
catch (Exception ex)
{
MessageBox.Show("Failed to create event" + Environment.NewLine + Environment.NewLine + ex.ToString(), "RemGen");
}
}
/// <summary>
/// Sets the contents of an entry from a row of the table.
/// </summary>
/// <param name='entry'>
/// The EventEntry to modify
/// </param>
/// <param name='row'>
/// The row number in which the data sits.
/// </param>
protected void CnvtRowToEntry(EventEntry entry, int row)
{
DateTime start;
DateTime end;
const int DateStartColumnIndex = 0;
const int TimeStartColumnIndex = 1;
const int TitleColumnIndex = 2;
const int TimeEndColumnIndex = 3;
const int PlaceColumnIndex = 4;
string timeSeparator = CultureInfo.CurrentCulture.DateTimeFormat.TimeSeparator;
string dateStart = "";
string timeStart = "";
string timeEnd = "";
// Prepare time information
entry.Times.Clear();
entry.Locations.Clear();
try {
dateStart = ( (string) this.grdEventsList.Rows[ row ].Cells[ DateStartColumnIndex ].Value ).Trim();
} catch(Exception)
{
throw new FormatException( StringsL18n.Get( StringsL18n.StringId.ErStartDateMissing ) );
}
try {
timeStart = ( (string) this.grdEventsList.Rows[ row ].Cells[ TimeStartColumnIndex ].Value ).Trim();
} catch(Exception)
{
throw new FormatException( StringsL18n.Get( StringsL18n.StringId.ErStartDateMissing ) );
}
try {
timeEnd = ( (string) this.grdEventsList.Rows[ row ].Cells[ TimeEndColumnIndex ].Value ).Trim();
} catch(Exception)
{
timeEnd = timeStart;
}
// Prepare times
timeEnd = timeEnd.Trim();
timeStart = timeStart.Trim();
if ( timeStart.ToLower().EndsWith( GCalFramework.EtqHourMark ) ) {
timeStart = timeStart.Substring( 0, timeStart.Length -1 ) + timeSeparator + "00";
}
if ( timeEnd.ToLower().EndsWith( GCalFramework.EtqHourMark ) ) {
timeEnd = timeEnd.Substring( 0, timeEnd.Length -1 ) + timeSeparator + "00";
}
// Set start/end date/time
timeEnd = dateStart + ' ' + timeEnd;
dateStart = dateStart + ' ' + timeStart;
try {
start = DateTime.Parse( dateStart, CultureInfo.CurrentCulture.DateTimeFormat );
} catch(FormatException exc) {
throw new FormatException( StringsL18n.Get( StringsL18n.StringId.ErParsingStartTime )
+ ": " + exc.Message );
}
try {
end = DateTime.Parse( timeEnd, CultureInfo.CurrentCulture.DateTimeFormat );
} catch(FormatException)
{
// Adapt the end time by one hour from the start
end = start.AddHours( 1 );
}
// Set times
if ( start == end ) {
end = start.AddHours( 1 );
}
var eventTime = new When( start, end );
entry.Times.Add( eventTime );
// Set title
try {
entry.Title.Text = ( (string) this.grdEventsList.Rows[ row ].Cells[ TitleColumnIndex ].Value ).Trim();
} catch(Exception)
{
entry.Title.Text = GCalFramework.EtqNotAvailable;
}
if ( entry.Title.Text.Trim().Length == 0 ) {
entry.Title.Text = GCalFramework.EtqNotAvailable;
}
// Set place
string strPlace = null;
try {
strPlace = ( (string) this.grdEventsList.Rows[ row ].Cells[ PlaceColumnIndex ].Value ).Trim();
} catch(Exception)
{
strPlace = GCalFramework.EtqNotAvailable;
}
if ( strPlace.Trim().Length == 0 ) {
entry.Title.Text = GCalFramework.EtqNotAvailable;
}
var eventLocation = new Where();
eventLocation.ValueString = strPlace;
entry.Locations.Add( eventLocation );
// Set alarm
Reminder reminder = new Reminder();
reminder.Minutes = 30;
reminder.Method = Reminder.ReminderMethod.all;
entry.Reminder = reminder;
return;
}
