245 lines
7.0 KiB
Go
245 lines
7.0 KiB
Go
package atom
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// It is advisable that each atom:entry element contain a non-empty atom:title
|
|
// element, a non-empty atom:content element when that element is present, and
|
|
// a non-empty atom:summary element when the entry contains no atom:content
|
|
// element.
|
|
type Entry struct {
|
|
*CommonAttributes
|
|
Authors []*Person `xml:"author,omitempty"`
|
|
Categories []*Category `xml:"category,omitempty"`
|
|
Content Content `xml:"content,omitempty"`
|
|
Contributors []*Person `xml:"contributors,omitempty"`
|
|
ID *ID `xml:"id"`
|
|
Links []*Link `xml:"link,omitempty"`
|
|
Published *Date `xml:"published,omitempty"`
|
|
Rights Text `xml:"rights,omitempty"`
|
|
Source *Source `xml:"source,omitempty"`
|
|
Summary Text `xml:"summary,omitempty"`
|
|
Title Text `xml:"title"`
|
|
Updated *Date `xml:"updated"`
|
|
Extensions []*ExtensionElement `xml:",any,omitempty"`
|
|
}
|
|
|
|
// checkAuthors checks the entry's authors for incompatibilities with RFC4287.
|
|
// It returns an errors.
|
|
// atom:entry elements MUST contain one or more atom:author elements, unless
|
|
// the atom:entry contains an atom:source element that contains an atom:author
|
|
// element or, in an Atom Feed Document, the atom:feed element contains an
|
|
// atom:author element itself.
|
|
func (e *Entry) checkAuthors(authorInFeed bool) error {
|
|
if e.Authors == nil {
|
|
if !authorInFeed {
|
|
if e.Source == nil {
|
|
return errors.New("no authors set in entry")
|
|
}
|
|
if e.Source.Authors == nil {
|
|
return errors.New("no authors set in entry")
|
|
}
|
|
}
|
|
} else {
|
|
for i, a := range e.Authors {
|
|
if err := a.Check(); err != nil {
|
|
return fmt.Errorf("author element %v of entry: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// NewEntry creates a new Entry. It returns a *Entry and an error.
|
|
func NewEntry(title string) (*Entry, error) {
|
|
text, err := NewText("text", title)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating new entry: %v", err)
|
|
}
|
|
|
|
return &Entry{
|
|
ID: NewID(),
|
|
Title: text,
|
|
Updated: NewDate(time.Now()),
|
|
}, nil
|
|
}
|
|
|
|
// AddAuthor adds the Person as an author to the Entry.
|
|
func (e *Entry) AddAuthor(p *Person) {
|
|
if e.Authors == nil {
|
|
e.Authors = make([]*Person, 1)
|
|
e.Authors[0] = p
|
|
} else {
|
|
e.Authors = append(e.Authors, p)
|
|
}
|
|
|
|
e.Updated.DateTime = DateTime(time.Now())
|
|
}
|
|
|
|
// AddCategory adds the Category to the Entry.
|
|
func (e *Entry) AddCategory(c *Category) {
|
|
if e.Categories == nil {
|
|
e.Categories = make([]*Category, 1)
|
|
e.Categories[0] = c
|
|
} else {
|
|
e.Categories = append(e.Categories, c)
|
|
}
|
|
|
|
e.Updated.DateTime = DateTime(time.Now())
|
|
}
|
|
|
|
// AddContributor adds the Person as a contributor to the Entry.
|
|
func (e *Entry) AddContributor(c *Person) {
|
|
if e.Contributors == nil {
|
|
e.Contributors = make([]*Person, 1)
|
|
e.Contributors[0] = c
|
|
} else {
|
|
e.Contributors = append(e.Contributors, c)
|
|
}
|
|
|
|
e.Updated.DateTime = DateTime(time.Now())
|
|
}
|
|
|
|
// AddLink adds the Link to the Entry.
|
|
func (e *Entry) AddLink(l *Link) {
|
|
if e.Links == nil {
|
|
e.Links = make([]*Link, 1)
|
|
e.Links[0] = l
|
|
} else {
|
|
e.Links = append(e.Links, l)
|
|
}
|
|
|
|
e.Updated.DateTime = DateTime(time.Now())
|
|
}
|
|
|
|
// AddExtension adds the ExtensionElement to the Entry.
|
|
func (e *Entry) AddExtension(x *ExtensionElement) {
|
|
if e.Extensions == nil {
|
|
e.Extensions = make([]*ExtensionElement, 1)
|
|
e.Extensions[0] = x
|
|
} else {
|
|
e.Extensions = append(e.Extensions, x)
|
|
}
|
|
|
|
e.Updated.DateTime = DateTime(time.Now())
|
|
}
|
|
|
|
// Check checks the Entry for incompatibilities with RFC4287. It returns an
|
|
// error.
|
|
func (e *Entry) Check() error {
|
|
if e.ID == nil {
|
|
return errors.New("no id element of entry")
|
|
} else {
|
|
if err := e.ID.Check(); err != nil {
|
|
return fmt.Errorf("id element of entry: %v", err)
|
|
}
|
|
}
|
|
|
|
if err := e.checkAuthors(true); err != nil {
|
|
return fmt.Errorf("entry %v: %v", e.ID.URI, err)
|
|
}
|
|
|
|
for i, c := range e.Categories {
|
|
if err := c.Check(); err != nil {
|
|
return fmt.Errorf("category element %v of entry %v: %v", i, e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
if e.Content != nil {
|
|
if err := e.Content.Check(); err != nil {
|
|
return fmt.Errorf("content element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
} else {
|
|
// atom:entry elements that contain no child atom:content element MUST
|
|
// contain at least one atom:link element with a rel attribute value of
|
|
// "alternate".
|
|
if !alternateRelExists(e.Links) {
|
|
return errors.New("no content element of entry %v and no link element with rel \"alternate\"")
|
|
}
|
|
}
|
|
|
|
for i, c := range e.Contributors {
|
|
if err := c.Check(); err != nil {
|
|
return fmt.Errorf("contributor element %v of entry %v: %v", i, e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
for i, l := range e.Links {
|
|
if err := l.Check(); err != nil {
|
|
return fmt.Errorf("link element %v of entry %v: %v", i, e.ID.URI, err)
|
|
}
|
|
}
|
|
if hasAlternateDuplicateLinks(e.Links) {
|
|
return fmt.Errorf("links with with a rel attribute value of \"alternate\" and duplicate type and hreflang attribute values found in entry %v", e.ID.URI)
|
|
}
|
|
|
|
if e.Published != nil {
|
|
if err := e.Published.Check(); err != nil {
|
|
return fmt.Errorf("published element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
if e.Rights != nil {
|
|
if err := e.Rights.Check(); err != nil {
|
|
return fmt.Errorf("rights element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
if e.Source != nil {
|
|
if err := e.Source.Check(); err != nil {
|
|
return fmt.Errorf("source element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
if e.Summary != nil {
|
|
if err := e.Summary.Check(); err != nil {
|
|
return fmt.Errorf("summary element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
} else {
|
|
// atom:entry elements MUST contain an atom:summary element in either
|
|
// of the following cases:
|
|
// the atom:entry contains an atom:content that has a "src" attribute
|
|
// (and is thus empty).
|
|
if e.Content.hasSRC() {
|
|
return fmt.Errorf("no summary element of entry %v but content of type out of line content", e.ID.URI)
|
|
}
|
|
// the atom:entry contains content that is encoded in Base64; i.e., the
|
|
// "type" attribute of atom:content is a MIME media type [MIMEREG], but
|
|
// is not an XML media type [RFC3023], does not begin with "text/", and
|
|
// does not end with "/xml" or "+xml".
|
|
mediaType := e.Content.getType()
|
|
if isValidMediaType(mediaType) && !isXMLMediaType(mediaType) && !strings.HasPrefix(mediaType, "text/") {
|
|
return fmt.Errorf("no summary element of entry %v but media type not xml", e.ID.URI)
|
|
}
|
|
}
|
|
|
|
if e.Title == nil {
|
|
return fmt.Errorf("no title element of entry %v", e.ID.URI)
|
|
} else {
|
|
if err := e.Title.Check(); err != nil {
|
|
return fmt.Errorf("title element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
if e.Updated == nil {
|
|
return fmt.Errorf("no updated element of entry %v", e.ID.URI)
|
|
} else {
|
|
if err := e.Updated.Check(); err != nil {
|
|
return fmt.Errorf("updated element of entry %v: %v", e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
for i, x := range e.Extensions {
|
|
if err := x.Check(); err != nil {
|
|
return fmt.Errorf("extension element %v of entry %v: %v", i, e.ID.URI, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|