def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('mphone', help='This field cannot be blank', required=True)
parser_copy.add_argument('pass', help='This field cannot be blank', required=True)
data = parser_copy.parse_args()
if not models.find_user({"mphone": data['mphone']}):
return {'status': 400,
'message': 'User {} doesn\'t exist'.format(data['mphone'])}
current_user = models.find_user({"mphone": data['mphone']})
if sha256.verify(data['pass'], current_user['pass']):
access_token = create_access_token(identity=data['mphone'], expires_delta=ACCESS_TOKEN_EXPIRE)
refresh_token = create_refresh_token(identity=data['mphone'])
current_user["_id"] = str(current_user['_id'])
logging.info('user logged in. user: {}'.format(data['mphone']))
return {
'status': 200,
'message': 'Logged in as {}'.format(current_user['mphone']),
'access_token': access_token,
'refresh_token': refresh_token,
'user_data': {key: current_user.get(key, None) for key in ['fname',
'lname',
'mphone',
'phone',
'email',
'mcode',
'state',
'city',
'address']}
}
else:
logging.warning('unsuccessful login attempt. ip: {}'.format(reqparse.request.headers.getlist("X-Real-IP")))
return {'status': 400,
'message': 'Wrong credentials'}
def user(mocker, setup, cleanup, email):
engine, connection, session = setup()
mocker.patch(SETUP, return_value=(engine, connection, session))
mocker.patch(CLEANUP)
create_user(session, User(email=email))
yield find_user(session, email)
cleanup(session, connection)
def post(self):
parser_copy = parser.copy()
# optional
parser_copy.add_argument('fname', required=False)
parser_copy.add_argument('lname', required=False)
# parser_copy.add_argument('mphone', required=False)
parser_copy.add_argument('email', required=False)
parser_copy.add_argument('mcode', required=False)
# parser_copy.add_argument('pass', required=False)
parser_copy.add_argument('phone', required=False)
parser_copy.add_argument('state', required=False)
parser_copy.add_argument('city', required=False)
parser_copy.add_argument('address', required=False)
data = parser_copy.parse_args()
current_user = models.find_user({"mphone": get_jwt_identity()})
updated_user = dict()
for item in data:
if not data[item]:
continue
else:
updated_user[item] = data[item]
if models.update_user({"_id": current_user["_id"]}, updated_user):
return {'status': 200,
'message': 'successfully updated'}
else:
return {'status': 500,
'message': 'internal error'}
def post(self):
parser_copy = parser.copy()
# optional
parser_copy.add_argument('fname', required=False)
parser_copy.add_argument('lname', required=False)
# parser_copy.add_argument('mphone', required=False)
parser_copy.add_argument('email', required=False)
parser_copy.add_argument('mcode', required=False)
# parser_copy.add_argument('pass', required=False)
parser_copy.add_argument('phone', required=False)
parser_copy.add_argument('state', required=False)
parser_copy.add_argument('city', required=False)
parser_copy.add_argument('address', required=False)
data = parser_copy.parse_args()
current_user = models.find_user({"mphone": get_jwt_identity()})
updated_user = dict()
for item in data:
if not data[item]:
continue
else:
updated_user[item] = data[item]
if models.update_user({"_id": current_user["_id"]}, updated_user):
logging.info('user edit. ip: {}, user: {}'.format(
reqparse.request.headers.getlist("X-Real-IP"),
current_user["mphone"]))
return {'status': 200, 'message': 'successfully updated'}
else:
logging.info('unsuccessful user edit. ip: {}, user: {}'.format(
reqparse.request.headers.getlist("X-Real-IP"),
current_user["mphone"]))
return {'status': 500, 'message': 'internal error'}
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('method',
help='This field cannot be blank',
required=True) # sent or get
parser_copy.add_argument(
'admin', required=False) # boolean: if request for admin or not
data = parser_copy.parse_args()
current_user = get_jwt_identity()
if current_user:
user = models.find_user({'mphone': current_user})
messages = models.get_message(data['method'], user['_id'])
else:
if data['admin']:
messages = models.get_message(data['method'], 'admin')
else:
return {
'status': 400,
'message': 'if not login, admin field must be include'
}
json_message = list()
for item in messages:
item['_id'] = str(item['_id'])
item['sender'] = str(item['sender'])
item['receiver'] = str(item['receiver'])
item['date'] = item['date'].isoformat()
if item['reply']:
item['reply'] = str(item['reply'])
json_message.append(item)
return json_message
def post(self):
current_user = get_jwt_identity()
user = models.find_user({"mphone": current_user})
courses = list()
for item in user['ipcourse']:
current_course = models.get_user_ip_course(item)
current_course['_id'] = str(current_course['_id'])
courses.append(current_course)
return courses
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('file',
type=werkzeug.datastructures.FileStorage,
location='files')
parser_copy.add_argument('to',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('title',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('body',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('reply',
required=False) # id of replied message
parser_copy.add_argument(
'exc', required=False) # boolean to check if its a exercise or not
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
message = {
'title': data['title'],
'body': data['body'],
'sender': user['_id'],
'receiver': data['to'],
'reply': data['reply'],
'exc': data['exc'],
'active': True,
'date': datetime.datetime.now()
}
if not data['file']:
if data['exc']:
return {'status': 400, 'message': 'exercise file not included'}
models.send_message(message)
return {'status': 200, 'message': 'email sent'}
file = data['file']
if file:
# file name format is: "date-user_id-filename" like: "201985-5db425890dfc269af386f9f0-file.zip"
file_name = '{}-{}-{}'.format(
str(datetime.datetime.now().date()).replace('-', ''),
user['_id'], file.filename)
file.save(os.path.join(UPLOAD_FOLDER, file_name))
message['attach'] = os.path.join(UPLOAD_FOLDER, file_name)
message_id = models.send_message(message)
if data['exc']:
models.user_rec_exc_update(user['_id'], data['receiver'],
message_id)
return {'status': 200, 'message': 'email sent'}
return {'status': 500, 'message': 'something went wrong!'}
def post(self):
current_user = get_jwt_identity()
user = models.find_user({"mphone": current_user})
live_course_ids = list(user['livecourse'].keys())
courses = list()
for item in live_course_ids:
current_course = models.get_user_live_course(item)
current_course['_id'] = str(current_course['_id'])
courses.append(current_course)
return courses
def post(self):
time = datetime.datetime.now()
parser_copy = parser.copy()
parser_copy.add_argument('course_id', help='This field cannot be blank', required=True)
parser_copy.add_argument('quiz_id', help='This field cannot be blank', required=True)
parser_copy.add_argument('answers', help='This field cannot be blank', required=True)
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
logging.info('user {} submits quiz.'.format(user['mphone']))
quiz = models.get_quiz(data["quiz_id"])
if user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1].get("end") is not None:
return {'status': 404,
'message': 'first start the quiz'}
else:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["end"] = time
if (time - user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["start"]).seconds > quiz["time"]:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["score"] = 0
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["passed"] = False
models.update_user({"_id": user["_id"]}, {"reccourse": user["reccourse"]})
return {"status": 403,
"messsage": "time passed"}
score = self.quiz_correction(ast.literal_eval(data["answers"]), quiz["answers"], quiz["points"])
if isinstance(score, list):
return {"status": 400,
"message": score}
user_answers = ast.literal_eval(data["answers"])
user_answers["user"] = user["_id"]
user_answers["exam"] = quiz["_id"]
user_answers["course"] = ObjectId(data["course_id"])
models.submit_exam(user_answers)
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["score"] = score
if score >= quiz["accept"]:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["passed"] = True
models.update_user({"_id": user["_id"]}, {"reccourse": user["reccourse"]})
return {"status": 200,
"score": score}
else:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["passed"] = False
models.update_user({"_id": user["_id"]}, {"reccourse": user["reccourse"]})
return {"status": 201,
"score": score}
def post(self):
parser_copy = parser.copy()
# required
parser_copy.add_argument('fname', help='This field cannot be blank', required=True)
parser_copy.add_argument('lname', help='This field cannot be blank', required=True)
parser_copy.add_argument('mphone', help='This field cannot be blank', required=True)
parser_copy.add_argument('email', help='This field cannot be blank', required=True)
parser_copy.add_argument('mcode', help='This field cannot be blank', required=True)
parser_copy.add_argument('pass', help='This field cannot be blank', required=True)
# not required
parser_copy.add_argument('phone', required=False)
parser_copy.add_argument('state', required=False)
parser_copy.add_argument('city', required=False)
parser_copy.add_argument('address', required=False)
data = parser_copy.parse_args()
# check if user is new or not
if models.find_user({"mphone": data['mphone']}):
logging.warning('request for registering user that exists. user: {}'.format(data['mphone']))
return {'status': 400,
'message': 'User {} already exists'. format(data['mphone'])}
new_user = {
"fname": data['fname'],
"lname": data['lname'],
"mphone": data['mphone'],
"phone": data['phone'],
"email": data['email'],
"mcode": data['mcode'],
"state": data['state'],
"city": data['city'],
"address": data['address'],
"pass": sha256.hash(data['pass']),
}
try:
models.create_user(new_user)
access_token = create_access_token(identity=data['mphone'],
expires_delta=ACCESS_TOKEN_EXPIRE)
refresh_token = create_refresh_token(identity=data['mphone'])
logging.info('user created. user: {}'.format(data['mphone']))
return {
'status': 200,
'message': 'User {} {} was created'.format(data['fname'], data['lname']),
'access_token': access_token,
'refresh_token': refresh_token
}
except Exception as e:
logging.error('exception occurred', exc_info=True)
return {'status': 500,
'message': 'Something went wrong'}
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('_id', help='This field cannot be blank', required=True)
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
if data['_id'] in user['reccourse'].keys():
return user['reccourse'][data['_id']]['status']['lastSeen']
else:
return {'status': 400,
'message': 'course id is invalid'}
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('_id', help='This field cannot be blank', required=True)
parser_copy.add_argument('week', help='This field cannot be blank', required=True)
parser_copy.add_argument('part', help='This field cannot be blank', required=True)
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
logging.info('set status. user: {} week: {} part: {}'.format(user["mphone"], data["week"], data["part"]))
if data['_id'] not in user['reccourse'].keys():
return {'status': 400,
'message': 'course id is invalid'}
try:
last_seen = user['reccourse'][data['_id']]['status']['lastSeen']
except:
user['reccourse'][data['_id']] = {'status': {'lastSeen': {'week': 0, 'part': 0}}}
last_seen = user['reccourse'][data['_id']]['status']['lastSeen']
if int(data['week']) < int(last_seen['week']):
return {'status': 401,
'message': 'user is ahead'}
elif int(data['week']) == int(last_seen['week']):
if int(data['part']) < int(last_seen['part']):
return {'status': 401,
'message': 'user is ahead'}
user['reccourse'][data['_id']]['status']['lastSeen'] = {'week': data['week'],
'part': data['part']}
models.update_user({"_id": user["_id"]}, {'reccourse': user['reccourse']})
return {'status': 200,
'message': 'status updated',
'data': {
'week': data['week'],
'part': data['part']
}}
def post(self):
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
rec_course_ids = [ObjectId(_id) for _id in user['reccourse'].keys()]
current_date = datetime.datetime.now()
current_time = datetime.date(current_date.year, current_date.month, current_date.day).isocalendar()
courses = list()
for item in rec_course_ids:
current_course = models.get_user_rec_course(item)
current_course['_id'] = str(current_course['_id'])
course_time = datetime.date(current_course['s_time'].year,
current_course['s_time'].month,
current_course['s_time'].day).isocalendar()
if current_time[0] == course_time[0]:
week_delta = current_time[1] - course_time[1]
else:
week_delta = current_time[1] + 52 - course_time[1]
if current_time[1] == course_time[1] and current_time[2] >= course_time[2]:
week_delta += 1
null_maker = False # use for nullify weeks after not passed quiz
for week in current_course['weeks']:
if null_maker is True or int(week) > week_delta + 1:
current_course['weeks'][week] = None
if current_course['weeks'][week] is not None:
if current_course['weeks'][week].get("quiz") is None:
null_maker = False
else:
if user["reccourse"][str(item)]["exams"].get(current_course['weeks'][week]["quiz"]) is None:
null_maker = True
else:
_last = user["reccourse"][str(item)]["exams"][current_course['weeks'][week]["quiz"]][-1]
if _last.get("passed") is None:
null_maker = True
elif _last["passed"] is False:
null_maker = True
current_course['s_time'] = current_course['s_time'].isoformat()
courses.append(current_course)
return courses
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('course_id', help='This field cannot be blank', required=True)
parser_copy.add_argument('quiz_id', help='This field cannot be blank', required=True)
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
quiz = models.get_quiz(data["quiz_id"])
if user["reccourse"][data["course_id"]]["exams"].get(data["quiz_id"]) is None:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]] = [{"attempt": 1,
"start": datetime.datetime.now()}]
else:
if user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1].get("end") is None:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]][-1]["end"] = "unfinished"
models.update_user({"_id": user["_id"]}, {"reccourse": user["reccourse"]})
return {'status': 403,
'message': 'last quiz was unfinished'}
attempt_num = len(user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]])
if attempt_num < quiz["attemptLock"]:
user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]].append({"attempt": attempt_num+1,
"start": datetime.datetime.now()}
)
else:
return {'status': 401,
'message': 'no attempt left'}
logging.info('user {} starts quiz.'.format(user['mphone']))
models.update_user({"_id": user["_id"]}, {"reccourse": user["reccourse"]})
return {"status": 200,
"questions": quiz["questions"],
"quiz_time": quiz["time"],
"min_score": quiz["accept"],
"negative_points": quiz["negPoint"],
"attempts_remaining": quiz["attemptLock"] -
len(user["reccourse"][data["course_id"]]["exams"][data["quiz_id"]])}
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('_id',
help='This field cannot be blank',
required=True)
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user_srid = models.find_user({'mphone': current_user})["srid"]
courses_srid = models.live_courses(_id=data['_id'])["srid"]
params = {
"room_id": courses_srid,
"user_id": user_srid,
"language": "fa",
"ttl": 300
}
try:
resp = skyroom_api.getLoginUrl(params=params)
return {"status": 200, "url": resp}
except:
return {"status": 404, "message": "not yet started"}
def post(self):
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
rec_course_ids = [ObjectId(_id) for _id in user['reccourse'].keys()]
current_date = datetime.datetime.now()
current_time = datetime.date(current_date.year, current_date.month,
current_date.day).isocalendar()
courses = list()
for item in rec_course_ids:
current_course = models.get_user_rec_course(item)
current_course['_id'] = str(current_course['_id'])
course_time = datetime.date(
current_course['s_time'].year, current_course['s_time'].month,
current_course['s_time'].day).isocalendar()
if current_time[0] == course_time[0]:
week_delta = current_time[1] - course_time[1]
else:
week_delta = current_time[1] + 52 - course_time[1]
for week in current_course['weeks']:
if int(week) > week_delta:
current_course['weeks'][week] = None
current_course['s_time'] = current_course['s_time'].isoformat()
courses.append(current_course)
return courses
def post(self):
parser_copy = parser.copy()
parser_copy.add_argument('_id',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('ctype',
help='This field cannot be blank',
required=True) # ip/rec/liv
parser_copy.add_argument('method',
help='This field cannot be blank',
required=True) # 1:full/2,3:installment
data = parser_copy.parse_args()
current_user = get_jwt_identity()
user = models.find_user({'mphone': current_user})
if data['ctype'] == "ip":
if ObjectId(data["_id"]) in user["ipcourse"]:
return {
'status': 405,
'message': 'this course is currently purchased'
}
courses = models.ip_courses(_id=data['_id'])
elif data['ctype'] == "rec":
if ObjectId(data["_id"]) in user["reccourse"].keys():
return {
'status': 405,
'message': 'this course is currently purchased'
}
courses = models.rec_courses(_id=data['_id'])
elif data['ctype'] == "liv":
if ObjectId(data["_id"]) in user["livecourse"].keys():
return {
'status': 405,
'message': 'this course is currently purchased'
}
courses = models.live_courses(_id=data['_id'])
else:
return {'status': 400, 'message': 'course type or id is incorrect'}
if courses['price'] == '0':
if data['ctype'] == 'ip':
models.add_user_ip_course(str(user["_id"]),
str(courses["_id"]))
elif data['ctype'] == 'rec':
models.add_user_rec_course(str(user["_id"]),
str(courses["_id"]))
elif data['ctype'] == 'liv':
srid = models.user_has_skyroom(str(user["_id"]))
if srid:
models.add_user_live_course(str(user["_id"]),
str(courses["_id"]), srid)
else:
srid = models.add_user_skyroom(str(user["_id"]))
models.add_user_live_course(str(user["_id"]),
str(courses["_id"]), srid)
else:
return {'status': 400, 'message': 'something went wrong'}
return {'status': 200, 'message': 'free course added to user'}
try:
# TODO: in db all prices must be in integer form not price with "," sign!
course_price = int(
int(courses['price'].replace(',', '')) / int(data['method']))
payment_desc = PAYMENT_DESCRIPTION.format(courses['title'])
# for item in courses:
# if item["_id"] == ObjectId(data['_id']):
# course_price = int(item['price'])/int(data['method'])
# payment_desc = PAYMENT_DESCRIPTION.format(item['title'])
if not course_price or not payment_desc:
return {'status': 500, 'message': 'course does not exist'}
except KeyError as e:
return {'status': 404, 'message': e}
callback_url = SERVER_IP + '/PayCallback/{}/{}/{}/{}/{}'.format(
data['method'], str(user['_id']), data['_id'], course_price,
data['ctype'])
client = Client(ZARINPAL_WEBSERVICE)
result = client.service.PaymentRequest(MMERCHANT_ID, course_price,
payment_desc, EMAIL, MOBILE,
callback_url)
# for debug
# print(result, course_price, callback_url, payment_desc)
if result.Status == 100:
return {
'status': 200,
'url':
'https://www.zarinpal.com/pg/StartPay/' + result.Authority
}
else:
return {'status': 500, 'error': 'Zarinpal not responding'}
def test_create_user(session, user):
assert create_user(session, user)
assert find_user(session, user.email).email == user.email
def test_find_user(session, user):
assert not find_user(session, user.email)
def post(self):
parser_copy = parser.copy()
# required
parser_copy.add_argument('fname',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('lname',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('mphone',
help='This field cannot be blank',
required=True)
parser_copy.add_argument('mcode',
help='This field cannot be blank',
required=True)
# parser_copy.add_argument('pass', help='This field cannot be blank', required=True)
# not required
parser_copy.add_argument('email', required=False)
parser_copy.add_argument('phone', required=False)
parser_copy.add_argument('state', required=False)
parser_copy.add_argument('city', required=False)
parser_copy.add_argument('address', required=False)
data = parser_copy.parse_args()
if models.find_user({"mphone":
data['mphone']}): # check if user is new or not
logging.warning(
'request for registering user that exists. user: {}'.format(
data['mphone']))
return {
'status': 400,
'message': 'User {} already exists'.format(data['mphone'])
}
if redis_cli.get(data['mphone']) != b'accepted':
return {
'status': 404,
'message': 'you should first submit yout mobile'
}
new_user = {
"fname": data['fname'],
"lname": data['lname'],
"mphone": data['mphone'],
"phone": data['phone'],
"email": data['email'],
"mcode": data['mcode'],
"state": data['state'],
"city": data['city'],
"address": data['address'],
"ipcourse": [],
"livecourse": {},
"reccourse": {}
}
try:
models.create_user(new_user)
access_token = create_access_token(
identity=data['mphone'], expires_delta=ACCESS_TOKEN_EXPIRE)
refresh_token = create_refresh_token(identity=data['mphone'])
logging.info('user created. user: {}'.format(data['mphone']))
telegram_bot.send_message(
"new user created, name: <b>{} {}</b>, phone: <b>{}</b>".
format(data['fname'], data['lname'], data['mphone']))
return {
'status':
200,
'message':
'User {} {} was created'.format(data['fname'], data['lname']),
'access_token':
access_token,
'refresh_token':
refresh_token
}
except Exception as e:
logging.error('exception occurred', exc_info=True)
return {'status': 500, 'message': 'Something went wrong'}
def user(session, email):
create_user(session, User(email=email))
return find_user(session, email)
