public void CreateWithIdTest()
        {
            DateTime updatedDate = DateTime.Now;

            AtomFeed atomFeed = new AtomFeed()
            {
                Id = new Uri("tag:[email protected],2008:collection")
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Id);
        }
        public void CreateWithSubtitleTest()
        {
            DateTime updatedDate = DateTime.Now;

            AtomFeed atomFeed = new AtomFeed()
            {
                Subtitle = new AtomSubtitle()
                {
                    Text = "aSubtitle"
                }
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Subtitle);
            Assert.AreEqual("aSubtitle", atomFeed.Subtitle.Text);
        }
        public void CreateWithRightsTest()
        {
            DateTime updatedDate = DateTime.Now;

            AtomFeed atomFeed = new AtomFeed()
            {
                Rights = new AtomRights()
                     {
                         Text = "aText"
                     }
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Rights);
            Assert.AreEqual("aText", atomFeed.Rights.Text);
        }
 protected void SetLinks(AtomFeed f)
 {
     if (f.Id != null && f.Id.Scheme == "tag")
     {
         if (!new BlogAppCollection(AppService.GetCollection(f.Id)).BloggingOn) return;
         LogService.Debug("BlogService.SetLinks feedId={0}", f.Id);
         var links = f.Links.ToList();
         var url = new UrlHelper(Container.GetInstance<RequestContext>());
         links.Merge(new AtomLink()
         {
             Rel = "alternate",
             Type = "text/html",
             Href = url.RouteIdUri("BlogListing", f.Id, AbsoluteMode.Force)
         });
         f.Links = links;
     }
 }
    protected void SetLinks(AtomFeed f)
    {
      LogService.Debug("AnnotateService.SetLinks feedId={0}", f.Id);
      var links = f.Links.ToList();

      var url = new UrlHelper(Container.GetInstance<RequestContext>());

      //atom threading extension
      if (f.Id != null && f.Id.Scheme == "tag")
      {
        links.Merge(new AtomLink
        {
          Href = url.RouteIdUri("AnnotateAnnotationsFeed", f.Id, AbsoluteMode.Force),
          Rel = "replies",
          Type = Atom.ContentType,
          Updated = DateTimeOffset.UtcNow
        });
      }
      f.Links = links;
    }
 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;
 }
    /// <summary>
    /// Gets a feed of the given type (rss or atom) and remove's emails
    /// to prevent spam
    /// </summary>
    /// <param name="feed"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    protected ActionResult GetFeedResult(AtomFeed feed, string type)
    {
      //remove email's to prevent spam
      foreach (AtomPerson person in feed.People.Concat(feed.Entries.SelectMany(e => e.People)))
      {
        person.Email = null; //string.Empty;
      }

      if (type == "atom")
      {
        return new XmlWriterResult((w) => feed.Xml.WriteTo(w))
        {
          ContentType = Atom.ContentTypeFeed
        };
      }
      else if (type == "rss")
      {
        return new XmlWriterResult((w) => feed.WriteRssTo(w))
        {
          ContentType = "text/xml"
        };
      }
      else
      {
        throw new ResourceNotFoundException(type + " feed", "requested");
      }
    }
    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;
    }
    protected void SetLinks(AtomFeed feed)
    {
      LogService.Debug("AtomPubService.SetLinks collectionId={0}", feed.Id);
      if (feed.Links == null) feed.Links = new List<AtomLink>();
      var links = feed.Links.ToList();

      var url = new UrlHelper(Container.GetInstance<RequestContext>());
      links.Merge(new AtomLink()
      {
        Rel = "service",
        Type = Atom.ContentTypeService,
        Href = url.RouteUriEx("AtomPubService", AbsoluteMode.Force)
      });
      if (feed.Id != null && feed.Id.Scheme == "tag")
      {
        links.Merge(new AtomLink()
        {
          Rel = "self",
          Type = Atom.ContentTypeFeed,
          Href = url.RouteIdUri("AtomPubFeed", feed.Id, AbsoluteMode.Force)
        });
        links.Merge(new AtomLink()
        {
          Rel = "alternate",
          Type = "text/html",
          Href = url.RouteIdUri("AtomPubCollectionIndex", feed.Id, AbsoluteMode.Force)
        });
      }
      feed.Links = links;
      foreach (AtomEntry entry in feed.Entries) SetLinks(entry);
      if (SettingFeedLinks != null) SettingFeedLinks(feed);
    }
        public void FullCreateTest()
        {
            DateTime updatedDate = DateTime.Now;

            AtomFeed atomFeed = new AtomFeed()
                {
                    Authors = new List<AtomPerson>(),
                    Contributors = new List<AtomPerson>(),
                    Base = new Uri("http://base.com"),
                    Categories = new List<AtomCategory>(),
                    Entries = new List<AtomEntry>(),
                    Generator = new AtomGenerator(),
                    Updated = updatedDate,
                    Icon = new Uri("http://icon.com"),
                    Lang = "EN",
                    Links = new List<AtomLink>(),
                    Logo = new Uri("http://logo.com")
                };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Authors);
            Assert.IsNotNull(atomFeed.Contributors);
            Assert.IsNotNull(atomFeed.Base);
            Assert.AreEqual(new Uri("http://base.com"), atomFeed.Base);
            Assert.IsNotNull(atomFeed.Categories);
            Assert.IsNotNull(atomFeed.Entries);
            Assert.IsNotNull(atomFeed.Generator);
            Assert.AreEqual(updatedDate, atomFeed.Updated);
            Assert.AreEqual(new Uri("http://icon.com"), atomFeed.Icon);
            Assert.AreEqual("EN", atomFeed.Lang);
            Assert.IsNotNull(atomFeed.Links);
            Assert.AreEqual(new Uri("http://logo.com"), atomFeed.Logo);
        }
    /// <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;
    }
 private IEnumerable<AtomCategory> GetCategories(AtomFeed Feed)
 {
     if (Feed.Entries.Count() == 0 ||
         Feed.Entries.SelectMany(e => e.Categories).Count() == 0)
         return Enumerable.Empty<AtomCategory>();
     return Feed.Entries.SelectMany(e => e.Categories).Distinct()
         .OrderBy(c => c.ToString());
 }
 public static AtomFeed Load(SyndicationFeed feed, int maxEntries)
 {
   feed.Items = feed.Items.Take(maxEntries);
   using (MemoryStream ms = new MemoryStream())
   {
     XmlWriter w = new XmlTextWriter(ms, Encoding.UTF8);
     feed.GetAtom10Formatter().WriteTo(w);
     w.Flush();
     AtomFeed atomFeed = new AtomFeed();
     ms.Position = 0;
     XmlReader r = new XmlTextReader(ms);
     atomFeed.ReadXml(r);
     return atomFeed;
   }
 }
    public static AtomFeed BuildFeed(AppCollection coll, IEnumerable<AtomEntry> entries,
      int total)//, int pageIndex, int pageSize), Func<string, Id, RouteValueDictionary, Uri> routeUri,
      //string atomRouteName, string webRouteName, bool addPaging)
    {
      AtomFeed feed = new AtomFeed();
      feed.Generator = new AtomGenerator { Text = "atomsite.net" };
      feed.Title = coll.Title;
      feed.Subtitle = coll.Subtitle;
      feed.Id = coll.Id;
      feed.Logo = coll.Logo;
      feed.Icon = coll.Icon;
      feed.Rights = coll.Rights;
      feed.Updated = DateTimeOffset.UtcNow;
      feed.TotalResults = total;
      feed.Entries = entries;

      //refresh links in case they change
      //foreach (AtomEntry e in feed.Entries) e.UpdateLinks(routeUri);

      //use newest updated date as feed updated date
      if (feed.Entries.Count() > 0)
        feed.Updated = feed.Entries.Max().Updated;

      //feed.GenerateLinks(routeUri, atomRouteName, webRouteName, pageIndex, pageSize, addPaging);

      //TODO: ensure all entries have author
      //NOTE: the below two statements would break any Views built on a FeedModel
      //TODO: save bandwidth, add author at feed level if all authors are the same, remove from entries
      //TODO: save bandwidth, add contrib at feed level if all contrib are the same, remove from entries
      return feed;
    }
        public void CreateWithLinksTest()
        {
            AtomFeed atomFeed = new AtomFeed()
            {
                Links = TestHelper.MakeLinks(5)
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Links);
            Assert.AreEqual(5, atomFeed.Links.Count());
        }
        public void CreateWithCategoriesTest()
        {
            AtomFeed atomFeed = new AtomFeed()
            {
                Categories = TestHelper.MakeAtomCategoryList(5)
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Categories);
            Assert.AreEqual(5, atomFeed.Categories.Count());
        }
        public void CreateWithContributorsTest()
        {
            AtomFeed atomFeed = new AtomFeed()
            {
                Contributors = TestHelper.MakePersonList(5, Atom.AtomNs + "contributor")
            };

            Assert.IsNotNull(atomFeed);
            Assert.IsNotNull(atomFeed.Contributors);
            Assert.AreEqual(5, atomFeed.Contributors.Count());
        }
        public void SimpleCreateTest()
        {
            AtomFeed atomFeed = new AtomFeed(); 

            Assert.IsNotNull(atomFeed);
        }