def close_session(self):
"""
Invalidates session
"""
for prop in self.lti_kwargs.get('property_list', LTI_PROPERTY_LIST):
if session.get(prop, None):
del session[prop]
session[LTI_SESSION_KEY] = False
async def message_receiving(dbc, session):
while True:
data = await websocket.receive()
message_document = {
"user_uid": session.get("user_uid"),
"body": data,
}
await Message(**message_document).save()
def get_authorization_token() -> dict:
"""A static method which returns a dict containing Discord OAuth2 token and other secrets which was saved
previously by `:py:meth:`quart_discord.DiscordOAuth2Session.save_authorization_token` from user's cookies.
You must override this method if you are implementing server side session handling.
"""
return session.get("DISCORD_OAUTH2_TOKEN")
async def send():
session['conversations'] = await request.json
print(session.get('conversations'))
server = SMSInterface()
await server.run_test()
server.post("Hi")
await fetchText()
return "Ok", 200
async def _():
user_ip = request.remote_addr
if request.path == '/login':
return
if session.get('user_ip') == user_ip: #登录过
return
#没有登录，重定向至登录界面
return redirect('/login')
async def yobot_clan_user_auto(group_id):
if 'yobot_user' not in session:
return redirect(url_for('yobot_login', callback=request.path))
return redirect(url_for(
'yobot_clan_user',
group_id=group_id,
uid=session.get('yobot_user'),
))
def get_session_token() -> Optional[str]:
"""Helper function to get the current session token.
Returns
-------
str or None: The refresh token string stored in the session
"""
return session.get("r_t")
def get_user(self) -> Union[User, UnauthedUser]:
user_id = session.get("DISCORD_ID")
if user_id:
if user_id in self.authed_users:
return self.authed_users[user_id]
# No valid user was found, so deauth the user.
self.deauth_user()
return self.unauthed_user
async def yobot_clan(group_id):
bm = ue.get_bm(group_id)
group = ue.get_group(bm)
if group is None:
return await render_template( '404.html', item='公会' ), 404
member = ue.get_member(bm, uid=session.get('yobot_user'))
if not member and member['authority_group'] >= 10:
return await render_template('clan/unauthorized.html')
return await render_template( 'clan/panel.html', is_member=member )
async def fetch(url, counter):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
html = await response.read()
return {
"resp": response,
"html": html,
"url": url,
}
def _verify_session(self):
"""
Verify that session was already created
:raises: LTIException
"""
if not session.get(LTI_SESSION_KEY, False):
log.debug('verify_session failed')
raise LTINotInSessionException('Session expired or unavailable')
async def _():
user_ip = request.remote_addr
if request.path == '/login':
return
if request.path == '/check':
return
if session.get('user_ip') == user_ip:
return
return redirect('/login')
async def frame_detail(uuid):
frame = await api.frame_from_uuid(uuid)
if not (frame.publish or session.get('logged_in')):
raise abort(404)
if await intercooler_request(request):
return await render('includes/frame_render.html',
frame=frame,
Kind=Kind)
return await render('frame.html', frame=frame, Kind=Kind)
async def search():
query = await query_or_form_field(request, 'q', 'awesome')
if session.get('logged_in'):
frames = await api.search_frames(query)
else:
frames = await api.search_public_frames(query)
if await intercooler_request(request):
return await render('includes/frames.html', frames=frames, Kind=Kind)
return await render('frames.html', frames=frames, Kind=Kind)
def load_logged_in_user():
user_id = session.get('user_id', '_id')
if user_id is None:
g.user = None
else:
g.user = myusers.find_one()
print("before_request is running!")
print(g.user)
async def dashboard():
if request.method == 'POST':
if not session.get('logged_in'):
abort(401)
else:
formdata = await request.form
server = formdata['postserver']
channel = formdata['postchannel']
message = formdata['postmessage']
# form['postserver']
# form['postchannel']
# form['postmessage']
await app.ipc_node.request("runPost", server=server, channel=channel, msg=message)
return redirect(url_for('dashboard'))
elif request.method == 'GET':
if session.get('logged_in'):
bot_latency = await app.ipc_node.request("get_bot_latency", data="")
guilds = await app.ipc_node.request("get_guilds", data="")
timer = str(await app.ipc_node.request("get_runtime", data=""))
def guildloop(listt):
final_members = []
for members in listt['members']:
final_members.append(members)
return final_members
def guildnamesloop(listt):
final_names = []
for names in listt['guild']:
final_names.append(names)
return final_names
def guildidloop(listt):
final_ids = []
for ids in listt['id']:
final_ids.append(ids)
return final_ids
return await render_template('dashboard.html', latency=bot_latency, guilds=guilds,
members=guildloop(guilds), ids=guildidloop(guilds),
names=guildnamesloop(guilds), runtime=timer)
else:
return redirect(url_for('login'))
async def logout():
client_store.pop(
client_store.get_index(api_id=session["current"]["api_id"]))
session["config"] = client_store.toconfig()
save_config()
if session["config"]:
session["current"] = session.get("config")[0]
session["phone"] = json.load(
open(build_phone_path(session["current"]["phone"])))
return redirect("/")
def decorated_function(*args, **kwargs):
session['previous_path'] = request.path
if session.get("oauth2_token") is None:
return redirect("/login")
should_check = False
if sum(1 if not session.get(c) else 0 for c in
['user_id', 'user_data', 'guild_data', 'oauth2_check']) > 0:
should_check = True
if session.get("oauth2_check") is None or time.time() - session.get(
"oauth2_check") > 604800:
should_check = True
if should_check:
return redirect("/login")
return f(*args, **kwargs)
async def home():
# print("CONFIG: ",client_store.toconfig())
# print("Home Request: ",client_store)
session["config"] = client_store.toconfig()
if len(session["config"]) == 0:
return await render_template("default.html", type="guest", info={})
elif not session.get("current"):
session["current"] = session.get("config")[0]
session["phone"] = json.load(
open(build_phone_path(session["current"]["phone"])))
client = client_store.get(phone=session["current"]["phone"])
group_store.load(client.phone)
if session["phone"].get("status"):
return await render_template("default.html",
type="active",
info=session["phone"])
else:
return await render_template("default.html",
type="inactive",
info=session["phone"])
async def create():
if not session.get('logged_in'):
abort(401)
db = get_db()
form = await request.form
db.execute(
"INSERT INTO post (title, text) VALUES (?, ?)",
[form['title'], form['text']],
)
db.commit()
return redirect(url_for('posts'))
async def _():
user_ip = request.remote_addr
if request.path in ['/login', '/login/c']:
return
if request.path.startswith('/statics'):
return
if session.get('user_ip') == user_ip:
return
if request.path.startswith("/manage"):
return redirect('/login')
return
def deauth_user(self, user_id: int = None) -> None:
"""
Deauthenticates a user.
If an id isn't given, then we are able to delete the session cookies from the user.
"""
if user_id is None:
if session.get("DISCORD_ID") in self.authed_users.keys():
del self.authed_users[session["DISCORD_ID"]]
session.pop("DISCORD_ID", None)
session.pop("DISCORD_TOKEN", None)
else:
self.authed_users.pop(user_id, None)
def user_id(self) -> typing.Union[int, None]:
"""A property which returns Discord user ID if it exists in quart :py:attr:`quart.session` object.
Returns
-------
int
The Discord user ID of current user.
None
If the user ID doesn't exists in quart :py:attr:`quart.session`.
"""
return session.get("DISCORD_USER_ID")
async def logout():
if request.method == 'POST':
username = str(session.get('username', ''))
if not username:
session.clear()
await flash('You are now logged out.', 'success')
return redirect(url_for('index'))
if await api.logout(username):
session.clear()
await flash('You are now logged out.', 'success')
return redirect(url_for('index'))
return await render('logout.html', title='logout')
async def create() -> redirect:
if not session.get("logged_in"):
abort(401)
form = await request.form
data = {
"title": form["title"],
"text": form["text"],
}
added = add_post_to_db(data)
if added:
return redirect(url_for("posts"))
return redirect(url_for("login")) # 500 error?
async def _():
user_ip = request.remote_addr
if session.get('user_ip') == user_ip:
return
if request.path.startswith(switcher.url_prefix):
r_path = request.path[len(switcher.url_prefix):]
if r_path == '/login':
return
if r_path.startswith(switcher.static_url_path):
return
if r_path == '/check':
return
return redirect(switcher.url_prefix + '/login')
async def page_delete(id):
"""delete a page of a particular id, and return to top-level index"""
if not (session.get('logged_in')):
# if not logged it, dump them back to index
return redirect(url_for('index'))
page = DB.blog.find_one({'_id': id})
if page is None:
abort(404)
DB.blog.delete_one({'_id': id})
return redirect(url_for('index'))
async def sign_in():
data = await request.get_json()
if not data:
resp, _, stat_code = await login(client=client,
phone=session.get("phone"))
return Response(status=stat_code, response=resp)
resp, mee, stat_code = await login(client=client, code=data.get("code"))
if isinstance(mee, Users):
usrs = await get_all_users(user_id=mee.id)
session["me"] = usrs.user_id
return Response(status=stat_code, response=resp)
else:
return Response(status=stat_code, response=resp)
async def page_edit(id=None):
"""edit serves to edit an existing page with a particular id, or create a new page"""
if not (session.get('logged_in')):
# if not logged it, dump them back to index
return redirect(url_for('index'))
status = ''
if id:
# find the page by its id, if it doesn't exist page = None, abort to 404 page
page = DB.blog.find_one({'_id': id})
if page is None:
abort(404)
else:
# new page starts as a blank document
status = 'Creating a new page.'
page = {'title': '', 'slug': '', 'content': ''}
if request.method == 'POST':
# check if user cancel was pressed.
if (await request.form)['submit'] == 'cancel':
if id:
# user canceled a page edit, return to page view
return redirect(url_for('page_view', id=id))
else:
# user canceled a new page creation, return to index
return redirect(url_for('index'))
# user hit submit, so get the data from the form.
page['title'] = (await request.form).get('title')
page['slug'] = (await request.form).get('slug')
page['content'] = (await request.form).get('editordata')
# look for required title and content
if page['title'] != '' and page['content'] != '':
# now, update or insert into database
if not (page.get('slug')):
# make a slug if user left it out.
page['slug'] = slugify(page.get('title'))
if id:
# update an existing page
DB.blog.update_one({'_id': id}, page)
else:
# insert a new page and get its id.
id = DB.blog.insert_one(page).inserted_id
# redirect to page view
return redirect(url_for('page_view', id=id))
else:
# indicate a failure to enter required data
status = 'ERROR: page title and content are required!'
return await render_template('edit.html', page=page, status=status)
async def yobot_user():
if 'yobot_user' not in session:
return redirect(url_for('yobot_login', callback=request.path))
user = ue.get_wm().get_user(session.get('yobot_user'))
user['authority_group'] = 1 if is_super_user(user['uid']) else 100
groups = ue.get_wm().get_clan_by_uid(user['uid'])
return await render_template(
'user.html',
user=user,
clan_groups=[{
'group_id': g['gid'],
'group_name': g['name'] or g['gid']
} for g in groups],
)
