def retrieve(package):
"""process the request of retrieving
"""
session = package.get('session')
params = package.get("params")
username = params.get(ParamType.Username)
phone = params.get(ParamType.Phone)
if username is None:
user = package.get('user')
else:
user = UserHelper.get_user_by_username(username)
if user is None:
return Response.error_response('No User')
if phone != str(user.get("phone")):
return Response.error_response('Phone Number Error')
code = VerifyHelper.add_code(session, phone)
if ConfigHelper.get_phone_verify_able():
PhoneSender.send_verify_code(phone, code)
else:
EmailSender.send("*****@*****.**", phone + "::" + code)
return Response.checked_response("Success")
def get(self, request):
phone_number = request.POST["phone_number"]
verification_code = request.POST["verification_code"]
password = request.POST["password"]
credential = HashedPassword.get_hashed_credential(password)
if not self.verify_code(phone_number, verification_code):
return error_response(Status.VERIFICATION_FAILED,
Status.VERIFICATION_FAILED.phrase,
_("Verification Code Incorrect"))
try:
with transaction.atomic():
user = User.objects.create(phone=int(phone_number))
Authentication.objects.create(
user=user,
identity_type=IdentityType.LOCAL.value,
identifier=user.id,
credential=credential,
)
# self.create_foreign_accounts(user)
except IntegrityError as e:
transaction.rollback()
logger.error(e)
return error_response(
Status.REGISTER_FAILED,
Status.REGISTER_FAILED.phrase,
)
tasks.notify_cpa.delay(user.id, request.qua.channel)
return Response()
def approve(package):
""" Processing the request of creating a school
"""
user = package.get('user')
params = package.get('params')
user_id = user.get('id')
school_id = PermissionHelper.get_user_school(user_id)
if school_id == 0:
return Response.error_response("You are not in a school")
permission = PermissionHelper.get_permission(user_id, school_id)
if not PermissionManager.check_permission(permission, ActionType.Approve):
return Response.error_response('Access Denied')
params = package.get('params')
apply_id = int(params.get(ParamType.ApplyId))
apply = SchoolApplyHelper.get_apply_by_id(apply_id)
apply_user_id = apply.get('userid')
if apply is None:
return Response.error_response('No Apply')
status = params.get(ParamType.Approve)
if status == 'true':
status = 1
else:
status = 2
SchoolApplyHelper.judge_apply(apply_id, user_id, status)
if status == 1:
PermissionHelper.user_join_school(apply_user_id, school_id)
return Response.checked_response('Approve Successed')
def like(package):
"""process the request of like program
"""
user = package.get('user')
params = package.get('params')
prog_id = (int)(params.get(ParamType.ProgramId))
program = ProgramHelper.get_program(prog_id)
if program is None:
return Response.error_response('No Program')
if program.get('status') != 5:
return Response.error_response('Program not valid')
user_id = user.get('id')
if ProgramLikeHelper.check_like(user_id, prog_id):
return Response.checked_response('User liked before')
ProgramLikeHelper.add_like(user_id, prog_id)
like_count = ProgramLikeHelper.count_like(prog_id)
ProgramHelper.set_likes(prog_id, like_count)
# program = ProgramHelper.get_program(prog_id)
# return Response.checked_response(str(program.get('likes')))
return Response.checked_response('Like Successful')
def delete_theme(package):
#pylint: disable-msg=too-many-return-statements
"""delete theme
"""
user = package.get('user')
user_id = user.get('id')
school_id = PermissionHelper.get_user_school(user_id)
params = package.get('params')
theme_id = int(params.get(ParamType.ThemeId))
theme = SubjectHelper.get_subject_with_schoolid(theme_id)
if theme is None:
return Response.error_response('No Subject')
theme_schoolid = theme.get('school_id')
private_permission = PermissionHelper.get_permission(user_id, school_id)
public_permission = user['permission']
if private_permission > 4: #为超级用户
SubjectHelper.delete_subject(theme_id)
return Response.checked_response('Deleted Success')
if theme_schoolid == 0:
if public_permission < 4:
return Response.error_response('Access Denied')
SubjectHelper.delete_subject(theme_id)
return Response.checked_response('Deleted')
if private_permission < 4: #非高级管理员
return Response.error_response('Access Denied')
if school_id != theme_schoolid: #学校必须匹配
return Response.error_response('Acess Denied')
SubjectHelper.delete_subject(theme_id)
return Response.checked_response('Delete Success')
def forget_password(package):
"""provess the request of forgetting the password
"""
session = package.get('session')
params = package.get('params')
username = params.get(ParamType.Username)
password = params.get(ParamType.Password)
captcha = params.get(ParamType.CAPTCHA)
user = UserHelper.get_user_by_username(username)
if user is None:
return Response.error_response('No User')
phone = user['phone']
code = VerifyHelper.get_latest_code(session, phone)
if code is None:
return Response.error_response('GUXYNB')
if code['code'] != captcha:
return Response.error_response('CAPTCHA Error')
info = {'password': password}
UserHelper.modify_user(user['id'], info)
return Response.success_response(None)
def delete_recipe():
received_form_response = json.loads(request.data.decode('utf-8'))
uuid = received_form_response.get('recipe_uuid')
if uuid is None:
return error_response(message='Failed')
recipe_entity = get_by_key(DS_exp_recipes_KIND, uuid)
if recipe_entity is None:
return error_response(message='Failed, recipe not found ' + uuid)
datastore_client.delete(key=recipe_entity.key);
return success_response(message='Success')
def signin(package):
"""process the request of signing in
"""
session = package.get('session')
params = package.get('params')
username = params.get(ParamType.Username)
password = params.get(ParamType.Password)
user = UserHelper.get_user_by_username(username)
if user is None:
return Response.error_response('NoUser')
if UserHelper.signin_check_password(user, password):
EntryLogHelper.add_entrylog(session, user['id'])
return Response.checked_response('SigninSuccess')
return Response.error_response('PasswordError')
def send():
body = request.get_json()
status, missing_field = validate_body(body, ['to', 'message'])
if not status:
return error_response(f'{missing_field} is required')
message_queue.put(body)
return response(True, 'Queued', None)
def get_list(package):
"""get theme list
"""
user = package.get('user')
params = package.get('params')
target_schoolid = int(params.get(ParamType.SchoolId))
page = params.get(ParamType.Page)
if page is None:
page = 1
page = int(page)
user_id = user.get('id')
school_id = PermissionHelper.get_user_school(user_id)
public_permission = user.get('permission')
if target_schoolid != 0:
if target_schoolid != school_id and public_permission < 8:
return Response.error_response('Access Denied')
theme_list = SubjectHelper.get_subjects(target_schoolid, 0, page)
for theme in theme_list:
theme.update({
'count':
ProgramHelper.get_subject_programs_count(theme.get('id'))
})
ret = {
'tot_count': SubjectHelper.get_subject_count(target_schoolid, 0),
'now_count': len(theme_list),
'theme_list': theme_list
}
return Response.success_response(ret)
def get_school_list(package):
""" Processing the request of getting school list
"""
params = package.get('params')
page = params.get(ParamType.Page)
search_text = params.get(ParamType.SearchText)
if page is None:
page = 1
page = int(page)
if int(page) < 1:
return Response.error_response('Invalid Page Number')
school_list = SchoolHelper.get_school_list(page, search_text)
for school in school_list:
buf_name = school.get('schoolname')
del school['schoolname']
school.update({'name': buf_name})
tot_count = SchoolHelper.get_school_count(search_text)
return Response.success_response({
'tot_count': tot_count,
'now_count': len(school_list),
'school_list': school_list
})
def signup(package):
"""process the request of signing up
"""
session = package.get('session')
params = package.get('params')
username = params.get(ParamType.Username)
password = params.get(ParamType.Password)
phone = params.get(ParamType.Phone)
verify_code = params.get(ParamType.CAPTCHA)
if UserHelper.get_user_by_username(username) is not None:
error_msg = 'Username exists'
elif not VerifyHelper.check_code(session, phone, verify_code):
error_msg = 'CAPTCHA Error'
else:
error_msg = None
if error_msg is not None:
return Response.error_response(error_msg)
user_id = UserHelper.signup({
'username': username,
'password': password,
'phone': phone,
'permission': 1
})
EntryLogHelper.add_entrylog(session, user_id)
return Response.checked_response('Signup Success')
def message_audience():
body = request.get_json()
status, missing_field = validate_body(body, ['message', 'phones'])
if not status:
return error_response(f'{missing_field} is missing')
send_bulk_sms(body['phones'], body['message'])
return response(True, 'Success', None)
def get_list(package):
""" get message list
"""
user = package.get('user')
params = package.get('params')
friendname = params.get(ParamType.Username)
friend = UserHelper.get_user_by_username(friendname)
if friend is None:
return Response.error_response("Error Username")
page = params.get(ParamType.Page)
if page is None:
page = 1
page = int(page)
chat = ChatHelper.get_chat(user['id'], friend['id'])
if chat:
ChatHelper.do_read(chat, user['id'])
count = MessageHelper.get_messages_count(chat)
messages = MessageHelper.get_messages(chat, page)
data = {
'tot_count': count,
'now_count': len(messages),
'msg_list': messages
}
return Response.success_response(data)
return Response.checked_response('NoChat')
def check_params(params):
"""check params for request
"""
for key, value in params.items():
name, _, _, need, param_type, _ = key.value
if param_type not in ['string', 'integer', 'boolean']:
return Response.failed_response('System Error (Unkown param type)')
if need is True and value is None:
return Response.error_response('Invalid ' + name)
if value is not None:
if param_type == 'boolean' and check_str_as_bool(value) is False:
return Response.error_response('Invalid ' + name)
if param_type == 'integer' and check_str_as_int(value) is False:
return Response.error_response('Invalid ' + name)
return None
def view_one(appointment_id):
try:
data = apt_service.get_appointment(appointment_id)
return response(True, 'Appointment', data)
except Exception as err:
print('=====> Error', err)
return error_response(str(err))
def create():
body = request.get_json()
status, missing_field = validate_body(
body, ['title', 'phone', 'description', 'time'])
if not status:
return error_response(f'{missing_field} is required')
status, error = parse_appointment(body)
if not status:
return error_response(error)
try:
apt_service.create_appointment(body)
jobs.schedule_appointment(body)
return response(True, 'Appointment created successfully', body)
except Exception as err:
print('=====> Error', err)
return error_response(str(err))
def action_check(package):
user = package['user']
action = package['action']
error = None
if not PermissionManager.check_user(user, action):
error = Response.error_response('Access Denied')
return package, error
def delete(appointment_id):
try:
apt_service.delete_appointment(appointment_id)
jobs.delete_scheduled_appointment(appointment_id)
return response(True, 'Appointment deleted successfully', None)
except Exception as err:
print('====> Error', err)
return error_response(str(err))
def view():
conditions = dict(request.args)
try:
data = apt_service.get_appointments(conditions)
return response(True, 'Appointments', data)
except Exception as err:
print('=====> Error', err)
return error_response(str(err))
def test(package):
"""method for uploading
"""
file = package.get('file')
if not file:
return Response.error_response('NoFILE')
name, pwd, _ = File.store_file(file.name, file.chunks(), 'file')
AttechmentHelper.add_file(0, pwd, name)
return Response.checked_response('Upload')
def undo(package):
""" undo a send
"""
user = package.get('user')
params = package.get('params')
message_id = params.get(ParamType.Id)
if MessageHelper.undo_message(user['id'], message_id):
return Response.checked_response('UndoSuccess')
return Response.error_response('UndoFailed')
def get_recipe():
received_form_response = json.loads(request.data.decode('utf-8'))
uuid = received_form_response.get('recipe_uuid')
if uuid is None:
return error_response(message='Failed', recipe={})
recipe_entity = get_by_key(DS_exp_recipes_KIND, uuid)
recipe = recipe_entity.get('recipe')
return success_response(message='Success', recipe=recipe)
def rate_limiting():
ip = request.remote_addr
count = redis_client.get(ip)
count = int(count) if count else None
if count is not None:
if count > MAX_REQUEST_COUNT:
return error_response("You can't send another request at this time.")
redis_client.incr(ip)
else:
redis_client.set(ip, 1, TIMEOUT)
def check(params):
"""检验 param 中的参数
"""
for key, value in params.items():
name, func = key.value
if value is None:
continue
if func(value) is not True:
return Response.error_response("Illegal " + name)
return None
def update(appointment_id):
body = request.get_json()
try:
parse_appointment(body)
appointment = apt_service.update_appointment(appointment_id, body)
jobs.update_scheduled_appointment(appointment_id, appointment)
return response(True, 'Updated Appointment', appointment)
except Exception as err:
print('=====> Error', err)
return error_response(str(err))
def unset_block(package):
""" unset block
"""
user = package.get('user')
params = package.get('params')
friendname = params.get(ParamType.Username)
friend = UserHelper.get_user_by_username(friendname)
if friend is None:
return Response.error_response("Error Username")
ChatBlockHelper.del_block(user['id'], friend['id'])
return Response.checked_response('Unset Success')
def chunk(package):
"""method for upload a chunk
"""
params = package.get('params')
key = params.get(ParamType.FileKey)
index = params.get(ParamType.ChunkId)
file = package.get('file')
if not file:
return Response.error_response('NoFILE')
File.store_chunk(key, index, file)
return Response.checked_response('Success')
def change_password(package):
"""process the request of changing password
"""
session = package.get('session')
params = package.get('params')
oldpassword = params.get(ParamType.OldPassword)
newpassword = params.get(ParamType.NewPassword)
user = UserHelper.get_user_by_session(session)
if user is None:
return Response.error_response('No User')
if not UserHelper.signin_check_password(user, oldpassword):
return Response.error_response('Old Password Error')
info = {'password': newpassword}
user_id = user.get('id')
UserHelper.modify_user(user_id, info)
return Response.success_response(None)
def session_check(package):
params = package['params']
ip_address = package['ip']
session = SessionHelper.get_session_id(params[ParamType.Token], ip_address)
error = None
if session is None:
error = Response.error_response('No Session')
else:
package['session'] = session
package['user'] = UserHelper.get_user_by_session(session)
return package, error
