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 new_blog_page(user_id):
if user_id is not None:
return RGUIController.ui_render_template(
"edit_blog.html", **{
"user": user.get_user(user_id),
})
else:
return RGUIController.ui_render_template("login.html")
def login_page():
try:
auth, user_id = RGUIController.do_auth()
if auth is False:
return RGUIController.ui_render_template("login.html")
else:
return redirect(url_for('RGBlog.auto_blog_page'))
except:
return RGUIController.ui_render_template("login.html")
def user_logout(user_id):
t = get_data_with_request(request)
token_type = int(t['type'])
result = tokens.destroy_token(user_id=user_id, token_type=token_type)
if result:
RGUIController.token_session_remove()
return jsonify(form_res(RGResCode.ok, None))
else:
return jsonify(form_res(RGResCode.del_fail, None))
def bind_page():
if not RGUIController.user_need_to_bind_page():
return redirect(url_for('login_page'))
auth, user_id, email, username = RGUIController.do_auth_more_info(
need_request_email=False)
return RGUIController.ui_render_template(
"login.html", **{
'username': username,
'coll_email': True,
'verify_type': RGVerifyType.bind
})
def video_view_page(user_file_id):
if is_int_number(user_file_id):
user_file_id = int(user_file_id)
auth, user_id = RGUIController.do_auth()
if not auth:
return redirect(url_for('login_page'))
if user_file_id == -1 or files.user_file_info(
user_id=user_id, id=user_file_id, type=1) is not None:
code = RGRequestHelp.did_encode(user_file_id, user_id)
return redirect(
url_for('RGFileUpDown.play_list_page',
user_id_directory_id=code))
return RGUIController.ui_render_template('VideoPreview.html')
def share_page(open_code):
try:
f_id, u_id = RGRequestHelp.fid_decode(open_code)
file_info = files.user_file_info(user_id=u_id,
id=f_id,
open_code=open_code)
if file_info is None:
return RGUIController.ui_render_template('VideoPreview.html')
if file_info['type'] == 1:
url = url_for('RGFileUpDown.play_list_share_page',
open_code=open_code)
return redirect(url)
return RGUIController.ui_render_template('VideoPreview.html')
except:
return RGUIController.ui_render_template('VideoPreview.html')
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 blog_view_page_render(view_user_id, art_user_id):
relation = user.get_relation(view_user_id, art_user_id)
t = {
"user": user.get_user(art_user_id),
"relation": relation,
}
return RGUIController.ui_render_template("blogView.html", **t)
def photos_page_render(user_id, other_id, album_id):
t = get_data_with_request(request)
page = t['page'] if 'page' in t else 0
size = t['size'] if 'size' in t else 10
relation = user.get_relation(user_id, other_id)
flag, album_detail = album.album_detail(album_id=album_id,
relation=relation)
if flag is False:
photos, page_count, now_page, page_size, count = \
([], 1, 1, 10, 0)
else:
photos, page_count, now_page, page_size, count = \
pic.page_list(other_id, album_id, page, size, relation)
t = {
"list": photos,
"pageCount": page_count,
"pageSize": page_size,
"nowPage": now_page,
"count": count,
"user": user.get_user(other_id, need_icon=True),
"home": user.isHome(user_id, other_id),
'album': album_detail
}
return RGUIController.ui_render_template("photos.html", **t)
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 home_page(art_user_id):
t = get_data_with_request(request)
page = t['page'] if 'page' in t else 0
size = t['size'] if 'size' in t else 10
auth, view_user_id = RGUIController.do_auth()
arts, page_count, now_page, page_size, count, re_relation = article.page_list(
other_id=view_user_id, art_user_id=art_user_id, page=page, size=size)
t = {
"list": arts,
"pageCount": page_count,
"pageSize": page_size,
"nowPage": now_page,
"count": count,
"home": user.isHome(view_user_id, art_user_id),
}
return RGUIController.ui_render_template("home.html", **t)
def photo_page_render(user_id, other_id):
albums, re_relation = album.album_list(user_id, other_id)
t = {
"list": albums,
"user": user.get_user(other_id),
"home": user.isHome(user_id, other_id),
}
return RGUIController.ui_render_template("albums.html", **t)
def blog_page_render(art_user_id, view_user_id):
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),
"home": user.isHome(view_user_id, art_user_id),
"authed": view_user_id is not None,
"relation": relation,
"re_relation": re_relation,
}
return RGUIController.ui_render_template("index.html", **t)
def edit_blog_page_render(art_id):
auth, user_id = RGUIController.do_auth()
if auth is True:
if art_id is not None:
art = article.art_detail(user_id, art_id)
if art is None:
return redirect(url_for('RGBlog.new_blog_page'))
a_user_id = art['user_id']
if a_user_id == user_id:
return RGUIController.ui_render_template(
"edit_blog.html", **{
'art': art,
"user": user.get_user(user_id),
})
return redirect(url_for('RGBlog.new_blog_page'))
else:
return RGUIController.ui_render_template("login.html")
def art_detail(art_id):
auth, user_id = RGUIController.do_auth()
art = article.art_detail(user_id, art_id)
if art is not None:
a_user_id = art['user_id']
_user = user.get_user(a_user_id)
home = a_user_id == user_id
if home is False:
collect_read_count(art_id=art_id, user_id=user_id)
else:
_user = None
home = False
return RGUIController.ui_render_template(
"blog_page.html", **{
'art': art,
'flag': art is not None,
'home': home,
"user": _user,
"authed": auth,
})
def user_file_path_get(user_file_id, path):
if user_file_id is None:
return jsonify(form_res(RGResCode.lack_param))
user_file_id = re.sub("[^A-Za-z0-9].*", "", user_file_id)
if not is_int_number(user_file_id):
return jsonify(form_res(RGResCode.lack_param))
auth, user_id = RGUIController.do_auth()
session.removeVaryCookie = True
file = files.user_file_info(user_id=user_id, id=user_file_id, type=0)
if path is not None:
file['filename'] = file['filename'] + '/' + path
file['name'] = path.split('/')[-1]
del file['mime']
return __get_file_stream(file, max_age=86400)
def apple_icon():
try:
auth, user_id = RGUIController.do_auth()
if auth is True:
from Model import user
filename = user.get_user_icon_name(user_id)
if filename:
return RGFileUpDownApp.handle_download_file(filename=filename)
return send_file("RGIgnoreConfig/apple-icon.png",
mimetype='image/png',
cache_timeout=0)
except:
return send_file("RGIgnoreConfig/apple-icon.png",
mimetype='image/png',
cache_timeout=0)
def friend_page(user_id):
t = get_data_with_request(request)
page = t['page'] if 'page' in t else 0
size = t['size'] if 'size' in t else 10
list, page_count, now_page, page_size, count = user.friend_page_list(
user_id, page, size)
t = {
"list": list,
"pageCount": page_count,
"pageSize": page_size,
"nowPage": now_page,
"count": count,
}
return RGUIController.ui_render_template("friends.html", **t)
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 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 blog_view_page(other_id):
if is_int_number(other_id):
auth, view_user_id = RGUIController.do_auth()
return blog_view_page_render(view_user_id, other_id)
else:
return redirect(url_for('RGBlog.auto_blog_view_page'))
def desktop_page(user_id):
return RGUIController.ui_render_template('FileSite.html')
def blog_page(other_id):
if is_int_number(other_id):
auth, view_user = RGUIController.do_auth()
return blog_page_render(other_id, view_user)
return redirect(url_for('login_page'))
def play_list_page(user_id_directory_id):
auth, user_id = RGUIController.do_auth()
if not auth:
return redirect(url_for('login_page'))
return RGUIController.ui_render_template('VideoPreview.html')
def photos_original_page():
t = get_data_with_request(request)
return RGUIController.ui_render_template("picOriginalView.html", **t)
def play_list_share_page(open_code):
return RGUIController.ui_render_template('VideoPreview.html')
def photos_page(other_id, album_id):
if is_int_number(other_id) and is_int_number(album_id):
auth, user_id = RGUIController.do_auth()
return photos_page_render(user_id, other_id, album_id)
return redirect(url_for('login_page'))
def photo_page(other_id):
if is_int_number(other_id):
auth, user_id = RGUIController.do_auth()
return photo_page_render(user_id, other_id)
else:
return redirect(url_for('RGPhoto.auto_photo_page'))