def friends_trending():
import trending_utilities
friends, cusfriends = utilities.get_friends(session.user_id)
# The Original IDs of duplicate custom_friends
custom_friends = []
for cus_id in cusfriends:
if cus_id[1] is None:
custom_friends.append(cus_id[0])
else:
custom_friends.append(cus_id[1])
friends, custom_friends = set(friends), set(custom_friends)
stable = db.submission
query = (stable.user_id.belongs(friends) | \
stable.custom_user_id.belongs(custom_friends))
last_submissions = trending_utilities.get_last_submissions_for_trending(
query)
# for api
if utilities.is_apicall():
problems = trending_utilities.get_trending_problem_list(
last_submissions)
return response.json(dict(problems=problems))
return trending_utilities.compute_trending_table(last_submissions,
"friends",
session.user_id)
def global_trending():
from trending_utilities import draw_trending_table
trending_problems = current.REDIS_CLIENT.get(
GLOBALLY_TRENDING_PROBLEMS_CACHE_KEY)
trending_problems = eval(trending_problems)
# for api
if utilities.is_apicall():
return response.json(dict(problems=trending_problems))
return draw_trending_table(trending_problems, "global", session.user_id)
def login_token():
"""
Only accesible to whitelisted Api Calls
"""
if not utilities.is_apicall():
raise HTTP(400, u'Invalid API params')
"""
@withparameter email and password return {token : ''} if valid credentials
@withparameter token returns the new refresh token
"""
auth_jwt.verify_expiration = False
return auth_jwt.jwt_token_manager()
def get_stopstalk_user_stats():
if request.extension != "json":
# for api request
if not utilities.is_apicall():
raise HTTP(400)
return
user_id = request.vars.get("user_id", None)
custom = request.vars.get("custom", None)
final_data = dict(rating_history=[],
curr_accepted_streak=0,
max_accepted_streak=0,
curr_day_streak=0,
max_day_streak=0,
solved_counts={},
status_percentages=[],
site_accuracies={},
solved_problems_count=0,
total_problems_count=0,
calendar_data={})
if user_id in [None, ""] or custom in [None, ""]:
return final_data
user_id = int(user_id)
custom = (custom == "True")
result = utilities.get_rating_information(user_id, custom,
auth.is_logged_in())
# for api request
if utilities.is_apicall():
return response.json(result)
return result
def recommendations():
"""
Problem recommendations for the user.
"""
import recommendations.problems as recommendations
ptable = db.problem
rtable = db.problem_recommendations
user_id = session.user_id
refresh = request.vars.get("refresh", "false") == "true"
output = {}
recommendation_pids = []
rows = db(rtable.user_id == user_id).select()
if len(rows) == 0:
refresh = True
if refresh:
recommendation_pids = recommendations.generate_recommendations(user_id)
else:
recommendation_pids, _ = recommendations.retrieve_past_recommendations(
user_id)
output["recommendations_length"] = len(recommendation_pids)
if len(recommendation_pids) > 0:
problem_details = db(ptable.id.belongs(recommendation_pids)).select()
if utilities.is_apicall():
output["problems"] = problem_details
return output
output["table"] = utilities.get_problems_table(problem_details,
user_id,
"recommendation", None)
output["can_update"] = recommendations.can_refresh_recommendations(user_id)
return output
def profile():
"""
Controller to show user profile
@ToDo: Lots of cleanup! Atleast run a lint
"""
if len(request.args) < 1:
if auth.is_logged_in():
handle = str(session.handle)
redirect(URL("user", "profile", args=str(session.handle)))
return
else:
redirect(
URL("default",
"user",
"login",
vars={"_next": URL("user", "profile")}))
return
else:
handle = str(request.args[0])
http_referer = request.env.http_referer
if auth.is_logged_in() and \
session.welcome_shown is None and \
http_referer is not None and \
http_referer.__contains__("/user/login"):
response.flash = T("Welcome StopStalker!!")
session.welcome_shown = True
query = (db.auth_user.stopstalk_handle == handle)
rows = db(query).select()
row = None
flag = "not-friends"
custom = False
actual_handle = handle
parent_user = None
cf_count = 0
cftable = db.custom_friend
output = {}
output["nouser"] = False
output["show_refresh_now"] = False
output["can_update"] = False
if len(rows) == 0:
query = (cftable.stopstalk_handle == handle)
rows = db(query).select()
if len(rows) == 0:
# No such user exists
raise HTTP(404)
return
else:
flag = "custom"
custom = True
row = rows.first()
parent_user = (row.user_id.first_name + " " + \
row.user_id.last_name,
row.user_id.stopstalk_handle)
if row.duplicate_cu:
flag = "duplicate-custom"
original_row = cftable(row.duplicate_cu)
if auth.is_logged_in():
output["show_refresh_now"] = (
row.user_id == session.user_id)
output["can_update"] = (
datetime.datetime.now() - row.refreshed_timestamp
).total_seconds() > current.REFRESH_INTERVAL
actual_handle = row.stopstalk_handle
handle = original_row.stopstalk_handle
original_row["first_name"] = row.first_name
original_row["last_name"] = row.last_name
original_row["institute"] = row.institute
original_row["country"] = row.country
original_row["user_id"] = row.user_id
output["user_id"] = row.duplicate_cu
row = original_row
else:
output["can_update"] = (
datetime.datetime.now() - row.refreshed_timestamp
).total_seconds() > current.REFRESH_INTERVAL
if auth.is_logged_in():
output["show_refresh_now"] = (
row.user_id == session.user_id)
output["user_id"] = row.id
output["row"] = row
else:
row = rows.first()
output["user_id"] = row.id
output["can_update"] = (
datetime.datetime.now() -
row.refreshed_timestamp).total_seconds() > current.REFRESH_INTERVAL
output["row"] = row
if auth.is_logged_in():
output["show_refresh_now"] = (row.id == session.user_id)
last_updated = str(
max([row[site.lower() + "_lr"] for site in current.SITES]))
if last_updated == current.INITIAL_DATE:
last_updated = "Never"
output["last_updated"] = last_updated
output["parent_user"] = parent_user
output["handle"] = handle
output["actual_handle"] = actual_handle
name = row.first_name + " " + row.last_name
output["name"] = name
output["custom"] = custom
stable = db.submission
user_query = (stable.user_id == row.id)
if custom:
user_query = (stable.custom_user_id == row.id)
total_submissions = db(user_query).count()
output["total_submissions"] = total_submissions
if custom:
if row.user_id == session.user_id:
flag = "my-custom-user"
else:
if row.id != session.user_id:
ftable = db.following
query = (ftable.follower_id == session.user_id) & \
(ftable.user_id == row.id)
if db(query).count():
flag = "already-friends"
else:
flag = "same-user"
output["flag"] = flag
profile_urls = {}
for site in current.SITES:
profile_urls[site] = utilities.get_profile_url(site,
row[site.lower() + \
'_handle'])
output["profile_urls"] = profile_urls
if custom is False:
cf_count = db(cftable.user_id == row.id).count()
output["cf_count"] = cf_count
# for api request
if utilities.is_apicall():
return response.json(output)
return output
def search():
"""
Search page for problems
"""
api_call = utilities.is_apicall()
ttable = db.tag
uetable = db.user_editorials
problem_name = request.vars.get("name", None)
orderby = request.vars.get("orderby", None)
clubbed_tags = request.vars.get("generalized_tags", None)
q = request.vars.get("q", None)
sites = request.vars.get("site", None)
include_editorials = request.vars.get("include_editorials", "")
exclude_solved = request.vars.get("exclude_solved", None)
generalized_tags = db(ttable).select(ttable.value, orderby=ttable.value)
generalized_tags = [x.value for x in generalized_tags]
if any([problem_name, orderby, clubbed_tags, q, sites]) is False:
if api_call:
return response.json({'generalized_tags': generalized_tags})
if request.extension == "json":
return dict(total_pages=0)
else:
if len(request.get_vars):
# No filter is applied
response.flash = "No filter is applied"
return dict(table=DIV(), generalized_tags=generalized_tags)
clubbed_tags = None if clubbed_tags == "" else clubbed_tags
try:
if sites == None or sites == "":
sites = []
elif isinstance(sites, str):
sites = [sites]
except:
sites = []
if orderby not in ("accuracy-asc", "accuracy-desc", "solved-count-asc",
"solved-count-desc"):
orderby = None
try:
curr_page = int(request.vars["page"])
except:
curr_page = 1
PER_PAGE = current.PER_PAGE
ptable = db.problem
query = True
rows = db(uetable.verification == "accepted").select(uetable.problem_id)
problem_with_user_editorials = set([x["problem_id"] for x in rows])
if q is not None and not clubbed_tags:
# Enables multiple space seperated tag search
q = q.split(" ")
for tag in q:
if tag == "":
continue
# Decision to make & or |
# & => Search for problem containing all these tags
# | => Search for problem containing one of the tags
query &= ptable.tags.contains(tag)
elif clubbed_tags:
clubbed_tags = [clubbed_tags] if isinstance(clubbed_tags,
str) else clubbed_tags
ttable = db.tag
sttable = db.suggested_tags
tag_ids = db(ttable.value.belongs(clubbed_tags)).select(ttable.id)
tag_ids = [x.id for x in tag_ids]
problem_ids = db(sttable.tag_id.belongs(tag_ids)).select(
sttable.problem_id)
problem_ids = [x.problem_id for x in problem_ids]
query &= ptable.id.belongs(problem_ids)
if problem_name:
query &= ptable.name.contains(problem_name)
if include_editorials:
# Check if the site editorial link is present or the problem id exists
# in user_editorials table with accepted status
query &= (((ptable.editorial_link != None) & \
(ptable.editorial_link != "")) | \
(ptable.id.belongs(problem_with_user_editorials)))
if exclude_solved and auth.is_logged_in():
solved_pids, _ = utilities.get_solved_problems(session.user_id, False)
query &= ~ptable.id.belongs(solved_pids)
elif exclude_solved and request.extension == "html":
response.flash = T("Login to apply this filter")
site_query = None
for site in sites:
if site_query is not None:
site_query |= ptable.link.contains(current.SITES[site])
else:
site_query = ptable.link.contains(current.SITES[site])
if site_query:
query &= site_query
accuracy_column = (ptable.solved_submissions * 1.0 /
ptable.total_submissions)
kwargs = dict(distinct=True,
limitby=((curr_page - 1) * PER_PAGE, curr_page * PER_PAGE))
if orderby and orderby.__contains__("accuracy"):
query &= ~(ptable.link.contains("hackerrank.com"))
kwargs[
"orderby"] = ~accuracy_column if orderby == "accuracy-desc" else accuracy_column
if orderby and orderby.__contains__("solved-count"):
kwargs["reverse"] = True if orderby == "solved-count-desc" else False
query &= (ptable.solved_submissions != None)
query &= (ptable.total_submissions != None) & (ptable.total_submissions !=
0)
query &= (ptable.user_ids != None)
query &= (ptable.custom_user_ids != None)
if request.extension == "json" and not api_call:
total_problems = db(query).count()
total_pages = total_problems / PER_PAGE
if total_problems % PER_PAGE != 0:
total_pages = total_problems / PER_PAGE + 1
return dict(total_pages=total_pages)
if orderby and orderby.__contains__("solved-count"):
all_problems = db(query).select().as_list()
all_problems.sort(key=lambda x: x["user_count"] + \
x["custom_user_count"],
reverse=kwargs["reverse"])
all_problems = all_problems[kwargs["limitby"][0]:kwargs["limitby"][1]]
else:
# No need of caching here
all_problems = db(query).select(**kwargs)
if api_call:
return response.json({'problems': all_problems})
return dict(table=utilities.get_problems_table(
all_problems, session.user_id, "problem-search",
problem_with_user_editorials),
generalized_tags=generalized_tags)
