async def before_request(request: Request):
if request.path.startswith('/build') or request.path in ['/api/login', '/api/register', '/api/is_authenticated']:
return None
token, user_id = authenticate(request)
if request.path in ['/', '/login', '/register']:
if user_id and request.path == '/login':
return redirect('/home')
return home(request)
else:
if not user_id:
return redirect('/login')
elif not request.path.startswith('/api'):
return home(request)
async def user(request, urltype, steamid):
path = urlparse(request.url).path
currentuser = await getcurrentuser(request)
if currentuser and currentuser['url'] == path:
user = currentuser
else:
user = await getuser(steamid, urltype)
if user:
if user['url'] != path:
return redirect(user['url'])
items = await getitems(item['index'] for item in user['wishlist'])
for i, item in enumerate(items):
item.update({'i': i})
item.update(user['wishlist'][i])
else:
abort(404)
return await render('user.html',
user=user,
items=items)
def redirect(self, request, path):
if request.query_string:
path = '{}?{}'.format(
path, request.query_string
)
r = response.redirect(path)
r.headers['Link'] = '<{}>; rel=preload'.format(path)
if self.ds.cors:
r.headers['Access-Control-Allow-Origin'] = '*'
return r
async def seek(request):
import time
begin = time.time()
keyword = request.args.get('kw', '').strip()
if not keyword:
return redirect('/books/search')
is_contain_chinese = chinese_contain_check(keyword)
book_name = f'{keyword} 小说 阅读 最新'
# print("request-"+str(request))
# print("request.url-"+str(request.url))
# print("request.args-"+str(request.args))
# print("request.json-"+str(request.json))
# print("request.raw_args-"+str(request.raw_args))
# print("request.files-"+str(request.files))
# print("request.form-"+str(request.form))
# print("request.body-"+str(request.body))
# print("request.ip-"+str(request.ip))
# print("request.app-"+str(request.app))
# print("request.scheme-"+str(request.scheme))
# print("request.host-"+str(request.host))
# print("request.path-"+str(request.path))
# print("request.query_string-"+str(request.query_string))
# print("request.uri_template-"+str(request.uri_template))
use_engine = None
seek_results = None
if is_contain_chinese:
for engine in ENGINE_PRIORITY.get('chinese'):
if engine == 'baidu':
seek_results = ''
if seek_results:
break
else:
for engine in ENGINE_PRIORITY.get('non-chinese'):
await mongo_obj.search_records.update_one({'keyword': keyword, 'use_engine': use_engine}, {'$inc': {'count': 1}}, upsert=True)
end = time.time()
seek_time = '%.2f' % (end - begin)
return page('books/search.html',
active_page = "/books/seek",
seek_results = seek_results,
seek_time = seek_time
)
async def get_candidate(request, candidate_id):
async with app.mysql.acquire() as conn:
async with conn.cursor() as cur:
await cur.execute('SELECT * FROM candidates WHERE id = {}'.format(candidate_id))
candidate = await cur.fetchone()
if not candidate:
return redirect('/')
await cur.execute('SELECT COUNT(*) AS count FROM votes WHERE candidate_id = {}'.format(candidate_id))
votes = (await cur.fetchone())['count']
keywords = await get_voice_of_supporter([candidate_id])
return render_template('candidate.html',
request,
candidate=candidate,
votes=votes,
keywords=keywords)
def login(request):
sid = b64encode(os.urandom(16)).decode()
session = {'sid': sid}
c = consumer.Consumer(session, None)
a = c.begin('http://steamcommunity.com/openid')
url = a.redirectURL(config.homepage, login_verify_url)
response = redirect(url)
response.cookies['sid'] = sid
response.cookies['sid']['expires'] = datetime.now() + session_age
response.cookies['sid']['httponly'] = True
response.cookies['sid']['secure'] = True
return response
async def login_verify(request):
sid = request.cookies.get('sid')
session = {'sid': sid}
c = consumer.Consumer(session, None)
info = c.complete(
{k: request.args.get(k) for k in request.args},
login_verify_url
)
if info.status == consumer.SUCCESS:
steamid = request.args.get('openid.claimed_id').split('/')[-1]
user = await getuser(steamid, create=True)
await store.setex(getsessionkey(sid), int(session_age.total_seconds()),
user['id'])
return redirect('/')
async def item(request, **kwargs):
slug = kwargs.get('slug')
index = kwargs.get('index')
is_json = kwargs.get('is_json')
item = await (getitembyslug(slug) if slug else getitem(index))
if item and index is not None and not is_json:
slug = slugify(item['name'])
return redirect(f'/{slug}', status=301)
if not item:
if is_json:
return tojson({'error': 'Item does not exist.'})
abort(404)
if is_json:
return tojson(item)
else:
name = item['name']
tags_text = '/'.join(item['tags']) if item['tags'] else 'item'
classes_text = getlistastext(item['classes'], 'all classes')
description = f'{name} is a TF2 {tags_text} for {classes_text}.'
if item['description']:
desc_parts = item['description'].partition('---')
desc = desc_parts[0].replace('\n', ' ')
bundle_items = getlistastext(desc_parts[2].split('\n'))
description = (
f"{description} {desc} {bundle_items}" if bundle_items else
f"{description} {desc}"
).rstrip(':')
if description[-1] not in ('.', '?', '!'):
description += '.'
return await render('item.html',
item=item,
description=description)
async def owllook_content(request):
"""
返回小说章节内容页
: content_url 这决定当前U页面url的生成方式
: url 章节内容页源url
: chapter_url 小说目录源url
: novels_name 小说名称
:return: 小说章节内容页
"""
url = request.args.get('url', None)
chapter_url = request.args.get('chapter_url', None)
novels_name = request.args.get('novels_name', None)
name = request.args.get('name', '')
is_ajax = request.args.get('is_ajax', '')
# 当小说内容url不在解析规则内 跳转到原本url
netloc = get_netloc(url)
if netloc not in RULES.keys():
return redirect(url)
user = request['session'].get('user', None)
# 拼接小说目录url
book_url = "/chapter?url={chapter_url}&novels_name={novels_name}".format(
chapter_url=chapter_url, novels_name=novels_name)
motor_db = motor_base.get_db()
if url == chapter_url:
# 阅读到最后章节时候 在数据库中保存最新阅读章节
if user and is_ajax == "owl_cache":
owl_referer = request.headers.get('Referer',
'').split('owllook_content')[1]
if owl_referer:
latest_read = "/owllook_content" + owl_referer
await motor_db.user_message.update_one(
{
'user': user,
'books_url.book_url': book_url
}, {'$set': {
'books_url.$.last_read_url': latest_read
}})
return redirect(book_url)
content_url = RULES[netloc].content_url
content_data = await cache_owllook_novels_content(url=url, netloc=netloc)
if content_data:
try:
content = content_data.get('content', '获取失败')
next_chapter = content_data.get('next_chapter', [])
title = content_data.get('title', '').replace(novels_name, '')
name = title if title else name
# 拼接小说书签url
bookmark_url = "{path}?url={url}&name={name}&chapter_url={chapter_url}&novels_name={novels_name}".format(
path=request.path,
url=url,
name=name,
chapter_url=chapter_url,
novels_name=novels_name)
# 破坏广告链接
content = str(content).strip('[]Jjs,').replace(
'http', 'hs').replace('.js', '').replace('();', '')
if user:
bookmark = await motor_db.user_message.find_one({
'user':
user,
'bookmarks.bookmark':
bookmark_url
})
book = await motor_db.user_message.find_one({
'user':
user,
'books_url.book_url':
book_url
})
bookmark = 1 if bookmark else 0
if book:
# 当书架中存在该书源
book = 1
# 保存最后一次阅读记录
if is_ajax == "owl_cache":
owl_referer = request.headers.get(
'Referer',
bookmark_url).split('owllook_content')[1]
latest_read = "/owllook_content" + owl_referer
await motor_db.user_message.update_one(
{
'user': user,
'books_url.book_url': book_url
}, {
'$set': {
'books_url.$.last_read_url': latest_read
}
})
else:
book = 0
if is_ajax == "owl_cache":
owl_cache_dict = dict(is_login=1,
user=user,
name=name,
url=url,
bookmark=bookmark,
book=book,
content_url=content_url,
chapter_url=chapter_url,
novels_name=novels_name,
next_chapter=next_chapter,
soup=content)
return json(owl_cache_dict)
return template('content.html',
is_login=1,
user=user,
name=name,
url=url,
bookmark=bookmark,
book=book,
content_url=content_url,
chapter_url=chapter_url,
novels_name=novels_name,
next_chapter=next_chapter,
soup=content)
else:
if is_ajax == "owl_cache":
owl_cache_dict = dict(is_login=0,
name=name,
url=url,
bookmark=0,
book=0,
content_url=content_url,
chapter_url=chapter_url,
novels_name=novels_name,
next_chapter=next_chapter,
soup=content)
return json(owl_cache_dict)
return template('content.html',
is_login=0,
name=name,
url=url,
bookmark=0,
book=0,
content_url=content_url,
chapter_url=chapter_url,
novels_name=novels_name,
next_chapter=next_chapter,
soup=content)
except Exception as e:
LOGGER.exception(e)
return redirect(book_url)
else:
if user:
is_login = 1
user = user
return template('parse_error.html',
url=url,
is_login=is_login,
user=user)
else:
is_login = 0
return template('parse_error.html', url=url, is_login=is_login)
def index(request):
return redirect("index.html")
async def handler(request):
return response.redirect("/sleep/3")
async def index(request):
return redirect('/quiz/list')
async def default(request, query):
return redirect(f"/p/{query}", status=301)
async def handle_request(request):
response = redirect('/')
del response.cookies['username']
return response
async def search_user(request):
user = request['session'].get('user', None)
name = request.args.get('ss', None)
if user and name:
try:
motor_db = motor_base.get_db()
data = await motor_db.user_message.find_one({'user': name})
books_url = data.get('books_url', None) if data else None
if books_url:
result = []
for i in books_url:
item_result = {}
book_url = i.get('book_url', None)
last_read_url = i.get("last_read_url", "")
book_query = parse_qs(urlparse(book_url).query)
last_read_chapter_name = parse_qs(last_read_url).get(
'name', ['暂无'])[0]
item_result['novels_name'] = book_query.get(
'novels_name', '')[0] if book_query.get(
'novels_name', '') else ''
item_result['book_url'] = book_url
latest_data = await motor_db.latest_chapter.find_one(
{'owllook_chapter_url': book_url})
if latest_data:
item_result['latest_chapter_name'] = latest_data[
'data']['latest_chapter_name']
item_result['owllook_content_url'] = latest_data[
'data']['owllook_content_url']
else:
get_latest_data = await get_the_latest_chapter(book_url
) or {}
item_result[
'latest_chapter_name'] = get_latest_data.get(
'latest_chapter_name', '暂未获取，请反馈')
item_result[
'owllook_content_url'] = get_latest_data.get(
'owllook_content_url', '')
item_result['add_time'] = i.get('add_time', '')
item_result[
"last_read_url"] = last_read_url if last_read_url else book_url
item_result[
"last_read_chapter_name"] = last_read_chapter_name
result.append(item_result)
return template('search_user.html',
title='{name}的书架'.format(name=name),
is_login=1,
user=user,
username=name,
is_bookmark=1,
result=result[::-1])
else:
return template('search_user.html',
title='{name}的书架'.format(name=name),
is_login=1,
user=user,
is_bookmark=0)
except Exception as e:
LOGGER.error(e)
return redirect('/')
else:
return redirect('/')
async def lcxs(request):
user = request['session'].get('user', None)
if user:
return template('admin_lcxs.html', is_login=1, user=user)
else:
return redirect('/')
async def check_request(request):
host = request.headers.get('host', None)
if not host or host not in HOST:
return redirect('http://www.google.com')
async def index(request):
return redirect('/index.html')
def index(request):
return response.redirect(
os.getenv("REDIRECT_URL",
"https://github.com/Magisk-Modules-Repo/Pix3lify"))
async def search(request, **kwargs):
user = asyncio.ensure_future(getcurrentuser(request))
slug = kwargs.get('slug')
is_json = kwargs.get('is_json', '')
query = slug.replace('-', ' ') if slug else request.args.get('q')
if not query:
if is_json:
return {'error': 'No query provided.'}
return redirect('/')
elif query == 'random':
index = await store.srandmember('items:indexes')
return redirect('/{}{}'.format(index, is_json))
itemnames = await store.hgetall('items:names')
if query in itemnames:
return redirect('/{}'.format(itemnames[query]))
t0 = time.time()
classes = set()
tags = set()
priceviz = False
if query == 'all':
items = store.Hashes(
[getitemkey(k.decode()) for k in await store.sort('items')])
results = [tf2search.getsearchresult(items=items)]
else:
sources = ('backpack.tf', 'trade.tf')
pricesource = request.cookies.get('price_source')
if pricesource not in sources:
pricesource = sources[0]
items = {
item['index']: item async for item in store.Hashes([
getitemkey(143), # Earbuds
getitemkey(5021), # Key
getitemkey(5002), # Refined
getitemkey(5001), # Reclaimed
getitemkey(5000), # Scrap
getitemkey(0) # Weapon
])
}
results = tf2search.visualizeprice(query, items, pricesource)
input_ = tf2search.parseinput(query)
classes = input_['classes']
tags = input_['tags']
if results is not None:
if len(results) != 0:
priceviz = True
if not is_json:
items = []
for item in results[0]['items']:
items.extend([item['item']] * item['count'])
results[0]['items'] = items
elif classes or tags:
results = await getresults(classes, tags)
else:
itemsdict = await store.SearchHashSet(
'items', getitemkey,
('index', 'name', 'image', 'classes', 'tags', 'marketprice'),
int)
itemsets = await store.get('items:sets')
bundles = await store.get('items:bundles')
results = tf2search.search(query, itemsdict, itemnames,
itemsets, bundles, pricesource)
for result in results:
result['items'] = store.Hashes(
[h.key for h in result['items']])
t1 = time.time()
count = sum(len(result['items']) for result in results)
all_classes = list(tf2api.getallclasses().keys())
classes_text = getlistastext(sorted(classes, key=all_classes.index))
tags_text = getlistastext(sorted(tags))
if query == 'all':
description = f'A list of all {count:,} items in TF2.'
elif classes and tags:
description = (
f'A list of the {count:,} {tags_text} items for {classes_text}'
' in TF2.'
)
elif classes:
description = (
f'A list of the {count:,} items for {classes_text} in TF2.'
)
elif tags:
description = f'A list of the {count:,} {tags_text} items in TF2.'
elif priceviz:
from_, equals, to = results[0]['title'].partition(' = ')
to = getlistastext(to.split(' + '))
description = (f'{from_} is the same as {to} in TF2.' if equals else
f'A list of {from_} items in TF2.')
elif results and ':' in results[0]['title']:
title = results[0]['title'].replace(':', '')
description = f'{count:,} {title} items in TF2.'
else:
description = f'Search results for "{query}" items in TF2.'
qualities = defaultdict(set)
user = await user
if user:
for item in user.get('backpack', {}).get('items', []):
qualities[item['defindex']].add(item['quality'])
if is_json:
for result in results:
result['items'] = [item async for item in result['items']]
return tojson(results)
else:
return await render('search.html',
query=query,
description=description,
results=results,
qualities=qualities,
count=count,
time=round(t1 - t0, 3))
async def parse_map_image(request, mapcode):
return response.redirect(
"https://cheese.formice.com/maps.php?code={}&nodefault".format(
mapcode))
async def redirect(request):
return response.redirect(request.raw_args['url'])
def redirect_on_404_with_trailing_slash(request, original_response):
if original_response.status == 404 and request.path.endswith("/"):
path = request.path.rstrip("/")
if request.query_string:
path = "{}?{}".format(path, request.query_string)
return response.redirect(path)
async def to_client(request):
return redirect("/client/index.html")
def redirect_to_index(
request: request.Request, ) -> response.HTTPResponse:
return response.redirect(
f"{blueprint.url_prefix}/client/index.html?{request.query_string}"
)
async def logout(request):
request.ctx.session["session"].clear()
return response.redirect("/")
async def main(request):
return response.redirect("https://github.com/team-alpha-kr/PUBG-API")
async def direct_download_legacy(request: Request, region: str, model: str):
return redirect(f'/direct/{region}/{model}')
async def logout(request):
if 'uid' in request['session']:
request['session'].pop('uid')
return redirect(app.url_for('home.index'))
async def owllook_search(request):
start = time.time()
name = str(request.args.get('wd', '')).strip()
novels_keyword = name.split(' ')[0]
motor_db = motor_base.get_db()
if not name:
return redirect('/')
else:
# 记录搜索小说名
try:
await motor_db.search_records.update_one({'keyword': name},
{'$inc': {
'count': 1
}},
upsert=True)
except Exception as e:
LOGGER.exception(e)
# 通过搜索引擎获取检索结果
parse_result = None
if name.startswith('!baidu'):
novels_keyword = name.split('baidu')[1].strip()
novels_name = 'intitle:{name} 小说 阅读'.format(name=novels_keyword)
parse_result = await get_novels_info(class_name='baidu',
novels_name=novels_name)
elif name.startswith('!360'):
novels_keyword = name.split('360')[1].strip()
novels_name = "{name} 小说 最新章节".format(name=novels_keyword)
parse_result = await get_novels_info(class_name='so',
novels_name=novels_name)
elif name.startswith('!bing'):
novels_keyword = name.split('bing')[1].strip()
novels_name = "{name} 小说 阅读 最新章节".format(name=novels_keyword)
parse_result = await get_novels_info(class_name='bing',
novels_name=novels_name)
elif name.startswith('!duck_go'):
novels_keyword = name.split('duck_go')[1].strip()
novels_name = '{name} 小说 阅读 最新章节'.format(name=novels_keyword)
parse_result = await get_novels_info(class_name='duck_go',
novels_name=novels_name)
else:
for each_engine in ENGINE_PRIORITY:
# for bing
if each_engine == "bing":
novels_name = "{name} 小说 阅读 最新章节".format(name=name)
parse_result = await get_novels_info(class_name='bing',
novels_name=novels_name)
if parse_result:
break
# for 360 so
if each_engine == "360":
novels_name = "{name} 小说 最新章节".format(name=name)
parse_result = await get_novels_info(class_name='so',
novels_name=novels_name)
if parse_result:
break
# for baidu
if each_engine == "baidu":
novels_name = 'intitle:{name} 小说 阅读'.format(name=name)
parse_result = await get_novels_info(class_name='baidu',
novels_name=novels_name)
if parse_result:
break
# for duckduckgo
if each_engine == "duck_go":
novels_name = '{name} 小说 阅读 最新章节'.format(name=name)
parse_result = await get_novels_info(class_name='duck_go',
novels_name=novels_name)
if parse_result:
break
if parse_result:
# result_sorted = sorted(
# parse_result, reverse=True, key=lambda res: res['timestamp']) if ':baidu' not in name else parse_result
# 优先依靠是否解析进行排序 其次以更新时间进行排序
result_sorted = sorted(parse_result,
reverse=True,
key=itemgetter('is_recommend', 'is_parse',
'timestamp'))
user = request['session'].get('user', None)
if user:
try:
time_current = get_time()
res = await motor_db.user_message.update_one(
{'user': user},
{'$set': {
'last_update_time': time_current
}},
upsert=True)
# 此处语法操作过多 下次看一遍mongo再改
if res:
is_ok = await motor_db.user_message.update_one(
{
'user': user,
'search_records.keyword': {
'$ne': novels_keyword
}
},
{
'$push': {
'search_records': {
'keyword': novels_keyword,
'counts': 1
}
}
},
)
if is_ok:
await motor_db.user_message.update_one(
{
'user': user,
'search_records.keyword': novels_keyword
}, {'$inc': {
'search_records.$.counts': 1
}})
except Exception as e:
LOGGER.exception(e)
return template('result.html',
is_login=1,
user=user,
name=novels_keyword,
time='%.2f' % (time.time() - start),
result=result_sorted,
count=len(parse_result))
else:
return template('result.html',
is_login=0,
name=novels_keyword,
time='%.2f' % (time.time() - start),
result=result_sorted,
count=len(parse_result))
else:
return html("No Result！请将小说名反馈给本站，谢谢！")
async def index(request: Request):
return redirect('https://c-w.github.io/gutenberg-http/')
def handler(request):
return redirect('/3')
async def index(request):
user = request['user']
if user:
return response.redirect(app.url_for('user_panel.index'))
else:
return response.redirect(app.url_for('auth.LoginView'))
async def reader_page(request):
return response.redirect('/')
async def init_handler(request, test):
assert test == test_str
return redirect("/api/v2/test/{}/".format(quote(test)))
def handler1(request):
return redirect("/2")
async def redirect_with_header_injection(request):
return redirect("/unsafe\ntest-header: test-value\n\ntest-body")
async def admin(request):
if not db.isadmin(request['session']['username']):
return redirect(app.url_for('/'))
async def default(request):
return redirect("/p", status=301)
async def redirect_init_with_301(request):
return redirect("/redirect_target", status=301)
async def main(request):
if not request['session'].get('logged_in'):
return redirect(app.url_for('login'))
else:
return redirect(app.url_for('dashboard'))
def handler2(request):
return redirect("/3")
async def verify(request):
if not request['session'].get('password_ok'):
return redirect(app.url_for('login'))
message = randomstr(20)
request['session']['message'] = message
return render_template('verify.html', message=message)
async def redirect_init(request):
return redirect("/redirect_target")
async def logout(request):
del request['session']['logged_in']
return redirect(app.url_for('main'))
async def dashboard(request):
if not request['session'].get('logged_in'):
return redirect(app.url_for('login'))
return render_template('dashboard.html')
def handle_request(request):
return response.redirect('/json')
