func readState(u content.User, dbo *db.DB, logger webfw.Logger, opts data.ArticleUpdateStateOptions, read bool, join, joinPredicate, deleteJoin, deleteWhere string, insertArgs, deleteArgs []interface{}) {
if u.HasErr() {
return
}
s := dbo.SQL()
var err error
if readStateInsertTemplate == nil {
readStateInsertTemplate, err = template.New("read-state-insert-sql").
Parse(s.User.ReadStateInsertTemplate)
if err != nil {
u.Err(fmt.Errorf("Error generating read-state-insert template: %v", err))
return
}
}
if readStateDeleteTemplate == nil {
readStateDeleteTemplate, err = template.New("read-state-delete-sql").
Parse(s.User.ReadStateDeleteTemplate)
if err != nil {
u.Err(fmt.Errorf("Error generating read-state-delete template: %v", err))
return
}
}
tx, err := dbo.Beginx()
if err != nil {
u.Err(err)
return
}
defer tx.Rollback()
if read {
args := append([]interface{}{u.Data().Login}, deleteArgs...)
buf := util.BufferPool.GetBuffer()
defer util.BufferPool.Put(buf)
data := readStateDeleteData{}
if deleteJoin != "" {
data.Join = deleteJoin
}
if opts.FavoriteOnly {
data.Join += s.User.ReadStateDeleteFavoriteJoin
}
if opts.UntaggedOnly {
data.Join += s.User.ReadStateDeleteUntaggedJoin
}
where := []string{}
if deleteWhere != "" {
where = append(where, deleteWhere)
}
if !opts.BeforeDate.IsZero() {
where = append(where, fmt.Sprintf("(a.date IS NULL OR a.date < $%d)", len(args)+1))
args = append(args, opts.BeforeDate)
}
if !opts.AfterDate.IsZero() {
where = append(where, fmt.Sprintf("a.date > $%d", len(args)+1))
args = append(args, opts.AfterDate)
}
if opts.BeforeId > 0 {
where = append(where, fmt.Sprintf("a.id < $%d", len(args)+1))
args = append(args, opts.BeforeId)
}
if opts.AfterId > 0 {
where = append(where, fmt.Sprintf("a.id > $%d", len(args)+1))
args = append(args, opts.AfterId)
}
if opts.FavoriteOnly {
where = append(where, "af.article_id IS NOT NULL")
}
if opts.UntaggedOnly {
where = append(where, "uft.feed_id IS NULL")
}
if len(where) > 0 {
data.Where = " WHERE " + strings.Join(where, " AND ")
}
if err := readStateDeleteTemplate.Execute(buf, data); err != nil {
u.Err(fmt.Errorf("Error executing read-state-delete template: %v", err))
return
}
sql := buf.String()
logger.Debugf("Read state delete SQL:\n%s\nArgs:%v\n", sql, args)
stmt, err := tx.Preparex(sql)
if err != nil {
u.Err(err)
return
}
defer stmt.Close()
_, err = stmt.Exec(args...)
if err != nil {
u.Err(err)
return
}
} else {
args := append([]interface{}{u.Data().Login}, insertArgs...)
buf := util.BufferPool.GetBuffer()
defer util.BufferPool.Put(buf)
data := readStateInsertData{}
if joinPredicate != "" {
data.JoinPredicate = " AND " + joinPredicate
}
if opts.FavoriteOnly {
data.Join += s.User.ReadStateInsertFavoriteJoin
}
if opts.UntaggedOnly {
data.Join += s.User.ReadStateInsertUntaggedJoin
}
if join != "" {
data.Join += joinPredicate
}
where := []string{}
if !opts.BeforeDate.IsZero() {
where = append(where, fmt.Sprintf("(a.date IS NULL OR a.date < $%d)", len(args)+1))
args = append(args, opts.BeforeDate)
}
if !opts.AfterDate.IsZero() {
where = append(where, fmt.Sprintf("a.date > $%d", len(args)+1))
args = append(args, opts.AfterDate)
}
if opts.BeforeId > 0 {
where = append(where, fmt.Sprintf("a.id < $%d", len(args)+1))
args = append(args, opts.BeforeId)
}
if opts.AfterId > 0 {
where = append(where, fmt.Sprintf("a.id > $%d", len(args)+1))
args = append(args, opts.AfterId)
}
if opts.FavoriteOnly {
where = append(where, "af.article_id IS NOT NULL")
}
if opts.UntaggedOnly {
where = append(where, "uft.feed_id IS NULL")
}
if len(where) > 0 {
data.Where = " WHERE " + strings.Join(where, " AND ")
}
if err := readStateInsertTemplate.Execute(buf, data); err != nil {
u.Err(fmt.Errorf("Error executing read-state-insert template: %v", err))
return
}
sql := buf.String()
logger.Debugf("Read state insert SQL:\n%s\nArgs:%q\n", sql, args)
stmt, err := tx.Preparex(sql)
if err != nil {
u.Err(err)
return
}
defer stmt.Close()
_, err = stmt.Exec(args...)
if err != nil {
u.Err(err)
return
}
}
if err = tx.Commit(); err != nil {
u.Err(err)
}
}
func internalGetArticles(u content.User, dbo *db.DB, logger webfw.Logger, opts data.ArticleQueryOptions, sorting content.ArticleSorting, join, where string, args []interface{}) (ua []content.UserArticle) {
renderData := getArticlesData{}
s := dbo.SQL()
if opts.IncludeScores {
renderData.Columns += ", asco.score"
renderData.Join += s.User.GetArticlesScoreJoin
}
if opts.UntaggedOnly {
renderData.Join += s.User.GetArticlesUntaggedJoin
}
if join != "" {
renderData.Join += " " + join
}
args = append([]interface{}{u.Data().Login}, args...)
whereSlice := []string{}
if opts.UnreadOnly {
whereSlice = append(whereSlice, "au.article_id IS NOT NULL")
} else if opts.ReadOnly {
whereSlice = append(whereSlice, "au.article_id IS NULL")
}
if opts.UntaggedOnly {
whereSlice = append(whereSlice, "uft.feed_id IS NULL")
}
if where != "" {
whereSlice = append(whereSlice, where)
}
if opts.BeforeId > 0 {
whereSlice = append(whereSlice, fmt.Sprintf("a.id < $%d", len(args)+1))
args = append(args, opts.BeforeId)
}
if opts.AfterId > 0 {
whereSlice = append(whereSlice, fmt.Sprintf("a.id > $%d", len(args)+1))
args = append(args, opts.AfterId)
}
if opts.FavoriteOnly {
whereSlice = append(whereSlice, "af.article_id IS NOT NULL")
}
if !opts.BeforeDate.IsZero() {
whereSlice = append(whereSlice, fmt.Sprintf("(a.date IS NULL OR a.date < $%d)", len(args)+1))
args = append(args, opts.BeforeDate)
}
if !opts.AfterDate.IsZero() {
whereSlice = append(whereSlice, fmt.Sprintf("a.date > $%d", len(args)+1))
args = append(args, opts.AfterDate)
}
if len(whereSlice) > 0 {
renderData.Where = "WHERE " + strings.Join(whereSlice, " AND ")
}
sortingField := sorting.Field()
sortingOrder := sorting.Order()
fields := []string{}
if opts.IncludeScores && opts.HighScoredFirst {
field := "asco.score"
if sortingOrder == data.DescendingOrder {
field += " DESC"
}
fields = append(fields, field)
}
if opts.UnreadFirst {
fields = append(fields, "read")
}
switch sortingField {
case data.SortById:
fields = append(fields, "a.id")
case data.SortByDate:
fields = append(fields, "a.date")
}
if len(fields) > 0 {
renderData.Order = " ORDER BY " + strings.Join(fields, ", ")
if sortingOrder == data.DescendingOrder {
renderData.Order += " DESC"
}
}
if opts.Limit > 0 {
renderData.Limit = fmt.Sprintf(" LIMIT $%d OFFSET $%d", len(args)+1, len(args)+2)
args = append(args, opts.Limit, opts.Offset)
}
buf := util.BufferPool.GetBuffer()
defer util.BufferPool.Put(buf)
if err := getArticlesTemplate.Execute(buf, renderData); err != nil {
u.Err(fmt.Errorf("Error executing get-articles template: %v", err))
return
}
sql := buf.String()
var data []data.Article
logger.Debugf("Articles SQL:\n%s\nArgs:%v\n", sql, args)
if err := dbo.Select(&data, sql, args...); err != nil {
u.Err(err)
return
}
ua = make([]content.UserArticle, len(data))
for i := range data {
ua[i] = u.Repo().UserArticle(u)
ua[i].Data(data[i])
}
processors := u.Repo().ArticleProcessors()
if !opts.SkipProcessors && len(processors) > 0 {
for _, p := range processors {
if opts.SkipSessionProcessors {
if _, ok := p.(processor.ProxyHTTP); ok {
continue
}
}
ua = p.ProcessArticles(ua)
}
}
return
}
func articleCount(u content.User, dbo *db.DB, logger webfw.Logger, opts data.ArticleCountOptions, join, where string, args []interface{}) (count int64) {
if u.HasErr() {
return
}
s := dbo.SQL()
var err error
if articleCountTemplate == nil {
articleCountTemplate, err = template.New("article-count-sql").
Parse(s.User.ArticleCountTemplate)
if err != nil {
u.Err(fmt.Errorf("Error generating article-count template: %v", err))
return
}
}
renderData := articleCountData{}
containsUserFeeds := !opts.UnreadOnly && !opts.FavoriteOnly
if containsUserFeeds {
renderData.Join += s.User.ArticleCountUserFeedsJoin
} else {
if opts.UnreadOnly {
renderData.Join += s.User.ArticleCountUnreadJoin
}
if opts.FavoriteOnly {
renderData.Join += s.User.ArticleCountFavoriteJoin
}
}
if opts.UntaggedOnly {
renderData.Join += s.User.ArticleCountUntaggedJoin
}
if join != "" {
renderData.Join += " " + join
}
args = append([]interface{}{u.Data().Login}, args...)
whereSlice := []string{}
if opts.UnreadOnly {
whereSlice = append(whereSlice, "au.article_id IS NOT NULL AND au.user_login = $1")
}
if opts.FavoriteOnly {
whereSlice = append(whereSlice, "af.article_id IS NOT NULL AND af.user_login = $1")
}
if opts.UntaggedOnly {
whereSlice = append(whereSlice, "uft.feed_id IS NULL")
}
if where != "" {
whereSlice = append(whereSlice, where)
}
if opts.BeforeId > 0 {
whereSlice = append(whereSlice, fmt.Sprintf("a.id < $%d", len(args)+1))
args = append(args, opts.BeforeId)
}
if opts.AfterId > 0 {
whereSlice = append(whereSlice, fmt.Sprintf("a.id > $%d", len(args)+1))
args = append(args, opts.AfterId)
}
if !opts.BeforeDate.IsZero() {
whereSlice = append(whereSlice, fmt.Sprintf("(a.date IS NULL OR a.date < $%d)", len(args)+1))
args = append(args, opts.BeforeDate)
}
if !opts.AfterDate.IsZero() {
whereSlice = append(whereSlice, fmt.Sprintf("a.date > $%d", len(args)+1))
args = append(args, opts.AfterDate)
}
if len(whereSlice) > 0 {
renderData.Where = "WHERE " + strings.Join(whereSlice, " AND ")
}
buf := util.BufferPool.GetBuffer()
defer util.BufferPool.Put(buf)
if err := articleCountTemplate.Execute(buf, renderData); err != nil {
u.Err(fmt.Errorf("Error executing article-count template: %v", err))
return
}
sql := buf.String()
logger.Debugf("Article count SQL:\n%s\nArgs:%v\n", sql, args)
if err := dbo.Get(&count, sql, args...); err != nil {
u.Err(err)
return
}
return
}
func getArticles(u content.User, dbo *db.DB, logger webfw.Logger, sorting content.ArticleSorting, columns, join, where, order string, args []interface{}, paging ...int) (ua []content.UserArticle) {
if u.HasErr() {
return
}
sql := dbo.SQL("get_article_columns")
if columns != "" {
sql += ", " + columns
}
sql += dbo.SQL("get_article_tables")
if join != "" {
sql += " " + join
}
sql += dbo.SQL("get_article_joins")
args = append([]interface{}{u.Data().Login}, args...)
if where != "" {
sql += " AND " + where
}
sortingField := sorting.Field()
sortingOrder := sorting.Order()
fields := []string{}
if order != "" {
fields = append(fields, order)
}
switch sortingField {
case data.SortById:
fields = append(fields, "a.id")
case data.SortByDate:
fields = append(fields, "a.date")
}
if len(fields) > 0 {
sql += " ORDER BY "
sql += strings.Join(fields, ",")
if sortingOrder == data.DescendingOrder {
sql += " DESC"
}
}
if len(paging) > 0 {
limit, offset := pagingLimit(paging)
sql += fmt.Sprintf(" LIMIT $%d OFFSET $%d", len(args)+1, len(args)+2)
args = append(args, limit, offset)
}
var data []data.Article
logger.Debugf("Articles SQL:\n%s\nArgs:%q\n", sql, args)
if err := dbo.Select(&data, sql, args...); err != nil {
u.Err(err)
return
}
ua = make([]content.UserArticle, len(data))
for i := range data {
ua[i] = u.Repo().UserArticle(u)
ua[i].Data(data[i])
}
return
}