def get_links_sr_ids(self, sr_ids, sort, time, link_cls = None):
from r2.lib.db import queries
from r2.models import Link
if not link_cls:
link_cls = Link
if not sr_ids:
srs = []
else:
srs = Subreddit._byID(sr_ids, return_dict = False)
if g.use_query_cache:
results = []
for sr in srs:
results.append(queries.get_links(sr, sort, time))
return queries.merge_cached_results(*results)
else:
q = link_cls._query(link_cls.c.sr_id == sr_ids,
sort = queries.db_sort(sort))
if sort == 'toplinks':
q._filter(link_cls.c.top_link == True)
elif sort == 'blessed':
q._filter(link_cls.c.blessed == True)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib.db import queries
from r2.models import Link
from r2.controllers.errors import UserRequiredException
if not c.user_is_loggedin:
raise UserRequiredException
friends = self.get_important_friends(c.user._id)
if not friends:
return []
if g.use_query_cache:
# with the precomputer enabled, this Subreddit only supports
# being sorted by 'new'. it would be nice to have a
# cleaner UI than just blatantly ignoring their sort,
# though
sort = 'new'
time = 'all'
friends = Account._byID(friends, return_dict=False)
crs = [
queries.get_submitted(friend, sort, time) for friend in friends
]
return queries.MergedCachedResults(crs)
else:
q = Link._query(Link.c.author_id == friends,
sort=queries.db_sort(sort),
data=True)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links_sr_ids(self, sr_ids, sort, time, link_cls=None):
from r2.lib.db import queries
from r2.models import Link
if not link_cls:
link_cls = Link
if not sr_ids:
srs = []
else:
srs = Subreddit._byID(sr_ids, return_dict=False)
if g.use_query_cache:
results = []
for sr in srs:
results.append(queries.get_links(sr, sort, time))
return queries.merge_cached_results(*results)
else:
q = link_cls._query(link_cls.c.sr_id == sr_ids,
sort=queries.db_sort(sort))
if sort == 'toplinks':
q._filter(link_cls.c.top_link == True)
elif sort == 'blessed':
q._filter(link_cls.c.blessed == True)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib.db import queries
from r2.models import Link
from r2.controllers.errors import UserRequiredException
if not c.user_is_loggedin:
raise UserRequiredException
friends = self.get_important_friends(c.user._id)
if not friends:
return []
if g.use_query_cache:
# with the precomputer enabled, this Subreddit only supports
# being sorted by 'new'. it would be nice to have a
# cleaner UI than just blatantly ignoring their sort,
# though
sort = "new"
time = "all"
friends = Account._byID(friends, return_dict=False)
crs = [queries.get_submitted(friend, sort, time) for friend in friends]
return queries.MergedCachedResults(crs)
else:
q = Link._query(Link.c.author_id == friends, sort=queries.db_sort(sort), data=True)
if time != "all":
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.models import Link
from r2.lib.db import queries
q = Link._query(sort = queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib import promote
from r2.models import Link
from r2.lib.db import queries
q = Link._query(sort=queries.db_sort(sort), read_cache=True, write_cache=True, cache_time=60, data=True)
if time != "all":
q._filter(queries.db_times[time])
return q
def _sponsored_link_query(status, author_id = None):
q = Link._query(Link.c.sr_id == get_promote_srid(),
Link.c._spam == (True, False),
Link.c._deleted == (True,False),
sort = db_sort('new'))
if status is not None:
q._filter(Link.c.promote_status == status)
if author_id is not None:
q._filter(Link.c.author_id == author_id)
return make_results(q)
def _sponsored_link_query(status, author_id=None):
q = Link._query(Link.c.sr_id == get_promote_srid(),
Link.c._spam == (True, False),
Link.c._deleted == (True, False),
sort=db_sort('new'))
if status is not None:
q._filter(Link.c.promote_status == status)
if author_id is not None:
q._filter(Link.c.author_id == author_id)
return make_results(q)
def get_links(self, sort, time, link_cls=None):
from r2.models import Link
from r2.lib.db import queries
if not link_cls:
link_cls = Link
q = link_cls._query(sort=queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time, link_cls = None):
from r2.models import Link
from r2.lib.db import queries
if not link_cls:
link_cls = Link
q = link_cls._query(sort = queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib import promote
from r2.models import Link
from r2.lib.db import queries
q = Link._query(sort = queries.db_sort(sort),
read_cache = True,
write_cache = True,
cache_time = 60)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib.db import queries
from r2.models import Link
from r2.controllers.errors import UserRequiredException
if not c.user_is_loggedin:
raise UserRequiredException
q = Link._query(Link.c.author_id == c.user.friends, sort=queries.db_sort(sort))
if time != "all":
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib import promote
from r2.models import Link
from r2.lib.db import queries
q = Link._query(Link.c.sr_id > 0,
sort = queries.db_sort(sort),
read_cache = True,
write_cache = True,
cache_time = 60,
data = True,
filter_primary_sort_only=True)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time):
from r2.lib import promote
from r2.models import Link
from r2.lib.db import queries
q = Link._query(Link.c.sr_id > 0,
sort=queries.db_sort(sort),
read_cache=True,
write_cache=True,
cache_time=60,
data=True,
filter_primary_sort_only=True)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links(self, sort, time, link_cls = None):
from r2.lib.db import queries
from r2.models import Link
if not c.user_is_loggedin:
raise UserRequiredException
if not link_cls:
link_cls = Link
q = link_cls._query(self.c.author_id == c.user.friends,
sort = queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def write_all_hot_cache():
from r2.models.link import Link
from r2.lib.db import queries
q = Link._query(
sort=queries.db_sort('hot'),
limit=NUM_LINKS,
)
top_links = resort_links(list(q))
link_ids = [link._fullname for link in top_links]
g.gencache.set(CACHE_KEY, link_ids)
return link_ids
def get_links(self, sort, time, link_cls=None):
from r2.lib.db import queries
from r2.models import Link
if not c.user_is_loggedin:
raise UserRequiredException
if not link_cls:
link_cls = Link
q = link_cls._query(self.c.author_id == c.user.friends,
sort=queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links_sr_ids(self, sr_ids, sort, time):
from r2.lib.db import queries
from r2.models import Link
if not sr_ids:
return []
else:
srs = Subreddit._byID(sr_ids, return_dict=False)
if g.use_query_cache:
results = [queries.get_links(sr, sort, time) for sr in srs]
return queries.merge_results(*results)
else:
q = Link._query(Link.c.sr_id == sr_ids, sort=queries.db_sort(sort))
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links_sr_ids(self, sr_ids, sort, time):
from r2.lib.db import queries
from r2.models import Link
if not sr_ids:
return []
else:
srs = Subreddit._byID(sr_ids, data=True, return_dict=False)
if g.use_query_cache:
results = [queries.get_links(sr, sort, time) for sr in srs]
return queries.merge_results(*results)
else:
q = Link._query(Link.c.sr_id == sr_ids, sort=queries.db_sort(sort), data=True)
if time != "all":
q._filter(queries.db_times[time])
return q
def get_all_query(sort, time):
""" Return a Query for r/all links sorted by anything other than Hot, which
has special treatment."""
from r2.models import Link
from r2.lib.db import queries
q = Link._query(
sort=queries.db_sort(sort),
read_cache=True,
write_cache=True,
cache_time=60,
data=True,
filter_primary_sort_only=True,
)
if time != 'all':
q._filter(queries.db_times[time])
return q
def get_links_sr_ids(self, sr_ids, sort, time):
from r2.lib.db import queries
from r2.models import Link
from r2.lib.normalized_hot import expand_children
if not sr_ids:
return []
else:
srs = Subsciteit._byID(sr_ids, data=True, return_dict = False)
if g.use_query_cache:
srs = expand_children(srs)
results = [queries.get_links(sr, sort, time,no_children=True)
for sr in srs]
return queries.merge_results(*results)
else:
sr_ids = expand_children(sr_ids,byID=True)
q = Link._query(Link.c.sr_id == sr_ids,
sort = queries.db_sort(sort), data=True)
if time != 'all':
q._filter(queries.db_times[time])
return q
