def world_image(self, request):
""" 显示正确的镇守府图片。
舰娘游戏中客户端FLASH请求的镇守府图片是根据FLASH本身的URL生成的，需要根据用户所在的镇守府IP为其显示正确的图片。
:param request: aiohttp.web.Request
:return: aiohttp.web.HTTPFound or aiohttp.web.HTTPBadRequest
"""
size = request.match_info['size']
session = yield from get_session(request)
world_ip = session['world_ip']
if world_ip:
ip_sections = map(int, world_ip.split('.'))
image_name = '_'.join([format(x, '03') for x in ip_sections]) + '_' + size
if image_name in self.worlds:
body = self.worlds[image_name]
else:
url = 'http://203.104.209.102/kcs/resources/image/world/' + image_name + '.png'
coro = aiohttp.get(url, connector=self.connector)
try:
response = yield from asyncio.wait_for(coro, timeout=5)
except asyncio.TimeoutError:
return aiohttp.web.HTTPBadRequest()
body = yield from response.read()
self.worlds[image_name] = body
return aiohttp.web.Response(body=body, headers={'Content-Type': 'image/png', 'Cache-Control': 'no-cache'})
else:
return aiohttp.web.HTTPBadRequest()
def handler(request):
session = yield from get_session(request)
self.assertIsInstance(session, Session)
self.assertTrue(session.new)
self.assertFalse(session._changed)
self.assertEqual({}, session)
return web.Response(body=b'OK')
def cancel(request):
session = yield from get_session(request)
parameters = request.rel_url.query
if 'uid' not in session:
return web.HTTPUnauthorized()
else:
uid = session['uid']
try:
mid = int(parameters['mid'])
except:
return web.HTTPBadRequest()
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
cancelled = yield from cursor.execute(
'delete from subscription where uid = %s and mid = %s', (uid, mid))
yield from connect.commit()
yield from cursor.close()
connect.close()
if cancelled:
return web.HTTPOk()
else:
return web.HTTPBadRequest()
def go():
req = self.make_request('GET', '/')
session = Session('identity')
req[SESSION_KEY] = session
ret = yield from get_session(req)
self.assertIs(session, ret)
async def get_sample_layer(request):
posted_data, session_redis = \
await asyncio.gather(*[request.post(), get_session(request)])
user_id = get_user_id(session_redis, request.app['app_users'])
name = posted_data.get('layer_name')
path = request.app['db_layers'][name]
hash_val = str(mmh3_hash(path))
f_name = '_'.join([user_id, hash_val])
asyncio.ensure_future(request.app['redis_conn'].incr('sample_layers'))
result = await request.app['redis_conn'].get(f_name)
if result:
result = result.decode()
request.app['logger'].debug(
'{} - Used result from redis'.format(user_id))
request.app['redis_conn'].pexpire(f_name, 86400000)
return web.Response(text=''.join([
'{"key":', hash_val, ',"file":',
result.replace(''.join([user_id, '_']), ''), '}'
]))
else:
res = await request.app.loop.run_in_executor(request.app["ThreadPool"],
ogr_to_geojson, path)
request.app['logger'].debug(
'{} - Transform coordinates from GeoJSON'.format(user_id))
result = await geojson_to_topojson2(res, name)
asyncio.ensure_future(request.app['redis_conn'].set(f_name,
result,
pexpire=86400000))
return web.Response(
text=''.join(['{"key":', hash_val, ',"file":', result, '}']))
def route(request):
session = yield from get_session(request)
if 'uid' in session:
uid = session['uid']
else:
return web.HTTPForbidden()
query_parameters = request.rel_url.query
if "fid" in query_parameters:
try:
fid = int(query_parameters["fid"])
except:
return web.HTTPBadRequest()
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
result = yield from cursor.execute('''
UPDATE feed SET
status = 0
WHERE id = %s and uid = %s;
''',(fid,uid))
yield from connect.commit()
yield from cursor.close()
connect.close()
if result:
return web.Response()
else:
return web.HTTPForbidden()
def setup(self, request):
session = yield from get_session(request)
token = self._tokens.get(session.get("uid", ""))
if not token:
return web.HTTPUnauthorized()
c = github.Client(token.decode('ascii'))
yield from request.post()
repo_data = json.loads(
self._repos.get(request.POST["id"]).decode('ascii'))
owner, repo = repo_data[0].split('/')
res = yield from c.get("/repos/:owner/:repo/hooks", owner, repo)
if len(res) == 0:
config = {
"url": "https://eyein.tk/webhook",
"secret": self._webhook_secret,
}
events = ["push", "pull_request"]
res = yield from c.post("/repos/:owner/:repo/hooks",
owner,
repo,
name="web",
active=True,
config=config,
events=events)
print(res)
else:
print(res)
def base_handler(request):
session = yield from get_session(request)
name = session.get('name')
if session.new or not name:
session['name'] = 'None'
return {'name': name}
def set_name_handler(request):
session = yield from get_session(request)
data = yield from request.json()
name = data.get('name')
# TODO unique names for players
session['name'] = name
return web.HTTPOk()
def handler(request):
session = yield from get_session(request)
self.assertIsInstance(session, Session)
self.assertFalse(session.new)
self.assertFalse(session._changed)
self.assertEqual({'a': 1, 'b': 12}, session)
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
assert isinstance(session, Session)
assert not session.new
assert not session._changed
assert {'a': 1, 'b': 12} == session
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
assert isinstance(session, Session)
assert not session.new
assert not session._changed
assert {'a': 1, 'b': 12} == session
return web.Response(body=b'OK')
def go():
req = self.make_request('GET', '/')
session = Session('identity')
req[SESSION_KEY] = session
ret = yield from get_session(req)
self.assertIs(session, ret)
def route(request):
session = yield from get_session(request)
if request.content_type != "application/x-www-form-urlencoded":
return toolbox.javaify(400,"wrong content type")
data = yield from request.post()
email = data['email'] if 'email' in data else ''
password = data['password'] if 'password' in data else ''
if not email:
return toolbox.javaify(400,"miss parameter")
hash_password = hashlib.sha1(password.encode("utf-8")).hexdigest()
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
yield from cursor.execute('''SELECT id FROM user WHERE email = %s AND password = %s AND status = 1''',(email,hash_password))
check = yield from cursor.fetchone()
yield from cursor.close()
connect.close()
if check:
session["uid"] = check[0]
return toolbox.javaify(200,"ok")
else:
session.clear()
return toolbox.javaify(403,"forbidden")
def world_image(self, request):
""" 显示正确的镇守府图片。
舰娘游戏中客户端FLASH请求的镇守府图片是根据FLASH本身的URL生成的，需要根据用户所在的镇守府IP为其显示正确的图片。
:param request: aiohttp.web.Request
:return: aiohttp.web.HTTPFound or aiohttp.web.HTTPBadRequest
"""
size = request.match_info['size']
session = yield from get_session(request)
world_ip = session['world_ip']
if world_ip:
ip_sections = map(int, world_ip.split('.'))
image_name = '_'.join([format(x, '03') for x in ip_sections]) + '_' + size
if image_name in self.worlds:
body = self.worlds[image_name]
else:
url = 'http://203.104.209.102/kcs/resources/image/world/' + image_name + '.png'
coro = aiohttp.get(url, connector=self.connector)
try:
response = yield from asyncio.wait_for(coro, timeout=5)
except asyncio.TimeoutError:
return aiohttp.web.HTTPBadRequest()
body = yield from response.read()
self.worlds[image_name] = body
return aiohttp.web.Response(body=body, headers={'Content-Type': 'image/png', 'Cache-Control': 'no-cache'})
else:
return aiohttp.web.HTTPBadRequest()
def home(self, request):
session = yield from get_session(request)
token = self._tokens.get(session.get("uid", ""), b"")
c = github.Client(token.decode('ascii'))
if not c.token:
return web.Response(body=b"""<form action=authorize method=post />
<input name=ok value=ok type=hidden>
<input type=submit value=Register></input></form>""")
repos_data = yield from c.get("user/repos", affiliation="owner")
repos = []
for repo in repos_data:
repo_id = str(repo["id"])
repo_data = self._repos.get(repo_id)
if not repo_data:
repo_data = [repo["full_name"], None]
self._repos[repo_id] = json.dumps(repo_data)
else:
repo_data = json.loads(repo_data.decode('ascii'))
repos.append((
repo_id,
repo["name"],
repo["full_name"],
repo["description"],
repo_data[1],
))
with open("app.html", "r") as app:
app = app.read()
app = app % json.dumps(repos)
return web.Response(body=app.encode("utf8"))
def remove(request):
session = yield from get_session(request)
query_string = request.rel_url.query
if 'uid' not in session:
return web.HTTPUnauthorized()
else:
uid = session['uid']
try:
mid = int(query_string['mid'])
except:
return web.HTTPBadRequest()
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
deleted = yield from cursor.execute(
'delete from follow where uid = %s and mid = %s', (uid, mid))
yield from connect.commit()
yield from cursor.close()
connect.close()
if deleted:
return web.HTTPOk()
else:
return web.HTTPBadRequest()
def api(self, request):
""" 转发客户端和游戏服务器之间的API通信。
:param request: aiohttp.web.Request
:return: aiohttp.web.Response or aiohttp.web.HTTPBadRequest
"""
action = request.match_info['action']
session = yield from get_session(request)
world_ip = session['world_ip']
if world_ip:
if action == 'api_start2' and self.api_start2 is not None:
return aiohttp.web.Response(body=self.api_start2,
headers=aiohttp.MultiDict({'Content-Type': 'text/plain'}))
else:
referrer = request.headers.get('REFERER')
referrer = referrer.replace(request.host, world_ip)
referrer = referrer.replace('https://', 'http://')
url = 'http://' + world_ip + '/kcsapi/' + action
headers = aiohttp.MultiDict({
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko',
'Origin': 'http://' + world_ip + '/',
'Referer': referrer,
})
data = yield from request.post()
coro = aiohttp.post(url, data=data, headers=headers, connector=self.connector)
try:
response = yield from asyncio.wait_for(coro, timeout=5)
except asyncio.TimeoutError:
return aiohttp.web.HTTPBadRequest()
body = yield from response.read()
if action == 'api_start2' and len(body) > 100000:
self.api_start2 = body
return aiohttp.web.Response(body=body, headers=aiohttp.MultiDict({'Content-Type': 'text/plain'}))
else:
return aiohttp.web.HTTPBadRequest()
def route(request):
if "Referer" not in request.headers:
return web.HTTPForbidden()
referer_check = re.search(
request.app["server_domain"] + "/preview/(\d{6})",
request.headers["Referer"])
if not referer_check:
return web.HTTPForbidden()
room = referer_check.group(1)
session = yield from get_session(request)
if "room" in session:
if not toolbox.in_session(session["room"], room):
return web.HTTPForbidden()
session["room"] = toolbox.remove_from_session(session["room"], room)
with (yield from request.app["pool"]) as connect:
cursor = yield from connect.cursor()
result = yield from cursor.execute(
"UPDATE article SET status = 0 WHERE id = %s;", (room, ))
yield from connect.commit()
yield from cursor.close()
connect.close()
return web.HTTPOk()
def test_get_stored_session():
req = make_mocked_request('GET', '/')
session = Session('identity', data=None, new=False)
req[SESSION_KEY] = session
ret = yield from get_session(req)
assert session is ret
def __run(self, request):
""" Run service """
try:
data = yield from decode(request)
except ParseError:
return JError().parse()
except InvalidRequest:
return JError().request()
except InternalError:
return JError().internal()
try:
method = _rpc.cirrina.rpc_methods[data['method']]
except Exception:
return JError(data).method()
session = yield from get_session(request)
try:
resp = yield from method(request, session,
*data['params']['args'],
**data['params']['kw'])
except TypeError as e:
# workaround for JError.custom bug
return JResponse(
jsonrpc={
'id': data['id'],
'error': {
'code': -32602,
'message': str(e)
},
})
except InternalError:
return JError(data).internal()
return JResponse(jsonrpc={"id": data['id'], "result": resp})
def prepare(request):
session = yield from get_session(request)
query_string = request.rel_url.query
if 'uid' not in session:
return web.HTTPUnauthorized()
else:
uid = session['uid']
try:
end_point = query_string['end_point']
except:
return web.HTTPBadRequest()
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
updated = yield from cursor.execute(
'update user set end_point = %s where id = %s', (end_point, uid))
yield from connect.commit()
yield from cursor.close()
connect.close()
if updated:
return web.HTTPOk()
else:
return web.HTTPOk()
def destroy(request):
session = yield from get_session(request)
parameters = request.rel_url.query
if 'uid' not in session:
return web.HTTPUnauthorized()
else:
uid = session['uid']
try:
fid = int(parameters['fid'])
except:
return web.HTTPBadRequest()
with (yield from request.app['pool']) as connect:
cursor= yield from connect.cursor()
deleted = yield from cursor.execute('''
delete from favor where uid = %s and fid = %s
''',(uid,fid))
yield from connect.commit()
yield from cursor.close()
connect.close()
if deleted:
return web.HTTPOk()
else:
return web.HTTPBadRequest()
def route(request):
room = request.match_info["room"]
script = ""
session = yield from get_session(request)
if 'room' in session:
if toolbox.in_session(session['room'], room):
script = '<script src="/static/modify.js"></script>'
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
exist = yield from cursor.execute(
'''
SELECT delivery, title, subtitle, provider, full
FROM article WHERE id = %s and status = 1
''', (room, ))
out = yield from cursor.fetchall()
yield from cursor.close()
connect.close()
if exist == 0: return web.HTTPNotFound()
delivery = out[0][0].strftime("%Y/%m/%d %H:%M")
title = out[0][1]
subtitle = out[0][2]
provider = out[0][3]
article = out[0][4]
article = re.sub(r'([\d|a-f]{32}\.(jpg|png|gif))',
'/photo/' + room + '/\g<1>', article)
article = toolbox.linkify_article(article)
html_back = '''
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>{title} | Platform · idol</title>
<link rel="stylesheet" type="text/css" href="/static/preview.css"/>
{script}
</head>
<body>
<div id="whole">
<div id="title">{title}</div>
<div id="subtitle">{subtitle}</div>
<div id="provider">{provider}</div>
<div id="delivery">Archive: {delivery}</div>
<div id="article">{article}</div>
</div>
</body>
</html>
'''.format(script=script,
title=title,
subtitle=subtitle,
provider=provider,
delivery=delivery,
article=article)
return toolbox.html_response(html_back)
async def csrf_middleware(request, handler):
session_info = await(get_session(request))
if request.method == 'POST':
csrf_form = CsrfForm(await request.post(), csrf_context=session_info)
if not csrf_form.validate():
raise web.HTTPBadRequest()
request['csrf'] = CsrfForm(csrf_context = session_info)
return await handler(request)
def handler(request):
session = yield from get_session(request)
self.assertIsInstance(session, Session)
self.assertFalse(session.new)
self.assertFalse(session._changed)
self.assertIsNotNone(session.created)
self.assertEqual(self.data, session)
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
self.assertIsInstance(session, Session)
self.assertFalse(session.new)
self.assertFalse(session._changed)
self.assertIsNotNone(session.created)
self.assertEqual({"a": 1, "b": 2}, session)
return web.Response(body=b"OK")
def logout(self, request):
""" 注销已登录的用户。
清除所有的session，返回首页。
:return: aiohttp.web.HTTPFound
"""
session = yield from get_session(request)
self.clear_session(session)
return aiohttp.web.HTTPFound('/')
def route(request):
session = yield from get_session(request)
if 'uid' not in session:
return web.Response(text=html,
content_type='text/html',
charset='utf-8')
else:
return web.HTTPFound('/home')
def wrapper(request):
session = yield from get_session(request)
provider_id = session.get('provider_id')
if provider_id:
uid = session.get(provider_id)
# if uid and uid == User.get_uid(provider_id):
if uid and uid == provider_id:
return func(request)
return web.Response(body=b'Not logged in')
def logout(self, request):
""" 注销已登录的用户。
清除所有的session，返回首页。
:return: aiohttp.web.HTTPFound
"""
session = yield from get_session(request)
self.clear_session(session)
return aiohttp.web.HTTPFound('/')
def login(self, request):
"""接受登录表单提交的数据，登录后跳转或登录失败后展示错误信息。
:param request: aiohttp.web.Request
:return: aiohttp.web.HTTPFound or aiohttp.web.Response
"""
post = yield from request.post()
session = yield from get_session(request)
login_id = post.get('login_id', None)
password = post.get('password', None)
mode = int(post.get('mode', 1))
session['mode'] = mode
f = open(config.white_list, encoding='utf-8')
WhiteList = f.readlines()
isre = False
for item in WhiteList:
if login_id.strip().upper() == item.upper().strip():
isre = True
break
if isre:
if login_id and password:
kancolle = KancolleAuth(login_id, password)
if mode in (1, 2, 3):
try:
yield from kancolle.get_flash()
session['api_token'] = kancolle.api_token
session['api_starttime'] = kancolle.api_starttime
session['world_ip'] = kancolle.world_ip
if mode == 2:
return aiohttp.web.HTTPFound('/kcv')
elif mode == 3:
return aiohttp.web.HTTPFound('/poi')
else:
return aiohttp.web.HTTPFound('/kancolle')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
elif mode == 4:
try:
osapi_url = yield from kancolle.get_osapi()
session['osapi_url'] = osapi_url
return aiohttp.web.HTTPFound('/connector')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
else:
raise aiohttp.web.HTTPBadRequest()
else:
context = {'errmsg': '请输入完整的登录ID和密码', 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
else:
context = {'errmsg': 'ID不在白名单', 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
def login(self, request):
"""接受登录表单提交的数据，登录后跳转或登录失败后展示错误信息。
:param request: aiohttp.web.Request
:return: aiohttp.web.HTTPFound or aiohttp.web.Response
"""
post = yield from request.post()
session = yield from get_session(request)
login_id = post.get('login_id', None)
password = post.get('password', None)
mode = int(post.get('mode', 1))
session['mode'] = mode
dbc = DbConnect(localhost, 3306, username, password, db)
if login_id and password and dbc.query(login_id):
kancolle = KancolleAuth(login_id, password)
dbc.update(login_id)
dbc.close()
del dbc
if mode in (1, 2, 3):
try:
yield from kancolle.get_flash()
session['api_token'] = kancolle.api_token
session['api_starttime'] = kancolle.api_starttime
session['world_ip'] = kancolle.world_ip
if mode == 2:
return aiohttp.web.HTTPFound('/kcv')
elif mode == 3:
return aiohttp.web.HTTPFound('/poi')
else:
return aiohttp.web.HTTPFound('/kancolle')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template(
'form.html', request, context)
elif mode == 4:
try:
osapi_url = yield from kancolle.get_osapi()
session['osapi_url'] = osapi_url
return aiohttp.web.HTTPFound('/connector')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template(
'form.html', request, context)
else:
raise aiohttp.web.HTTPBadRequest()
else:
context = {'errmsg': '请输入完整的有效的ID和密码', 'mode': mode}
dbc.close()
del dbc
return aiohttp_jinja2.render_template('form.html', request,
context)
def route(request):
session = yield from get_session(request)
if 'uid' in session:
uid = session['uid']
else:
return toolbox.javaify(403,"forbidden")
query_parameters = request.rel_url.query
path = query_parameters["path"] if "path" in query_parameters else ''
if not path:
return toolbox.javaify(400,"miss parameter")
(directory,name) = os.path.split(path)
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
directory_id = yield from fs.directory_exists(cursor,uid,directory)
if not directory_id:
yield from cursor.close()
connect.close()
return toolbox.javaify(404,"no directory")
file_meta = yield from fs.file_query(cursor,directory_id,[name])
if not file_meta or file_meta[0]['type'] == 'directory':
yield from cursor.close()
connect.close()
return toolbox.javaify(404,"no file")
yield from cursor.execute('''
SELECT name, modify, size, md5 FROM history WHERE id = %s ORDER BY version DESC
''',(file_meta[0]['id']))
out = yield from cursor.fetchall()
yield from cursor.close()
connect.close()
data = []
for line in out:
if line[0] == "":
continue
data.append({
"name": line[0],
"extension": os.path.splitext(line[0])[-1][1:],
"modify": toolbox.time_utc(line[1]),
"size": line[2],
"source": mask.generate(uid,line[3],os.path.splitext(line[0])[-1][1:])
})
return toolbox.javaify(200,"ok",data)
async def remove_layer(request):
posted_data, session_redis = \
await asyncio.gather(*[request.post(), get_session(request)])
user_id = get_user_id(session_redis, request.app['app_users'])
f_names = posted_data.getall('layer_name')
for name in f_names:
f_name = '_'.join([user_id, name])
request.app['logger'].debug("Deleting " + name)
asyncio.ensure_future(request.app["redis_conn"].delete(f_name))
return web.Response(text=json.dumps({"code": "Ok"}))
def oauth(self, request):
yield from req_data(request)
c = yield from self._oauth.oauth(request.GET["code"],
request.GET["state"])
user_data = yield from c.get("user")
uid = hex(user_data["id"])[2:]
self._tokens[uid] = c.token
session = yield from get_session(request)
session["uid"] = uid
return web.HTTPFound("home")
def manifest(request):
session = yield from get_session(request)
if 'uid' not in session:
return web.HTTPUnauthorized()
else:
uid = session['uid']
with (yield from request.app['pool']) as connect:
cursor = yield from connect.cursor()
yield from cursor.execute(
'''
select
member.id,
member.romaji,
member.name,
member.affiliation,
member.follows,
member.subscribes,
follow.uid,
subscription.uid
from member
left join follow on follow.uid = %s and follow.mid = member.id
left join subscription on subscription.uid = %s and subscription.mid = member.id
''', (uid, uid))
data = yield from cursor.fetchall()
yield from cursor.close()
connect.close()
if not data:
return web.HTTPNotFound()
json_back = []
for member in data:
json_back.append({
"uid": str(member[0]).zfill(4),
"name": member[2],
"romaji": member[1],
"avatar": "/avatar/{}.jpg".format(member[1]),
"affiliation": member[3],
"followed": True if member[6] else False,
"subscribed": True if member[7] else False,
"follows": member[4],
"subscribes": member[5]
})
return web.Response(text=tool.jsonify(json_back),
content_type="application/json",
charset="utf-8")
def middleware(request):
session = yield from get_session(request)
auth_key = session.get(SESSION_AUTH_KEY, None)
if auth_key:
user = get_users().get(auth_key, None)
if user:
request[REQUEST_USER_KEY] = user
return (yield from handler(request))
def form(self, request):
"""展示登录表单。
:param request: aiohttp.web.Request
:return: dict
"""
session = yield from get_session(request)
if 'mode' in session:
mode = session['mode']
else:
session['mode'] = 1
mode = 1
return {'mode': mode}
def connector(self, request):
"""适配登录器直连模式结果页面，提供osapi.dmm.com的链接。
:param request: aiohttp.web.Request
:return: aiohttp.web.Response or aiohttp.web.HTTPFound
"""
session = yield from get_session(request)
osapi_url = session.get('osapi_url', None)
if osapi_url:
context = {'osapi_url': osapi_url}
return aiohttp_jinja2.render_template('connector.html', request, context)
else:
self.clear_session(session)
return aiohttp.web.HTTPFound('/')
def process(request): session = yield from get_session(request) flash_incoming = session.get(SESSION_KEY, []) request[REQUEST_KEY] = flash_incoming[:] # copy flash for modification try: response = yield from handler(request) finally: flash_outgoing = request[REQUEST_KEY] if flash_outgoing != flash_incoming: if flash_outgoing: session[SESSION_KEY] = flash_outgoing else: del session[SESSION_KEY] return response
def me(request):
session = yield from get_session(request)
try:
user_id = session['user_id']
except KeyError:
return json_response({})
else:
with(yield from request.app['db']) as conn:
query = sa.select([models.users]).where(models.users.c.id == user_id)
u = yield from conn.execute(query)
user = yield from u.fetchone()
schema = schemas.UserSchema()
result = schema.dump(user)
return json_response(result.data)
def kcv(self, request):
"""适配KanColleViewer或者74EO中进行游戏的页面，提供一个iframe，在iframe中载入游戏FLASH。该页面会检查会话中是否有api_token、
api_starttime和world_ip三个参数，缺少其中任意一个都不能进行游戏，跳转回登录页面。
:param request: aiohttp.web.Request
:return: aiohttp.web.Response or aiohttp.web.HTTPFound
"""
session = yield from get_session(request)
token = session.get('api_token', None)
starttime = session.get('api_starttime', None)
world_ip = session.get('world_ip', None)
if token and starttime and world_ip:
return aiohttp_jinja2.render_template('kcv.html', request, context={})
else:
self.clear_session(session)
return aiohttp.web.HTTPFound('/')
def login(self, request):
"""接受登录表单提交的数据，登录后跳转或登录失败后展示错误信息。
:param request: aiohttp.web.Request
:return: aiohttp.web.HTTPFound or aiohttp.web.Response
"""
post = yield from request.post()
session = yield from get_session(request)
login_id = post.get('login_id', None)
password = post.get('password', None)
mode = int(post.get('mode', 1))
session['mode'] = mode
if login_id and password:
kancolle = KancolleAuth(login_id, password)
if mode in (1, 2, 3):
try:
yield from kancolle.get_flash()
session['api_token'] = kancolle.api_token
session['api_starttime'] = kancolle.api_starttime
session['world_ip'] = kancolle.world_ip
if mode == 2:
return aiohttp.web.HTTPFound('/kcv')
elif mode == 3:
return aiohttp.web.HTTPFound('/poi')
else:
return aiohttp.web.HTTPFound('/kancolle')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
elif mode == 4:
try:
osapi_url = yield from kancolle.get_osapi()
session['osapi_url'] = osapi_url
return aiohttp.web.HTTPFound('/connector')
except OOIAuthException as e:
context = {'errmsg': e.message, 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
else:
raise aiohttp.web.HTTPBadRequest()
else:
context = {'errmsg': '请输入完整的登录ID和密码', 'mode': mode}
return aiohttp_jinja2.render_template('form.html', request, context)
def create_notification(request, type, message, team_id):
if not type:
raise ValueError("type arg is required")
if not message:
raise ValueError("message arg is required")
if not team_id:
raise ValueError("team_id arg is required")
session = yield from get_session(request)
nf_data = {
'team': team_id,
'author': session['user_id'],
'type': type,
'message': message,
'creation_date': datetime.datetime.now()
}
with(yield from request.app['db']) as conn:
trans = yield from conn.begin()
try:
ins_query = models.notifications.insert().values(nf_data)
try:
res = yield from conn.execute(ins_query)
except Exception as e:
print(str(e))
raise AssertionError('can not save notification')
else:
nf_data['id'] = (yield from res.first())[0]
nf_data['creation_date'] = str(nf_data['creation_date'])
usr_query = sa.select([models.users]).where(models.users.c.id == session['user_id'])
usr_res = yield from conn.execute(usr_query)
usr_res = yield from usr_res.first()
nf_data['author'] = {
'id': usr_res['avatar'],
'first_name': usr_res['first_name'],
'last_name': usr_res['last_name'],
'avatar': usr_res['avatar']
}
except Exception:
yield from trans.rollback()
else:
yield from trans.commit()
return nf_data
def notifications(request, team=None, limit=20, offset=0):
limit = int(request.GET.get('limit', 20))
offset = int(request.GET.get('offset', 0))
with(yield from request.app['db']) as conn:
nf = models.notifications.alias()
us = models.users.alias()
items = []
nf_count = 0
trans = yield from conn.begin()
session = yield from get_session(request)
user_id = session['user_id'] if 'user_id' in session else None
try:
nf_count = yield from conn.scalar(sa.select([sa.func.count(nf.c.id)])
.where(nf.c.team == team['id']))
nf_query = sa.select([nf])\
.where(nf.c.team == team["id"])\
.order_by(sa.desc(nf.c.creation_date))\
.limit(limit)\
.offset(offset)
nfs = yield from conn.execute(nf_query)
for n in nfs:
item = dict(n)
author_query = sa.select([us]).where(us.c.id == item["author"])
author = yield from conn.execute(author_query)
item["author"] = yield from author.fetchone()
items.append(item)
except Exception:
yield from trans.rollback()
else:
yield from trans.commit()
schema = schemas.NotificationSchema(many=True)
result = {
'meta': {
'offset': offset,
'limit': limit,
'total': nf_count,
'user_id': user_id
},
'items': schema.dump(items).data
}
return json_response(result)
def wrapped(request, **kwargs):
res = yield from handler(request, **kwargs)
if isinstance(res, dict):
session = yield from get_session(request)
try:
user_id = session['user_id']
except KeyError:
pass
else:
with (yield from request.app['db']) as conn:
query = sa.select([models.users]).where(models.users.c.id == user_id)
usr = yield from conn.execute(query)
user = yield from usr.fetchone()
res['user'] = {
'id': user['id'],
'first_name': user['first_name'],
'last_name': user['last_name'],
'avatar': user['avatar'],
}
return res
def normal(self, request):
"""适配浏览器中进行游戏的页面，该页面会检查会话中是否有api_token、api_starttime和world_ip三个参数，缺少其中任意一个都不能进行
游戏，跳转回登录页面。
:param request: aiohttp.web.Request
:return: aiohttp.web.Response or aiohttp.web.HTTPFound
"""
session = yield from get_session(request)
token = session.get('api_token', None)
starttime = session.get('api_starttime', None)
world_ip = session.get('world_ip', None)
if token and starttime and world_ip:
context = {'scheme': request.scheme,
'host': request.host,
'token': token,
'starttime': starttime}
return aiohttp_jinja2.render_template('normal.html', request, context)
else:
self.clear_session(session)
return aiohttp.web.HTTPFound('/')
def check(request, **kwargs):
url_to_login = request.app.router['login'].url()
session = yield from get_session(request)
if not 'user_id' in session:
print('Team is not allowed, sign in first')
return web.HTTPFound(url_to_login)
team_slug = request.match_info['team_slug']
with (yield from request.app["db"]) as conn:
team_query = sa.select([models.teams]).where(models.teams.c.slug==team_slug)
select_team = yield from conn.execute(team_query)
team = yield from select_team.first()
if not team:
return web.HTTPNotFound()
else:
relation_query = sa.select([models.teams_users])\
.where(sa.and_(models.teams_users.c.team==team['id'],
models.teams_users.c.user==session['user_id']))
find_relation = yield from conn.execute(relation_query)
rel = yield from find_relation.first()
if not rel:
return web.HTTPNotFound()# user is not in this team, return 404
return (yield from handler(request, team=team, **kwargs))
def api(self, request):
""" 转发客户端和游戏服务器之间的API通信。
:param request: aiohttp.web.Request
:return: aiohttp.web.Response or aiohttp.web.HTTPBadRequest
"""
action = request.match_info['action']
session = yield from get_session(request)
world_ip = session['world_ip']
if world_ip:
if action == 'api_start2' and self.api_start2 is not None:
return aiohttp.web.Response(body=self.api_start2,
headers=aiohttp.MultiDict({'Content-Type': 'text/plain'}))
else:
referrer = request.headers.get('REFERER')
referrer = referrer.replace(request.host, world_ip)
referrer = referrer.replace('https://', 'http://')
url = 'http://' + world_ip + '/kcsapi/' + action
headers = aiohttp.MultiDict({
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko',
'Origin': 'http://' + world_ip + '/',
'Referer': referrer,
'X-Requested-With': 'ShockwaveFlash/18.0.0.232'
})
data = yield from request.post()
coro = aiohttp.post(url, data=data, headers=headers, connector=self.connector)
try:
response = yield from asyncio.wait_for(coro, timeout=5)
except asyncio.TimeoutError:
return aiohttp.web.HTTPBadRequest()
body = yield from response.read()
if action == 'api_start2' and len(body) > 100000:
self.api_start2 = body
return aiohttp.web.Response(body=body, headers=aiohttp.MultiDict({'Content-Type': 'text/plain'}))
else:
return aiohttp.web.HTTPBadRequest()
def remove_notification(request):
id = request.path.split('/')[-1]
result = {'error': ''}
if id:
session = yield from get_session(request)
user_id = session['user_id'] if 'user_id' in session else None
if not user_id:
result = {'error': 'You must be loged in to remove item'}
else:
with(yield from request.app['db']) as conn:
trans = yield from conn.begin()
try:
query = sa.select([models.notifications])\
.where(models.notifications.c.id == id)
res = yield from conn.execute(query)
nf = yield from res.fetchone()
if not nf:
result = {'error': 'No such item'}
elif nf['author'] != user_id:
result = {'error': 'You can not remove this item. Its not yours, you silly dog!'}
else:
if (yield from conn.execute(models.notifications.delete()\
.where(models.notifications.c.id == id))):
result = {"id": id}
else:
result = {'erorr': 'Error on save'}
except Exception as e:
print(str(e))
yield from trans.rollback()
else:
yield from trans.commit()
else:
print('Can not delete noitfication: no id')
result = {'error': 'Can not delete noitfication: no id'}
print(json.dumps(result))
return json_response(json.dumps(result))
def remember(self, request, response, identity, **kwargs):
session = yield from get_session(request)
session[self._session_key] = identity
def handler(request):
session = yield from get_session(request)
session.invalidate()
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
session['c'] = 3
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
assert session.new
return web.Response(body=b'OK')
def handler(request):
session = yield from get_session(request)
self.assertTrue(session.new)
return web.Response(body=b'OK')
def forget(self, request, response):
session = yield from get_session(request)
session.pop(self._session_key, None)
def identify(self, request):
session = yield from get_session(request)
return session.get(self._session_key)
def handler(request):
session = yield from get_session(request)
session["a"] = 1
return web.Response(body=b"OK")
