def ui_render_template(template_name_or_list, **context):
art_user_id = request_value(request, 'user_id', None)
need_user = int(request_value(request, 'needUserInfo', 0))
if need_user > 0 and (art_user_id is None
or is_int_number(art_user_id) is False):
return jsonify(form_res(RGResCode.lack_param))
params = dict({"js_ver": RGJSVersion, "css_ver": RGCSSVersion}, **context)
render = render_template(template_name_or_list, **params)
if need_user > 0:
from Model import user
auth, view_user_id = do_auth()
relation = user.get_relation(view_user_id, art_user_id)
re_relation = user.get_relation(art_user_id, view_user_id)
t = {
"user": user.get_user(art_user_id).__dict__,
"home": user.isHome(view_user_id, art_user_id),
"auth": view_user_id is not None,
"relation": relation,
"re_relation": re_relation,
'render': render
}
return jsonify(form_res(RGResCode.ok, t))
return render
def user_bind():
verify_code = int(request_value(request, 'code'))
pwd = request_value(request, 'pwd')
email = request_value(request, 'email').strip()
username = request_value(request, 'username').strip()
auth, user_id, pass_email, auth_username = RGUIController.do_auth_more_info(
need_request_email=False)
if not auth or username != auth_username:
return jsonify(form_res(RGResCode.auth_fail))
uid, res = user.verify_user(username=username,
email=email,
pwd=pwd,
verify_code=verify_code,
verify_type=RGVerifyType.bind)
if uid is not None:
token = RGUIController.token_session(uid=uid,
token_type=session['type'],
username=username,
email=email,
remember=None)
return jsonify(form_res(RGResCode.ok, {'token': token}))
else:
return jsonify(form_res(res, None))
def user_password():
username = request_value(request, 'username')
if username is not None:
username = username.strip()
pwd = request_value(request, 'pwd')
verify_code = int(request_value(request, 'code', default='0'))
uid, res = user.verify_user(username=username,
email=None,
pwd=pwd,
verify_code=verify_code,
verify_type=RGVerifyType.forget_pwd)
if uid is not None:
_user = user.get_user_with_username(username=username, need_email=True)
remember = int(request_value(request, 'remember', default='0'))
token_type = int(request_value(request, 'type', default='0'))
token = RGUIController.token_session(uid=uid,
token_type=token_type,
username=username,
email=_user.email,
remember=remember)
return jsonify(form_res(RGResCode.ok, {'token': token}))
else:
return jsonify(form_res(res, None))
def openid_base_params(extra=None):
# 登录验证, 注册新用户, 更新用户信息
# token 保留字段;
# username 用户名;
# pwd 密码;
# appid 来自何种应用的注册请求;
# clientId 用户设备唯一号;
# timestamp 注册请求到达应用的时间戳;
# login_channel 用户渠道标识符; iOS pc android
# extra_payload 保留字典字段;
# user_ip 客户端ip;
# remote_ip 服务端ip；
params = {
# 'token': '',
# 'username': username,
# 'email': email,
# 'pwd': password,
'request_id': str(uuid.uuid1()),
'appid': 'RGBlog',
'clientId': request_value(request, 'clientId', default=''),
'timestamp': RGTimeUtil.timestamp(),
'login_channel': request_value(request, 'channel', default=''),
# 'extra_payload': '用户名',
'user_ip': request_ip(request, default=''),
'remote_ip': RGPublicHost
}
if extra is not None:
params = dict(params, **extra)
return params
def user_file_del(user_id):
user_file_id = request_value(request, 'id')
if user_file_id is None:
return jsonify(form_res(RGResCode.lack_param))
conn = None
try:
conn = dao.get()
delete_files = files.user_file_del_and_return_files(user_id=user_id,
id=user_file_id,
conn=conn)
if len(delete_files) > 0:
executor.submit(do_del_file, delete_files)
conn.commit()
return jsonify(form_res(RGResCode.ok, None))
except Exception as e:
print(e)
conn.rollback()
conn.commit()
return jsonify(form_res(RGResCode.del_fail, None))
finally:
if conn:
conn.close()
def user_file_move(user_id):
user_file_id = request_value(request, 'id')
if user_file_id is None:
return jsonify(form_res(RGResCode.lack_param))
to_id = request_value(request, 'to_id')
if to_id is None:
return jsonify(form_res(RGResCode.lack_param))
flag = files.user_file_move(user_id=user_id,
move_id=user_file_id,
to_id=to_id)
if flag is True:
code = RGResCode.ok
else:
code = RGResCode.del_fail
return jsonify(form_res(code, None))
def new_file(user_id):
"""
上传文件
body 参数:
fileUpInfo 文件信息
{file} 文件流
"""
re_files = request.files
file_up_info = request_value(request, 'fileUpInfo')
if file_up_info is None:
return jsonify(form_res(RGResCode.lack_param))
file_up_info = json.loads(file_up_info, encoding="utf-8")
for file_key in re_files:
up_info = file_up_info.get(file_key, None)
if up_info is None:
return jsonify(form_res(RGResCode.lack_param))
if up_info.get('md5', None) is None:
return jsonify(form_res(RGResCode.lack_param))
if up_info.get('in_file', 0):
if not files.capacity_enough(
user_id=user_id, new_file_size=request_file_size(request)):
return jsonify(form_res(RGResCode.full_size))
code, result = do_new_file()
if code != RGResCode.ok:
return jsonify(form_res(code))
data = {}
for up_res in result:
file_key = up_res['key']
up_info = file_up_info.get(file_key)
set_name = up_info.get('name', '')
in_album = up_info.get('in_album', 0)
album_id = up_info.get('album_id', -1)
in_file = up_info.get('in_file', 0)
did = up_info.get('directory_id', -1)
handle = handler_upload_res(user_id,
up_res=up_res,
set_name=set_name,
in_album=in_album,
album_id=album_id,
in_file=in_file,
directory_id=did)
code = handle['code']
data[file_key] = {
'code': code,
'file': handle['data'],
}
if code != RGResCode.ok and 'path' in up_res:
del_filename = up_res['path']
executor.submit(do_del_file, [del_filename])
return jsonify(form_res(RGResCode.ok, data))
def verify_page():
username = request_value(request, 'username')
if username is None:
return redirect(url_for('login_page'))
_user = user.get_user_with_username(username, need_email=True)
if _user is None:
return redirect(url_for('login_page'))
verify_type = _user.get_payload(key='type')
if _user.is_full_active() and verify_type != RGVerifyType.forget_pwd:
return redirect(url_for('login_page'))
elif _user.is_active_and_need_bind_email():
return redirect(url_for('login_page'))
elif _user.is_time_out():
return redirect(url_for('login_page'))
email = _user.get_payload(key='email')
if email is None:
return redirect(url_for('login_page'))
return RGUIController.ui_render_template(
"login.html", **{
'username': username,
'email': email,
'coll_pwd': True,
'verify_type': verify_type
})
def password_page():
return RGUIController.ui_render_template(
"login.html", **{
'username': request_value(request, key='username', default=''),
'coll_user_email': True,
'verify_type': 2
})
def handle_download_file(filename,
download_name=None,
mime=None,
max_age=604800):
range_mode = 'Range' in request.headers
remote_url = handle_download_file_url(filename)
params = {
'mime': mime,
'name': download_name,
'cover': int(request_value(request, 'cover', 0))
}
req = requests.get(remote_url,
headers=request.headers,
json=params,
stream=not range_mode)
if req.status_code != 200 and req.status_code != 206:
return Response(req.content, req.status_code, direct_passthrough=True)
if range_mode:
response = Response(req.content, 206, direct_passthrough=True)
else:
response = Response(
stream_with_context(req.iter_content(chunk_size=2048)))
if req.status_code == 200:
response.headers['Cache-Control'] = 'max-age=' + str(max_age)
response.headers['Expires'] = gmt_time_string(
timedelta(seconds=max_age))
for key in req.headers:
response.headers[key] = req.headers[key]
return response
def new_user_file_with_hash(user_id):
up_files = request_value(request, 'files')
if up_files is None:
return jsonify(form_res(RGResCode.lack_param))
for file_key in up_files:
file = up_files[file_key]
file_type = int(file.get('type', 0))
in_file = int(file.get('in_file', 0))
if 'md5' not in file:
if in_file:
if file_type != 1:
return jsonify(form_res(RGResCode.lack_param))
else:
return jsonify(form_res(RGResCode.lack_param))
in_album = file.get('in_album', False)
album_id = file.get('album_id', None)
if in_album and album_id is None:
return jsonify(form_res(RGResCode.lack_param))
data = {}
for file_key in up_files:
file = up_files[file_key]
result = __fast_up(user_id=user_id, file=file)
data[file_key] = result
return jsonify(form_res(RGResCode.ok, data))
def user_file_directory_list(user_id):
directory_id = request_value(request, 'directory_id', -1)
try:
result = files.user_file_directory_list(user_id=user_id,
directory_id=directory_id)
return jsonify(form_res(RGResCode.ok, result))
except:
return jsonify(form_res(RGResCode.database_error))
def user_file_set(user_id):
user_file_id = request_value(request, 'id')
if user_file_id is None:
return jsonify(form_res(RGResCode.lack_param))
args = {}
personal_name = request_value(request, 'name')
if personal_name is not None:
args['personal_name'] = personal_name
flag = files.user_file_set(user_id=user_id, id=user_file_id, args=args)
if flag is True:
code = RGResCode.ok
else:
code = RGResCode.update_fail
return jsonify(form_res(code, None))
def user_login():
username = request_value(request, 'username').strip()
pwd = request_value(request, 'pwd')
_user = user.user_login(username, pwd)
remember = int(request_value(request, 'remember', default='0'))
token_type = int(request_value(request, 'type', default='0'))
if _user is not None:
token = RGUIController.token_session(uid=_user.ID,
token_type=token_type,
username=_user.username,
email=_user.email,
remember=remember)
resp = jsonify(form_res(RGResCode.ok, {'token': token}))
return resp
else:
return jsonify(form_res(RGResCode.not_existed, None))
def user_file_search(user_id):
name = request_value(request, 'name')
if name is None or len(name) <= 0:
return jsonify(form_res(RGResCode.lack_param))
try:
result = files.user_file_list_with_name(user_id=user_id, name=name)
return jsonify(form_res(RGResCode.ok, result))
except:
return jsonify(form_res(RGResCode.database_error))
def user_file_open_code_cancel(user_id):
file_id = request_value(request, 'id')
if file_id is None:
return jsonify(form_res(RGResCode.lack_param))
flag = files.user_file_set(user_id=user_id,
id=file_id,
args={"open_code": None})
if flag:
code = RGResCode.ok
else:
code = RGResCode.database_error
return jsonify(form_res(code))
def __get_file_stream(file, max_age=604800):
filename = file[
'filename'] if file is not None and 'filename' in file else None
mime = file['mime'] if file is not None and 'mime' in file else None
name = file['name'] if file is not None and 'name' in file else None
img_quality = request_value(request, 'img_quality', 'original')
if img_quality == 'low':
filename = name_fix(filename=filename, thumb=True, gif_activity=False)
if filename is None:
return jsonify(form_res(RGResCode.not_existed))
return handle_download_file(filename, name, mime=mime, max_age=max_age)
def user_file_info(user_id):
file_id = request_value(request, 'id')
if file_id is None:
return jsonify(form_res(RGResCode.lack_param))
info = files.user_file_info(user_id=user_id, id=file_id)
if info is not None:
del info['filename']
code = RGResCode.ok
else:
code = RGResCode.database_error
return jsonify(form_res(code, {"file": info}))
def user_file_size(user_id):
user_file_id = request_value(request, 'id', -1)
if user_file_id is None:
return jsonify(form_res(RGResCode.lack_param))
user_file_id = int(user_file_id)
error, file_size = files.user_file_size(user_id=user_id, id=user_file_id)
if error is None:
code = RGResCode.ok
else:
code = RGResCode.database_error
return jsonify(form_res(code, {"size": file_size}))
def user_file_share_code(user_id):
file_id = request_value(request, 'id')
if file_id is None:
return jsonify(form_res(RGResCode.lack_param))
share_code = RGRequestHelp.fid_encode(file_id, user_id)
flag = files.user_file_set(user_id=user_id,
id=file_id,
args={"open_code": share_code})
if flag:
code = RGResCode.ok
else:
share_code = None
code = RGResCode.database_error
return jsonify(form_res(code, {"shareCode": share_code}))
def user_check():
username = request_value(request, 'username', default=None)
if username is None:
return jsonify(form_res(RGResCode.lack_param))
exist = False
_user = user.login_sign_check(username)
if _user is None:
code, _users = User.RGOpenIdController.user_list(username)
if code == RGResCode.ok and len(_users) > 0:
exist = True
else:
exist = True
code = RGResCode.ok if exist else RGResCode.not_existed
return jsonify(form_res(code, _user))
def user_visit_page_info(view_user_id):
art_user_id = request_value(request, 'user_id', None)
if art_user_id is None or is_int_number(art_user_id) is False:
return jsonify(form_res(RGResCode.lack_param))
relation = user.get_relation(view_user_id, art_user_id)
re_relation = user.get_relation(art_user_id, view_user_id)
t = {
"user": user.get_user(art_user_id).__dict__,
"home": user.isHome(view_user_id, art_user_id),
"auth": view_user_id is not None,
"relation": relation,
"re_relation": re_relation,
}
return jsonify(form_res(RGResCode.ok, t))
def get_verify_code():
username = request_value(request, 'username').strip()
email = request_value(request, 'email').strip()
verify_type = int(request_value(request, 'verifyType', default='0'))
if verify_type == RGVerifyType.bind:
auth, user_id, pass_email, auth_username = RGUIController.do_auth_more_info(
need_request_email=False)
if auth is False or username != auth_username:
return jsonify(form_res(RGResCode.auth_fail))
verify_code = user.generate_verify_code()
res = user.new_user_and_save_verify_code(username=username,
email=email,
verify_code=verify_code,
verify_type=verify_type)
if res == RGResCode.ok:
try:
if verify_type == RGVerifyType.forget_pwd:
title = RGMailConfig['newPasswordUserMailTitle']
content = RGMailConfig[
'newPasswordVerifyCodeMailFormat'].format(verify_code)
else:
title = RGMailConfig['newUserMailTitle']
content = RGMailConfig['bindVerifyCodeMailFormat'].format(
verify_code)
send_verify_mail(receiver=email, title=title, content=content)
return jsonify(form_res(RGResCode.ok))
except Exception as e:
print(e)
user.update_user_info(username=username, info_payload='')
return jsonify(form_res(RGResCode.server_error))
return jsonify(form_res(res))
def user_file_relative_list(user_id):
code = request_value(request, 'code')
if code is None:
return jsonify(form_res(RGResCode.lack_param))
u_id = None
try:
directory_id, u_id = RGRequestHelp.did_decode(code)
except Exception as e:
return jsonify(form_res(RGResCode.param_error))
finally:
if u_id != user_id:
return jsonify(form_res(RGResCode.auth_fail))
try:
result, error = files.user_file_files_relative_with_id(user_id=user_id,
id=directory_id)
if error is not None:
raise error
return jsonify(form_res(RGResCode.ok, result))
except:
return jsonify(form_res(RGResCode.database_error))
def wrapper(*args, **kwargs):
code = request_value(request, 'open_code')
if code is None:
if wrapper_code_key is not None:
code = kwargs.get(wrapper_code_key)
if code is None:
return jsonify(form_res(RGResCode.lack_param))
else:
code = re.sub("[^A-Za-z0-9].*", "", code)
try:
f_id, u_id = RGRequestHelp.fid_decode(code)
except Exception as e:
return jsonify(form_res(RGResCode.param_error))
conn = None
try:
conn = dao.get()
open_code_info = files.user_file_info(user_id=u_id,
id=f_id,
open_code=code,
conn=conn)
if open_code_info is None:
return jsonify(form_res(RGResCode.not_existed))
file_id = request_value(request, 'id')
info = open_code_info
if file_id is not None:
file_id = int(file_id)
if f_id != file_id:
# 共享文件夹内的文件可访问
file_info = files.user_file_info(user_id=u_id,
id=file_id)
if file_info is None:
return jsonify(form_res(RGResCode.not_existed))
paths = file_info['directory_path'].split(sep=',')
open_path = str(open_code_info['id'])
if open_path in paths:
info = file_info
if wrapper_path_key is not None:
path = kwargs.get(wrapper_path_key, '')
info['filename'] = info['filename'] + '/' + path
info['name'] = path.split('/')[-1]
del info['mime']
kwargs.update({
'conn': conn,
'info': info,
'open_code': code,
'f_id': f_id,
'u_id': u_id,
})
response = func(*args, **kwargs)
conn.commit()
return response
except Exception as e:
print(e)
conn.rollback()
conn.commit()
return jsonify(form_res(RGResCode.database_error))
finally:
if conn:
conn.close()
def user_set_info(user_id):
t = get_data_with_request(request)
url = RGFullThisServerHost + '/file/fastUpload'
fast_json = {}
file_up_info = request_value(request, 'fileUpInfo')
if file_up_info is not None:
fast_json = json.loads(file_up_info, encoding="utf-8")
bg_id, icon_id = None, None
req = requests.post(url=url,
auth=request.authorization,
cookies=request.cookies,
json={"files": fast_json})
if req.status_code != 200:
return jsonify(form_res(RGResCode.server_error, None))
res_json = req.json()
code = res_json['code']
if code != RGResCode.ok:
return jsonify(form_res(code, None))
data = res_json['data']
need_upload = False
file_stream = {}
for key in data:
result = data[key]
if result['code'] == RGResCode.ok:
file = result['file']['id']
if key == "background":
bg_id = file
elif key == "icon":
icon_id = file
elif result['code'] == RGResCode.not_existed:
stream = request.files[key]
value = (stream.filename, stream.stream, stream.content_type)
file_stream[key] = value
need_upload = True
else:
return jsonify(form_res(result['code'], None))
if need_upload:
url = RGFullThisServerHost + '/file/upload'
req = requests.post(url=url,
files=file_stream,
data=request.form,
params=None,
auth=request.authorization,
cookies=request.cookies,
hooks=None,
json=request.json,
stream=True)
res_json = req.json()
code = res_json['code']
if code != RGResCode.ok:
return jsonify(form_res(code, None))
data = res_json['data']
for key in data:
result = data[key]
if result['code'] == RGResCode.ok:
file_id = result['file']['id']
if key == "background":
bg_id = file_id
elif key == "icon":
icon_id = file_id
else:
return jsonify(form_res(result['code'], None))
tag = None
nickname = None
style = None
if 'nickname' in t:
nickname = t['nickname']
if 'style' in t:
style = t['style']
if 'tag' in t:
tag = t['tag']
if icon_id is None:
if 'iconId' in t:
icon_id = t['iconId']
if bg_id is None:
if 'bgId' in t:
bg_id = t['bgId']
flag = user.update_user_info(user_id=user_id,
nickname=nickname,
tag=tag,
icon=icon_id,
background=bg_id,
style=style)
if flag is True:
code = RGResCode.ok
else:
code = RGResCode.update_fail
return jsonify(form_res(code, None))
