async def setCrossfade(request, VoiceClient) -> response.empty:
if "crossfade" not in request.json or not isinstance(
request.json["crossfade"], float):
abort(400, "Bad data `crossfade`")
VoiceClient.crossfade = request.json["crossfade"]
return response.empty()
async def setVolume(request, VoiceClient) -> response.empty:
if "volume" not in request.json or not isinstance(request.json["volume"],
float):
abort(400, "Bad data `volume`")
VoiceClient.volume = request.json["volume"]
return response.empty()
async def seek(request, VoiceClient) -> response.empty:
if "offset" not in request.json or not isinstance(request.json["offset"],
float):
abort(400, "Bad data `offset`")
await VoiceClient.seek(request.json["offset"])
return response.empty()
async def post_states(request, valid_json):
global states
states = valid_json
with open(app.config.STATES_FILE, 'w') as f:
dump(states, f)
update_titles(sw)
update_states(sw)
return empty()
async def setFilter(request, VoiceClient) -> response.empty:
if "filter" not in request.json or not isinstance(request.json["filter"],
dict):
abort(400, "Bad data `filter`")
VoiceClient.filter = request.json["filter"]
return response.empty()
async def setAutoplay(request, VoiceClient) -> response.empty:
if "autoplay" not in request.json or not isinstance(
request.json["autoplay"], bool):
abort(400, "Bad data `autoplay`")
VoiceClient.autoplay = request.json["autoplay"]
return response.empty()
def get_contact(_, id):
"""Gets a specific contact"""
try:
contact = Contact[id]
except ObjectNotFound:
return empty(404)
return json(contact.to_dict())
async def delete_message(request, user_id, msg_id):
try:
msg_id = bson.ObjectId(msg_id)
except bson.errors.InvalidId:
return response.empty(status=404)
await request.app.db.messages.delete_one({"_id": msg_id, "user_id": user_id})
return response.json({})
async def put(self, request: Request, user: User):
customer = await Customer.filter(id=request.args.get('id', None)
).first()
if customer is None:
return empty(status=404)
customer.name = request.json.get('name', customer.name)
await customer.save()
return json(customer.dict())
async def add(request, user, watchlist, movie_id):
logger.debug(movie_id)
if not is_in_default_watchlist(movie_id, user):
with db_session():
watchlist = Watchlist.get(id=watchlist.id)
item = MovieItem(imdb_id=movie_id,
date=datetime.now(),
watchlist=watchlist)
return response.empty()
async def destroy(request: Request, uid: str):
user = User.get_or_none(id=uid)
if user is None:
return response.json({'user': '******'}, status=404)
user.delete_instance(recursive=True)
return response.empty()
def item_delete(_: Request, item_ids: str):
try:
item_ids = [int(i) for i in item_ids.split(',')]
except ValueError:
raise ValidationError('Could not parse item_ids')
delete_items(item_ids)
save_inventories_file()
return response.empty()
async def bot_post(request):
message = request.json.get('message', {})
chat_id = message.get('chat', {}).get('id')
reply = await utils.get_reply(message)
if chat_id:
utils.send_reply(chat_id, reply)
return empty()
return json(reply, sort_keys=True)
async def snapshot_post(request):
"Handle a client POSTing its currently running programs"
LOGGER.info("got a snapshot POST: %s", request.json)
elapsed_seconds = request.json.get("elapsed_seconds", 0)
hostname = request.json["hostname"]
username = request.json["username"]
pid_to_program = request.json["programs"]
queries.snapshot_store(app.db_connection, hostname, username, elapsed_seconds, pid_to_program)
return empty()
async def edit_history(request, user, item_id):
logger.debug(item_id)
logger.debug(request.form.get("date"))
date_string = request.form.get("date")
if date_string:
with db_session():
movie = MovieItem.select(
lambda m: m.id == item_id and m.user.id == user.id).first()
movie.date = datetime.strptime(date_string, "%Y-%m-%d")
return response.empty()
async def send_message(request, json={}):
user = load_auth(request)
_send_message(user, json['message'], incoming=True)
handle_message(user, json['message'])
await asyncio.sleep(0.5)
return response.empty(status=200)
def post(self, request):
email = request.json['email']
password = request.json['password']
user = authenticate(email, password)
if user is None:
return response.empty(status=404)
token = authorize(user).decode()
return response.json({'token': token})
async def remove_employee(request, json={}):
user = load_auth(request)
selected_user = User.from_id(json['userId'])
depth = user.get_depth()
if depth in [1, 2] and not selected_user.parent_id == user.id:
raise Exception('Вы не можете удалить этого пользователя')
selected_user.drop()
return response.empty(status=200)
def post(self, request):
serializer = UserSerializer()
try:
user = serializer.load(request.json)
except ValidationError as error:
return response.json(error.messages, status=400)
register(user)
return response.empty(status=201)
async def _handler(self, req: request.Request) -> response.HTTPResponse:
"""handle inbound web-requests for dns-packets"""
# check content-type
if req.headers['Content-Type'] != CONTENT_TYPE:
return response.empty(status=400)
# run handler using thread-pool executor
handler = Handler()
loop = asyncio.get_event_loop()
future = loop.run_in_executor(self._pool,
handler.request_received, req)
print(future)
async def remove_history(request, user, item_id):
logger.debug(item_id)
with db_session():
date_string = request.args.get("date", None)
if date_string:
date = datetime.strptime(date_string, "%Y-%m-%d")
MovieItem.select(lambda m: m.id == item_id and m.date == date and m
.user.id == user.id).delete()
else:
MovieItem.select(lambda m: m.id == item_id).delete()
return response.empty()
async def sanic_entry(self, request):
from sanic import response
raw_data = request.body.decode("utf-8")
signature = request.headers.get("x-signature-ed25519")
timestamp = request.headers.get("x-signature-timestamp")
if signature is None or timestamp is None:
return response.empty(status=401)
try:
self.public_key.verify(f"{timestamp}{raw_data}".encode(), bytes.fromhex(signature))
except BadSignatureError:
return response.empty(status=401)
data = InteractionPayload(json.loads(raw_data))
resp = await self.interaction_received(data)
if resp is None:
return response.json({}, status=400)
return response.json(resp.to_dict())
def create_contact(request):
"""Creates a contact"""
try:
try:
contact_payload = request.json
except:
raise ValueError
if contact_payload is None:
raise ValueError
id = str(uuid.uuid4())
Contact(id=id,
firstName=contact_payload['firstName'],
lastName=contact_payload['lastName'],
phoneNumber=contact_payload['phoneNumber'])
return empty(201, {'Location': f"/{id}"})
except ValueError:
return empty(400)
async def webtoon_search_endpoint(request):
terms = request.args.get('terms', None)
limit = request.args.get('limit', 5)
if terms is None:
return response.empty(status=400)
if limit > 15:
limit = 15
data = await asyncio.get_event_loop() \
.run_in_executor(pool, webtoon_info.search, terms, limit)
return response.json(data)
async def request_handler(request):
"""
Route function to handle request data depending on data's keys.
Return empty request with status code 204.
"""
message = request.json.get('message')
if 'photo' in message:
await photo_handler(message)
elif 'voice' in message:
await voice_handler(message)
return response.empty()
async def get_mesh_chunks(request: Request, organization_name: str,
dataset_name: str,
layer_name: str) -> response.HTTPResponse:
request_body = request.json
(backend_name,
dataset) = request.app.ctx.repository.get_dataset(organization_name,
dataset_name)
backend = request.app.ctx.backends[backend_name]
segment_id = request_body["segmentId"]
mesh_name = request_body["meshFile"]
try:
chunks = await backend.get_chunks_for_mesh(dataset, layer_name,
mesh_name, segment_id)
if chunks is None:
return response.empty(status=404)
return response.json(chunks)
except NotImplementedError:
return response.empty(status=501)
async def story(request):
topic = request.args.get("topic")
if topic:
cursor = db.cursor()
cursor.execute(
"SELECT id, date, text FROM track WHERE topic = ? ORDER BY date DESC",
[
topic,
])
return json(cursor.fetchall())
else:
return empty()
async def get_integration(request, user_id, integration_id):
try:
integration_id = bson.ObjectId(integration_id)
except bson.errors.InvalidId:
return response.empty(status=404)
integration = await request.app.db.integrations.find_one({"_id": integration_id, "user_id": user_id})
if integration is None:
raise abort(404, "Unknown integration")
del integration["user_id"]
integration["values"].pop("bot_token", None)
return response.json(json_ready(integration))
async def website_post(request):
"Handle a client POSTing a website it visits"
tables.WebsiteVisit.insert(
app.db_connection,
at=datetime.datetime.now(),
hostname=request.json["hostname"],
incognito=request.json["incognito"],
url=request.json["url"],
username=request.json["username"],
)
if "github" in request.json["url"]:
return text("Parentopticon says no", status=499)
return empty()
async def replies_editor_add_reply(request: Request) -> HTTPResponse:
app = request.app
replies = await app.bot.aload_json('replies')
data = {}
for raw_key, tags in app.bot.replies_config_tags.items():
keys = raw_key[2:-2].split("']['")
app.bot.set_dict_key(data, keys, tags[0]())
if app.bot.get_dict_key_default(replies, ['replies'], None) is None:
app.bot.set_dict_key(replies, ['replies'], [])
app.bot.get_dict_key(replies, ['replies']).append(data)
app.bot.save_json('replies', replies)
return res.empty()
