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)