def upload_doc(username, file_url, file_name, course_id,course_schedule_id,room_id,is_view):
"""
Upload file as courseware into classroom
:param username:
:param file_url: courseware file url
:param file_name: courseware file display name
:return: uuid refer to uploaded courseware from provider
"""
with session_scope(db) as session:
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/uploadFileUrl',
data=json.dumps({
'filename': file_name,
'roomId': room_id,
'fileUrl': file_url,
'username': username
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
cw = Courseware(
ware_name=file_name,
ware_desc=file_name,
ware_url=file_url,
ware_uid=r.json()['uuid'],
checked_result=CoursewareCheckResultEnum.BEFORE_CHECK,
course_id=course_id,
course_schedule_id = course_schedule_id,
room_id = room_id,
is_view = is_view
)
session.add(cw)
return r.json()['uuid']
def process(self):
""" Data is saved into the database """
with session_scope() as session:
self._event_data_session(session)
self._venues_data_session(session)
self._attractions_data_session(session)
session.commit()
def student_logo():
"""
swagger-doc: 'schedule'
required: []
req:
res:
url:
description: ''
type: 'string'
"""
student_id = getattr(g, current_app.config['CUR_USER'])['id']
url = 'images/logo.png'
domain_address = 'http://www.vipustutor.com/'
with session_scope(db) as session:
student = session.query(Student).filter_by(id=student_id).one_or_none()
if student is not None and student.channel_id is not None:
channel = session.query(Channel).filter_by(id=student.channel_id).one_or_none()
if channel is not None :
if channel.logo_url is not None:
url = channel.logo_url
if channel.domain_address is not None:
domain_address = channel.domain_address
return jsonify({'url':url,'domain_address':domain_address })
def remove_doc(username, room_id, ware_uid):
"""
Remove attached course ware from room
:param username:
:param room_id: class room created for lecture
:param ware_uid: previously uploaded course ware uid returned by provider
:return: None
"""
with session_scope(db) as session:
cw = session.query(Courseware).filter(
Courseware.ware_uid == ware_uid).one_or_none()
if cw:
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/removeDocument',
data=json.dumps({
'documentId': ware_uid,
'roomId': room_id,
'username': username
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
if cw.room_id:
temp = eval(cw.room_id)
temp.remove(room_id)
cw.room_id = str(temp)
session.merge(cw)
else:
raise RuntimeError('calling removeDocument failed')
else:
raise RuntimeError(
'can not find course ware, according to ware_uid')
def preview_doc(username, ware_uid):
"""
Get course ware preview url
:param username:
:param ware_uid:
:return: url
"""
with session_scope(db) as session:
cw = session.query(Courseware).filter(
Courseware.ware_uid == ware_uid).one_or_none()
if cw:
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/previewDocUrl',
data=json.dumps({
'documentId': ware_uid,
'username': username
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
return r.json()['url']
else:
raise RuntimeError('calling previewDocUrl failed')
else:
raise RuntimeError(
'can not find course ware, according to ware_uid')
def delete_room(username, room_id):
"""
Delete living teaching room.
:param username: user account name
:param room_id: room id returned by provider after doing room creation
:return: None if delete succ
"""
current_app.logger.debug(room_id)
with session_scope(db) as session:
course_classroom = session.query(CourseClassroom).filter(
CourseClassroom.room_id == room_id).one_or_none()
if not course_classroom:
raise RuntimeError('CourseClassroom of room_id passed in not found')
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/deleteRoom',
data=json.dumps({
'roomId': room_id,
'userName': username
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
course_classroom.state = ClassroomStateEnum.DELETED
session.merge(course_classroom)
else:
raise RuntimeError(r.json()['message'])
def do_query(params, generate_sql):
current_app.logger.debug(params)
with session_scope(db) as session:
columns, sql = generate_sql(params)
current_app.logger.debug(sql)
result = session.execute(sql, params)
# default page_no to 1
page_no = 1
if params['page_no']:
page_no = params['page_no']
# default page_limit to 10 records per page
page_limit = 10
if params['page_limit']:
page_limit = params['page_limit']
# calculate offset
offset = (page_no - 1) * page_limit
rows = result.fetchall()
row_count = len(rows)
total_pages = row_count // page_limit
if row_count % page_limit != 0:
total_pages = total_pages + 1
final_result = {
'objects': [],
'num_results': row_count,
'page': page_no,
'total_pages': total_pages
}
for index, row in enumerate(rows):
current_app.logger.debug('row ' + str(index) + ' = ' + str(row))
if (offset + page_limit) > index >= offset:
final_result['objects'].append(
dict((c, v) for c, v in zip(columns, row)))
return final_result
def upload_courseware():
"""
swagger-doc: 'schedule'
required: []
req:
course_schedule_id:
description: '课节id'
type: 'string'
start:
description: '开始时间'
type: 'string'
end:
description: '结束时间'
type: 'string'
res:
verify_code:
description: 'id'
type: ''
"""
course_schedule_id = request.json['course_schedule_id']
start = request.json['start'].replace('T', ' ').replace('Z', '')
end = request.json['end'].replace('T', ' ').replace('Z', '')
with session_scope(db) as session:
courseSchedule = session.query(CourseSchedule).filter_by(id=course_schedule_id).one_or_none()
courseclassroom = session.query(CourseClassroom).filter_by(course_schedule_id=course_schedule_id).one_or_none()
if courseSchedule is None or courseclassroom is None:
return jsonify({
"error": "not found course_schedule: {0}".format(
course_schedule_id)
}), 500
setattr(courseSchedule,'start',start)
setattr(courseSchedule,'end',end)
session.add(courseSchedule)
session.flush()
live_service.edit_room(getattr(g, current_app.config['CUR_USER'])['username'],courseclassroom.room_id,courseclassroom.room_title,
getTimeDiff(start,end),request.json['start'],request.json['end'],0,'en')
studyschedules = session.query(StudySchedule).filter_by(course_schedule_id=course_schedule_id).all()
if studyschedules is None or len(studyschedules)<1:
return jsonify({
"error": "not found Course_Class_room: {0}".format(
course_schedule_id)
}), 500
for studyschedule in studyschedules:
setattr(studyschedule,'actual_start',start)
setattr(studyschedule,'actual_end',end)
session.add(studyschedule)
session.flush()
return jsonify({'id':courseSchedule.id })
def register_account(data):
username = data.get('username')
password = data.get('password')
age = data.get('age')
with session_scope() as db_session:
user = User(username=username, password=password, age=age)
db_session.add(user)
db_session.commit()
return {'username': user.username}
def resetpassword():
"""
swagger-doc: 'do resetpassword with verify code sent by email or sms'
required: ['username', 'password', 'verify_code']
req:
username:
description: 'login user name'
type: 'string'
password:
description: 'login user password'
type: 'string'
verify_code:
description: 'code sent by calling email verify or sms verify'
type: 'string'
res:
message:
description: 'success message for reset password'
type: 'string'
"""
current_app.logger.debug(request.json)
user_name = request.json['username']
verify_code = request.json['verify_code']
password = request.json['password']
oldpassword = ''
mobile = ''
check_target = redis_store.get('VC:' + user_name)
if check_target:
check_target = check_target.decode('utf8')
else:
check_target = 'None'
current_app.logger.debug(verify_code + ' ' + check_target + ' ' +
str(verify_code != check_target))
if verify_code != check_target:
return jsonify({'message': 'verify code check failed'}), 401
with session_scope(db) as session:
# check existing username in all 3 tables
for table_checked in user_source.values():
row1 = session.query(table_checked).filter(
table_checked.username == user_name).one_or_none()
current_app.logger.debug("table_checked.__name__ " +
str(table_checked.__name__))
if row1:
# update password
current_app.logger.debug('password: '******'new password: '******'en')
return jsonify({'message': 'reset password succ!'})
return jsonify({'message': user_name + ' not found!'}), 401
def create_room(username, course_schedule_id, title, length=60,
room_type=ClassroomTypeEnum.ONE_VS_ONE,
start_time=datetime.now().isoformat()[:-3] + 'Z', user_type=0,
lang='en'):
"""
Create living teaching room for teach and students.
:param username: user account name
:param course_schedule_id: course schedule id
:param title: room title displayed
:param length: lecture room services time duration
:param room_type: 1: 1V1, 2:1VMany, 3:Public-lecture
:param start_time: room available time
:param user_type: preserved for future use
:param lang: user preferred lang
:return: room created by third-party provider
"""
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/createRoom',
data=json.dumps({
'title': title,
'startTime': start_time,
'length': length,
'menNum': ClassroomTypeEnum[room_type].value,
'userName': username,
'lang': lang,
'userType': user_type,
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
j = r.json()['room']
with session_scope(db) as session:
if r.json()['code'] == 0:
# succ, insert CourseClassroom record
duration_start = datetime.strptime(j['startTime'],
'%Y-%m-%dT%H:%M:%S.%fZ')
duration_end = datetime.strptime(j['endTime'],
'%Y-%m-%dT%H:%M:%S.%fZ')
course_classroom = CourseClassroom(
provider=1,
course_schedule_id=course_schedule_id,
video_ready=1,
updated_by=username,
room_type=room_type,
state=ClassroomStateEnum.CREATED,
host_code=j['hostCode'],
room_id=j['roomId'],
room_title=title,
duration_start=duration_start,
duration_end=duration_end)
session.add(course_classroom)
return r.json()['room']
else:
raise RuntimeError(r.json()['message'])
def edit_course_schedule_type():
"""
swagger-doc: 'schedule'
required: []
req:
course_schedule_id:
description: '课节id'
type: 'string'
type:
description: '类型'
type: 'string'
res:
verify_code:
description: 'id'
type: ''
"""
course_schedule_id = request.json['course_schedule_id']
type = request.json['type']
with session_scope(db) as session:
courseSchedule = session.query(CourseSchedule).filter_by(id=course_schedule_id).one_or_none()
if courseSchedule is None :
return jsonify({
"error": "not found course_schedule: {0}".format(
course_schedule_id)
}), 500
setattr(courseSchedule,'schedule_type',type)
session.add(courseSchedule)
session.flush()
studyschedules = session.query(StudySchedule).filter_by(course_schedule_id=course_schedule_id).all()
if studyschedules is None or len(studyschedules)<1:
return jsonify({
"error": "not found Course_Class_room: {0}".format(
course_schedule_id)
}), 500
for studyschedule in studyschedules:
setattr(studyschedule,'schedule_type',type)
session.add(studyschedule)
session.flush()
return jsonify({'id':courseSchedule.id })
def enter_room(username, room_id, nick_name,
role_in_classroom=ClassroomRoleEnum.ASSISTANT,
device_type=ClassroomDeviceEnum.PC):
"""
Get url for classroom by provide nick_name, role and device_type
:param username:
:param room_id: class room created before
:param nick_name: name displayed in class room
:param role_in_classroom: ClassroomRoleEnum
:param device_type: ClassroomDeviceEnum
:return: url for class room
"""
current_app.logger.debug(room_id)
with session_scope(db) as session:
# course_classroom = session.query(CourseClassroom).filter(
# CourseClassroom.room_id == room_id).one_or_none()
# if not course_classroom:
# raise RuntimeError('CourseClassroom of room_id passed in not found')
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/getRoomEnterUrl',
data=json.dumps({
'roomId': room_id,
'userName': username,
'nickname': nick_name,
'userRole': ClassroomRoleEnum[role_in_classroom].value - 1,
'deviceType': ClassroomDeviceEnum[device_type].value - 1
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
# if r.json()['code'] == 0:
# if course_classroom.room_url:
# temp = eval(course_classroom.room_url)
# temp.append(r.json()['url'])
# course_classroom.room_url = str(temp)
# else:
# course_classroom.room_url = "['{}']".format(r.json()['url'])
# c_c_p = CourseClassParticipant(
# role_in_course=role_in_classroom,
# access_url=r.json()['url'],
# device_type=device_type,
# course_classroom_id=course_classroom.id,
# role_id=nick_name,
# updated_by=username
# )
# session.add(c_c_p)
# session.merge(course_classroom)
return r.json()['url']
def smsverify():
"""
swagger-doc: 'send verify code by sms'
required: ['mobile_no']
req:
mobile_no:
description: 'mobile NO to receive verify code'
type: 'string'
country_code:
description: 'country code, if omit, default to 86'
type: 'string'
res:
verify_code:
description: 'verify code sent to user mobile NO'
type: 'string'
"""
mobile_no = request.json['mobile_no']
country_code = '86'
verify_code = random.randint(100000, 999999)
if 'country_code' in request.json:
country_code = request.json['country_code']
r = requests.post(current_app.config['EP_LOCATION'] +
current_app.config['EP_SMS_PATH'],
data=json.dumps({
'type': 1,
'userName': mobile_no,
'registerType': 1,
'countryCode': country_code,
'code': str(verify_code)
}),
headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
with session_scope(db) as session:
smslog = SmsLog(country_code=country_code,
mobile=mobile_no,
content=verify_code,
sms_channel='TX',
state=1,
result_code=0,
fee=5)
session.add(smslog)
redis_store.set('VC:' + mobile_no, str(verify_code))
return jsonify({'verify_code': str(verify_code)})
else:
return jsonify({'message': r.json()['message']}), 500
def sql_query(self):
with session_scope(db) as session:
session.add_all([
Notification(notice='test-1'),
Notification(notice='test-2', updated_by='rawsql')
])
session.flush()
sql1 = "select id, notice, updated_at, updated_by " \
"from notification where notice like :x"
r2 = session.execute(sql1, {'x': 'test-2'})
row = r2.first()
self.app.logger.debug('row=' + str(row))
self.assertEqual(row['updated_by'], 'rawsql',
'check updated_at=rawsql')
r3 = session.execute(sql1, {'x': 'test%'})
for index, row in enumerate(r3.fetchall()):
self.app.logger.debug('row ' + str(index) + ' = ' + str(row))
def test_duobei_live(self):
'''
Test for services.live_service
'''
url = 'http://docs-aliyun.cn-hangzhou.oss.aliyun-inc.com/pdf/' \
'dds-product-introduction-intl-zh-2018-03-30.pdf'
start_time = datetime.now().isoformat()[:-3] + 'Z'
self.app.logger.debug(start_time)
with session_scope(db) as session:
cs = session.query(CourseSchedule).filter(
CourseSchedule.updated_by == os.getpid()).first()
if cs:
r = create_room('86-13521273258', cs.id, 'test room', 60)
self.app.logger.debug(r)
self.assertIsNotNone(r, 'create room not return room for succ')
room_id = r['roomId']
r = edit_room('86-13521273258', room_id, 'edit room', 90)
self.app.logger.debug(r)
r = enter_room('86-13521273258', room_id, 'Tom')
self.app.logger.debug(r)
self.assertIsNotNone(r, 'enter room not return url')
# test upload course ware
r = upload_doc('86-13521273258', url, 'python-consul.pdf',
cs.course_id)
self.app.logger.debug(r)
self.assertIsNotNone(r, 'upload_doc not return ware_uid')
# attach uploaded course ware with created room
ware_uid = r
r = attach_doc('86-13521273258', room_id, ware_uid)
self.app.logger.debug(r)
self.assertEqual(None, r,
'attach_doc not return None for succ')
# get preview document url from ware_uid
self.app.logger.debug('ware_uid: ' + ware_uid)
r = preview_doc('86-13521273258', ware_uid)
self.app.logger.debug(r)
self.assertIsNotNone(r, 'preview_doc not return url for succ')
# remove document from room
r = remove_doc('86-13521273258', room_id, ware_uid)
self.app.logger.debug(r)
# self.assertEqual(None, r, 'remove_doc not return None for succ')
# finally delete class room
r = delete_room('86-13521273258', room_id)
self.app.logger.debug(r)
self.assertEqual(None, r,
'delete_room not return None for succ')
def edit_room(username, room_id, title=None, length=None,
start_time=None,start_end=None, user_type=0,
lang='en'):
"""
Edit living teaching room created before.
:param username: user account name
:param room_id: room id returned by provider after doing room creation
:param title: room title displayed
:param length: lecture room services time duration
:param start_time: room available time
:param user_type: preserved for future use
:param lang: user preferred lang
:return: None if succ without error
"""
with session_scope(db) as session:
course_classroom = session.query(CourseClassroom).filter(
CourseClassroom.room_id == room_id).one_or_none()
if not course_classroom:
raise RuntimeError('CourseClassroom of room_id passed in not found')
r = requests.post(
current_app.config['EP_LOCATION'] + current_app.config[
'EP_LIVE_PATH'] + '/editRoom',
data=json.dumps({
'roomId': room_id,
'title': title,
'startTime': start_time,
'langth': length,
'userName': username,
'lang': lang,
'userType': user_type,
}), headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
j = r.json()['room']
if r.json()['code'] == 0:
# succ, insert CourseClassroom record
if title:
course_classroom.room_title = title
if start_time:
course_classroom.duration_start = start_time.replace('T', ' ').replace('Z', '')
if length:
course_classroom.duration_end = start_end.replace('T', ' ').replace('Z', '')
course_classroom.updated_by = username
session.merge(course_classroom)
else:
raise RuntimeError(r.json()['message'])
def save_attachment(file):
fn = file.filename
ext = fn.rsplit('.', 1)[1].lower()
hashed_fn = hashlib.sha256(fn.encode('utf8')).hexdigest() + '.' + ext
disk_file = os.path.join(current_app.config['UPLOAD_FOLDER'], hashed_fn)
file.save(disk_file)
size = os.stat(disk_file).st_size
updated_by = getattr(g, current_app.config['CUR_ID'])
with session_scope(db) as session:
attachment = Attachment(file_name=fn,
url_path=hashed_fn,
size=size,
mime_type=ext,
state=1,
updated_by=updated_by)
result = session.add(attachment)
current_app.logger.debug(result)
return hashed_fn
def save_subject():
"""
swagger-doc: 'schedule'
required: []
req:
subject_id:
description: '课节id'
type: 'int'
subject_type:
description: '1:学习科目，2：意向科目'
type: 'int'
res:
id:
description: ''
type: ''
"""
student_id = getattr(g, current_app.config['CUR_USER'])['id']
subject_id = request.json['subject_id']
subject_type = request.json['subject_type']
optional = 2
if 'optional' in request.json:
optional = request.json['optional']
with session_scope(db) as session:
studentSubject = session.query(StudentSubject).filter_by(student_id=student_id,subject_type=subject_type).one_or_none()
if studentSubject is None :
studentSubject = StudentSubject(optional = optional,
subject_type = subject_type,
student_id = student_id,
subject_id = subject_id,
updated_by=getattr(g, current_app.config['CUR_USER'])['username']
)
session.add(studentSubject)
session.flush()
else:
setattr(studentSubject,'subject_id',subject_id)
setattr(studentSubject,'subject_type',subject_type)
setattr(studentSubject,'optional',optional)
session.add(studentSubject)
session.flush()
return jsonify({'id':studentSubject.id })
def get_enter_room_url():
"""
swagger-doc: 'schedule'
required: []
req:
study_schedule_id:
description: '课节id'
type: 'string'
res:
url:
description: '登录地址'
type: ''
"""
study_schedule_id = request.json['study_schedule_id']
with session_scope(db) as session:
studyschedule = session.query(StudySchedule).filter_by(id=study_schedule_id).one_or_none()
if studyschedule is None :
return jsonify({
"error": "not found Study_Schedule: {0}".format(
study_schedule_id)
}), 500
if studyschedule.schedule_type.name == 'LOCKED' :
return jsonify({
"error": "study schedule has locked"
}), 500
courseclassroom = session.query(CourseClassroom).filter_by(course_schedule_id =studyschedule.course_schedule_id).one_or_none()
if courseclassroom is None :
return jsonify({
"error": "found courseclassroom existing in {0}".format(
study_schedule_id)
}), 500
url = live_service.enter_room(getattr(g, current_app.config['CUR_USER'])['username'],courseclassroom.room_id,getattr(g, current_app.config['CUR_USER'])['name'],
ClassroomRoleEnum.STUDENT.name,ClassroomDeviceEnum.PC.name)
return jsonify({'url':url })
def delFile(folderId, user_type=0, lang='en'):
"""
"""
with session_scope(db) as session:
r = requests.post(current_app.config['EP_LOCATION'] +
current_app.config['EP_CLASSIN_PATH'] + '/delFile',
data=json.dumps({
'fileId': folderId,
'lang': lang,
'userType': user_type,
}),
headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
return r.json()['fileId']
else:
raise RuntimeError(r.json()['message'])
def editCourseClass(courseId,
classId,
className,
beginTime,
endTime,
teacherAccount,
teacherName,
user_type=0,
lang='en'):
"""
"""
with session_scope(db) as session:
r = requests.post(current_app.config['EP_LOCATION'] +
current_app.config['EP_CLASSIN_PATH'] +
'/editCourseClass',
data=json.dumps({
'courseId':
courseId,
'classId':
classId,
'className':
className,
'beginTime':
beginTime.replace('T', ' ').replace('Z', ''),
'endTime':
endTime.replace('T', ' ').replace('Z', ''),
'teacherAccount':
teacherAccount,
'teacherName':
teacherName,
'lang':
lang,
'userType':
user_type,
}),
headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
return r.json()['code']
else:
raise RuntimeError(r.json()['message'])
def apply_tryout():
"""
swagger-doc: 'schedule'
required: []
req:
start:
description: '开始时间'
type: 'string'
end:
description: '结束时间'
type: 'string'
student_id:
description: '学生id，不传默认自己'
type: 'string'
res:
verify_code:
description: 'id'
type: ''
"""
start = request.json['start'].replace('T', ' ').replace('Z', '')
end = request.json['end'].replace('T', ' ').replace('Z', '')
student_id = getattr(g, current_app.config['CUR_USER'])['id']
if 'student_id' in request.json:
student_id = request.json['student_id']
with session_scope(db) as session:
studyAppointment = StudyAppointment(
student_id = student_id,
delete_flag = 'IN_FORCE',
open_time_start= start,
open_time_end = end,
appointment_state='WRITE_APPOINTMENT',
updated_by=getattr(g, current_app.config['CUR_USER'])['username'],
apply_by=getattr(g, current_app.config['CUR_USER'])['username']
)
session.add(studyAppointment)
session.flush()
return jsonify({'id':studyAppointment.id })
def getTempLoginKey(telephone, user_type=0, lang='en'):
"""
"""
with session_scope(db) as session:
r = requests.post(current_app.config['EP_LOCATION'] +
current_app.config['EP_CLASSIN_PATH'] +
'/getTempLoginKey',
data=json.dumps({
'telephone': telephone,
'lang': lang,
'userType': user_type,
}),
headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
return r.json()['key']
else:
raise RuntimeError(r.json()['message'])
def changeTeacher(courseId, teacherAccount, user_type=0, lang='en'):
"""
"""
with session_scope(db) as session:
r = requests.post(current_app.config['EP_LOCATION'] +
current_app.config['EP_CLASSIN_PATH'] +
'/changeTeacher',
data=json.dumps({
'courseId': courseId,
'teacherAccount': teacherAccount,
'lang': lang,
'userType': user_type,
}),
headers={'Content-type': 'application/json'})
current_app.logger.debug(r.text)
if r.json()['code'] == 0:
return r.json()['code']
else:
raise RuntimeError(r.json()['message'])
def sql_check(self):
todo_user = random_username()
json.loads(super().register(todo_user,
'Student').get_data(as_text=True))
with session_scope(db) as session:
r1 = session.execute("select * from student")
row1 = r1.first()
self.assertIsNotNone(
row1, "After student register, no record found for "
"student")
r2 = session.add_all([
Notification(notice='meeting today'),
Notification(notice='meeting cancel')
])
self.app.logger.debug('r2=' + str(r2))
r3 = session.query(Notification).delete()
self.app.logger.debug('r3=' + str(r3))
r4 = session.query(Notification).first()
self.app.logger.debug('r4=' + str(r4))
self.assertIsNone(r4, "After delete all, first should return None")
r5 = session.query(Notification).one_or_none()
self.app.logger.debug('r5=' + str(r5))
async def verify_user(request):
"""
是否放到线程池中执行是可选的，所以不一定要加装饰器，这个时候只能优化sql，确保速度够快
:param request:
:return:
"""
request_data = request.json
username = request_data.get('username')
password = request_data.get('password')
# user_agent = request.headers.get('User-Agent')
with session_scope() as db_session:
user = db_session.query(User).filter_by(username=username).first()
if not user:
raise exceptions.UserNotFound()
if not user.check_password(password):
raise exceptions.PasswordError()
client_info = client_info_from_request_data(request_data)
token = await create_and_cache_token(user.id, password, client_info)
return {'user_id': user.id, 'token': token}
def login():
"""
swagger-doc: 'do login for registered user'
required: ['username', 'password', 'usertype']
req:
username:
description: 'login user name'
type: 'string'
password:
description: 'login user password'
type: 'string'
usertype:
description: 'login user type (Student, Teacher, SysUser)'
type: 'string'
res:
Authorization:
description: 'Athorization jwt http header'
type: 'string'
"""
user_name = request.json['username']
password = request.json['password']
user_type = request.json['usertype']
with session_scope(db) as session:
user = session.query(
user_source[user_type]).filter_by(username=user_name).first()
if user:
# check password
if check_password_hash(getattr(user, 'password', ''), password):
token = generate_jwt_token(current_app.config['JWT_HEADER'],
user_name)
return jsonify({**token, **{'id': getattr(user, 'id')}})
else:
return jsonify({'message': 'password check failed!'}), 401
else:
return jsonify({'message': user_name + ' not found!'}), 401
def register():
"""
swagger-doc: 'do register for new user'
required: ['username', 'password', 'usertype', 'verify_code']
req:
username:
description: 'login user name'
type: 'string'
password:
description: 'login user password'
type: 'string'
usertype:
description: 'login user type (Student, Teacher, SysUser)'
type: 'string'
verify_code:
description: 'code sent by calling email verify or sms verify'
type: 'string'
first_name:
description: 'first_name'
type: 'string'
last_name:
description: 'last_name'
type: 'string'
code:
description: '国家代码'
type: 'int'
res:
Authorization:
description: 'Athorization jwt http header'
type: 'string'
"""
current_app.logger.debug(request.json)
user_name = request.json['username']
user_type = request.json['usertype']
verify_code = request.json['verify_code']
check_target = redis_store.get('VC:' + user_name)
code = request.json['code']
firstName = ''
lastName = ''
if 'first_name' in request.json:
firstName = request.json['first_name']
if 'last_name' in request.json:
lastName = request.json['last_name']
if check_target:
check_target = check_target.decode('utf8')
else:
check_target = 'None'
current_app.logger.debug(verify_code + ' ' + check_target + ' ' +
str(verify_code != check_target))
if verify_code != check_target:
return jsonify({'message': 'verify code check failed'}), 500
target_table = user_source[user_type]
with session_scope(db) as session:
# check existing username in all 3 tables
found = False
message = ''
if target_table in user_source.values():
result = session.execute(
select([target_table
]).where(target_table.username == user_name))
current_app.logger.debug("table_checked.__name__ " +
str(target_table.__name__))
row1 = result.first()
message = target_table.__name__ if (row1 is not None) else ''
found = found or (row1 is not None)
else:
return jsonify({"error":
" not found {0} ".format(target_table)}), 500
if found:
result.close()
return jsonify({
"error":
"found {0} existing in {1}".format(user_name, message)
}), 500
# check if username is mobile or email, the mobile or email
# should be unique in all 3 tables
if '@' in user_name:
for table_checked in user_source.values():
result = session.execute(
select([table_checked
]).where(table_checked.email == user_name))
row1 = result.first()
message = table_checked.__name__ + ' email' if (
row1 is not None) else ''
found = found or (row1 is not None)
else:
for table_checked in user_source.values():
result = session.execute(
select([table_checked
]).where(table_checked.mobile == user_name))
row1 = result.first()
message = table_checked.__name__ + ' mobile' if (
row1 is not None) else ''
found = found or (row1 is not None)
if found:
result.close()
return jsonify({
"error":
"found {0} existing in {1}".format(user_name, message)
}), 500
email = user_name if '@' in user_name else None
mobile = user_name if '@' not in user_name else None
user = target_table(username=user_name,
password=generate_password_hash(
request.json['password']),
state=1,
updated_by=user_name,
email=email,
mobile=mobile,
nickname=user_name,
first_name=firstName,
last_name=lastName,
nation=code)
current_app.logger.debug('encrypted password:'******'JWT_HEADER'], user.username)
user_id = getattr(user, 'id')
token.update({'id': user_id})
# handle acl redis record
redis_key = 'ACL:' + user_name + ':' + user_type.lower() + ':' + str(
user_id)
value = hashlib.md5(str(user).encode('utf-8')).hexdigest()
redis_store.set(redis_key, value)
# if user.mobile is not None:
# if code != '86':
# mobile = '00'+code+'-'+mobile
# current_app.logger.debug('code--->' + code+":"+mobile+"----->"+str(user_id))
# teacher_id = classin_service.register(mobile,mobile, request.json['password'], 0, 'en')
# current_app.logger.debug('target_table:' + user_type+'---table_id:'+str(user_id)+'-----teacher_id:'+str(teacher_id))
# thirdDateLog = ThirdDateLog(table_name = user_type,
# table_id = user_id,
# third_id = str(teacher_id),
# third_date = '',
# delete_flag = 'IN_FORCE')
# session.add(thirdDateLog)
# session.flush()
return jsonify(token)
def sysUser():
"""
swagger-doc: 'do register for new user'
required: ['username', 'password', 'usertype', 'verify_code']
req:
mobile:
description: '手机号'
type: 'string'
name:
description: '用户名'
type: 'string'
password:
description: 'login user password'
type: 'string'
code:
description: '国家代码'
type: 'int'
email:
description: '邮箱'
type: 'string'
rolse:
description: '角色id字符串 例如：1，2，3，4'
type: 'string'
res:
id:
description: '用户id'
type: 'string'
"""
current_app.logger.debug(request.json)
mobile = request.json['mobile']
name = request.json['name']
email = request.json['email']
rolse = request.json['rolse']
user_type = 'SysUser'
code = '86'
if code in request.json:
code = request.json['code']
target_table = user_source[user_type]
with session_scope(db) as session:
sysUser = session.query(SysUser).filter_by(
username=mobile).one_or_none()
if sysUser is not None:
return jsonify({"error": "found SysUser: {0}".format(mobile)}), 500
sysUser = SysUser(
username=mobile,
password=generate_password_hash(request.json['password']),
state=1,
updated_by=getattr(g, current_app.config['CUR_USER'])['username'],
email=email,
mobile=mobile,
nickname=mobile,
nation=code,
name=name)
session.add(sysUser)
session.flush()
user_id = getattr(sysUser, 'id')
for rolesId in rolse.split(','):
sysUserRole = SysUserRole(
sys_user_id=user_id,
role_definition_id=rolesId,
updated_by=getattr(g,
current_app.config['CUR_USER'])['username'])
session.add(sysUserRole)
session.flush()
if sysUser.mobile is not None:
mobile = code + '-' + mobile
if sysUser.nation is '86':
mobile = sysUser.mobile
teacher_id = classin_service.register(mobile, mobile,
request.json['password'], 0,
'en')
thirdDateLog = ThirdDateLog(table_name='sys_user',
table_id=user_id,
third_id=teacher_id,
third_date='',
delete_flag='IN_FORCE')
session.add(thirdDateLog)
session.flush()
return jsonify({'id': user_id})