package gofeed import ( "fmt" "strings" "time" "github.com/mmcdole/gofeed/atom" ext "github.com/mmcdole/gofeed/extensions" "github.com/mmcdole/gofeed/internal/shared" "github.com/mmcdole/gofeed/rss" ) // Translator converts a particular feed (atom.Feed or rss.Feed) // into the generic Feed struct type Translator interface { Translate(feed interface{}) (*Feed, error) } // DefaultRSSTranslator converts an rss.Feed struct // into the generic Feed struct. // // This default implementation defines a set of // mapping rules between rss.Feed -> Feed // for each of the fields in Feed. type DefaultRSSTranslator struct{} // Translate converts an RSS feed into the universal // feed type. func (t *DefaultRSSTranslator) Translate(feed interface{}) (*Feed, error) { rss, found := feed.(*rss.Feed) if !found { return nil, fmt.Errorf("Feed did not match expected type of *rss.Feed") } result := &Feed{} result.Title = t.translateFeedTitle(rss) result.Description = t.translateFeedDescription(rss) result.Link = t.translateFeedLink(rss) result.FeedLink = t.translateFeedFeedLink(rss) result.Updated = t.translateFeedUpdated(rss) result.UpdatedParsed = t.translateFeedUpdatedParsed(rss) result.Published = t.translateFeedPublished(rss) result.PublishedParsed = t.translateFeedPublishedParsed(rss) result.Author = t.translateFeedAuthor(rss) result.Language = t.translateFeedLanguage(rss) result.Image = t.translateFeedImage(rss) result.Copyright = t.translateFeedCopyright(rss) result.Generator = t.translateFeedGenerator(rss) result.Categories = t.translateFeedCategories(rss) result.Items = t.translateFeedItems(rss) result.ITunesExt = rss.ITunesExt result.DublinCoreExt = rss.DublinCoreExt result.Extensions = rss.Extensions result.FeedVersion = rss.Version result.FeedType = "rss" return result, nil } func (t *DefaultRSSTranslator) translateFeedItem(rssItem *rss.Item) (item *Item) { item = &Item{} item.Title = t.translateItemTitle(rssItem) item.Description = t.translateItemDescription(rssItem) item.Content = t.translateItemContent(rssItem) item.Link = t.translateItemLink(rssItem) item.Published = t.translateItemPublished(rssItem) item.PublishedParsed = t.translateItemPublishedParsed(rssItem) item.Author = t.translateItemAuthor(rssItem) item.GUID = t.translateItemGUID(rssItem) item.Image = t.translateItemImage(rssItem) item.Categories = t.translateItemCategories(rssItem) item.Enclosures = t.translateItemEnclosures(rssItem) item.DublinCoreExt = rssItem.DublinCoreExt item.ITunesExt = rssItem.ITunesExt item.Extensions = rssItem.Extensions return } func (t *DefaultRSSTranslator) translateFeedTitle(rss *rss.Feed) (title string) { if rss.Title != "" { title = rss.Title } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Title != nil { title = t.firstEntry(rss.DublinCoreExt.Title) } return } func (t *DefaultRSSTranslator) translateFeedDescription(rss *rss.Feed) (desc string) { return rss.Description } func (t *DefaultRSSTranslator) translateFeedLink(rss *rss.Feed) (link string) { if rss.Link != "" { link = rss.Link } else if rss.ITunesExt != nil && rss.ITunesExt.Subtitle != "" { link = rss.ITunesExt.Subtitle } return } func (t *DefaultRSSTranslator) translateFeedFeedLink(rss *rss.Feed) (link string) { atomExtensions := t.extensionsForKeys([]string{"atom", "atom10", "atom03"}, rss.Extensions) for _, ex := range atomExtensions { if links, ok := ex["link"]; ok { for _, l := range links { if l.Attrs["Rel"] == "self" { link = l.Value } } } } return } func (t *DefaultRSSTranslator) translateFeedUpdated(rss *rss.Feed) (updated string) { if rss.LastBuildDate != "" { updated = rss.LastBuildDate } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Date != nil { updated = t.firstEntry(rss.DublinCoreExt.Date) } return } func (t *DefaultRSSTranslator) translateFeedUpdatedParsed(rss *rss.Feed) (updated *time.Time) { if rss.LastBuildDateParsed != nil { updated = rss.LastBuildDateParsed } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Date != nil { dateText := t.firstEntry(rss.DublinCoreExt.Date) date, err := shared.ParseDate(dateText) if err == nil { updated = &date } } return } func (t *DefaultRSSTranslator) translateFeedPublished(rss *rss.Feed) (published string) { return rss.PubDate } func (t *DefaultRSSTranslator) translateFeedPublishedParsed(rss *rss.Feed) (published *time.Time) { return rss.PubDateParsed } func (t *DefaultRSSTranslator) translateFeedAuthor(rss *rss.Feed) (author *Person) { if rss.ManagingEditor != "" { name, address := shared.ParseNameAddress(rss.ManagingEditor) author = &Person{} author.Name = name author.Email = address } else if rss.WebMaster != "" { name, address := shared.ParseNameAddress(rss.WebMaster) author = &Person{} author.Name = name author.Email = address } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Author != nil { dcAuthor := t.firstEntry(rss.DublinCoreExt.Author) name, address := shared.ParseNameAddress(dcAuthor) author = &Person{} author.Name = name author.Email = address } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Creator != nil { dcCreator := t.firstEntry(rss.DublinCoreExt.Creator) name, address := shared.ParseNameAddress(dcCreator) author = &Person{} author.Name = name author.Email = address } else if rss.ITunesExt != nil && rss.ITunesExt.Author != "" { name, address := shared.ParseNameAddress(rss.ITunesExt.Author) author = &Person{} author.Name = name author.Email = address } return } func (t *DefaultRSSTranslator) translateFeedLanguage(rss *rss.Feed) (language string) { if rss.Language != "" { language = rss.Language } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Language != nil { language = t.firstEntry(rss.DublinCoreExt.Language) } return } func (t *DefaultRSSTranslator) translateFeedImage(rss *rss.Feed) (image *Image) { if rss.Image != nil { image = &Image{} image.Title = rss.Image.Title image.URL = rss.Image.URL } else if rss.ITunesExt != nil && rss.ITunesExt.Image != "" { image = &Image{} image.URL = rss.ITunesExt.Image } return } func (t *DefaultRSSTranslator) translateFeedCopyright(rss *rss.Feed) (rights string) { if rss.Copyright != "" { rights = rss.Copyright } else if rss.DublinCoreExt != nil && rss.DublinCoreExt.Rights != nil { rights = t.firstEntry(rss.DublinCoreExt.Rights) } return } func (t *DefaultRSSTranslator) translateFeedGenerator(rss *rss.Feed) (generator string) { return rss.Generator } func (t *DefaultRSSTranslator) translateFeedCategories(rss *rss.Feed) (categories []string) { cats := []string{} if rss.Categories != nil { for _, c := range rss.Categories { cats = append(cats, c.Value) } } if rss.ITunesExt != nil && rss.ITunesExt.Keywords != "" { keywords := strings.Split(rss.ITunesExt.Keywords, ",") for _, k := range keywords { cats = append(cats, k) } } if rss.ITunesExt != nil && rss.ITunesExt.Categories != nil { for _, c := range rss.ITunesExt.Categories { cats = append(cats, c.Text) if c.Subcategory != nil { cats = append(cats, c.Subcategory.Text) } } } if rss.DublinCoreExt != nil && rss.DublinCoreExt.Subject != nil { for _, c := range rss.DublinCoreExt.Subject { cats = append(cats, c) } } if len(cats) > 0 { categories = cats } return } func (t *DefaultRSSTranslator) translateFeedItems(rss *rss.Feed) (items []*Item) { items = []*Item{} for _, i := range rss.Items { items = append(items, t.translateFeedItem(i)) } return } func (t *DefaultRSSTranslator) translateItemTitle(rssItem *rss.Item) (title string) { if rssItem.Title != "" { title = rssItem.Title } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Title != nil { title = t.firstEntry(rssItem.DublinCoreExt.Title) } return } func (t *DefaultRSSTranslator) translateItemDescription(rssItem *rss.Item) (desc string) { if rssItem.Description != "" { desc = rssItem.Description } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Description != nil { desc = t.firstEntry(rssItem.DublinCoreExt.Description) } return } func (t *DefaultRSSTranslator) translateItemContent(rssItem *rss.Item) (content string) { return rssItem.Content } func (t *DefaultRSSTranslator) translateItemLink(rssItem *rss.Item) (link string) { return rssItem.Link } func (t *DefaultRSSTranslator) translateItemUpdated(rssItem *rss.Item) (updated string) { if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Date != nil { updated = t.firstEntry(rssItem.DublinCoreExt.Date) } return updated } func (t *DefaultRSSTranslator) translateItemUpdatedParsed(rssItem *rss.Item) (updated *time.Time) { if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Date != nil { updatedText := t.firstEntry(rssItem.DublinCoreExt.Date) updatedDate, err := shared.ParseDate(updatedText) if err == nil { updated = &updatedDate } } return } func (t *DefaultRSSTranslator) translateItemPublished(rssItem *rss.Item) (pubDate string) { if rssItem.PubDate != "" { return rssItem.PubDate } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Date != nil { return t.firstEntry(rssItem.DublinCoreExt.Date) } return } func (t *DefaultRSSTranslator) translateItemPublishedParsed(rssItem *rss.Item) (pubDate *time.Time) { if rssItem.PubDateParsed != nil { return rssItem.PubDateParsed } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Date != nil { pubDateText := t.firstEntry(rssItem.DublinCoreExt.Date) pubDateParsed, err := shared.ParseDate(pubDateText) if err == nil { pubDate = &pubDateParsed } } return } func (t *DefaultRSSTranslator) translateItemAuthor(rssItem *rss.Item) (author *Person) { if rssItem.Author != "" { name, address := shared.ParseNameAddress(rssItem.Author) author = &Person{} author.Name = name author.Email = address } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Author != nil { dcAuthor := t.firstEntry(rssItem.DublinCoreExt.Author) name, address := shared.ParseNameAddress(dcAuthor) author = &Person{} author.Name = name author.Email = address } else if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Creator != nil { dcCreator := t.firstEntry(rssItem.DublinCoreExt.Creator) name, address := shared.ParseNameAddress(dcCreator) author = &Person{} author.Name = name author.Email = address } else if rssItem.ITunesExt != nil && rssItem.ITunesExt.Author != "" { name, address := shared.ParseNameAddress(rssItem.ITunesExt.Author) author = &Person{} author.Name = name author.Email = address } return } func (t *DefaultRSSTranslator) translateItemGUID(rssItem *rss.Item) (guid string) { if rssItem.GUID != nil { guid = rssItem.GUID.Value } return } func (t *DefaultRSSTranslator) translateItemImage(rssItem *rss.Item) (image *Image) { if rssItem.ITunesExt != nil && rssItem.ITunesExt.Image != "" { image = &Image{} image.URL = rssItem.ITunesExt.Image } return } func (t *DefaultRSSTranslator) translateItemCategories(rssItem *rss.Item) (categories []string) { cats := []string{} if rssItem.Categories != nil { for _, c := range rssItem.Categories { cats = append(cats, c.Value) } } if rssItem.ITunesExt != nil && rssItem.ITunesExt.Keywords != "" { keywords := strings.Split(rssItem.ITunesExt.Keywords, ",") for _, k := range keywords { cats = append(cats, k) } } if rssItem.DublinCoreExt != nil && rssItem.DublinCoreExt.Subject != nil { for _, c := range rssItem.DublinCoreExt.Subject { cats = append(cats, c) } } if len(cats) > 0 { categories = cats } return } func (t *DefaultRSSTranslator) translateItemEnclosures(rssItem *rss.Item) (enclosures []*Enclosure) { if rssItem.Enclosure != nil { e := &Enclosure{} e.URL = rssItem.Enclosure.URL e.Type = rssItem.Enclosure.Type e.Length = rssItem.Enclosure.Length enclosures = []*Enclosure{e} } return } func (t *DefaultRSSTranslator) extensionsForKeys(keys []string, extensions ext.Extensions) (matches []map[string][]ext.Extension) { matches = []map[string][]ext.Extension{} if extensions == nil { return } for _, key := range keys { if match, ok := extensions[key]; ok { matches = append(matches, match) } } return } func (t *DefaultRSSTranslator) firstEntry(entries []string) (value string) { if entries == nil { return } if len(entries) == 0 { return } return entries[0] } // DefaultAtomTranslator converts an atom.Feed struct // into the generic Feed struct. // // This default implementation defines a set of // mapping rules between atom.Feed -> Feed // for each of the fields in Feed. type DefaultAtomTranslator struct{} // Translate converts an Atom feed into the universal // feed type. func (t *DefaultAtomTranslator) Translate(feed interface{}) (*Feed, error) { atom, found := feed.(*atom.Feed) if !found { return nil, fmt.Errorf("Feed did not match expected type of *atom.Feed") } result := &Feed{} result.Title = t.translateFeedTitle(atom) result.Description = t.translateFeedDescription(atom) result.Link = t.translateFeedLink(atom) result.FeedLink = t.translateFeedFeedLink(atom) result.Updated = t.translateFeedUpdated(atom) result.UpdatedParsed = t.translateFeedUpdatedParsed(atom) result.Author = t.translateFeedAuthor(atom) result.Language = t.translateFeedLanguage(atom) result.Image = t.translateFeedImage(atom) result.Copyright = t.translateFeedCopyright(atom) result.Categories = t.translateFeedCategories(atom) result.Generator = t.translateFeedGenerator(atom) result.Items = t.translateFeedItems(atom) result.Extensions = atom.Extensions result.FeedVersion = atom.Version result.FeedType = "atom" return result, nil } func (t *DefaultAtomTranslator) translateFeedItem(entry *atom.Entry) (item *Item) { item = &Item{} item.Title = t.translateItemTitle(entry) item.Description = t.translateItemDescription(entry) item.Content = t.translateItemContent(entry) item.Link = t.translateItemLink(entry) item.Updated = t.translateItemUpdated(entry) item.UpdatedParsed = t.translateItemUpdatedParsed(entry) item.Published = t.translateItemPublished(entry) item.PublishedParsed = t.translateItemPublishedParsed(entry) item.Author = t.translateItemAuthor(entry) item.GUID = t.translateItemGUID(entry) item.Image = t.translateItemImage(entry) item.Categories = t.translateItemCategories(entry) item.Enclosures = t.translateItemEnclosures(entry) item.Extensions = entry.Extensions return } func (t *DefaultAtomTranslator) translateFeedTitle(atom *atom.Feed) (title string) { return atom.Title } func (t *DefaultAtomTranslator) translateFeedDescription(atom *atom.Feed) (desc string) { return atom.Subtitle } func (t *DefaultAtomTranslator) translateFeedLink(atom *atom.Feed) (link string) { l := t.firstLinkWithType("alternate", atom.Links) if l != nil { link = l.Href } return } func (t *DefaultAtomTranslator) translateFeedFeedLink(atom *atom.Feed) (link string) { feedLink := t.firstLinkWithType("self", atom.Links) if feedLink != nil { link = feedLink.Href } return } func (t *DefaultAtomTranslator) translateFeedUpdated(atom *atom.Feed) (updated string) { return atom.Updated } func (t *DefaultAtomTranslator) translateFeedUpdatedParsed(atom *atom.Feed) (updated *time.Time) { return atom.UpdatedParsed } func (t *DefaultAtomTranslator) translateFeedAuthor(atom *atom.Feed) (author *Person) { a := t.firstPerson(atom.Authors) if a != nil { feedAuthor := Person{} feedAuthor.Name = a.Name feedAuthor.Email = a.Email author = &feedAuthor } return } func (t *DefaultAtomTranslator) translateFeedLanguage(atom *atom.Feed) (language string) { return atom.Language } func (t *DefaultAtomTranslator) translateFeedImage(atom *atom.Feed) (image *Image) { if atom.Logo != "" { feedImage := Image{} feedImage.URL = atom.Logo image = &feedImage } return } func (t *DefaultAtomTranslator) translateFeedCopyright(atom *atom.Feed) (rights string) { return atom.Rights } func (t *DefaultAtomTranslator) translateFeedGenerator(atom *atom.Feed) (generator string) { if atom.Generator != nil { if atom.Generator.Value != "" { generator += atom.Generator.Value } if atom.Generator.Version != "" { generator += " v" + atom.Generator.Version } if atom.Generator.URI != "" { generator += " " + atom.Generator.URI } generator = strings.TrimSpace(generator) } return } func (t *DefaultAtomTranslator) translateFeedCategories(atom *atom.Feed) (categories []string) { if atom.Categories != nil { categories = []string{} for _, c := range atom.Categories { categories = append(categories, c.Term) } } return } func (t *DefaultAtomTranslator) translateFeedItems(atom *atom.Feed) (items []*Item) { items = []*Item{} for _, entry := range atom.Entries { items = append(items, t.translateFeedItem(entry)) } return } func (t *DefaultAtomTranslator) translateItemTitle(entry *atom.Entry) (title string) { return entry.Title } func (t *DefaultAtomTranslator) translateItemDescription(entry *atom.Entry) (desc string) { return entry.Summary } func (t *DefaultAtomTranslator) translateItemContent(entry *atom.Entry) (content string) { if entry.Content != nil { content = entry.Content.Value } return } func (t *DefaultAtomTranslator) translateItemLink(entry *atom.Entry) (link string) { l := t.firstLinkWithType("alternate", entry.Links) if l != nil { link = l.Href } return } func (t *DefaultAtomTranslator) translateItemUpdated(entry *atom.Entry) (updated string) { return entry.Updated } func (t *DefaultAtomTranslator) translateItemUpdatedParsed(entry *atom.Entry) (updated *time.Time) { return entry.UpdatedParsed } func (t *DefaultAtomTranslator) translateItemPublished(entry *atom.Entry) (updated string) { return entry.Published } func (t *DefaultAtomTranslator) translateItemPublishedParsed(entry *atom.Entry) (updated *time.Time) { return entry.PublishedParsed } func (t *DefaultAtomTranslator) translateItemAuthor(entry *atom.Entry) (author *Person) { a := t.firstPerson(entry.Authors) if a != nil { author = &Person{} author.Name = a.Name author.Email = a.Email } return } func (t *DefaultAtomTranslator) translateItemGUID(entry *atom.Entry) (guid string) { return entry.ID } func (t *DefaultAtomTranslator) translateItemImage(entry *atom.Entry) (image *Image) { return nil } func (t *DefaultAtomTranslator) translateItemCategories(entry *atom.Entry) (categories []string) { if entry.Categories != nil { categories = []string{} for _, c := range entry.Categories { categories = append(categories, c.Term) } } return } func (t *DefaultAtomTranslator) translateItemEnclosures(entry *atom.Entry) (enclosures []*Enclosure) { if entry.Links != nil { enclosures = []*Enclosure{} for _, e := range entry.Links { if e.Rel == "enclosure" { enclosure := &Enclosure{} enclosure.URL = e.Href enclosure.Length = e.Length enclosure.Type = e.Type enclosures = append(enclosures, enclosure) } } if len(enclosures) == 0 { enclosures = nil } } return } func (t *DefaultAtomTranslator) firstLinkWithType(linkType string, links []*atom.Link) *atom.Link { if links == nil { return nil } for _, link := range links { if link.Rel == linkType { return link } } return nil } func (t *DefaultAtomTranslator) firstPerson(persons []*atom.Person) (person *atom.Person) { if persons == nil || len(persons) == 0 { return } person = persons[0] return }