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})