public void GetAtomEntriesNotNullTest() { MakeTestCollections(false); IAtomEntryRepository repository = GetEntryRepository(); int totalEntries; EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, Authorized = true }; IEnumerable<AtomSite.Domain.AtomEntry> results = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(results); }
public virtual AtomFeed GetFeedBySearch(Id collectionId, string term, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeedBySearch collectionId={0} term={1} pageIndex={2}", collectionId, term, pageIndex); Auth(collectionId, AuthAction.GetFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, SearchTerm = term, Authorized = AuthorizeService.IsAuthorized(GetUser(), collectionId.ToScope(), AuthAction.GetEntryOrMedia) }; int total; //search annotations? AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total), total);//, pageIndex, pageSize, RouteFunc, "AtomPubFeed", "AtomPubCollectionIndex", false); feed.Subtitle = new AtomSubtitle { Text = "Search for '" + term + "'" }; SetLinks(feed); return feed; }
public AtomFeed GetFeedBySearch(string workspace, string term, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeedBySearch workspace={0} term={1} pageIndex={2}", workspace, term, pageIndex); AuthorizeService.Auth(new Scope() { Workspace = workspace }, AuthAction.GetFeed); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = workspace, SearchTerm = term, Authorized = AuthorizeService.IsAuthorized(GetUser(), new Scope() { Workspace = workspace }, AuthAction.GetEntryOrMedia) }; int total; //search annotations? AtomFeed feed = new AtomFeed(); feed.Generator = new AtomGenerator { Text = "atomsite.net" }; AppWorkspace w = AppServiceRepository.GetService().GetWorkspace(workspace); feed.Title = w.Title; feed.Updated = DateTimeOffset.UtcNow; feed.Entries = AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total); feed.TotalResults = total; //use newest updated date as feed updated date if (feed.Entries.Count() > 0) feed.Updated = feed.Entries.Max().Updated; feed.Subtitle = new AtomSubtitle { Text = "Search for '" + term + "'" }; SetLinks(feed); return feed; }
public virtual AtomFeed GetFeedByCategory(Id collectionId, string term, Uri scheme, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeedByCategory collectionId={0}, term={1}", collectionId, term); Auth(collectionId, AuthAction.GetFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); //TODO: support external categories AtomCategory category = c.Categories.SelectMany(cats => cats.Categories).Where(cat => cat.Term == term && cat.Scheme == scheme).SingleOrDefault(); if (category == null) throw new ResourceNotFoundException("category", term); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, CategoryTerm = term, CategoryScheme = scheme, Authorized = AuthorizeService.IsAuthorized(GetUser(), collectionId.ToScope(), AuthAction.GetEntryOrMedia) }; int total; AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total), total);//, pageIndex, pageSize, RouteFunc, "AtomPubFeed", "AtomPubCollectionIndex", false); feed.Subtitle = new AtomSubtitle { Text = "Browsing " + category.ToString() }; SetLinks(feed); return feed; }
public virtual AtomFeed GetFeedByPerson(Id collectionId, string personName, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeedByPerson collectionId={0}, personName={1}", collectionId, personName); Auth(collectionId, AuthAction.GetFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, PersonName = personName, PersonType = "person", Authorized = AuthorizeService.IsAuthorized(GetUser(), collectionId.ToScope(), AuthAction.GetEntryOrMedia) }; int total; AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total), total);//, pageIndex, pageSize, RouteFunc, "AtomPubFeed", "AtomPubCollectionIndex", false); feed.Subtitle = new AtomSubtitle() { Text = personName }; SetLinks(feed); return feed; }
public virtual AtomFeed GetFeedByDate(Id collectionId, DateTime startDate, DateTime endDate, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeedByDate collectionId={0}, startDate={1}, endDate={2}", collectionId, startDate, endDate); Auth(collectionId, AuthAction.GetFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, StartDate = startDate, EndDate = endDate, Authorized = AuthorizeService.IsAuthorized(GetUser(), collectionId.ToScope(), AuthAction.GetEntryOrMedia) }; int total; AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total), total);//, pageIndex, pageSize, RouteFunc, "AtomPubFeed", "AtomPubCollectionIndex", false); if (startDate.DayOfYear == 1 && endDate.DayOfYear > 354) { feed.Subtitle = new AtomSubtitle() { Text = "For the year " + startDate.Year.ToString("0000") }; } else if (startDate.Day == 1 && endDate.Day == DateTime.DaysInMonth(endDate.Year, endDate.Month)) { feed.Subtitle = new AtomSubtitle() { Text = "For " + startDate.ToString("MMMM yyyy") }; } else if (startDate.Day == endDate.Day) { feed.Subtitle = new AtomSubtitle() { Text = "For " + startDate.ToString("D") }; } else { feed.Subtitle = new AtomSubtitle() { Text = "From " + startDate.ToShortDateString() + " to " + endDate.ToShortDateString() }; } SetLinks(feed); return feed; }
public void GetEntriesAprovedAuthorizedTest() { MakeTestCollections(true); DateTime now = DateTime.Now; DateTime oneDayAgo = now.AddDays(-1); // make an entry for today AtomEntry entry1 = TestDataHelper.MakeTestEntry(now, TestCollection1Name); // and an entry for yesterday AtomEntry entry2 = TestDataHelper.MakeTestEntry(oneDayAgo, TestCollection1Name); entry2.Control.Approved = false; IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry1); repository.CreateEntry(entry2); //now retrieve entries with authorized EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, Authorized = true }; int totalEntries; IEnumerable<AtomEntry> entries = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entries); Assert.AreEqual(2, entries.Count()); // now get them without auth criteria.Authorized = false; IEnumerable<AtomEntry> entriesNotAuth = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesNotAuth); Assert.AreEqual(1, entriesNotAuth.Count()); DataTester.AssertEntriesEqual(entry1, entriesNotAuth.First()); }
public AtomFeed GetAnnotations(string workspace, bool deep, int pageIndex, int pageSize) { LogService.Info("AnnotateService.GetAnnotations workspace={0} deep={1}", workspace, deep); EntryCriteria criteria = new EntryCriteria() { Annotations = true, WorkspaceName = workspace, SortMethod = SortMethod.Default, Authorized = AuthorizeService.IsAuthorized(GetUser(), new Scope() { Workspace = workspace }, AuthAction.GetEntryOrMedia), Deep = deep }; return GetAnnotations(criteria, pageIndex, pageSize); }
public void AddEntryWorkspaceAndCollectionMismatchTest() { MakeTestCollections(false); IAtomEntryRepository repository = GetEntryRepository(); // count the entries before adding one int totalEntries; // create an entry AtomSite.Domain.AtomEntry entry = TestDataHelper.MakeTestEntry(TestCollection1Name); // save the entry repository.CreateEntry(entry); // should be retrieved EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, Authorized = true }; IEnumerable<AtomSite.Domain.AtomEntry> entriesFound = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsTrue(entriesFound.ContainsId(entry.Id), "entry not retrieved"); // should not be retrieved criteria = new EntryCriteria { WorkspaceName = Guid.NewGuid().ToString(), CollectionName = TestCollection1Name, Authorized = true }; // sql repository returns empty list, file provider throws an exception IEnumerable<AtomSite.Domain.AtomEntry> entriesNotFound; try { entriesNotFound = repository.GetEntries(criteria, 0, PageSize, out totalEntries); } catch (Exception) { entriesNotFound = new List<AtomSite.Domain.AtomEntry>(); } Assert.IsFalse(entriesNotFound.ContainsId(entry.Id), "Entry retrieved with wrong workspace"); // should not be retrieved criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = Guid.NewGuid().ToString(), Authorized = true }; try { entriesNotFound = repository.GetEntries(criteria, 0, PageSize, out totalEntries); } catch (Exception) { entriesNotFound = new List<AtomSite.Domain.AtomEntry>(); } Assert.IsFalse(entriesNotFound.ContainsId(entry.Id), "Entry retrieved with wrong collection"); }
public void EntrySearchCriteriaTest() { MakeTestCollections(false); // make an entry AtomEntry entry = TestDataHelper.MakeTestEntry(DateTime.Now, TestCollection1Name); string correctGuid = Guid.NewGuid().ToString(); string otherGuid = Guid.NewGuid().ToString(); // save the entry entry.Content = new AtomContent { Type = "text", Text = "some entry text " + correctGuid + "" }; IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry); // get entries EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, Authorized = true, SearchTerm = correctGuid }; int totalEntries; IEnumerable<AtomEntry> searchEnties = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.AreEqual(1, searchEnties.Count()); Assert.IsTrue(searchEnties.ContainsId(entry.Id)); // try the wrong guid criteria.SearchTerm = otherGuid; searchEnties = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.AreEqual(0, searchEnties.Count()); }
public void GetEntriesByCategoryTest() { MakeTestCollections(true); DateTime now = DateTime.Now; DateTime oneDayAgo = now.AddDays(-1); DateTime twoDaysAgo = now.AddDays(-2); // make two categories AtomCategory category1 = GetCategory(true); AtomCategory category2 = GetCategory(false); // make an entry for today AtomEntry entry1 = TestDataHelper.MakeTestEntry(now, TestCollection1Name); // in category 1 entry1.Categories = entry1.Categories.Add(category1); // and an entry for yesterday AtomEntry entry2 = TestDataHelper.MakeTestEntry(oneDayAgo, TestCollection1Name); // in category 2 entry2.Categories = entry2.Categories.Add(category2); // and the day before yesteday AtomEntry entry3 = TestDataHelper.MakeTestEntry(twoDaysAgo, TestCollection1Name); // in both categories entry3.Categories = entry3.Categories.Add(category1, category2); IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry1); repository.CreateEntry(entry2); repository.CreateEntry(entry3); //now retrieve entries by category 1 EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, CategoryScheme = category1.Scheme, CategoryTerm = category1.Term, Authorized = true, }; int totalEntries; IEnumerable<AtomEntry> entriesPerson1 = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesPerson1); Assert.AreEqual(2, entriesPerson1.Count()); // should contain entries 1 and 3 Assert.IsTrue(entriesPerson1.ContainsId(entry1.Id), "Entry 1 not found"); Assert.IsTrue(entriesPerson1.ContainsId(entry3.Id), "Entry 3 not found"); // now get them with category 2 criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, CategoryScheme = category2.Scheme, CategoryTerm = category2.Term, Authorized = true, }; IEnumerable<AtomEntry> entriesPerson2 = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesPerson2); Assert.AreEqual(2, entriesPerson2.Count()); // should contain entries 2 and 3 Assert.IsTrue(entriesPerson2.ContainsId(entry2.Id), "Entry 2 not found"); Assert.IsTrue(entriesPerson2.ContainsId(entry3.Id), "Entry 3 not found"); }
public void GetEntriesByPersonTest() { MakeTestCollections(false); DateTime now = DateTime.Now; DateTime oneDayAgo = now.AddDays(-1); DateTime twoDaysAgo = now.AddDays(-2); // make two people AtomPerson person1 = TestDataHelper.MakeTestPerson(); AtomPerson person2 = TestDataHelper.MakeTestPerson(); // make an entry for today AtomEntry entry1 = TestDataHelper.MakeTestEntry(now, TestCollection1Name); // person 1 is the author entry1.Authors = entry1.Authors.Add(person1); // and an entry for yesterday AtomEntry entry2 = TestDataHelper.MakeTestEntry(oneDayAgo, TestCollection1Name); // person 2 is the author entry2.Authors = entry2.Authors.Add(person2); // and the day before yesteday AtomEntry entry3 = TestDataHelper.MakeTestEntry(twoDaysAgo, TestCollection1Name); // join authors - both people entry3.Authors = entry1.Authors.Add(person1, person2); IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry1); repository.CreateEntry(entry2); repository.CreateEntry(entry3); //now retrieve entries by person 1 EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, PersonName = person1.Name, PersonType = person1.Type, Authorized = true, }; int totalEntries; IEnumerable<AtomEntry> entriesPerson1 = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesPerson1); Assert.AreEqual(2, entriesPerson1.Count()); // should contain entries 1 and 3 Assert.IsTrue(entriesPerson1.ContainsId(entry1.Id), "Entry 1 not found"); Assert.IsTrue(entriesPerson1.ContainsId(entry3.Id), "Entry 3 not found"); // now get them with person 2 criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, PersonName = person2.Name, PersonType = person2.Type, Authorized = true }; IEnumerable<AtomEntry> entriesPerson2 = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesPerson2); Assert.AreEqual(2, entriesPerson2.Count()); // should contain entries 2 and 3 Assert.IsTrue(entriesPerson2.ContainsId(entry2.Id), "Entry 2 not found"); Assert.IsTrue(entriesPerson2.ContainsId(entry3.Id), "Entry 3 not found"); }
public void GetEntriesByDateTest() { MakeTestCollections(true); DateTime now = DateTime.Now; DateTime oneMonthAgo = now.AddMonths(-1); DateTime twoMonthAgo = oneMonthAgo.AddMonths(-1); AtomEntry entry1 = TestDataHelper.MakeTestEntry(now, TestCollection1Name); AtomEntry entry2 = TestDataHelper.MakeTestEntry(oneMonthAgo, TestCollection1Name); AtomEntry entry3 = TestDataHelper.MakeTestEntry(twoMonthAgo, TestCollection1Name); IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry1); repository.CreateEntry(entry2); repository.CreateEntry(entry3); //now retrieve recent entries EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, StartDate = now.AddDays(-1), EndDate = now.AddDays(1), Authorized = true }; int totalEntries; IEnumerable<AtomEntry> entriesAfter = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.AreEqual(1, entriesAfter.Count(), "recent entries"); DataTester.AssertEntriesEqual(entry1, entriesAfter.First()); // a month back - two entries criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, StartDate = oneMonthAgo.AddDays(-1), EndDate = now.AddDays(1), Authorized = true }; IEnumerable<AtomEntry> oneMonthEntries = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.AreEqual(2, oneMonthEntries.Count(), "one month of entries"); DataTester.AssertEntriesEqual(entry1, oneMonthEntries.First()); DataTester.AssertEntriesEqual(entry2, oneMonthEntries.Skip(1).First()); criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, StartDate = twoMonthAgo.AddDays(-1), EndDate = now.AddDays(1), Authorized = true }; // two months back - three entries IEnumerable<AtomEntry> twoMonthEntries = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.AreEqual(3, twoMonthEntries.Count(), "two month of entries"); DataTester.AssertEntriesEqual(entry1, twoMonthEntries.First()); DataTester.AssertEntriesEqual(entry2, twoMonthEntries.Skip(1).First()); DataTester.AssertEntriesEqual(entry3, twoMonthEntries.Skip(2).First()); }
public virtual AtomFeed GetCollectionFeed(Id collectionId, int pageIndex) { LogService.Info("AtomPubService.GetCollectionFeed collectionId={0} pageIndex={1}", collectionId, pageIndex); Auth(collectionId, AuthAction.GetCollectionFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, Authorized = true, SortMethod = SortMethod.EditDesc //according to spec, collection feeds should be ordered by edited }; int total; AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, c.PageSize, out total), total);//, pageIndex, c.PageSize, RouteFunc, "AtomPubCollection", "AtomPubCollectionIndex", true); SetLinks(feed); var url = new UrlHelper(Container.GetInstance<RequestContext>()); feed.Links = feed.Links.Concat(url.GetPagingLinks("AtomPubCollection", feed.Id, null, feed.TotalResults ?? 0, pageIndex, c.PageSize, Atom.ContentTypeFeed, AbsoluteMode.Force)); return feed; }
/// <summary> /// Gets a consolidated feed of all collections in a workspace. /// </summary> /// <param name="workspaceName"></param> /// <param name="pageIndex"></param> /// <param name="pageSize"></param> /// <returns></returns> public virtual AtomFeed GetFeed(string workspaceName, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetFeed: workspace={0}", workspaceName); AuthorizeService.Auth(new Scope() { Workspace = workspaceName }, AuthAction.GetFeed); AppService svc = AppServiceRepository.GetService(); AtomFeed feed = new AtomFeed(); feed.Generator = new AtomGenerator { Text = "atomsite.net" }; feed.Id = new Uri("urn:" + Guid.NewGuid().ToString()); feed.Title = new AtomText() { Text = svc.Base.Authority }; int grandTotal = 0; if (!string.IsNullOrEmpty(workspaceName) || svc.Workspaces.Count() == 1) { //fill info from workspace feed.Title = svc.Workspaces.First().Title; feed.Subtitle = svc.Workspaces.First().Subtitle; //TODO: other props } //build feed for entire service or a single workspace var collections = svc.Workspaces.Where(w => w.Name == workspaceName || workspaceName == null) .SelectMany(w => w.Collections) .Where(c => c.SyndicationOn && c.Visible); List<AtomEntry> entries = new List<AtomEntry>(); foreach (AppCollection coll in collections) { if (AuthorizeService.IsAuthorized(GetUser(), coll.Id.ToScope(), AuthAction.GetFeed)) { int total; EntryCriteria criteria = new EntryCriteria() { WorkspaceName = coll.Id.Workspace, CollectionName = coll.Id.Collection, Authorized = AuthorizeService.IsAuthorized(GetUser(), coll.Id.ToScope(), AuthAction.GetEntryOrMedia), }; entries.AddRange(AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total)); grandTotal += total; } } feed.TotalResults = grandTotal; entries.OrderByDescending(e => e.Date); entries.Take(pageSize); feed.Entries = entries; SetLinks(feed); return feed; }
/// <summary> /// Get entries by the given criteria. /// </summary> /// <remarks>This method will likely deprecate many of the specific feed based functions.</remarks> /// <param name="criteria"></param> /// <param name="pageIndex"></param> /// <param name="pageSize"></param> /// <returns></returns> public IPagedList<AtomEntry> GetEntries(EntryCriteria criteria, int pageIndex, int pageSize) { LogService.Info("AtomPubService.GetEntries"); AuthorizeService.Auth(new Scope() { Workspace = criteria.WorkspaceName, Collection = criteria.CollectionName }, AuthAction.GetFeed); criteria.Authorized = true;//TODO: AuthorizeService.IsAuthorized(GetUser(), coll.Id, AuthAction.GetEntryOrMedia); int total; var entries = AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total); foreach (AtomEntry entry in entries) SetLinks(entry); PagedList<AtomEntry> pagedList = new PagedList<AtomEntry>(entries, pageIndex, pageSize, total); return pagedList; }
public virtual AtomFeed GetFeed(Id collectionId, int pageIndex, int pageSize) { //<atom:link rel="alternate" type="text/html" href="https://atomsite.net/blog.xhtml" /> LogService.Info("AtomPubService.GetFeed collectionId={0}", collectionId); Auth(collectionId, AuthAction.GetFeed); AppCollection c = AppServiceRepository.GetService().GetCollection(collectionId); EntryCriteria criteria = new EntryCriteria() { WorkspaceName = collectionId.Workspace, CollectionName = collectionId.Collection, Authorized = AuthorizeService.IsAuthorized(GetUser(), collectionId.ToScope(), AuthAction.GetEntryOrMedia), }; int total; AtomFeed feed = AtomFeed.BuildFeed(c, AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total), total);//, pageIndex, pageSize, RouteFunc, "AtomPubFeed", "AtomPubCollectionIndex", true); var url = new UrlHelper(Container.GetInstance<RequestContext>()); feed.Links = feed.Links.Concat(url.GetPagingLinks("AtomPubFeed", feed.Id, null, feed.TotalResults ?? 0, pageIndex, pageSize,Atom.ContentTypeFeed, AbsoluteMode.Force)); SetLinks(feed); return feed; }
protected virtual AtomFeed GetAnnotations(EntryCriteria criteria, int pageIndex, int pageSize) { AtomFeed feed = new AtomFeed(); feed.Subtitle = new AtomText(Atom.AtomNs + "subtitle") { Text = "Annotations" }; if (criteria.EntryId != null) //get annotations for an entry { AtomEntry parent = AtomEntryRepository.GetEntry(criteria.EntryId); feed.Title = parent.Title; feed.Id = parent.Id; //feed.Authors = parent.Authors; //feed.Contributors = parent.Contributors; } else if (criteria.CollectionName != null) //get annotations for a collection { AppCollection coll = AppService.GetCollection(criteria.WorkspaceName, criteria.CollectionName); feed.Id = coll.Id; feed.Title = coll.Title; //TODO: feed.Authors = coll.Authors; //TODO: feed.Contributors = coll.Contributors; } else if (criteria.WorkspaceName != null) //get annotations for an entire workspace { AppWorkspace ws = AppService.GetWorkspace(criteria.WorkspaceName); feed.Title = ws.Title; //TODO: feed.Authors = ws.Authors; //TODO: feed.Contributors = ws.Contributors; } else { feed.Title = new AtomTitle { Text = "Annotations" }; } int total; feed.Entries = AtomEntryRepository.GetEntries(criteria, pageIndex, pageSize, out total); feed.TotalResults = total; //foreach (AtomEntry e in feed.Entries) //{ // e.UpdateLinks(this.UrlHelper.RouteIdUri); //} return feed; }
public void GetEntriesSortOrderThreeEntriesTest() { MakeTestCollections(true); DateTime now = DateTime.Now; DateTime oneDayAgo = now.AddDays(-1); DateTime twoDaysAgo = now.AddDays(-2); // make an entry for today AtomEntry entry1 = TestDataHelper.MakeTestEntry(now, TestCollection1Name); entry1.Edited = now.AddHours(1); // and an entry for yesterday AtomEntry entry2 = TestDataHelper.MakeTestEntry(oneDayAgo, TestCollection1Name); // created yesterday, edited after the others entry2.Edited = now.AddHours(3); // third entry, day before yesterday AtomEntry entry3 = TestDataHelper.MakeTestEntry(twoDaysAgo, TestCollection1Name); // created yesterday, edited in the middle entry2.Edited = now.AddHours(2); IAtomEntryRepository repository = GetEntryRepository(); repository.CreateEntry(entry1); repository.CreateEntry(entry2); repository.CreateEntry(entry3); //now retrieve recent entries with no sort order EntryCriteria criteria = new EntryCriteria { WorkspaceName = TestWorkspaceName, CollectionName = TestCollection1Name, Authorized = true }; int totalEntries; IEnumerable<AtomEntry> entries = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entries); Assert.IsTrue(entries.Count() > 0); DataTester.AssertEntriesEqual(entry1, entries.First()); DataTester.AssertEntriesEqual(entry2, entries.Skip(1).First()); DataTester.AssertEntriesEqual(entry3, entries.Skip(2).First()); // now get them in edit order - the second entry should now be first criteria.SortMethod = SortMethod.EditDesc; IEnumerable<AtomEntry> entriesEditSort = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesEditSort); Assert.IsTrue(entriesEditSort.Count() > 0); DataTester.AssertEntriesEqual(entry2, entriesEditSort.First()); DataTester.AssertEntriesEqual(entry3, entriesEditSort.Skip(2).First()); DataTester.AssertEntriesEqual(entry1, entriesEditSort.Skip(1).First()); // date ascending order criteria.SortMethod = SortMethod.DateAsc; IEnumerable<AtomEntry> entriesSortDateAsc = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesSortDateAsc); Assert.IsTrue(entriesSortDateAsc.Count() > 0); DataTester.AssertEntriesEqual(entry3, entriesSortDateAsc.First()); DataTester.AssertEntriesEqual(entry2, entriesSortDateAsc.Skip(1).First()); DataTester.AssertEntriesEqual(entry1, entriesSortDateAsc.Skip(2).First()); // date descending order criteria.SortMethod = SortMethod.DateDesc; IEnumerable<AtomEntry> entriesSortDateDesc = repository.GetEntries(criteria, 0, PageSize, out totalEntries); Assert.IsNotNull(entriesSortDateDesc); Assert.IsTrue(entriesSortDateDesc.Count() > 0); DataTester.AssertEntriesEqual(entry1, entriesSortDateDesc.First()); DataTester.AssertEntriesEqual(entry2, entriesSortDateDesc.Skip(1).First()); DataTester.AssertEntriesEqual(entry3, entriesSortDateDesc.Skip(2).First()); }