async def on_post(req: Request, resp: Response, *, serial_number: str): """Create a new device data record.""" try: data = await req.media() schema = DeviceDataSchema() device_data_object = schema.load(data)[0] device_data_object.serial_number = serial_number device_data_object.save() except (json.JSONDecodeError, mongoengine.ValidationError) as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = {"error": str(error)} except mongoengine.NotUniqueError as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = { "error": f"Device data has already been uploaded for " f"{serial_number}. Please use the PUT HTTP method to " f"update this record." } else: resp.media = schema.dump(device_data_object)[0]
async def on_put(req: Request, resp: Response, *, serial_number: str): """Update a device data record.""" try: data = await req.media() assert isinstance(data, dict) device_data_object = DeviceData.objects.get( serial_number=serial_number, ) for attribute, value in data.items(): setattr(device_data_object, attribute, value) device_data_object.save() device_data_object.reload() except (json.JSONDecodeError, mongoengine.ValidationError) as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = {"error": str(error)} except mongoengine.DoesNotExist: resp.status_code = api.status_codes.HTTP_404 except mongoengine.MultipleObjectsReturned as error: logger.error(error) resp.status_code = api.status_codes.HTTP_500 resp.media = {"error": str(error)} else: schema = DeviceDataSchema() resp.media = schema.dump(device_data_object)[0]
async def get_sent_keitai_messages(req: Request, resp: Response): json = await req.media() from_user = User.get_or_none(User.email == json['email']) if not from_user: resp.media = [] query = (KeitaiMessage .select() .where(KeitaiMessage.from_user == from_user) .order_by(KeitaiMessage.created_at)) resp.media = [{ "id": msg.id, "to_user": { "id": msg.to_user.id, "email": msg.to_user.email, "username": msg.from_user.username, }, "title": msg.title, "content": msg.content, "content_dict": pokebell.text_to_dic(msg.content), "created_at": msg.created_at.isoformat(), } for msg in query]
async def get_received_pokebel_messages(req: Request, resp: Response): json = await req.media() print(json) to_user = User.get_or_none(User.number == json['number']) if not to_user: resp.media = [] query = (PokebelMessage .select() .where(PokebelMessage.to_user == to_user) .order_by(PokebelMessage.created_at)) resp.media = [{ "id": msg.id, "from_user": { "id": msg.from_user.id, "number": msg.from_user.number, "username": msg.from_user.username, }, "content": msg.content, "created_at": msg.created_at.isoformat(), } for msg in query]
def on_get(req: Request, resp: Response, *, serial_number: str): """Get rendered device configuration, by device serial number.""" try: device_data_object = DeviceData.objects.get( serial_number=serial_number) template = get_template(device_data_object.template_name) except mongoengine.DoesNotExist: resp.status_code = api.status_codes.HTTP_404 resp.media = { "error": f"The device data for serial number " f"`{serial_number}` could not be found.", } except jinja2.TemplateNotFound as error: logger.error(error) resp.status_code = api.status_codes.HTTP_404 resp.media = { "error": f"The template `{device_data_object.template_name}` " f"specified in the device data record could not be " f"found.", } except mongoengine.MultipleObjectsReturned as error: logger.error(error) resp.status_code = api.status_codes.HTTP_500 resp.media = {"error": str(error)} else: resp.content = template.render( config_data=device_data_object.config_data).encode("utf-8") resp.headers["Content-Type"] = "text/plain; encoding=utf-8"
async def get_user_by_attr(req: Request, resp: Response): try: result = await users_blueprint.build_query_set(models.User, req) if result is None: resp.media = None elif isinstance(result, int): resp.media = result elif isinstance(result, models.User): UserModel.from_orm(result).send_json(resp) else: UserModel.list_model([UserModel.from_orm(user) for user in result]).send_json(resp) except Exception: # pylint: disable=bare-except logger.exception("Unable to perform filter")
async def on_post(self, req: Request, resp: Response): """ request { first: "柿食えば", second: "鐘が鳴るなり", third: "法隆寺" } response { "images": [ "/static/6qqV9MTuEemXsrj2sRfcWw.png", "/static/L2oLJMUTEem_8bj2sRfcWw.png" ], "season": "fall" } """ haiku = schema.Haiku().load(await req.media()) kigo = Kigo.select().where( (fn.Instr(haiku['first'], Kigo.kigo) > 0) | (fn.Instr(haiku['second'], Kigo.kigo) > 0) | (fn.Instr(haiku['third'], Kigo.kigo) > 0)).first() Haiku.create(first=haiku['first'], second=haiku['second'], third=haiku['third'], kigo=kigo).save() resp.media = { 'images': [req.api.static_url(i.image + '.png') for i in kigo.images], 'season': kigo.season.name.lower() }
async def verify_user( req: responder.Request, resp: responder.Response, *, data ): # pylint: disable=unused-variable, unused-argument if req.method == "get": # Generate a verification token for this user. # First check, if the user exists user = await models.User.get_or_none(id=int(data)) if user is None: resp.status_code = 404 resp.text = f"User with id {data} not found." else: lifetime = timedelta(hours=6) # TODO: make this configurable # The user may or may not be verified. # Also the state of the user is set to "not verified". # Because only active user can verify, # the user is set so active. user.is_verified = False user.is_active = True await user.save() payload = {} payload["user_id"] = user.id payload["exp"] = datetime.utcnow() + lifetime payload["iat"] = datetime.utcnow() token = jwt.encode(payload, self.secret_key, algorithm="HS256") resp.media = {"token": token, "user_id": int(data)} elif req.method == "put": # Check the provided token and verify the user. try: token = str(data) payload = jwt.decode(token, self.secret_key, algorithms=["HS256"]) user_id = payload["user_id"] user = await models.User.get_or_none(id=user_id) if user is None: resp.status_code = 404 resp.text = f"No user with id {user_id} found" else: user.is_verified = True user.is_active = True await user.save() credentials = self.createBearerToken(user_id=user.id) response_data = VerificationInfo( user=UserModel.from_orm(user), token=credentials.bearer_token, ) resp.text = response_data.json() except Exception: # pylint: disable=bare-except logger.exception("Could not verify.") else: resp.status_code = 405 resp.text = f"Method {req.method} not allowed."
async def on_post(req: Request, resp: Response, *, name: str): """Create a new template or update an existing template, by name.""" try: # Parse the post data and extract the template text if req.headers["Content-Type"] == "application/json": data = await req.media() assert isinstance(data, dict) and data.get("template") template_text = data["template"] else: template_text = await req.text # Get the template from MongoDB, if it exists, otherwise create a # new template object. try: template_object = Template.objects.get(name=name) except mongoengine.DoesNotExist: template_object = Template(name=name) template_object.template = template_text template_object.save() except (json.JSONDecodeError, mongoengine.ValidationError) as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = {"error": str(error)} except AssertionError as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = { "error": "Missing Template Attribute: The posted data should " "be a object (dictionary) containing a `template` " "key." } except mongoengine.MultipleObjectsReturned as error: logger.error(error) resp.status_code = api.status_codes.HTTP_500 resp.media = {"error": str(error)} else: if req.headers["Accept"] == "text/plain": resp.media = template_object.template else: schema = TemplateSchema() resp.media = schema.dump(template_object)[0]
def search_by_imdb_number( _, response: responder.Response, imdb_number: str, ) -> None: movie = db.find_by_imdb(imdb_number) movie_dict = db.movie_to_dict(movie) response.media = movie_dict
def on_get(self, req: Request, res: Response): if res.status_code == 401: return session = self.session(req) url = self.url + '?' + (req.url.params or '') response = session.get(url) res.media = response.json() res.status_code = response.status_code
async def on_post(self, req: Request, res: Response): if res.status_code == 401: return session = self.session(req) url = self.url + '?' + (req.url.params or '') response = session.post(url, data=await req.media()) res.media = response.json() res.status_code = response.status_code
async def search_movie_top_ten(_: Request, response: Response) -> None: movies = movies_by_popularity() _logger.info("Searching for top 10 movies") limited: bool = len(movies) > ResponseCount.MAX.value response.media = { "keyword": f"top_{ResponseCount.MAX.value}", "hits": _hits(movies), "truncated_results": limited, }
async def search_employee_by_id(_: Request, response: Response, identifier: str) -> None: employees = Employees(limit=10) response.media = { "employee_id": identifier, "truncated_results": employees.truncated, "hits": 1, "results": employees.search_by_id(int(identifier)).to_dict(), }
def on_get(req: Request, resp: Response, *, serial_number: str): """Get device data, by device serial number.""" try: device_data_object = DeviceData.objects.get( serial_number=serial_number ) except mongoengine.DoesNotExist: resp.status_code = api.status_codes.HTTP_404 except mongoengine.MultipleObjectsReturned as error: logger.error(error) resp.status_code = api.status_codes.HTTP_500 resp.media = {"error": str(error)} else: schema = DeviceDataSchema() resp.media = schema.dump(device_data_object)[0]
async def convert_text_to_pokebell_style(req: Request, resp: Response): json = await req.media() words, numbers = pokebell.text_to_pkebell(json["text"], threshold=0.5) resp.media = { "words": words, "numbers": numbers, }
async def search_movie_by_imdb(_: Request, response: Response, imdb_number: str) -> None: movie = find_by_imdb(imdb_number) _logger.info( "Looking up movie by code: %s, found? %s", imdb_number, "Yes" if movie else "NO", ) response.media = movie_to_dict(movie)
async def search_employees_by_keyword(_: Request, response: Response, keyword: str) -> None: employees = Employees(limit=10) hits: List[Employee] = employees.search_by_keyword(keyword) response.media = { "keyword": keyword, "truncated_results": employees.truncated, "hits": len(hits), "results": employees.to_dict(hits), }
async def on_post(req: Request, resp: Response): """Replace device data collection.""" try: data = await req.media() schema = DeviceDataSchema(many=True) device_data_objects = schema.load(data)[0] for device_data_object in device_data_objects: device_data_object.validate() except (json.JSONDecodeError, mongoengine.ValidationError) as error: logger.error(error) resp.status_code = api.status_codes.HTTP_400 resp.media = {"error": str(error)} else: DeviceData.drop_collection() for device_data_object in device_data_objects: device_data_object.save() resp.media = schema.dump(device_data_objects)[0]
async def search_by_keyword(_: Request, response: Response, keyword: str) -> None: movies = search_keyword(keyword) _logger.info("Searching for movie by keyword: %s", keyword) limited: bool = len(movies) > ResponseCount.MAX.value response.media = { "keyword": keyword, "hits": _hits(movies), "truncated_results": limited, }
async def search_by_director(_: Request, response: Response, director_name: str) -> None: movies = search_director(director_name) _logger.info("Searching for movie by director: %s", director_name) limited: bool = len(movies) > ResponseCount.MAX.value response.media = { "keyword": director_name, "hits": _hits(movies), "truncated_results": limited, }
async def search_movies_by_genre(_: Request, response: Response, genre: str) -> None: movies = movies_by_genre(genre) _logger.info("Searching for movies by genre %s, %s results", genre, len(movies)) limited: bool = len(movies) > ResponseCount.MAX.value response.media = { "genre": genre, "hits": _hits(movies), "truncated_results": limited, }
def on_get(req: Request, resp: Response, *, name: str): """Get template details, by name.""" try: template_object = Template.objects.get(template_name=name) except mongoengine.DoesNotExist: resp.status_code = api.status_codes.HTTP_404 except mongoengine.MultipleObjectsReturned as error: logger.error(error) resp.status_code = api.status_codes.HTTP_500 resp.media = {"error": str(error)} else: if req.accepts("text/plain"): resp.content = template_object.template.encode("utf-8") resp.headers["Content-Type"] = "text/plain; encoding=utf-8" else: schema = TemplateSchema() resp.media = schema.dump(template_object)[0]
def search_by_director(_, resp: responder.Response, director_name: str): movies = db.search_director(director_name) limited = len(movies) > response_count_max if limited: movies = movies[:response_count_max] movie_dicts = [db.movie_to_dict(m) for m in movies] resp.media = { "keyword": director_name, "hits": movie_dicts, "truncated_results": limited, }
def search_by_keyword(_, resp: responder.Response, keyword: str): movies = db.search_keyword(keyword) limited = len(movies) > response_count_max if limited: movies = movies[:response_count_max] movie_dicts = [db.movie_to_dict(m) for m in movies] resp.media = { "keyword": keyword, "hits": movie_dicts, "truncated_results": limited }
def movies_by_genre(_, resp: Response, genre: str): hits = db.movies_by_genre(genre) print("Searching for movies by genre {}, {} results".format(genre, len(hits))) limited = len(hits) > response_count_max if limited: hits = hits[:response_count_max] hits_dicts = [ db.movie_to_dict(m) for m in hits ] resp.media = {'genre': genre, 'hits': hits_dicts, 'truncated_results': limited}
def search_by_keyword(_, resp: responder.Response, keyword: str): movies = db.search_keyword(keyword) print("Searching for movie by keyword: {}".format(keyword)) limited = len(movies) > response_count_max if limited: movies = movies[:10] movie_dicts = [ db.movie_to_dict(m) for m in movies ] resp.media = {'keyword': keyword, 'hits': movie_dicts, 'truncated_results': limited}
def search_by_director(_, resp: responder.Response, director_name: str): movies = db.search_director(director_name) print("Searching for movie by director: {}".format(director_name)) limited = len(movies) > response_count_max if limited: movies = movies[:10] movie_dicts = [ db.movie_to_dict(m) for m in movies ] resp.media = {'keyword': director_name, 'hits': movie_dicts, 'truncated_results': limited}
async def upload_kigo(req: Request, resp: Response): @api.background.task def process_data(data, kigo): image_id = urlsafe_b64encode( uuid1().bytes).rstrip(b'=').decode('ascii') with open(f"static/{image_id}.png", 'wb') as f: f.write(data['image']['content']) kigo = Kigo.get(kigo=kigo) Image.create(image=image_id, kigo=kigo).save() process_data(await req.media(format='files'), req.params['kigo']) resp.media = {'success': 'ok'}
def top_movies(_, resp: Response): hits = db.movies_by_popularity() limited = len(hits) > response_count_max if limited: hits = hits[:response_count_max] hits_dicts = [ db.movie_to_dict(m) for m in hits ] keyword = "top_{}".format(response_count_max) resp.media = {'keyword': keyword, 'hits': hits_dicts, 'truncated_results': limited}