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()