def get_images(self, page=1, category='all', order_by='created_at', limit=None):
if limit:
images = orm.select(rv for rv in m.Image if
rv.user_id == self.id).order_by(lambda rv:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
return images[:limit]
if category == 'all':
images = orm.select(rv for rv in m.Image if rv.user_id == self.id)
else:
images = orm.select(rv for rv in m.Image if rv.user_id == self.id and rv.role == category)
if order_by == 'created_at':
images = images.order_by(lambda rv: orm.desc(rv.created_at))
elif order_by == 'up_count':
images = images.order_by(lambda rv: orm.desc(rv.up_count))
elif order_by == 'thank_count':
images = images.order_by(lambda rv: orm.desc(rv.thank_count))
elif order_by == 'smart':
images = images.order_by(lambda rv:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count - rv.down_count) * 5 +
rv.created_at / 4))
if page:
return images[(page - 1) * config.paged: page * config.paged]
else:
return images
def add(self, key, value):
# value must be a list
elem = select(
e for e in self.Store
if e.key == key).order_by(lambda o: desc(o.create_at)).first()
if elem:
value_db = copy(elem.value)
if isinstance(value_db, list):
if isinstance(value, str):
vs = [value] if value not in value_db else []
else:
vs = [v for v in value if v not in value_db]
value_db.extend(vs)
elem.value = value_db
elem.update_at = datetime.utcnow()
commit()
if key not in self.ids:
self.ids.add(key)
else:
if isinstance(value, str):
self.Store(key=key, value=[value])
else:
self.Store(key=key, value=value)
if key not in self.ids:
self.ids.add(key)
elem = select(
e for e in self.Store
if e.key == key).order_by(lambda o: desc(o.create_at)).first()
return {
'key': elem.key,
'value': elem.value,
'create_at': elem.create_at.strftime("%Y-%m-%d %H:%M:%S"),
'update_at': elem.update_at.strftime("%Y-%m-%d %H:%M:%S"),
}
def album_list():
ltype = request.values['type']
size, offset = map(request.values.get, [ 'size', 'offset' ])
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = select(t.folder for t in Track)
if ltype == 'random':
return request.formatter('albumList', dict(
album = [ a.as_subsonic_child(request.user) for a in query.without_distinct().random(size) ]
))
elif ltype == 'newest':
query = query.order_by(desc(Folder.created))
elif ltype == 'highest':
query = query.order_by(lambda f: desc(avg(f.ratings.rating)))
elif ltype == 'frequent':
query = query.order_by(lambda f: desc(avg(f.tracks.play_count)))
elif ltype == 'recent':
query = select(t.folder for t in Track if max(t.folder.tracks.last_play) is not None).order_by(lambda f: desc(max(f.tracks.last_play)))
elif ltype == 'starred':
query = select(s.starred for s in StarredFolder if s.user.id == request.user.id and count(s.starred.tracks) > 0)
elif ltype == 'alphabeticalByName':
query = query.order_by(Folder.name)
elif ltype == 'alphabeticalByArtist':
query = query.order_by(lambda f: f.parent.name + f.name)
else:
raise GenericError('Unknown search type')
return request.formatter('albumList', dict(
album = [ f.as_subsonic_child(request.user) for f in query.limit(size, offset) ]
))
def get_entries_query(cls,
sort_by=None,
sort_asc=True,
query_filter=None):
"""
Get some metadata entries. Optionally sort the results by a specific field, or filter the channels based
on a keyword/whether you are subscribed to it.
:return: A tuple. The first entry is a list of ChannelMetadata entries. The second entry indicates
the total number of results, regardless the passed first/last parameter.
"""
# Warning! For Pony magic to work, iteration variable name (e.g. 'g') should be the same everywhere!
# Filter the results on a keyword or some keywords
pony_query = cls.search_keyword(
query_filter, lim=1000) if query_filter else select(
g for g in cls)
# Sort the query
sort_expression = None
if sort_by:
if sort_by == "HEALTH":
pony_query = pony_query.sort_by("(g.health.seeders, g.health.leechers)") if sort_asc else \
pony_query.sort_by("(desc(g.health.seeders), desc(g.health.leechers))")
else:
sort_expression = "g." + sort_by
sort_expression = sort_expression if sort_asc else desc(
sort_expression)
pony_query = pony_query.sort_by(sort_expression)
# Workaround to always show legacy entries last
pony_query = pony_query.order_by(lambda g: (desc(g.status != LEGACY_ENTRY), sort_expression)) \
if sort_expression else pony_query.order_by(lambda g: desc(g.status != LEGACY_ENTRY))
return pony_query
def torrents_to_check(self):
"""
Two categories of torrents are selected (popular & old). From the pool of selected torrents, a certain
number of them are submitted for health check. The torrents that are within the freshness window are
excluded from the selection considering the health information is still fresh.
1. Popular torrents (50%)
The indicator for popularity here is considered as the seeder count with direct proportionality
assuming more seeders -> more popular. There could be other indicators to be introduced later.
2. Old torrents (50%)
By old torrents, we refer to those checked quite farther in the past, sorted by the last_check value.
"""
last_fresh_time = time.time() - HEALTH_FRESHNESS_SECONDS
popular_torrents = list(
self.tribler_session.mds.TorrentState.select(
lambda g: g.last_check < last_fresh_time).order_by(
lambda g: (desc(g.seeders), g.last_check)).limit(
TORRENT_SELECTION_POOL_SIZE))
old_torrents = list(
self.tribler_session.mds.TorrentState.select(
lambda g: g.last_check < last_fresh_time).order_by(
lambda g: (g.last_check, desc(g.seeders))).limit(
TORRENT_SELECTION_POOL_SIZE))
selected_torrents = popular_torrents + old_torrents
selected_torrents = random.sample(
selected_torrents,
min(TORRENT_SELECTION_POOL_SIZE, len(selected_torrents)))
return selected_torrents
def get_images(self, page=1, category='all', order_by='created_at', limit=None, desc=True):
if category == 'all':
images = m.Image.select(lambda rv: rv.album_id == self.id)
else:
if category == 'hot':
images = m.Image.select(lambda rv: rv.album_id == self.id)
limit = 10
order_by = 'smart'
elif category == 'author':
images = orm.select(rv for rv in m.Image if
rv.topic_id == self.id and rv.user_id == self.user_id)
else:
images = orm.select(rv for rv in m.Image if rv.album_id == self.id and rv.role == category)
if order_by == 'smart':
images = images.order_by(lambda rv: orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
else:
if desc:
images = images.order_by(lambda rv: orm.desc(rv.created_at))
else:
images = images.order_by(lambda rv: rv.created_at)
if limit:
return images[:limit]
elif page:
return images[(page - 1) * config.paged: page * config.paged]
else:
return images
def remove(self, key, value):
# value must be a list
elem = select(
e for e in self.Store
if e.key == key).order_by(lambda o: desc(o.create_at)).first()
if elem:
value_db = copy(elem.value)
if isinstance(value_db, list):
if isinstance(value, str):
vs = [value] if value in value_db else []
else:
vs = [v for v in value if v in value_db]
for vv in vs:
value_db.remove(vv)
elem.value = value_db
elem.update_at = datetime.utcnow()
commit()
elem = select(
e for e in self.Store
if e.key == key).order_by(lambda o: desc(o.create_at)).first()
return {
'key': elem.key,
'value': elem.value,
'create_at': elem.create_at.strftime("%Y-%m-%d %H:%M:%S"),
'update_at': elem.update_at.strftime("%Y-%m-%d %H:%M:%S"),
}
def _last(self, **spec):
""" Get the latest entry in this category, optionally including subcategories """
for record in self._entries(spec).order_by(
orm.desc(model.Entry.local_date),
orm.desc(model.Entry.id))[:1]:
return entry.Entry(record)
return None
def get_data():
node = request.args.getlist('node', None)
limit = request.args.get('limit', 100)
assert isinstance(limit, int) or str.isnumeric(
limit) # TODO: specify error message, on error # like int("abc")
limit = int(limit)
if node:
for i in node:
assert str.isnumeric(i) # TODO: specify error message
# end for
node_values = orm.select(m for m in DBInitMessage
if m.node in list(node)).order_by(
orm.desc(DBInitMessage.date)).limit(limit)
else:
node_values = orm.select(m for m in DBInitMessage).order_by(
orm.desc(DBInitMessage.date)).limit(limit)
if not node_values:
return jsonify({}, allow_all_origin=True)
# end if
data = {}
for msg in node_values:
assert isinstance(msg, DBInitMessage)
assert isinstance(msg.date, datetime)
if str(msg.node) not in data:
data[str(msg.node)] = dict()
# end if
data[str(msg.node)][msg.date.timestamp()] = msg.value
# end for
return jsonify(data, allow_all_origin=True)
def album_list():
ltype = request.values["type"]
size, offset = map(request.values.get, ("size", "offset"))
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = select(t.folder for t in Track)
if ltype == "random":
return request.formatter(
"albumList",
{
"album": [
a.as_subsonic_child(request.user)
for a in distinct(query.random(size))
]
},
)
elif ltype == "newest":
query = query.sort_by(desc(Folder.created)).distinct()
elif ltype == "highest":
query = query.sort_by(lambda f: desc(avg(f.ratings.rating)))
elif ltype == "frequent":
query = query.sort_by(lambda f: desc(avg(f.tracks.play_count)))
elif ltype == "recent":
query = select(t.folder for t in Track
if max(t.folder.tracks.last_play) is not None).sort_by(
lambda f: desc(max(f.tracks.last_play)))
elif ltype == "starred":
query = select(
s.starred for s in StarredFolder
if s.user.id == request.user.id and count(s.starred.tracks) > 0)
elif ltype == "alphabeticalByName":
query = query.sort_by(Folder.name).distinct()
elif ltype == "alphabeticalByArtist":
query = query.sort_by(lambda f: f.parent.name + f.name)
elif ltype == "byYear":
startyear = int(request.values["fromYear"])
endyear = int(request.values["toYear"])
query = query.where(lambda t: between(t.year, min(startyear, endyear),
max(startyear, endyear)))
if endyear < startyear:
query = query.sort_by(lambda f: desc(min(f.tracks.year)))
else:
query = query.sort_by(lambda f: min(f.tracks.year))
elif ltype == "byGenre":
genre = request.values["genre"]
query = query.where(lambda t: t.genre == genre)
else:
raise GenericError("Unknown search type")
return request.formatter(
"albumList",
{
"album": [
f.as_subsonic_child(request.user)
for f in query.limit(size, offset)
]
},
)
def get_users(page=1, category='all', limit=None):
if category == 'all':
users = orm.select(rv for rv in User).order_by(lambda:
orm.desc(rv.created_at))
elif category == 'hot':
users = mc.get('hot_users')
if not users:
if not limit:
limit = 8
users = orm.select(rv for rv in User).order_by(lambda:
orm.desc(rv.thank_count * 4 +
rv.up_count * 3 +
rv.topic_count * 2 +
rv.reply_count))[:limit]
mc.set('hot_users', list(users), 60 * 60 * 12)
elif category == 'new':
users = orm.select(rv for rv in User).order_by(lambda: orm.desc(rv.created_at))
else:
return []
if limit:
return users[:limit]
if page:
return users[(page - 1) * config.user_paged: page *
config.user_paged]
else:
return users
def get_entries_query(cls, sort_by=None, sort_asc=True, query_filter=None):
"""
Get some metadata entries. Optionally sort the results by a specific field, or filter the channels based
on a keyword/whether you are subscribed to it.
:return: A tuple. The first entry is a list of ChannelMetadata entries. The second entry indicates
the total number of results, regardless the passed first/last parameter.
"""
# Warning! For Pony magic to work, iteration variable name (e.g. 'g') should be the same everywhere!
# Filter the results on a keyword or some keywords
pony_query = cls.search_keyword(query_filter, lim=1000) if query_filter else select(g for g in cls)
# Sort the query
sort_expression = None
if sort_by:
if sort_by == "HEALTH":
pony_query = pony_query.sort_by("(g.health.seeders, g.health.leechers)") if sort_asc else \
pony_query.sort_by("(desc(g.health.seeders), desc(g.health.leechers))")
else:
sort_expression = "g." + sort_by
sort_expression = sort_expression if sort_asc else desc(sort_expression)
pony_query = pony_query.sort_by(sort_expression)
# Workaround to always show legacy entries last
pony_query = pony_query.order_by(lambda g: (desc(g.status != LEGACY_ENTRY), sort_expression)) \
if sort_expression else pony_query.order_by(lambda g: desc(g.status != LEGACY_ENTRY))
return pony_query
def get_images(self, page=1, category='all', order_by='created_at', limit=None):
if limit:
images = orm.select(rv for rv in m.Image if
rv.user_id == self.id).order_by(lambda rv:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
return images[:limit]
if category == 'all':
images = orm.select(rv for rv in m.Image if rv.user_id == self.id)
else:
images = orm.select(rv for rv in m.Image if rv.user_id == self.id and rv.role == category)
if order_by == 'created_at':
images = images.order_by(lambda rv: orm.desc(rv.created_at))
elif order_by == 'up_count':
images = images.order_by(lambda rv: orm.desc(rv.up_count))
elif order_by == 'thank_count':
images = images.order_by(lambda rv: orm.desc(rv.thank_count))
elif order_by == 'smart':
images = images.order_by(lambda rv:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count - rv.down_count) * 5 +
rv.created_at / 4))
if page:
return images[(page - 1) * config.paged: page * config.paged]
else:
return images
def read(page=None, order="date"):
post_query = Post.select()
post_count = count(post_query)
if order == "date":
post_query = post_query.order_by(desc(Post.date_created))
if "thumbs" in order:
up = "up" in order
post_query = post_query.order_by(
lambda p: desc(count(t for t in p.thumbs if t.up == up)))
if page:
posts = list(post_query.page(page))
else:
posts = list(post_query)
posts_json = {
"count":
post_count,
"posts": [{
"id": p.id,
"content": p.content,
"up": len([t for t in p.thumbs if t.up]),
"down": len([t for t in p.thumbs if not t.up]),
"date_created": p.date_created.timestamp()
} for p in posts]
}
return posts_json
def get_albums(self, page=1, category='all', order_by='created_at', limit=None):
if limit:
albums = orm.select(rv for rv in collipa.models.Album if
rv.user_id == self.id).order_by(lambda:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
return albums[:limit]
if category == 'all':
albums = orm.select(rv for rv in collipa.models.Album if rv.user_id == self.id)
else:
albums = orm.select(rv for rv in collipa.models.Album if rv.user_id == self.id and rv.role == category)
if order_by == 'created_at':
albums = albums.order_by(lambda: orm.desc(rv.created_at))
elif order_by == 'up_count':
albums = albums.order_by(lambda: orm.desc(rv.up_count))
elif order_by == 'thank_count':
albums = albums.order_by(lambda: orm.desc(rv.thank_count))
elif order_by == 'smart':
albums = albums.order_by(lambda:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count - rv.down_count) * 5))
if page:
return albums[(page - 1) * config.paged: page * config.paged]
else:
return albums
def album_list_id3():
ltype = request.values['type']
size, offset = map(request.values.get, [ 'size', 'offset' ])
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == 'random':
return request.formatter('albumList2', dict(
album = [ a.as_subsonic_album(request.user) for a in query.random(size) ]
))
elif ltype == 'newest':
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == 'frequent':
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == 'recent':
query = Album.select(lambda a: max(a.tracks.last_play) is not None).order_by(lambda a: desc(max(a.tracks.last_play)))
elif ltype == 'starred':
query = select(s.starred for s in StarredAlbum if s.user.id == request.user.id)
elif ltype == 'alphabeticalByName':
query = query.order_by(Album.name)
elif ltype == 'alphabeticalByArtist':
query = query.order_by(lambda a: a.artist.name + a.name)
else:
raise GenericError('Unknown search type')
return request.formatter('albumList2', dict(
album = [ f.as_subsonic_album(request.user) for f in query.limit(size, offset) ]
))
def album_list_id3():
ltype = request.values["type"]
size, offset = map(request.values.get, ("size", "offset"))
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == "random":
return request.formatter(
"albumList2",
{
"album": [
a.as_subsonic_album(request.user)
for a in query.random(size)
]
},
)
elif ltype == "newest":
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == "frequent":
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == "recent":
query = Album.select(
lambda a: max(a.tracks.last_play) is not None).order_by(
lambda a: desc(max(a.tracks.last_play)))
elif ltype == "starred":
query = select(s.starred for s in StarredAlbum
if s.user.id == request.user.id)
elif ltype == "alphabeticalByName":
query = query.order_by(Album.name)
elif ltype == "alphabeticalByArtist":
query = query.order_by(lambda a: a.artist.name + a.name)
elif ltype == "byYear":
startyear = int(request.values["fromYear"])
endyear = int(request.values["toYear"])
query = query.where(lambda a: between(min(
a.tracks.year), min(startyear, endyear), max(startyear, endyear)))
if endyear < startyear:
query = query.order_by(lambda a: desc(min(a.tracks.year)))
else:
query = query.order_by(lambda a: min(a.tracks.year))
elif ltype == "byGenre":
genre = request.values["genre"]
query = query.where(lambda a: genre in a.tracks.genre)
else:
raise GenericError("Unknown search type")
return request.formatter(
"albumList2",
{
"album": [
f.as_subsonic_album(request.user)
for f in query.limit(size, offset)
]
},
)
def get_message_boxes(self, page=1, category='all'):
if category == 'all':
message_boxes = (collipa.models.MessageBox.select(
lambda rv: rv.sender_id == self.id).order_by(
lambda: orm.desc(rv.updated_at)))
elif category == 'unread':
message_boxes = (collipa.models.MessageBox.select(
lambda rv: rv.sender_id == self.id and rv.status == 0).
order_by(lambda: orm.desc(rv.updated_at)))
else:
return []
return message_boxes[(page - 1) * config.paged:page * config.paged]
def _previous(**kwargs):
""" Get the previous item in any particular category """
spec = self._pagination_default_spec(kwargs)
spec.update(kwargs)
query = queries.build_query(spec)
query = queries.where_before_entry(query, self._record)
for record in query.order_by(orm.desc(model.Entry.local_date),
orm.desc(model.Entry.id))[:1]:
return Entry(record)
return None
def get_created_by_user(self, id_):
"""Obtiene la lista de entidades de esta clase que han sido creadas
por el usuario cuyo id se suministra. No funcionará correctamente
si la clase no tiene campo 'creador'"""
quien = model.Profesor.get(id=id_)
if quien.role == "admin":
return self.clase.select().order_by(
desc(self.clase.fecha_modificacion))
creados = (self.clase.select(lambda p: p.creador == quien).order_by(
desc(self.clase.fecha_modificacion)))
print(creados)
return creados
def show_home():
"""
Homepage of the blog
"""
last = Articles.select().order_by(desc(Articles.timestamp)).first()
lasts_art = Articles.select().order_by(desc(Articles.timestamp))[1:4]
list_of_dict = []
for item in lasts_art:
list_of_dict.append(fill_informations(item))
return render_template('blog/home.html',
last=last,
lasts=list_of_dict,
socials=socials)
def get_nodes(page=1, category='all', limit=None):
if category == 'all':
nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.created_at))
elif category == 'hot':
nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.topic_count))
elif category == 'new':
nodes = orm.select(rv for rv in Node).order_by(lambda rv: orm.desc(rv.created_at))
if limit:
return nodes[:limit]
if page:
return nodes[(page - 1) * config.node_paged: page * config.node_paged]
else:
return nodes
def get_message_boxes(self, page=1, category='all'):
if category == 'all':
message_boxes = (collipa.models.MessageBox
.select(lambda rv: rv.sender_id == self.id)
.order_by(lambda: orm.desc(rv.updated_at)))
elif category == 'unread':
message_boxes = (collipa.models.MessageBox
.select(lambda rv: rv.sender_id == self.id and rv.status == 0)
.order_by(lambda: orm.desc(rv.updated_at)))
else:
return []
return message_boxes[(page - 1) * config.paged: page *
config.paged]
def most_integral():
"""
各小组晋级的前两名，排名优先级：积分、净胜球、球队名)
"""
_data = []
for g in GROUPS:
res = orm.select(x for x in TeamDetails if x.t_group == g).order_by(
orm.desc(TeamDetails.t_integral),
orm.desc(TeamDetails.t_goal_difference),
orm.desc(TeamDetails.t_team),
)
lst = [(r.t_team, r.t_integral) for i, r in enumerate(res) if i < 2]
_data.append({g: lst})
return _data
def get_timeline(self, page=1, from_id=None, count=config.paged):
user_ids = self.followed_user_ids[:] or [0]
user_ids.append(self.id)
if not from_id:
tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.user_id in user_ids)
.order_by(lambda: orm.desc(rv.created_at))
[(page - 1) * config.paged: page * config.paged])
return tweets
all_ids_q = orm.select(rv.id for rv in collipa.models.Tweet if
rv.user_id in user_ids).order_by(lambda: orm.desc(rv.created_at))
tweet_ids = collect_items_from_query(all_ids_q, from_id, count)
return orm.select(rv for rv in collipa.models.Tweet if rv.id in tweet_ids)[:][::-1]
def get_topics(self, page=1, category='all', order_by='created_at'):
if category == 'all':
topics = orm.select(rv for rv in collipa.models.Topic
if rv.node_id == self.id)
order_by = 'last_reply_date'
else:
if category == 'hot':
topics = mc.get('node_%s_hot_topics' % self.id)
if not topics:
now = int(time.time())
ago = now - 60 * 60 * 24
topics = orm.select(
rv for rv in collipa.models.Topic
if rv.node_id == self.id and rv.created_at > ago)
topics = topics.order_by(lambda: orm.desc(
(rv.collect_count + rv.thank_count - rv.report_count
) * 10 + (rv.up_count - rv.down_count
) * 5 + rv.reply_count * 3))
mc.set('node_%s_hot_topics' % self.id, list(topics),
60 * 60 * 3)
order_by = 'none'
elif category == 'latest':
topics = orm.select(rv for rv in collipa.models.Topic
if rv.node_id == self.id)
elif category == 'desert':
topics = orm.select(
rv for rv in collipa.models.Topic
if rv.node_id == self.id and rv.reply_count == 0)
else:
topics = orm.select(
rv for rv in collipa.models.Topic
if rv.node_id == self.id and rv.role == category)
order_by = 'last_reply_date'
if order_by == 'last_reply_date':
topics = topics.order_by(lambda: orm.desc(rv.last_reply_date))
elif order_by == 'created_at':
topics = topics.order_by(lambda: orm.desc(rv.created_at))
elif order_by == 'active':
topics = topics.order_by(lambda: orm.desc(rv.active))
elif order_by == 'smart':
topics = topics.order_by(lambda: orm.desc(
(rv.collect_count + rv.thank_count - rv.report_count) * 10 +
(rv.up_count - rv.down_count) * 5 + rv.reply_count * 3))
if page:
return topics[(page - 1) * config.paged:page * config.paged]
else:
return topics
def get_topics(self, page=1, category='all', order_by='created_at'):
if category == 'all':
topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id)
order_by = 'last_reply_date'
else:
if category == 'hot':
topics = mc.get('node_%s_hot_topics' % self.id)
if not topics:
now = int(time.time())
ago = now - 60 * 60 * 24
topics = orm.select(rv for rv in m.Topic if
rv.node_id == self.id and
rv.created_at > ago)
topics = topics.order_by(lambda rv: orm.desc((rv.collect_count +
rv.thank_count - rv.report_count) * 10 +
(rv.up_count - rv.down_count) * 5 +
rv.reply_count * 3))
mc.set('node_%s_hot_topics' % self.id, list(topics),
60 * 60 * 3)
order_by = 'none'
elif category == 'latest':
topics = orm.select(rv for rv in m.Topic if rv.node_id == self.id)
elif category == 'desert':
topics = orm.select(rv for rv in m.Topic if
rv.node_id == self.id and rv.reply_count == 0)
else:
topics = orm.select(rv for rv in m.Topic if
rv.node_id == self.id and rv.role == category)
order_by = 'last_reply_date'
if order_by == 'last_reply_date':
topics = topics.order_by(lambda rv: orm.desc(rv.last_reply_date))
elif order_by == 'created_at':
topics = topics.order_by(lambda rv: orm.desc(rv.created_at))
elif order_by == 'active':
topics = topics.order_by(lambda rv: orm.desc(rv.active))
elif order_by == 'smart':
topics = topics.order_by(lambda rv: orm.desc((rv.collect_count +
rv.thank_count -
rv.report_count) * 10 +
(rv.up_count -
rv.down_count) * 5 +
rv.reply_count * 3))
if page:
return topics[(page - 1) * config.paged: page * config.paged]
else:
return topics
def GetNotes(code, text=u'', creation=False):
if code is None and creation:
return select(note for note in Note
if text in note.text).order_by(desc(Note.id))
elif code is None:
return select(note for note in Note if text in note.text).order_by(
Note.volume, Note.page)
elif creation:
return select(note for note in Note
if note.code == code and text in note.text).order_by(
desc(Note.id))
else:
return select(note for note in Note
if note.code == code and text in note.text).order_by(
Note.volume, Note.page)
def verify(self, reprocess, action, mute=False):
"""Verify roos until we have one last good roo"""
with db_session:
offset = 0
good = False
while not good:
q = select(s for s in Switcharoo).order_by(
desc(Switcharoo.time)).limit(10, offset)
if len(q) == 0:
good = True
break
for roo in q:
self._link_reddit(roo)
# Maybe use check_errors here instead now?
tracker = reprocess(self.reddit,
roo,
self,
action,
mute=mute,
verbose=False)
if tracker:
if not tracker.has_bad_issues():
good = True
break
offset += 10
def last_good(self, before_roo=None, offset=0, user=None, all=False):
time = before_roo.time if before_roo else datetime.now()
roo = None
with db_session:
q = select(
s for s in Switcharoo
if True not in s.issues.bad and s.link_post and s.time < time)
# SQLite, I love you but why
if self.db_type == "sqlite" and before_roo:
q = q.filter(lambda x: x.id != before_roo.id)
if user:
q = q.filter(lambda x: x.user == user)
q = q.order_by(desc(Switcharoo.time)).limit(limit=1, offset=offset)
if q:
if all:
roo = list(q)
else:
roo = q[0]
if roo:
if all:
for i in roo:
self._link_reddit(i)
else:
self._link_reddit(roo)
return roo
def category(category_name):
with orm.db_session:
return [
mappers.log(l)
for l in models.CultureLog.select(lambda l: l.category.lower(
) == category_name).sort_by(orm.desc(models.CultureLog.event_date))
]
def _query_recents(self, annee):
query = (
select(p for p in Page if p.activite.matiere.groupe.annee.id == annee)
.order_by(desc(Page.modified))
.limit(50)
) # pragma: no cover_all
return query
def get_articles_in_range(min, max):
lasts_art = Articles.select().order_by(desc(
Articles.timestamp))[min:max]
list_of_dict = []
for item in lasts_art:
list_of_dict.append(fill_informations(item))
return list_of_dict
def get_last_id_date(cls):
try:
date = TelegaMessaga.select().order_by(desc(
TelegaMessaga.date))[:1][0]
except Exception:
date = datetime(2007, 12, 6)
return date
def jobsearch():
form = SearchForm(request.form)
with orm.db_session:
prevmaps = orm.select(c.departure
for c in Direction).prefetch(Airport)[:]
logs = Log.select(lambda p: p.country != 'AIR').order_by(
orm.desc(Log.id))[:]
if request.method == 'GET':
keyword = request.args.get('k', '')
country = request.args.get('c', '')
if keyword == '':
return renderform(form, logs, prevmaps)
else:
return renderjobs(kw=keyword, country=country)
else:
if form.validate_on_submit():
keyword = form.keyword.data
country = form.country.data
#if keyword==logs[0].keyword and logs[0].dt+timedelta(hours=1)>datetime.now():
if keyword == logs[0].keyword and logs[0].dt + timedelta(
seconds=1) > datetime.now():
return renderjobs(kw=keyword, country=country)
else:
return renderjobs(kw=keyword, country=country, isrefresh=True)
else:
return renderform(form, logs, prevmaps)
def get_cell_history(token: str,
cell_id: int,
res: Response,
with_closed: bool = False):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
l = [
x.to_dict() for x in select(
t for t in Lease if t.is_returned in (with_closed, False) and
t.cell_id.id == cell_id).order_by(lambda y: desc(y.start_time))[:]
]
history = []
for lease in l:
curr = lease.copy()
try:
u = User[curr["user_id"]]
curr["user_name"] = u.first_name
curr["user_surname"] = u.last_name
curr["user_email"] = u.email
except RowNotFound:
curr["user_name"], curr["user_surname"], curr["user_email"] = (
None,
None,
None,
)
history.append(curr)
return history
def get_replies(self, page=1, category='all', order_by='created_at', limit=None):
if category == 'all':
replies = collipa.models.Reply.select(lambda rv: rv.topic_id == self.id)
else:
if category == 'hot':
replies = collipa.models.Reply.select(lambda rv: rv.topic_id == self.id)
limit = 10
order_by = 'smart'
elif category == 'author':
replies = orm.select(rv for rv in collipa.models.Reply if rv.topic_id == self.id and rv.user_id == self.user_id)
else:
replies = orm.select(rv for rv in collipa.models.Reply if rv.topic_id == self.id and rv.role == category)
if order_by == 'smart':
replies = replies.order_by(lambda: orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
else:
replies = replies.order_by(lambda: rv.created_at)
if limit:
return replies[:limit]
elif page:
return replies[(page - 1) * config.reply_paged: page * config.reply_paged]
else:
return replies
def index(self):
'''Get all people, ordered by creation date.'''
all_people = orm.select(p for p in Person).order_by(
orm.desc(Person.created))[:]
data = PersonSerializer(all_people, many=True,
exclude=('created', )).data
return jsonify({"people": data})
def datos_del_año(año):
# Nombres más populares de ese año
# Filtramos por prefijo
filtrado = orm.select(n for n in Dato if n.año == año).order_by(
orm.desc(Dato.contador)
)[:50]
return filtrado
def get_followers(self, page=1):
follower_ids = orm.select(rv.who_id for rv in m.Follow if
rv.whom_id == self.id).order_by(lambda rv: orm.desc(rv)) or [0]
followers = orm.select(rv for rv in User if rv.id in follower_ids)
if page:
return followers[(page - 1) * config.user_paged: page * config.user_paged]
else:
return followers
def answer():
page = request.args.get('page', 1, int)
answers_query = select(a for a in Answer).order_by(desc(Answer.vote_up))
answers = answers_query.page(page, pagesize=LIMIT)
pagination = get_pagination(answers_query.count(), LIMIT, page)
return render_template('answer/index.html', answers=answers, pagination=pagination)
def get_notifications(self, page=1, category='all'):
if category == 'all':
notifications = m.Notification.select(lambda rv:
rv.receiver_id == self.id)
elif category == 'unread':
notifications = m.Notification.select(lambda rv:
rv.receiver_id == self.id and rv.status == 0)
notifications = notifications.order_by(lambda rv: orm.desc(rv.updated_at))
return notifications[(page - 1) * config.paged: page * config.paged]
def get_followings(self, page=1):
following_ids = (orm.select(rv.whom_id for rv in collipa.models.Follow
if rv.who_id == self.id and rv.whom_id)
.order_by(lambda: orm.desc(rv.created_at)) or [0])
followings = orm.select(rv for rv in User if rv.id in following_ids)
if page:
return followings[(page - 1) * config.user_paged: page * config.user_paged]
else:
return followings
def question():
page = request.args.get('page', 1, int)
questions_query = select(a for a in Question).order_by(desc(Question.answer_count))
questions = questions_query.page(page, pagesize=LIMIT)
pagination = get_pagination(questions_query.count(), LIMIT, page)
return render_template('question/index.html', questions=questions, pagination=pagination)
def collection():
page = request.args.get('page', 1, int)
collections_query = select(c for c in Collection).order_by(desc(Collection.review_count))
collections = collections_query.page(page, pagesize=LIMIT)
pagination = get_pagination(collections_query.count(), LIMIT, page)
return render_template('collection/index.html', collections=collections, pagination=pagination)
def get_followed_topics(self, role=None, category='all', order_by='created_at', page=1):
node_ids = self.followed_node_ids
user_ids = self.followed_user_ids
if not node_ids:
node_ids = [0]
if not user_ids:
user_ids = [0]
if category == 'hot':
now = int(time.time())
ago = now - 60 * 60 * 24
try:
return orm.select(rv for rv in collipa.models.Topic if
(rv.node_id in node_ids or rv.user_id in user_ids) and
rv.created_at > ago).order_by(lambda:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5))
except:
return None
elif category == 'all':
topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id in node_ids or rv.user_id in user_ids)
elif category == 'user':
topics = orm.select(rv for rv in collipa.models.Topic if rv.user_id in user_ids)
elif category == 'node':
topics = orm.select(rv for rv in collipa.models.Topic if rv.node_id in node_ids)
else:
return []
if order_by == 'smart':
topics = topics.order_by(lambda:
orm.desc((rv.collect_count +
rv.thank_count) * 10 +
(rv.up_count -
rv.down_count) * 5 +
rv.active / 4))
else:
topics = topics.order_by(lambda: orm.desc(rv.last_reply_date))
if page:
return topics[(page - 1) * config.paged: page * config.paged]
else:
return topics
def feed():
rendered = cache.get("rss_feed")
if rendered is None:
posts = orm.select(p for p in Post if p.draft is False).order_by(orm.desc(Post.posted)).limit(10)
rendered = render_template('index.xml', posts=posts)
cache.set("rss_feed", rendered)
response = make_response(rendered)
response.mimetype = "application/xml"
return response
def author():
page = request.args.get('page', 1, int)
authors_query = select(a for a in Author).order_by(desc(Author.id))
authors = authors_query.page(page, pagesize=LIMIT)
pagination = get_pagination(authors_query.count(), LIMIT, page)
return render_template('author/index.html', authors=authors, pagination=pagination)
def get_timeline(page=1, from_id=None, user_id=None, count=config.paged):
if not from_id:
if not user_id:
tweets = (orm.select(rv for rv in Tweet)
.order_by(lambda: orm.desc(rv.created_at))
[(page - 1) * count: page * count])
else:
tweets = (orm.select(rv for rv in Tweet if rv.user_id == user_id)
.order_by(lambda: orm.desc(rv.created_at))
[(page - 1) * count: page * count])
else:
if not user_id:
tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.id < from_id)
.order_by(lambda: orm.desc(rv.created_at))
[:count])
else:
tweets = (orm.select(rv for rv in collipa.models.Tweet if rv.id < from_id and rv.user_id == user_id)
.order_by(lambda: orm.desc(rv.created_at))
[:count])
return tweets
def get(self):
page = force_int(self.get_argument('page', 1), 1)
category = self.get_argument('category', None)
view = self.get_argument('view', 'all')
user = self.current_user
if not category:
category = self.index_category
else:
self.set_index_category(category)
if category == 'timeline' and not user:
category = self.set_index_category('index')
if category == 'hot':
topics = mc.get('hot_topics')
if not topics:
now = int(time.time())
ago = now - 60 * 60 * 24
topics = orm.select(rv for rv in Topic if
rv.created_at > ago).order_by(lambda:
orm.desc((rv.collect_count + rv.thank_count
- rv.report_count) * 10 +
(rv.up_count - rv.down_count) * 5 +
rv.reply_count * 3))
mc.set('hot_topics', list(topics), 60 * 60 * 2)
elif category == 'timeline':
topics = user.get_followed_topics(page=None, category=view)
elif category == 'latest':
topics = orm.select(rv for rv in Topic).order_by(lambda:
orm.desc(rv.created_at))
elif category == 'desert':
topics = orm.select(rv for rv in Topic if rv.reply_count == 0).order_by(lambda:
orm.desc(rv.created_at))
else:
topics = orm.select(rv for rv in Topic).order_by(lambda: orm.desc(rv.last_reply_date))
if isinstance(topics, list):
topic_count = len(topics)
else:
topic_count = orm.count(topics)
topics = topics[(page - 1) * config.paged: page * config.paged]
page_count = (topic_count + config.paged - 1) // config.paged
return self.render("site/index.html", topics=topics, category=category,
page=page, view=view, page_count=page_count, url='/')
def get_thankers(self, after_date=None, before_date=None):
if after_date:
user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id and rv.created_at > after_date)
elif before_date:
user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id and rv.created_at < before_date)
else:
user_ids = orm.select(rv.user_id for rv in m.Thank if rv.topic_id == self.id)
users = []
if user_ids:
user_ids = user_ids.order_by(lambda rv: orm.desc(rv.created_at))
users = orm.select(rv for rv in m.User if rv.id in user_ids)
return users
def get_uppers(self, after_date=None, before_date=None):
if after_date:
user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id and rv.created_at > after_date)
elif before_date:
user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id and rv.created_at < before_date)
else:
user_ids = orm.select(rv.user_id for rv in collipa.models.Up if rv.album_id == self.id)
users = []
if user_ids:
user_ids = user_ids.order_by(lambda: orm.desc(rv.created_at))
users = orm.select(rv for rv in collipa.models.User if rv.id in user_ids)
return users
def get_timeline(self, page=1, from_id=None, count=config.paged):
user_ids = self.followed_user_ids[:] or [0]
user_ids.append(self.id)
if not from_id:
tweets = orm.select(rv for rv in m.Tweet if
rv.user_id in user_ids).order_by(lambda rv:
orm.desc(rv.created_at))[(page - 1) * config.paged: page * config.paged]
return tweets
all_ids = orm.select(rv.id for rv in m.Tweet if
rv.user_id in user_ids).order_by(lambda rv: orm.desc(rv.created_at))
i = -1
for i, _id in enumerate(all_ids):
if i == 1000:
return []
if _id == from_id:
break
tweet_ids = all_ids[i + 1: i + 1 + count]
if tweet_ids:
tweets = orm.select(rv for rv in m.Tweet if rv.id in tweet_ids)[:][::-1]
else:
tweets = []
return tweets
def query_by_album_id(album_id, from_id=None, limit=config.paged, desc=True):
q = orm.select(rv for rv in Image if rv.album_id == album_id)
if desc:
q = q.order_by(lambda: orm.desc(rv.created_at))
else:
q = q.order_by(lambda: rv.created_at)
if from_id:
return helpers.collect_items_from_query(q, from_id, limit, "id")
if limit:
return q[:limit]
return q[:]
def index():
special_pages = []
posts_qs = orm.select(p for p in Post if p.draft is False).order_by(orm.desc(Post.posted))
try:
start_page = int(request.args.get("page", 1))
if start_page < 1: start_page = 1
except ValueError:
start_page = 1
pag = Pagination(start_page, 5, posts_qs.count())
posts = posts_qs.limit(5, offset=pag.offset)
return render_template("index.html",
posts=posts, paginator=pag,
title=app.config["SITE_TITLE"], show_header=True, special_pages=special_pages)
def query_by_album_id(album_id, from_id=None, limit=None, desc=True):
limit = limit or config.paged
images = orm.select(rv for rv in Image if rv.album_id == album_id)
if desc:
images = images.order_by(lambda rv: orm.desc(rv.created_at))
else:
images = images.order_by(lambda rv: rv.created_at)
if from_id:
i = -1
for i, image in enumerate(images):
if i == 1000:
return []
if image.id == from_id:
break
images = images[i + 1: i + 1 + limit]
return images
return images
def callback_query(bot, update):
cb = update.callback_query
chat_id = cb.message.chat_id
data = update.callback_query.data
logger.info(data)
data = data.split('%')
action = ''
offset = 0
disabled_attachments = set()
query = ''
confirmed = False
show_download = True
for elem in data:
name, *args = elem.split('=')
if name == 'act':
action = args[0]
elif name == 'off':
offset = int(args[0])
elif name == 'noatt':
disabled_attachments = set(int(arg) for arg in args if arg != '')
elif name == 'qry':
query = '='.join(args)
elif name == 'cnf':
confirmed = bool(int(args[0]))
elif name == 'dl':
show_download = bool(int(args[0]))
reporter = get_reporter(cb.from_user)
if action == 'old':
new_offset = offset + 1
elif action == 'new':
new_offset = offset - 1
else:
new_offset = offset
try:
scammers = select(
s for s in Scammer if
query in s.phone_nr or
query in s.account_nr or
query in s.bank_name or
query in s.remark
).order_by(
desc(Scammer.created)
)[new_offset:new_offset + 1]
except TypeError:
scammers = None
else:
offset = new_offset
reply = None
if action in ('old', 'new'):
if scammers:
scammer = scammers[0]
reply = str(scammer)
if not scammer.attached_file:
disabled_attachments.add(offset)
confirmed = reporter in scammer.reported_by if reporter else False
else:
bot.answerCallbackQuery(callback_query_id=cb.id, text="No more results")
return
elif action == 'confirm':
if not scammers:
bot.answerCallbackQuery(callback_query_id=cb.id, text="Not found, please search again")
return
scammer = scammers[0]
if not confirmed:
if not reporter:
reporter = Reporter(id=cb.from_user.id,
first_name=cb.from_user.first_name,
last_name=cb.from_user.last_name,
username=cb.from_user.username)
track(update, 'new_reporter')
scammer.reported_by.add(reporter)
bot.answerCallbackQuery(callback_query_id=cb.id, text="You confirmed this report.")
else:
scammer.reported_by.remove(reporter)
bot.answerCallbackQuery(callback_query_id=cb.id, text="You removed your confirmation.")
confirmed = not confirmed
reply = str(scammer)
elif action == 'att':
if not scammers:
bot.answerCallbackQuery(callback_query_id=cb.id, text="Not found, please search again")
return
kind, _, file_id = scammers[0].attached_file.partition(':')
if kind == 'photo':
bot.sendPhoto(chat_id, photo=file_id,
reply_to_message_id=cb.message.message_id)
elif kind == 'document':
bot.sendDocument(chat_id, document=file_id,
reply_to_message_id=cb.message.message_id)
disabled_attachments.add(offset)
elif action == 'dl':
bot.sendChatAction(chat_id, action=ChatAction.UPLOAD_DOCUMENT)
with db_session:
scammers = select(s for s in Scammer if
query in s.phone_nr or
query in s.account_nr or
query in s.bank_name or
query in s.remark).limit(100)
content = "\r\n\r\n".join(str(s) for s in scammers)
file = BytesIO(content.encode())
show_download = False
bot.sendDocument(chat_id, document=BufferedReader(file),
filename='search.txt',
reply_to_message_id=update.callback_query.message.message_id)
kb = search_keyboard(offset=offset, show_download=show_download,
disabled_attachments=disabled_attachments, confirmed=confirmed,
query=query)
reply_markup = InlineKeyboardMarkup(kb)
if reply:
bot.editMessageText(chat_id=chat_id, message_id=cb.message.message_id, text=reply,
reply_markup=reply_markup, parse_mode=ParseMode.HTML)
else:
bot.editMessageReplyMarkup(chat_id=chat_id,
message_id=update.callback_query.message.message_id,
reply_markup=reply_markup)
