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}
