public static AtomEntryCollection GetAllEvents(CalendarService service, DateTime?startData, DateTime?endDate)
{
EventQuery query = new EventQuery(QueryUri);
//query.Uri = new Uri("http://www.google.com/calendar/feeds/" + service.Credentials.Username + "/public/full");
if (startData != null)
{
query.StartTime = startData.Value;
query.RecurrenceStart = startData.Value;
}
if (endDate != null)
{
query.EndDate = endDate.Value;
query.RecurrenceEnd = endDate.Value;
}
query.SortOrder = CalendarSortOrder.ascending;
//query.SingleEvents = true;
query.FutureEvents = true;
query.NumberToRetrieve = 5;
//query.NumberToRetrieve = 5;
// Tell the service to query:
EventFeed calFeed = service.Query(query);
return(((AtomFeed)(calFeed)).Entries);
}
public Boolean updateResults(int entryNumber, String resultsURL)
{
try
{
EventEntry entry = (EventEntry)m_entries[entryNumber];
String contents = entry.Content.Content;
entry.Content.Content = "<a href=\"" + resultsURL + "\">Results</a>\n" + removeOldResultsText_(contents);
entry.Update();
EventQuery query = new EventQuery("https://www.google.com/calendar/feeds/dl2ahhopqnt5j8p0082h1pst3s%40group.calendar.google.com/private/full");
query.StartTime = entry.Times[0].StartTime;
query.EndTime = entry.Times[0].EndTime;
query.Query = entry.Title.Text;
query.NumberToRetrieve = 1;
EventFeed calFeed = m_service.Query(query);
if (calFeed.Entries.Count >= 1)
{
entry = (EventEntry)calFeed.Entries[0];
contents = entry.Content.Content;
entry.Content.Content = "<a href=\"" + resultsURL + "\">Results</a>\n" + removeOldResultsText_(contents);
entry.Update();
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.ToString());
return(false);
}
return(true);
}
/// <summary>
/// Gets a list of all the calender events in the given calendar
/// </summary>
public List <CalendarEvent> GetAllEvents()
{
List <CalendarEvent> events = new List <CalendarEvent>();
EventQuery query = new EventQuery(string.Format(calendarUrl, this.calendarId));
EventFeed myResultsFeed = this.calService.Query(query);
foreach (EventEntry entry in myResultsFeed.Entries)
{
string id = "";
foreach (object obj in entry.ExtensionElements)
{
if (obj is ExtendedProperty)
{
ExtendedProperty exProp = obj as ExtendedProperty;
if (exProp.Name == syncExtendedParameterName)
{
id = exProp.Value;
break;
}
}
}
events.Add(new CalendarEvent(id,
entry.Times[0].StartTime,
entry.Times[0].EndTime,
entry.Locations[0].ValueString,
entry.Title.Text,
entry.Content.Content
));
}
return(events);
}
/// <summary>
/// Update a calendar event
/// </summary>
public void UpdateEvent(CalendarEvent cEvent)
{
EventQuery query = new EventQuery(string.Format(calendarUrl, this.calendarId));
query.ExtraParameters = string.Format("extq=[{1}:{0}]", cEvent.Id, syncExtendedParameterName);
EventFeed myResultsFeed = this.calService.Query(query);
if (myResultsFeed.Entries.Count == 1)
{
EventEntry firstMatchEntry = (EventEntry)myResultsFeed.Entries[0];
firstMatchEntry.Content.Content = cEvent.Body;
firstMatchEntry.Title.Text = cEvent.Subject;
Where eventLocation = new Where();
eventLocation.ValueString = cEvent.Location;
firstMatchEntry.Locations.Clear();
firstMatchEntry.Locations.Add(eventLocation);
When eventTime = new When(cEvent.StartDate, cEvent.EndDate);
firstMatchEntry.Times.Clear();
firstMatchEntry.Times.Add(eventTime);
this.calService.Update(firstMatchEntry);
}
else if (myResultsFeed.Entries.Count > 1)
{
throw new Exception("UpdateEvent: Found more then one event with the given id.");
}
}
public SortableBindingList <IndianCalendarEvent> getEvents(DateTime startDate, DateTime endDate, String searchString)
{
SortableBindingList <IndianCalendarEvent> events = new SortableBindingList <IndianCalendarEvent>();
Trace.WriteLine("Getting Events");
EventQuery query = new EventQuery("http://www.google.com/calendar/feeds/[email protected]/private/full");
query.SingleEvents = true;
query.Query = searchString;
query.StartTime = startDate;
query.EndTime = endDate;
// Tell the service to query:
EventFeed calFeed = m_service.Query(query) as EventFeed;
m_entries = calFeed.Entries;
for (int i = 0; i < calFeed.Entries.Count; ++i)
{
EventEntry entry = (EventEntry)calFeed.Entries[i];
Trace.WriteLine(entry.Title.Text + " at position " + i);
IndianCalendarEvent ice = new IndianCalendarEvent(entry.Times[0].StartTime, entry.Title.Text, entry.Locations[0].ValueString, i);
events.Add(ice);
}
Trace.WriteLine("Found " + calFeed.Entries.Count + " items");
return(events);
}
public async Task ReadModelFeed()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("http://localost:5000/api/DomainEvents/?lastVersion=0")
.Respond("application/json", "[{ \"domainEventType\": \"UNKNOWN_TYPE\",\"entityStreamVersion\": 12, \"overallVersion\": \"1\", \"domainEvent\": {\"EntityId\" : \"5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180\"}}, { \"domainEventType\": \"TestEv\",\"entityStreamVersion\": 12, \"overallVersion\": \"2\", \"domainEvent\": {\"EntityId\" : \"5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180\" }}]");
var domainOverallEventClient = new HttpClient(mockHttp);
domainOverallEventClient.BaseAddress = new Uri("http://localost:5000/api/DomainEvents/");
var factoryMock = new Mock <IDomainEventClientFactory>();
factoryMock.Setup(m => m.GetClient <ReadModelEventHandler <TestReadModel> >()).ReturnsAsync(domainOverallEventClient);
var domainEventFactory = new DomainEventFactory(_eventTypeRegistration);
var readModelFeed = new EventFeed <ReadModelEventHandler <TestReadModel> >(
domainEventFactory,
factoryMock.Object, new MicrowaveLogger <EventFeed <ReadModelEventHandler <TestReadModel> > >());
var domainEvents = await readModelFeed.GetEventsAsync();
var domainEventWrappers = domainEvents.ToList();
Assert.AreEqual(1, domainEventWrappers.Count);
Assert.AreEqual(new Guid("5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180").ToString(), domainEventWrappers[0].DomainEvent
.EntityId);
}
public override void ReadAppointments()
{
EventQuery myQuery = new EventQuery(uri);
myQuery.StartTime = startDate;
myQuery.EndTime = endDate;
if (String.IsNullOrEmpty(subject))
{
myQuery.Query = subject;
}
try
{
appointmentArray.Clear();
EventFeed myResultsFeed = service.Query(myQuery) as EventFeed;
for (int i = 0; i < myResultsFeed.Entries.Count; i++)
{
EventEntry eE = myResultsFeed.Entries[i] as EventEntry;
appointmentArray.Add(eE);
}
}
catch (Exception)
{
throw;
}
}
protected void ButtonQueryGCalFB_Click(object sender, EventArgs e)
{
verifyAllowed();
try
{
EventFeed feed =
GCalTester.QueryGCalFreeBusy(TextBoxQueryGCalEmail.Text);
LabelGCalFBSummary.Text = "Verified";
SyncServiceFreeBusy.CssClass = "verified";
StringBuilder sb = new StringBuilder();
sb.AppendFormat("Busy Times for {0}:", TextBoxQueryGCalEmail.Text);
sb.Append("<ul>");
foreach (Google.GData.Calendar.EventEntry entry in feed.Entries)
{
sb.AppendFormat("<li>{0} to {1}</li>", entry.Times[0].StartTime, entry.Times[0].EndTime);
}
sb.Append("</ul>");
LabelGCalFBDetail.Text = sb.ToString();
}
catch (Exception ex)
{
LabelGCalFBSummary.Text = ex.Message;
SyncServiceFreeBusy.CssClass = "failed";
LabelGCalFBDetail.Text = string.Format("<blockquote>{0}</blockquote>", ex.ToString());
}
}
public Calendar[] GetEvents()
{
try
{
if (google_authentication())
{
EventQuery qry = new EventQuery(g_CalUrl);
EventFeed fd = g_calService.Query(qry);
return((from EventEntry entry in fd.Entries
select new Calendar()
{
dt = entry.Times[0].StartTime,
tle = entry.Title.Text
}).ToArray());
}
else
{
return(new Calendar[0]);
}
}
catch (Exception)
{
return(new Calendar[0]);
}
}
public List <JaevnerEntry> ListEntries()
{
CalendarService calendarService = GetCalendarService();
var eventQuery = new EventQuery(_settings.CalendarUrl);
EventFeed eventFeed = calendarService.Query(eventQuery);
var jaevnerEntries = new List <JaevnerEntry>();
var entries = eventFeed.Entries;
if (entries.Count > 0)
{
foreach (object entry in entries)
{
var feedEntry = (EventEntry)entry;
JaevnerEntry jaevnerEntry = EntryConverter.GetJaevnerEntry(feedEntry);
jaevnerEntries.Add(jaevnerEntry);
}
}
return(jaevnerEntries);
}
//public static EventEntry GetElementByDaytimerID(string id, CalendarService service, DateTime? startDate = null)
//{
// EventQuery oEventQuery = new EventQuery(FeedUrl(service));
// oEventQuery.ExtraParameters = "extq=[" + DaytimerID + ":" + id + "]";
// oEventQuery.NumberToRetrieve = 1;// 000;
// if (startDate.HasValue)
// oEventQuery.StartDate = startDate.Value;
// EventFeed oEventFeed = service.Query(oEventQuery);
// AtomEntryCollection entries = oEventFeed.Entries;
// if (entries.Count > 0)
// return (EventEntry)entries[0];
// return null;
//}
public static EventEntry GetElementByDaytimerID(string id, CalendarService service, string feedUrl)
{
EventQuery oEventQuery = new EventQuery(feedUrl);
oEventQuery.ExtraParameters = "extq=[" + DaytimerID + ":" + id + "]";
oEventQuery.NumberToRetrieve = 1;
EventFeed oEventFeed = service.Query(oEventQuery);
AtomEntryCollection entries = oEventFeed.Entries;
if (entries.Count > 0)
{
EventEntry entry = (EventEntry)entries[0];
if (entry.OriginalEvent == null)
{
return(entry);
}
else
{
// Get the base element.
return(GetElementByGoogleID(entry.EventId, service, feedUrl));
}
}
return(null);
}
/// <summary>
/// Returns a set of appointments from a GoogleApps Feed
/// </summary>
/// <param name="user">The exchange user to get apointments for</param>
/// <param name="srcTimeZone">The time zone to use</param>
/// <param name="googleAppsFeed">Source feed to create array from</param>
/// <returns></returns>
private IntervalTree <Appointment> CreateAppointments(
ExchangeUser user,
OlsonTimeZone srcTimeZone,
EventFeed googleAppsFeed)
{
IntervalTree <Appointment> result = new IntervalTree <Appointment>();
foreach (EventEntry eventEntry in googleAppsFeed.Entries)
{
try
{
CreateAppointment(result, user, srcTimeZone, eventEntry);
}
catch (GCalExchangeException ex)
{
if (ex.ErrorCode == GCalExchangeErrorCode.OlsonTZError)
{
log.Error("Error creating appointment (TimeZone issue)", ex);
}
else
{
throw;
}
}
}
return(result);
}
public void TestOverlappingEndEvent()
{
DateTime start = DateUtil.ParseDateToUtc("2007-07-30T13:00:00.000Z");
DateTimeRange window = new DateTimeRange(start.AddDays(-7), start.AddDays(7));
// Test overlapping events
// - 13:30 - 14:00 in Exchange
// - 13:00 - 14:00 in GCal
// Should create an exchange event [13:00-14:00]
AddEventExchange(start, start.AddMinutes(30));
AddEventGCal(start, start.AddHours(1));
EventFeed feed = createEventFeedFromEvents(_gcalEvents);
FreeBusyCollection fb = createFreeBusyFromExistingEvents(_exchEvents);
ExchangeUser user = createFauxUser("*****@*****.**", "*****@*****.**");
user.BusyTimes = fb;
ExchangeGatewayMock gateway = new ExchangeGatewayMock();
this.SyncUser(user, feed, gateway, window);
Assert.AreEqual(0, gateway.AppointmentsMock.Deleted.Count);
Assert.AreEqual(1, gateway.AppointmentsMock.Written.Count);
Assert.AreEqual(0, gateway.AppointmentsMock.Updated.Count);
Assert.AreEqual(gateway.AppointmentsMock.Written[0].StartDate, start);
Assert.AreEqual(gateway.AppointmentsMock.Written[0].EndDate, start.AddHours(1));
}
public static void mergeChanges()
{
if (authenticated == true)
{
MySqlDataReader events = Database.executeQuery("SELECT GoogleEventID FROM EVENT WHERE GoogleEventID IS NOT NULL AND StartDateTime > DATETIME('now', 'localtime')");
while (events.Read() == true)
{
try {
EventQuery myQuery = new EventQuery(postUri.ToString() + "/" + events.GetString(0));
lock (threadLock) {
EventFeed resultFeed = (EventFeed)service.Query(myQuery);
//only update if an event is found
if (resultFeed.Entries.Count > 0)
{
EventEntry calendar = (EventEntry)resultFeed.Entries[0];
Database.modifyDatabase("UPDATE Event SET Title = " + Util.quote(calendar.Title.Text) + ", Description = "
+ Util.quote(calendar.Content.Content) + ", Location = " + Util.quote(calendar.Locations[0].ValueString)
+ ", StartDateTime = DATETIME('" + Database.getDateTime(calendar.Times[0].StartTime) + "'), EndDateTime = DATETIME('"
+ Database.getDateTime(calendar.Times[0].EndTime) + "') WHERE GoogleEventID = '" + events.GetString(0) + "';");
}
}
}
catch (Exception e) {
Util.logError("Google Calendar Error: " + e.Message);
}
}
events.Close();
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (listBox1.SelectedIndex == -1)
{
toolStripStatusLabel1.Text = "No valid calendar is selected";
}
else
{
richTextBox1.Clear();
string calendarTitle = listBox1.Items[listBox1.SelectedIndex].ToString();
string uri = getUriOfSelectedCalendar(calendarTitle);
// Create the query object:
EventQuery query = new EventQuery();
uri.Replace("http", "https");
query.Uri = new Uri(uri);
//query.Uri = new Uri("https://www.google.com/calendar/feeds/[email protected]/private/full");
// Tell the service to query:
EventFeed calFeed = myService.Query(query);
//add the feature for showing events here
foreach (EventEntry myEntry in calFeed.Entries)
{
richTextBox1.AppendText("Title: " + myEntry.Title.Text);
foreach (When a in myEntry.Times)
{
richTextBox1.AppendText(a.StartTime.ToString());
}
richTextBox1.AppendText("\n\n");
}
}
}
public CalendarEventObject[] GetEvents()
{
try
{
if (Authenticate())
{
EventQuery query = new EventQuery(m_CalendarUrl);
EventFeed feed = m_Service.Query(query);
return((from EventEntry entry in feed.Entries
select new CalendarEventObject()
{
Date = entry.Times[0].StartTime,
Title = entry.Title.Text
}).ToArray());
}
else
{
return(new CalendarEventObject[0]);
}
}
catch (Exception)
{
return(new CalendarEventObject[0]);
}
}
/// <summary>
/// Check if a given entry already exists in the calendar
/// </summary>
public CalendarEvent GetEventFromSyncId(string id)
{
EventQuery query = new EventQuery(string.Format(calendarUrl, this.calendarId));
//query.StartTime = cEvent.StartDate;
//query.EndTime = cEvent.EndDate;
//query.Query = cEvent.Id;
query.ExtraParameters = string.Format("extq=[{1}:{0}]", id, syncExtendedParameterName);
EventFeed myResultsFeed = this.calService.Query(query);
if (myResultsFeed.Entries.Count == 1)
{
EventEntry firstMatchEntry = (EventEntry)myResultsFeed.Entries[0];
CalendarEvent cEvent = new CalendarEvent(id,
firstMatchEntry.Times[0].StartTime,
firstMatchEntry.Times[0].EndTime,
firstMatchEntry.Locations[0].ValueString,
firstMatchEntry.Title.Text,
firstMatchEntry.Content.Content
);
return(cEvent);
}
else if (myResultsFeed.Entries.Count > 1)
{
throw new Exception("GetEventFromSyncId: Found more then one event with the given id.");
}
return(null);
}
public static EventEntry GetElementByGoogleID(string id, CalendarService service, string feedUrl, string etag = null)
{
try
{
EventQuery oEventQuery = new EventQuery(feedUrl);
oEventQuery.Uri = new Uri(feedUrl + "/" + id);
if (etag != null)
{
oEventQuery.Etag = etag;
}
EventFeed oEventFeed = service.Query(oEventQuery);
AtomEntryCollection entries = oEventFeed.Entries;
if (entries.Count > 0)
{
return((EventEntry)entries[0]);
}
}
catch (GDataRequestException exc)
{
if (exc.Response is HttpWebResponse &&
((HttpWebResponse)exc.Response).StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
else
{
throw;
}
}
return(null);
}
/// <summary>
/// Queries the calendar for events matching the specified criteria.
/// </summary>
/// <param name="fullTextQuery"></param>
/// <param name="from"></param>
/// <param name="until"></param>
/// <returns></returns>
public CalendarEvent[] GetEvents(string fullTextQuery, DateTime?from, DateTime?until)
{
EventQuery query = new EventQuery();
query.Uri = new Uri(CALENDAR_URI);
query.Query = fullTextQuery;
if (from != null)
{
query.StartTime = from.Value;
}
if (until != null)
{
query.EndTime = until.Value;
}
EventFeed calFeed = _service.Query(query);
List <CalendarEvent> events = CollectionUtils.Map <EventEntry, CalendarEvent, List <CalendarEvent> >(calFeed.Entries,
delegate(EventEntry e) { return(new CalendarEvent(e)); });
events.Sort();
return(events.ToArray());
}
/// <summary>
/// Gets the old tasklist from GCal.
/// </summary>
/// <param name="username">Given by user.</param>
/// <param name="password">Given by user.</param>
private void GoogleGetTasks(string username, string password)
{
Gcal = new CalendarService("remMe");
Gcal.setUserCredentials(username, password);
query = new EventQuery("https://www.google.com/calendar/feeds/default/private/full");
EventFeed feed = Gcal.Query(query);
}
public Form1()
{
InitializeComponent();
ExchangeServer = new EventFeed();
Security security = new Security("SBI");
ExchangeServer.AddSecurity(security);
}
public PdfGenerateServiceTest()
{
_logger = new Mock<ILogger>();
_service = new PdfGenerateService(_logger.Object);
using (StreamReader r = new StreamReader("TestPayload/EventFeed.json"))
{
_feed = JsonConvert.DeserializeObject<EventFeed>(r.ReadToEnd());
}
}
public bool IsUserAvailable(string user, DateTime datetime)
{
EventQuery query = new EventQuery(string.Format(feedUrl, user));
query.StartTime = datetime;
query.EndTime = datetime + new System.TimeSpan(0, 0, 30, 0);
EventFeed feed = calendar.Query(query);
return(feed.Entries.Count == 0);
}
/// <summary>
/// Deletes the old tasks from GCal (all tasks prefixed with RM!).
/// </summary>
private void GoogleDelete()
{
query.Query = Utility.RM_TAG;
EventFeed allTasks = Gcal.Query(query);
for (int i = 0; i < allTasks.Entries.Count; i++)
{
AtomEntry task = allTasks.Entries[i];
task.Delete();
}
}
/// <summary>
/// GoogleCalendarUtil/GetCalendarUri
/// </summary>
/// <param name="service">CalendarService</param>
/// <param name="gmail">Gmail address string</param>
/// <returns>Uri</returns>
private static Uri GetCalendarUri(CalendarService service, string gmail)
{
EventQuery query = new EventQuery();
Uri calendarUri = new Uri("https://www.google.com/calendar/feeds/" + gmail + "/private/full");
query.Uri = calendarUri;
EventFeed calFeed = service.Query(query);
return(calendarUri);
}
public IEnumerable <CalendarItem> GetItems()
{
var query = new EventQuery
{
Uri = new Uri(GOOGLE_CALENDAR_URI),
StartTime = DateTime.Now.AddMonths(_monthsPast),
EndTime = DateTime.Now.AddMonths(_monthsFuture)
};
EventFeed calFeed = Service.Query(query);
return(calFeed.Entries.Select(item => new GoogleCalendarItem((EventEntry)item)).OrderBy(calendarItem => calendarItem.Start));
}
internal static IEventFeed AsADirectFeedReader(string connectionStringName)
{
var feed = new EventFeed
{
EventPeristance = new SqlPersistance(connectionStringName),
Serializer = new SimpleXmlMessageSerializaion(),
SyndicationFormatter = new AtomFormatter()
};
feed.EnsureWorkingFeedExists();
return feed;
}
/// <summary>
/// Prints the titles of all events on the specified calendar.
/// </summary>
/// <param name="service">The authenticated CalendarService object.</param>
static void PrintAllEvents(CalendarService service)
{
EventQuery myQuery = new EventQuery(feedUri);
EventFeed myResultsFeed = service.Query(myQuery) as EventFeed;
Console.WriteLine("All events on your calendar:");
Console.WriteLine();
for (int i = 0; i < myResultsFeed.Entries.Count; i++)
{
Console.WriteLine(myResultsFeed.Entries[i].Title.Text);
}
Console.WriteLine();
}
public static void EditEvent(string oldTitle, string newTitle, string contents, string location, DateTime startTime, DateTime endTime, string calendarname)
{
GoogleCalendar ggadmin = new GoogleCalendar(calendarname, AdminuserName, AdminuserPwd);
string CalendarId = ggadmin.GetCalendarId();
EventQuery query = new EventQuery("https://www.google.com/calendar/feeds/" + CalendarId + "/private/full");
query.Query = oldTitle;
string[] oldtitle = oldTitle.Split('-');
//query.StartDate = startTime;
//query.EndDate = endTime;
EventFeed feed = GetService(AdminuserName, AdminuserName, AdminuserPwd).Query(query);
foreach (CalendarEntry entry in feed.Entries)
{
string[] item = entry.Title.Text.Split('-');
//if (oldTitle.Equals(entry.Title.Text))
//{
// entry.Delete(); break;
//}
if (oldTitle[0].ToString() == item[0].ToString())
{
entry.Delete();
break;
}
}
//if (feed.Entries.Count > 0)
//{
// AtomEntry firstMatchEntry = feed.Entries[0];
// String myEntryTitle = firstMatchEntry.Title.Text;
//}
// Create an batch entry to update an existing event.
//EventEntry toDelete = (EventEntry)feed.Entries[0];
//toDelete.Title.Text = oldTitle;// "updated First New";
//toUpdate.Content.Content = contents;
//Where eventLocation = new Where();
//eventLocation.ValueString = location;
//toUpdate.Locations.Clear();
//toUpdate.Locations.Add(eventLocation);
//When eventTime = new When(startTime, endTime);
//toUpdate.Locations.Clear();
//toUpdate.Times.Add(eventTime);
//toUpdate.Update();
// toDelete.Delete();
}
public async Task ProcessEventFeedCollection(EventFeed eventFeed, string invoiceDirectory, string templatePath)
{
if (eventFeed != null && eventFeed.Items != null)
{
_logger.LogInformation("Processing invoice items count: {0}", eventFeed.Items.Count);
List <Task> tasks = new List <Task>();
foreach (var item in eventFeed.Items)
{
tasks.Add(ProcessInvoiceItem(item, invoiceDirectory, templatePath));
}
await Task.WhenAll(tasks.ToArray());
}
}
public void TestConvertEventsToFreeBusy()
{
ExchangeUser user = new ExchangeUser();
EventEntry googleAppsEvent = new EventEntry("title", "description", "location");
DateTimeRange coveredRange = new DateTimeRange(DateTime.MaxValue, DateTime.MinValue);
List <DateTimeRange> busyTimes = new List <DateTimeRange>();
List <DateTimeRange> tentativeTimes = new List <DateTimeRange>();
DateTime startDate = new DateTime(2007, 07, 1, 10, 0, 0, DateTimeKind.Utc);
DateTime endDate = new DateTime(2007, 07, 1, 11, 0, 0, DateTimeKind.Utc);
When when = new When(startDate, endDate);
Uri uri = new Uri("https://www.google.com/calendar/feeds/[email protected]/private/full");
EventFeed googleAppsFeed = new EventFeed(uri, null);
AtomEntryCollection entries = new AtomEntryCollection(googleAppsFeed);
}
public void SetUp()
{
serializer = new Mock<IMessageSerializer>();
persistance = new Mock<IEventPersistance>();
syndication = new Mock<ISyndicationFormatter>();
environment = new Mock<IEnvironment>();
SimpleAtomPubSub.Environment.Environment.Current = environment.Object;
target = new EventFeed()
{
EventPeristance = persistance.Object,
Serializer = serializer.Object,
SyndicationFormatter = syndication.Object
};
}
