// Renders feed in Atom format
func (c *Context) Atom(feed *feeds.Feed) *Result {
atom, err := feed.ToAtom()
if err != nil {
return c.Error(err)
}
return c.Result(http.StatusOK, []byte(atom), "application/atom+xml", nil)
}
func Feed(context *GoInk.Context) {
baseUrl := model.GetSetting("site_url")
article, _ := model.GetArticleList(1, 20)
feed := new(feeds.Feed)
feed.Title = model.GetSetting("site_title")
feed.Link = &feeds.Link{Href: baseUrl}
feed.Description = model.GetSetting("site_description")
author := model.GetUsersByRole("ADMIN")[0]
feed.Author = &feeds.Author{author.Nick, author.Email}
feed.Items = make([]*feeds.Item, 0)
var create int64
if len(article) > 0 {
create = article[0].EditTime
} else {
create = utils.Now()
}
feed.Created = time.Unix(create, 0)
for _, a := range article {
item := new(feeds.Item)
item.Title = a.Title
item.Link = &feeds.Link{Href: path.Join(baseUrl, a.Link())}
item.Author = feed.Author
item.Created = time.Unix(a.CreateTime, 0)
item.Description = utils.Html2str(a.Summary())
feed.Items = append(feed.Items, item)
}
str, e := feed.ToRss()
if e != nil {
panic(e)
}
context.ContentType("application/rss+xml;charset=UTF-8")
context.Body = []byte(str)
}
func renderFeed(w http.ResponseWriter, feed *feeds.Feed) {
if err := feed.WriteAtom(w); err != nil {
log.Println(err)
w.WriteHeader(http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/atom+xml")
}
func getRss() string {
twitterConfig := oauth1.NewConfig(conf.ConsumerKey, conf.ConsumerSecret)
token := oauth1.NewToken(conf.AccessToken, conf.AccessSecret)
// OAuth1 http.Client will automatically authorize Requests
httpClient := twitterConfig.Client(oauth1.NoContext, token)
// Twitter Client
client := twitter.NewClient(httpClient)
// debugging & testing
/*if conf.Debug {
var tweetId int64 = 7654321
tweet, _, err := client.Statuses.Show(tweetId, &twitter.StatusShowParams{})
if err != nil {
processAPIError("Couldn't load client.Statuses.Show: ", err)
return ""
}
fmt.Println(parser.GetTweetUrl(*tweet))
spew.Dump(tweet)
fmt.Println(parser.ParseTweetText(*tweet))
return ""
}*/
// Get timeline
homeTimelineParams := &twitter.HomeTimelineParams{Count: conf.MaxTweets}
tweets, _, err := client.Timelines.HomeTimeline(homeTimelineParams)
if err != nil {
processAPIError("Couldn't load HomeTimeline: ", err)
return ""
}
// get either single tweets or combine multiple tweets of the same author together
var rssFeed *feeds.Feed
if conf.CombinedFeed == false {
rssFeed = feed.CreateIndividualFeed(conf, tweets)
} else {
rssFeed = feed.CreateCombinedUserFeed(conf, tweets)
}
// Create feed
atom, err := rssFeed.ToAtom()
if err != nil {
log.Fatal(err)
}
return atom
}
func makeHandler(master *feeds.Feed, sourceName string) rss.ItemHandlerFunc {
return func(feed *rss.Feed, ch *rss.Channel, items []*rss.Item) {
for i := 0; i < len(items); i++ {
published, _ := items[i].ParsedPubDate()
weekAgo := time.Now().AddDate(0, 0, -7)
if published.After(weekAgo) {
item := &feeds.Item{
Title: stripPodcastEpisodePrefix(items[i].Title),
Link: &feeds.Link{Href: items[i].Links[0].Href},
Description: items[i].Description,
Author: &feeds.Author{Name: sourceName},
Created: published,
}
master.Add(item)
}
}
}
}
func main() {
pflag.Parse()
now := time.Now()
feed := feeds.Feed{
Title: *feedTitle,
Link: &feeds.Link{
Href: *feedPublishUrl,
},
Description: *feedDescription,
Author: &feeds.Author{
*feedAuthorName, *feedAuthorEmail,
},
Created: now,
}
filepath.Walk(*inputDir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
relPath, err := filepath.Rel(*inputDir, path)
if err != nil {
return err
}
feed.Items = append(feed.Items, &feeds.Item{
Id: "file:" + url.QueryEscape(path),
Title: info.Name(),
Link: &feeds.Link{
Href: *feedFilesBaseUrl + relPath,
},
Description: path,
Author: &feeds.Author{*feedAuthorName, *feedAuthorEmail},
Created: info.ModTime(),
})
return nil
})
var content string
var err error
switch *outputFormat {
case "rss":
content, err = feed.ToRss()
case "atom":
content, err = feed.ToAtom()
default:
log.Fatalf("Unknown format: %s", *outputFormat)
}
if err != nil {
log.Fatalf("Failed to generate feed: %#v", err)
}
err = ioutil.WriteFile(*outputFile, []byte(content), 0777)
if err != nil {
log.Fatalf("Failed to store feed: %#v", err)
}
}