def process_request(self, request):
if not request.user.is_authenticated():
return
urlsModule = __import__(settings.ROOT_URLCONF, {}, {}, [''])
skipList = getattr(urlsModule, 'ignore_latest_activity', None)
skippedPath = request.path
if skippedPath.startswith('/'):
skippedPath = skippedPath[1:]
if skipList is not None:
for expression in skipList:
compiledVersion = None
if not compiledLists.has_key(expression):
compiledLists[expression] = re.compile(expression)
compiledVersion = compiledLists[expression]
if compiledVersion.search(skippedPath):
return
activity = None
try:
activity = request.user.useractivity
except:
activity = UserActivity()
activity.user = request.user
activity.latest_activity = datetime.now()
activity.current_template = request.build_absolute_uri()
activity.save()
return
activity.latest_activity = datetime.now()
activity.current_template = request.build_absolute_uri()
activity.save()
def before_request():
g.user = current_user
if g.user is not None and g.user.is_authenticated():
g.activity = UserActivity.get_activity(UserActivity)
g.my_activity = UserActivity.get_my_activity(UserActivity, g.user.id)
else:
g.activity = None
g.my_activity = None
def add_activity():
""" Add activity to user's list of saved activities """
try:
# Gets form data and checks for activity_id
data = request.form
if data.get('activity_id'):
# If user is logged in, check if they already have saved this activity
if session.get('user_id'):
user_activity = UserActivity.query.filter_by(activity_id=data['activity_id'], user_id=session['user_id']).first()
# If it hasn't already been saved, save it
if user_activity is None:
user_activity = UserActivity(activity_id=data['activity_id'], user_id=session['user_id'])
activity = Activity.query.get(data['activity_id'])
# If the relevant activity does not exist in the DB, create it too
if activity is None:
activity = Activity(**data)
db.session.add(activity)
db.session.commit()
db.session.add(user_activity)
db.session.commit()
else:
# If not logged in, store the id of the current activity and redirect to login
session['temp_activity_id'] = data['activity_id']
return login()
except exc.SQLAlchemyError as e:
# In case of a DB error, roll it back
db.session.rollback()
except Exception as e:
# If an error occurs, returns an error page
return error(e.args)
# Go back to home page
return index()
def process_request(self, request):
# Checks if we need to keep track of this activity...
request_url = request.META.get('PATH_INFO', '').strip()
if request_url[0] == '/': request_url = request_url[1:]
if True in [bool(k.match(request_url)) for k in NOTRACK_REGEXP]:
self.activity = None
return
self.activity = UserActivity(
user = request.user if request.user.is_authenticated() else None,
date = datetime.now(),
request_url = request.META.get('PATH_INFO', ''),
referer_url = request.META.get('HTTP_REFERER', ''),
client_address = request.META.get('REMOTE_ADDR', ''),
client_host = request.META.get('REMOTE_HOST', ''),
browser_info = request.META.get('HTTP_USER_AGENT', ''),
languages = request.META.get('HTTP_ACCEPT_LANGUAGE', ''),
)
# Makes 1 database lookup. If the city database is available, prefer that
# one, otherwise, mark the city as "Unknown" and perform country lookup.
try_set_location(self.activity)
# Makes a second database lookup for decoding the UserAgent string
try_ua_parsing(self.activity)
def download_artists(user, username, limit=500, period='overall', page=1):
"""Download artists from a LastFM account into the user's library.
Period options: overall | 7day | 1month | 3month | 6month | 12month"""
data = grab_json(
"http://ws.audioscrobbler.com/2.0/?method=user.gettopartists&user={}&limit={}&api_key={}&period={}&page={}&format=json"
.format(username, limit, app.config.get('LAST_FM_API_KEY'), period,
page))
artists_added = 0
for artist in data.get('topartists').get('artist'):
found_import = ArtistImport.query.filter_by(
user_id=user.id, import_name=artist['name']).first()
if found_import is None:
new_import = ArtistImport(user_id=user.id,
import_name=artist['name'],
import_mbid=artist['mbid'],
import_method=ImportMethod.LASTFM)
db.session.add(new_import)
artists_added += 1
activity = UserActivity(user_id=user.id,
activity=ActivityTypes.LASTFM_IMPORT)
db.session.add(activity)
db.session.commit()
return {'artists_added': artists_added}
def problem_submit():
params = utils.flat_multi(request.form)
pid = params.get("pid")
flag = params.get("flag")
tid = session.get("tid")
_user = user.get_user().first()
username = _user.username
problem = Problems.query.filter_by(pid=pid).first()
team = Teams.query.filter_by(tid=tid).first()
solved = Solves.query.filter_by(pid=pid, tid=tid, correct=1).first()
if solved:
raise WebException("You already solved this problem.")
flag_tried = Solves.query.filter_by(pid=pid, flag=flag).first()
if flag_tried:
raise WebException("Your team has already tried this solution.")
if problem:
if problem.category == "Programming":
raise WebException(
"Please submit programming problems using the Programming interface."
)
grader = imp.load_source("grader", problem.grader)
random = None
if problem.autogen:
random = autogen.get_random(pid, tid)
correct, response = grader.grade(random, flag)
solve = Solves(pid, _user.uid, tid, flag, correct)
db.session.add(solve)
db.session.commit()
if correct:
# Wait until after the solve has been added to the database before adding bonus
solves = get_solves(pid)
solve.bonus = [-1, solves][solves < 4]
cache.invalidate_memoization(get_solves, pid)
if _user:
activity = UserActivity(_user.uid, 3, tid=tid, pid=pid)
db.session.add(activity)
db.session.commit()
logger.log(__name__,
"%s has solved %s by submitting %s" %
(team.teamname, problem.title, flag),
level=logger.WARNING)
return {"success": 1, "message": response}
else:
logger.log(__name__,
"%s has incorrectly submitted %s to %s" %
(team.teamname, flag, problem.title),
level=logger.WARNING)
raise WebException(response)
else:
raise WebException("Problem does not exist!")
def post(self):
request_data=request.get_json()
list_data=list(request_data)
for data in list_data:
useractivity=UserActivity(record_id=data['record_id'],user_email=data['user_email'],post_id=data['post_id'],contributed_date=data['contributed_date'],activity_category=data['activity_category'])
db_session.add(useractivity)
db_session.commit()
return {'Message':'Success'}
def register_user(name, username, email, password, utype, admin=False):
user = Users(name, username, email, password, utype=utype, admin=admin)
token = utils.generate_string(length=64)
user.email_token = token
with app.app_context():
db.session.add(user)
db.session.commit()
join_activity = UserActivity(user.uid, 0)
db.session.add(join_activity)
db.session.commit()
db.session.close()
return True
def login():
form = LoginForm()
if flask.request.method == "POST":
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is None:
return render_template(
"login.html",
title="Login",
form=form,
form_title="Login",
login_failure=True,
)
if not check_password_hash(user.password, form.password.data):
abort(403)
user.create_session()
user = user.save()
login_user(user)
user_activity = UserActivity(activity_name="login", user=user)
user_activity.save()
return redirect(url_for("spell_checker"))
else:
return render_template(
"login.html",
title="Login",
form=form,
form_title="Login",
login_failure=True,
)
# default is a GET request
return render_template("login.html",
title="Login",
form=form,
form_title="David's Spell Checker")
def team_create():
params = utils.flat_multi(request.form)
_user = user.get_user().first()
if (_user.tid is not None and _user.tid >= 0) or get_team(
owner=_user.uid).first() is not None:
raise WebException("You're already in a team!")
verify_to_schema(TeamSchema, params)
teamname = params.get("teamname")
school = params.get("school")
team = Teams(teamname, school, _user.uid, _user.utype != 1)
with app.app_context():
db.session.add(team)
db.session.commit()
Users.query.filter_by(uid=_user.uid).update({"tid": team.tid})
team_activity = UserActivity(_user.uid, 1, tid=team.tid)
db.session.add(team_activity)
db.session.commit()
session["tid"] = team.tid
return {"success": 1, "message": "Success!"}
def submit_program():
params = utils.flat_multi(request.form)
pid = params.get("pid")
tid = session.get("tid")
_user = user.get_user().first()
language = params.get("language")
submission_contents = params.get("submission")
_problem = problem.get_problem(pid=pid).first()
if _problem is None:
raise WebException("Problem does not exist.")
if _problem.category != "Programming":
raise WebException("Can't judge this problem.")
if language not in extensions:
raise WebException("Language not supported.")
solved = Solves.query.filter_by(pid=pid, tid=tid, correct=1).first()
if solved:
raise WebException("You already solved this problem.")
judge_folder = os.path.join(app.config["GRADER_FOLDER"], pid)
if not os.path.exists(judge_folder):
os.makedirs(judge_folder)
submission_folder = os.path.join(judge_folder, utils.generate_string())
while os.path.exists(submission_folder):
submission_folder = os.path.join(judge_folder, utils.generate_string())
os.makedirs(submission_folder)
submission_path = os.path.join(submission_folder,
"program.%s" % extensions[language])
open(submission_path, "w").write(submission_contents)
message, log, duration = judge(submission_path, language, pid)
number = ProgrammingSubmissions.query.filter_by(tid=tid).with_entities(
ProgrammingSubmissions.number).order_by(
ProgrammingSubmissions.number.desc()).first()
if number is None:
number = 1
else:
number = number[0] + 1
submission = ProgrammingSubmissions(pid, tid, submission_path, message,
log, number, duration)
correct = message == "Correct!"
with app.app_context():
solve = Solves(pid, _user.uid, tid, submission_path, correct)
db.session.add(solve)
db.session.add(submission)
db.session.commit()
if correct:
# Wait until after the solve has been added to the database before adding bonus
solves = problem.get_solves(pid=pid)
solve.bonus = [-1, solves][solves < 3]
db.session.add(solve)
cache.invalidate_memoization(problem.get_solves, pid)
if _user:
activity = UserActivity(_user.uid, 3, tid=tid, pid=pid)
db.session.add(activity)
db.session.commit()
new = {
"psid": submission.psid,
"title": _problem.title,
"message": submission.message,
"log": submission.log,
"date": utils.isoformat(submission.date),
"number": submission.number
}
shutil.rmtree(submission_folder)
return {
"success": message == "Correct!",
"message": message,
"new_submission": new
}
def logout():
user_id = current_user.id
logout_user()
user_activity = UserActivity(activity_name="logout", user_id=user_id)
user_activity.save()
return redirect(url_for("login"))
def process_request(self, request):
if not request.user.is_authenticated():
return
urlsModule = __import__(settings.ROOT_URLCONF, {}, {}, [''])
skipList = getattr(urlsModule, 'ignore_latest_activity', None)
skippedPath = request.path
if skippedPath.startswith('/'):
skippedPath = skippedPath[1:]
if skipList is not None:
for expression in skipList:
compiledVersion = None
if not compiledLists.has_key(expression):
compiledLists[expression] = re.compile(expression)
compiledVersion = compiledLists[expression]
if compiledVersion.search(skippedPath):
return
activity = None
try:
activity = request.user.useractivity
except:
activity = UserActivity()
activity.user = request.user
activity.latest_activity = datetime.now()
activity.current_template = request.build_absolute_uri()
activity.save()
return
activity.latest_activity = datetime.now()
activity.current_template = request.build_absolute_uri()
activity.save()