func ttRssSetupSorting(req ttRssRequest, sorting content.ArticleSorting) { switch req.OrderBy { case "date_reverse": sorting.SortingByDate() sorting.Order(data.AscendingOrder) default: sorting.SortingByDate() sorting.Order(data.DescendingOrder) } }
func getFeedArticles(user content.User, sp content.SearchProvider, id string, minId, maxId data.ArticleId, limit int, offset int, olderFirst bool, unreadOnly bool) (resp responseError) { resp = newResponse() if limit > 200 { limit = 200 } var as content.ArticleSorting var ar content.ArticleRepo var ua []content.UserArticle o := data.ArticleQueryOptions{Limit: limit, Offset: offset, UnreadOnly: unreadOnly, UnreadFirst: true} if maxId > 0 { o.AfterId = maxId resp.val["MaxId"] = maxId } if id == "favorite" { o.FavoriteOnly = true ar = user as = user } else if id == "all" { ar = user as = user } else if strings.HasPrefix(id, "popular:") { o.IncludeScores = true o.HighScoredFirst = true o.BeforeDate = time.Now() o.AfterDate = time.Now().AddDate(0, 0, -5) if id == "popular:all" { ar = user as = user } else if strings.HasPrefix(id, "popular:tag:") { tag := user.Repo().Tag(user) tag.Data(data.Tag{Value: data.TagValue(id[12:])}) ar = tag as = tag } else { var f content.UserFeed var feedId int64 feedId, resp.err = strconv.ParseInt(id[8:], 10, 64) if resp.err != nil { resp.err = errors.New("Unknown feed id " + id) return } if f = user.FeedById(data.FeedId(feedId)); f.HasErr() { /* TODO: non-fatal error */ resp.err = f.Err() return } ar = f as = f } } else if strings.HasPrefix(id, "search:") && sp != nil { var query string id = id[7:] parts := strings.Split(id, ":") if parts[0] == "tag" { id = strings.Join(parts[:2], ":") query = strings.Join(parts[2:], ":") } else { id = strings.Join(parts[:1], ":") query = strings.Join(parts[1:], ":") } sp.SortingByDate() if olderFirst { sp.Order(data.AscendingOrder) } else { sp.Order(data.DescendingOrder) } ua, resp.err = performSearch(user, sp, query, id, limit, offset) } else if strings.HasPrefix(id, "tag:") { tag := user.Repo().Tag(user) tag.Data(data.Tag{Value: data.TagValue(id[4:])}) as = tag ar = tag } else { var f content.UserFeed var feedId int64 feedId, resp.err = strconv.ParseInt(id, 10, 64) if resp.err != nil { resp.err = errors.New("Unknown feed id " + id) return } if f = user.FeedById(data.FeedId(feedId)); f.HasErr() { /* TODO: non-fatal error */ resp.err = f.Err() return } as = f ar = f } if as != nil { as.SortingByDate() if olderFirst { as.Order(data.AscendingOrder) } else { as.Order(data.DescendingOrder) } } if ar != nil { ua = ar.Articles(o) if minId > 0 { qo := data.ArticleIdQueryOptions{BeforeId: maxId + 1, AfterId: minId - 1} qo.UnreadOnly = true resp.val["UnreadIds"] = ar.Ids(qo) qo.UnreadOnly = false qo.FavoriteOnly = true resp.val["FavoriteIds"] = ar.Ids(qo) resp.val["MinId"] = minId } if e, ok := ar.(content.Error); ok && e.HasErr() { resp.err = e.Err() } } resp.val["Articles"] = ua resp.val["Limit"] = limit resp.val["Offset"] = offset return }
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 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 }