def pay(course_id):
course_id = course_id.lower()
ucs = m.UserCourse.objects(course_id=course_id,
user_id=current_identity.id).first()
referrer = flask.request.headers.get("Referer")
if ucs and ucs.payment_success:
return util.json_dumps({
'id': str(ucs.id),
'is_paid': True,
'token': ucs.payment_token,
'payer_id': ucs.payer_id,
'price': ucs.price,
'course_id': course_id,
})
if not ucs:
ucs = m.UserCourse(course_id=course_id, user_id=current_identity.id)
ucs.save()
token = paypal_helper.get_payment_token(ucs.price,
referrer,
referrer,
currency='USD')
ucs.payment_token = token
ucs.payment_token_expired = datetime.utcnow() + timedelta(hours=4)
ucs.save()
return util.json_dumps({
'id': ucs.id,
'is_paid': False,
'token': ucs.payment_token,
'expiration': ucs.payment_token_expired,
'payment_url': paypal['url_template'] % token,
'price': ucs.price,
'course_id': course_id,
})
def next_course_to_review():
current_user = view_helpers.get_current_user()
uc = current_user.next_course_to_review() if current_user else None
if not uc:
return util.json_dumps({})
uc.select_for_review(current_user)
return util.json_dumps(uc.to_dict())
def sign_up():
user = flask.request.get_json()
try:
new_user = User.create_new_user_from_email(user['first_name'],
user['last_name'],
user['email'],
user['password'])
identity = UserToken(str(new_user.pk), new_user.email or '')
access_token = _jwt.jwt_encode_callback(identity)
return util.json_dumps({'accessToken': access_token})
except User.UserCreationError as e:
return util.json_dumps({"error": str(e)}), 400
def use_promotion_code(course_id):
course_id = course_id.lower()
ucs = m.UserCourse.objects(course_id=course_id,
user_id=current_identity.id).first()
promotion = util.json_loads(flask.request.data)
promotion_code = m.PromotionCode.objects(code=promotion['code']).first()
if not ucs:
ucs = m.UserCourse(course_id=course_id, user_id=current_identity.id)
ucs.save()
if not promotion_code or promotion_code.quantity <= 0:
flask.abort(403)
promotion_code.quantity = promotion_code.quantity - 1
if promotion_code._type == 'halfmonthfree':
ucs.payment_success = True
ucs.read = True
ucs.payment_at = datetime.utcnow()
ucs.start_from = datetime.utcnow()
ucs.expired_at = datetime.utcnow() + timedelta(days=15)
ucs.promotion_code = promotion_code['code']
ucs.save()
promotion_code.save()
return util.json_dumps(ucs.to_mongo())
def user_course_share():
user_course_id = flask.request.form['user_course_id']
review_type = flask.request.form['review_type']
current_user = view_helpers.get_current_user()
review = None
points_gained = 0
user_course = m.UserCourse.objects.get(
id=user_course_id, user_id=current_user.id)
if review_type == 'course':
review = user_course.course_review
points_gained = m.PointSource.SHARE_COURSE_REVIEW
elif review_type == 'professor':
review = user_course.professor_review
points_gained = m.PointSource.SHARE_PROFESSOR_REVIEW
# Only award points on the first share
if not review.share_date:
redis = view_helpers.get_redis_instance()
current_user.award_points(points_gained, redis)
else:
points_gained = 0
review.share_date = datetime.now()
user_course.save()
current_user.save()
return util.json_dumps({
'points_gained': points_gained,
})
def get_courses(course_id):
course_id = course_id.lower()
course = m.Course.objects(id=course_id).first()
if course is None:
return flask.abort(404)
else:
return util.json_dumps(course.to_dict())
def get_prof(prof_id):
prof_id = prof_id.lower()
prof = m.Professor.objects(id=prof_id).first()
if prof is None:
return flask.abort(404)
else:
return util.json_dumps(prof.to_dict())
def get_count():
course_id = flask.request.args.get('course_id')
if not course_id:
return flask.abort(400)
current_user = view_helpers.get_current_user()
comments = m.CourseComment.get_course_comments(course_id,
current_user.friend_ids, 0,
10000)
return util.json_dumps(len(comments))
def get_stream(course_id):
course_id = course_id.lower()
ucs = m.UserCourse.objects(course_id=course_id,
user_id=current_identity.id).first()
if not ucs:
flask.abort(403)
ucs = _update_user_course(ucs)
if not ucs.read:
flask.abort(403)
_tk = flask.request.args.get('_tk')
url = _video_client.get_stream(_tk, current_identity.id)
return util.json_dumps(url)
def get_or_create():
course_id = flask.request.args.get('course_id')
if not course_id:
return flask.abort(400)
current_user_id = current_identity.id
comment = m.CourseComment.objects(course_id=course_id,
user_id=current_user_id).first()
if not comment:
comment = m.CourseComment(user_id=current_user_id, course_id=course_id)
comment_dict = comment.to_mongo()
if '_id' in comment_dict:
comment_dict['id'] = str(comment_dict['_id'])
return util.json_dumps(comment_dict)
def search_courses():
current_user = view_helpers.get_current_user()
courses, has_more = m.Course.search(flask.request.values, current_user)
course_dict_list, user_course_dict_list, user_course_list = (
m.Course.get_course_and_user_course_dicts(
courses, current_user, include_friends=True,
full_user_courses=False, include_sections=True))
return util.json_dumps({
'course_objs': course_dict_list,
'has_more': has_more,
})
def update_prof_comment(prof_id):
course_prof_comment = m.CourseProfessorComment.objects(id=prof_id).first()
comment = util.json_loads(flask.request.data)
current_user = view_helpers.get_current_user()
if not current_user or comment[
'user_id'] != current_user.id or course_prof_comment is None:
return flask.abort(400)
if 'course_id' not in comment or 'professor_id' not in comment:
return flask.abort(400)
course_prof_comment.update_by_dict(comment)
course_prof_comment.save()
return util.json_dumps({})
def last_schedule_paste():
user_id = flask.request.values.get('user_id')
if not user_id:
user_id = view_helpers.get_current_user().id
else:
user_id = bson.ObjectId(user_id)
user = m.User.objects.with_id(user_id)
last_schedule_paste = user.last_schedule_paste
return util.json_dumps({
'last_schedule_paste': last_schedule_paste,
})
def get_comments():
course_id = flask.request.args.get('course_id')
if not course_id:
return flask.abort(400)
start = int(flask.request.args.get('start') or 0)
rows = int(flask.request.args.get('rows') or 100)
comments = [
comment.to_mongo() for comment in m.CourseComment.get_course_comments(
course_id, None, start, rows)
]
for comment in comments:
comment['id'] = str(comment['_id'])
if 'user_id' in comment:
comment['user_id'] = 'undefined'
return util.json_dumps(comments)
def pasted_schedule_users():
include_good_paste = bool(flask.request.values.get('include_good_paste'))
include_bad_paste = bool(flask.request.values.get('include_bad_paste'))
# Start off with a query that maches no one
query = me.Q(id__exists=False)
if include_good_paste:
query = query | me.Q(last_good_schedule_paste__exists=True)
if include_bad_paste:
query = query | me.Q(last_bad_schedule_paste__exists=True)
users = m.User.objects.filter(query).only('id')
user_ids = [user.id for user in users]
print 'num_users', len(user_ids)
return util.json_dumps({
'user_ids': user_ids,
})
def create_prof_comment():
comment = util.json_loads(flask.request.data)
current_user = view_helpers.get_current_user()
if not current_user or comment['user_id'] != current_user.id:
return flask.abort(400)
if 'course_id' not in comment or 'professor_id' not in comment:
return flask.abort(400)
comment_obj = m.CourseProfessorComment(
course_id=comment['course_id'],
professor_id=comment['professor_id'],
user_id=comment['user_id'])
comment_obj.update_by_dict(comment)
comment_obj.save()
saved_comment_obj = comment_obj.to_mongo()
if '_id' in saved_comment_obj:
saved_comment_obj['id'] = str(saved_comment_obj['_id'])
return util.json_dumps(saved_comment_obj)
def get_user_course(course_id):
course_id = course_id.lower()
ucs = m.UserCourse.objects(course_id=course_id,
user_id=current_identity.id).first()
if ucs and not ucs.payment_success and ucs.payment_token and ucs.payment_token_expired and ucs.payment_token_expired < datetime.utcnow(
):
payer_id = paypal_helper.check_payment(ucs.payment_token)
if payer_id:
ucs.payer_id = payer_id
ucs.payment_success = True
ucs.read = True
ucs.payment_at = datetime.utcnow()
ucs.start_from = datetime.utcnow()
ucs.expired_at = datetime.utcnow() + timedelta(days=10000)
ucs.promotion_code = promotion_code['code']
ucs.save()
elif not ucs:
ucs = m.UserCourse(course_id=course_id, user_id=current_identity.id)
ucs.save()
return util.json_dumps(ucs.to_mongo())
def save():
comment = util.json_loads(flask.request.data)
current_user_id = current_identity.id
print comment, current_user_id
if 'course_id' not in comment or 'course_id' not in comment:
return flask.abort(400)
if str(comment['user_id']) != current_user_id:
return flask.abort(400)
comment_obj = None
if 'id' in comment:
comment_obj = m.CourseComment.objects(id=comment['id']).first()
if comment_obj is None:
comment_obj = m.CourseComment(course_id=comment['course_id'],
user_id=comment['user_id'])
comment_obj.update_by_dict(comment)
comment_obj.save()
saved_comment_obj = comment_obj.to_mongo()
if '_id' in saved_comment_obj:
saved_comment_obj['id'] = str(saved_comment_obj['_id'])
return util.json_dumps(saved_comment_obj)
def get_current_user():
user = m.User.objects(id=current_identity.id).first()
if user:
return util.json_dumps(user.to_dict())
else:
flask.abort(404)
def get_profs():
prof_ids = flask.request.args.getlist('prof_id')
print flask.request.args
profs = [prof.to_dict() for prof in m.Professor.objects(id__in=prof_ids)]
print len(profs)
return util.json_dumps(profs)
def get_courses_video(course_id):
course_id = course_id.lower()
videos = _video_client.get_course_videos(course_id)
video_metas = [_video_client.get_video(video['id']) for video in videos]
return util.json_dumps(video_metas)
def user_course():
uc_data = util.json_loads(flask.request.data)
user = view_helpers.get_current_user()
rmclogger.log_event(
rmclogger.LOG_CATEGORY_API,
rmclogger.LOG_EVENT_USER_COURSE, {
'uc_data': uc_data,
'user_id': user.id,
},
)
# Validate request object
course_id = uc_data.get('course_id')
term_id = uc_data.get('term_id')
if course_id is None or term_id is None:
logging.error("/api/user/course got course_id (%s) and term_id (%s)" %
(course_id, term_id))
# TODO(david): Perhaps we should have a request error function that
# returns a 400
raise exceptions.ImATeapot('No course_id or term_id set')
# if not m.UserCourse.can_review(term_id):
# logging.warning("%s attempted to rate %s in future/shortlist term %s"
# % (user.id, course_id, term_id))
# raise exceptions.ImATeapot(
# "Can't review a course in the future or shortlist")
# Fetch existing UserCourse
uc = m.UserCourse.objects(
user_id=user.id,
course_id=uc_data['course_id'],
term_id=uc_data['term_id']
).first()
if uc is None:
logging.error("/api/user/course User course not found for "
"user_id=%s course_id=%s term_id=%s" %
(user.id, course_id, term_id))
# TODO(david): Perhaps we should have a request error function that
# returns a 400
raise exceptions.ImATeapot('No user course found')
orig_points = uc.num_points
# TODO(Sandy): Consider the case where the user picked a professor and
# rates them, but then changes the professor. We need to remove the ratings
# from the old prof's aggregated ratings and add them to the new prof's
# Maybe create professor if newly added
if uc_data.get('new_prof_added'):
new_prof_name = uc_data['new_prof_added']
# TODO(mack): should do guess_names first, and use that to
# generate the id
prof_id = m.Professor.get_id_from_name(new_prof_name)
uc.professor_id = prof_id
# TODO(Sandy): Have some kind of sanity check for professor names.
# Don't allow ridiculousness like "Santa Claus", "aksnlf",
# "swear words"
if m.Professor.objects(id=prof_id).count() == 0:
first_name, last_name = m.Professor.guess_names(new_prof_name)
m.Professor(
id=prof_id,
first_name=first_name,
last_name=last_name,
).save()
course = m.Course.objects.with_id(uc.course_id)
course.professor_ids = list(set(course.professor_ids) | {prof_id})
course.save()
logging.info("Added new course professor %s (name: %s)" % (prof_id,
new_prof_name))
elif uc_data.get('professor_id'):
uc.professor_id = uc_data['professor_id']
else:
uc.professor_id = None
now = datetime.now()
if uc_data.get('course_review'):
# New course review data
uc_data['course_review']['comment_date'] = now
uc.course_review.update(**uc_data['course_review'])
if uc_data.get('professor_review'):
# New prof review data
uc_data['professor_review']['comment_date'] = now
uc.professor_review.update(**uc_data['professor_review'])
uc.save()
points_gained = uc.num_points - orig_points
user.award_points(points_gained, view_helpers.get_redis_instance())
user.save()
return util.json_dumps({
'professor_review.comment_date': uc['professor_review'][
'comment_date'],
'course_review.comment_date': uc['course_review']['comment_date'],
'points_gained': points_gained,
})
def login_with_facebook():
req_json = flask.request.get_json()
fbsr = req_json.get('fb_signed_request')
if (fbsr is None):
raise exceptions.ImATeapot('No fbsr set')
fb_data = facebook.get_fb_data(fbsr, app.config)
fbid = fb_data['fbid']
fb_access_token = fb_data['access_token']
fb_access_token_expiry_date = fb_data['expires_on']
is_invalid = fb_data['is_invalid']
user = User.objects(fbid=fbid).first()
if user:
# Existing user. Update with their latest Facebook info
user.fb_access_token = fb_access_token
user.fb_access_token_expiry_date = fb_access_token_expiry_date
user.fb_access_token_invalid = is_invalid
user.save()
else:
# New user, or existing email logins user.
now = datetime.now()
email = req_json.get('email')
user_data = {
'fb_access_token': fb_access_token,
'fb_access_token_expiry_date': fb_access_token_expiry_date,
'fbid': fbid,
'friend_fbids': flask.json.loads(req_json.get('friend_fbids')),
'gender': req_json.get('gender'),
'last_visited': now,
}
user = User.objects(email=email).first() if email else None
if user:
for k, v in user_data.iteritems():
user[k] = v
user.save()
else:
# Create an account with their Facebook data
user_data.update({
'email': email,
'first_name': req_json.get('first_name'),
'join_date': now,
'join_source': User.JoinSource.FACEBOOK,
'last_name': req_json.get('last_name'),
'middle_name': req_json.get('middle_name'),
})
referrer_id = req_json.get('referrer_id')
if referrer_id:
try:
user_data['referrer_id'] = bson.ObjectId(referrer_id)
except bson.errors.InvalidId:
pass
user = User(**user_data)
user.save()
if user:
identity = UserToken(str(user.pk), user.email or '')
access_token = _jwt.jwt_encode_callback(identity)
return util.json_dumps({'accessToken': access_token})
