def next_verse(request):
schema = VerseSchema()
verse_id = request.GET.get("verse_id")
if not verse_id:
raise api_exceptions.BadRequestData(
errors="verse_id is a mandatory parameter")
if verse_id == "12.13.23":
raise api_exceptions.BadRequestData(
errors="This is the end of knowledge")
canto, chapter, verse = verse_id.split(".")
nex = None
if "-" in verse:
nex = int(verse.split('-')[1]) + 1
else:
nex = int(verse) + 1
verse_id = ".".join([canto, chapter, str(nex)])
filter_params = {"verse_id": verse_id}
verse_obj = get_verse(filter_params)
if not verse_obj:
verse_id = ".".join([canto, str(int(chapter) + 1), "1"])
filter_params = {"verse_id": verse_id}
verse_obj = get_verse(filter_params)
if not verse_obj:
verse_id = ".".join([str(int(canto) + 1), "1", "1"])
filter_params = {"verse_id": verse_id}
verse_obj = get_verse(filter_params)
resp_data = schema.dump(verse_obj, many=True)
return JsonResponse(
make_response(resp_data,
message="Successfully fetched next verse",
code=GET_SUCCESS_CODE))
def login(request):
"""
This API is used to login a user in system. Access Token is return per user session.
"""
schema = LoginSchema()
response = dict()
# validate request data
try:
data = schema.loads(request.body)
except ValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
print(data)
# authenticate user in system
user = authenticate(username=data["username"], password=data["password"])
if not user:
raise api_exceptions.BadRequestData(errors="Invalid credentials")
# generate user session id
session_id = generate_random_alphenumeric_number(32)
# get session data
session = UserSession
exp_time = settings.JWT_WEB_EXP_DELTA_HOURS
# if session exists, delete this session and create new one
session.objects.filter(user=user).delete()
# create new session for user
try:
session.objects.create(user=user, session_id=session_id)
# # Handling scenario for multiple user creation at same time
except IntegrityError:
raise api_exceptions.BadRequestData(errors="Session already exists")
# read private secret key
private_key = settings.JWT_SECRET
# set payload with user id and expiry time
payload = {
"user_id": str(user.id),
"exp": (timezone.now() + timezone.timedelta(hours=exp_time)),
"session_id": session_id,
}
# encode token with private key
token = jwt.encode(payload, private_key).decode("utf-8")
response["token"] = token
response["user_id"] = str(user.id)
response["account_type"] = user.user_type
request.user = user
print(response)
return JsonResponse(make_response(response,
"Successfully logged in",
code=201),
status=201)
def put(self, request, id, *args, **kwargs):
nested_fields = []
model_inst, errors = self.schema.load(self.req_data, partial=True)
if errors:
api_exceptions.BadRequestData(errors=errors)
if model_inst.get(self.schema.nested_schema["related"]):
nested_fields.extend(
model_inst.get(self.schema.nested_schema["related"]))
del model_inst[self.schema.nested_schema["related"]]
model_obj, update_fields, errors = self.process_data(
self.schema.model, id, model_inst)
if errors:
raise api_exceptions.BadRequestData(errors=errors)
try:
model_obj.clean_save(update_fields=update_fields)
except dj_core_exceptions.ValidationError as e:
raise api_exceptions.BadRequestData(errors=e.message_dict)
if nested_fields:
errors_detail = []
try:
for record in nested_fields:
pk = self.schema.nested_schema["pk"]
if pk in record:
model_obj, update_fields, errors = self.process_data(
self.schema.nested_schema["model"], record[pk],
record)
if errors:
errors_detail.append(errors)
else:
model_obj.clean_save(update_fields=update_fields)
else:
record.update({
self.schema.nested_schema["referenced_field"]:
id
})
self.schema.nested_schema["model"](
**record).clean_save()
except dj_core_exceptions.ValidationError as e:
errors_detail.append(e.message_dict)
if errors:
raise api_exceptions.BadRequestData(errors=errors_detail)
response = JsonResponse(
{
"response":
build_response(
request, response_type="PUT", response_text=self.message)
},
status=202,
)
return response
def put(self, request):
req_data = json.loads(request.body)
schema = (self.schema)()
try:
verse_updates = schema.load(req_data,
partial=('verse', 'translation',
'purport'))
except MarshmallowValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
remove = ['chapter_num', 'canto_num', 'verse_num']
for item in remove:
if item in verse_updates.keys():
del verse_updates[item]
verse_obj = Verse.objects.filter(verse_id=req_data["verse_id"])
if not verse_obj:
raise api_exceptions.ValidationError(errors="Verse doesn't exist")
try:
verse_obj.update(**verse_updates)
except (DjangoValidationError, IntegrityError) as e:
raise api_exceptions.ValidationError(errors=e.message_dict)
resp_data = make_response({},
message="Successfully updated verse",
code=PUT_SUCCESS_CODE)
return JsonResponse(resp_data)
def post(self, request):
# TODO :- Need to handle validation of verse_id in POST and PUT updates
req_data = json.loads(request.body)
schema = (self.schema)()
verse_details = req_data["verse_id"].split(".")
req_data["canto_num"] = int(verse_details[0])
req_data["chapter_num"] = int(verse_details[1])
if '-' in verse_details[2]:
start, end = verse_details[2].split("-")
req_data["verse_num"] = int(start)
req_data["verse_num_end"] = int(end)
else:
req_data["verse_num"] = int(verse_details[2])
try:
new_verses_data = schema.load(req_data)
except MarshmallowValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
try:
new_verses = Verse.objects.create(**new_verses_data)
except DjangoValidationError as e:
raise api_exceptions.ValidationError(errors=e.message_dict)
except IntegrityError as e:
raise api_exceptions.ValidationError(errors="DB Integrity error")
resp_data = schema.dump(new_verses)
return JsonResponse(resp_data)
def dispatch(self, request, **kwargs):
if request.body:
try:
self.req_data = json.loads(request.body)
except ValueError:
raise api_exceptions.BadRequestData(errors="Parse Errors")
return super(ResourceView, self).dispatch(request, **kwargs)
def post(self, request):
req_data = json.loads(request.body)
schema = (self.schema)()
resp_data = []
verse_id = req_data['verse_id']
for req in req_data['purporttags']:
try:
req['verse_id'] = verse_id
new_purport_section_tag = schema.load(req)
except MarshmallowValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
try:
new_purport_section_tag["tag"] = Tag3.objects.get(
name=new_purport_section_tag["tag"])
purport_section_tags = PurportSectionTag.objects.create(
**new_purport_section_tag)
except DjangoValidationError as e:
raise api_exceptions.ValidationError(errors=e.message_dict)
except IntegrityError as e:
raise api_exceptions.ValidationError(
errors="DB Integrity error")
resp_data.append(schema.dump(purport_section_tags))
return JsonResponse(
make_response(resp_data, "Successfully added purport tags",
POST_SUCCESS_CODE))
def post(self, request, *args, **kwargs):
nested_fields = []
nested_ids = []
model_inst, errors = self.schema.load(self.req_data)
if errors:
raise api_exceptions.BadRequestData(errors=errors)
if model_inst.get(self.schema.nested_schema["related"]):
nested_fields.extend(
model_inst.get(self.schema.nested_schema["related"]))
del model_inst[self.schema.nested_schema["related"]]
try:
related_object = self.schema.model(**model_inst)
related_object.clean_save()
except dj_core_exceptions.ValidationError as e:
raise api_exceptions.BadRequestData(errors=e.message_dict)
if nested_fields:
try:
for record in nested_fields:
record.update({
self.schema.nested_schema["referenced_field"]:
str(related_object.id)
})
nested_obj = self.schema.nested_schema["model"](**record)
nested_obj.clean_save()
nested_ids.append(nested_obj.id)
except dj_core_exceptions.ValidationError as e:
raise api_exceptions.BadRequestData(errors=e.message_dict)
response = JsonResponse(
{
"response":
build_response(request,
response_type="POST",
response_text=self.message,
response_data={
"id": related_object.id,
"nested_ids": nested_ids
})
},
status=201,
)
return response
def jsonResponse(self, data, status=200, headers=None):
headers = headers or {}
if isinstance(data, dict):
if 'Content-Type' not in headers:
headers['Content-Type'] = self.json_mime_type
return make_response(
jsonify({
"response": data
}), status, headers)
else:
raise api_exceptions.BadRequestData()
def post(self, *args, **kwargs):
data, errors = self.schema_class().load(request.json)
if errors:
raise api_exceptions.BadRequestData(str(errors))
self.model().create(name=data['name'], service_id=data['service_id'])
return self.jsonResponse(
{
"message": "Service is registered successfully",
"service_id": data['service_id'],
"name": data['name'],
"status_code": HTTPStatus.CREATED
}, HTTPStatus.CREATED)
def notif():
"""
This is the endpoint which act as a subscriber for our AWS SNS service, this endpoint would subscribe
all the events related to all services registered.
Endpoint: https://<hostname>:<portNumber>/sns
Method accepts: [POST]
Status Codes:
201: success
400: Bad request Data
:return: string
"""
try:
alert_logger.info("SNS Endpoint hit")
# check if request data is received
if request.data:
alert_logger.info("SNS Data Received %s" % request.data)
data = request.get_json()
# check sns event type
if data['Type'] == 'Notification':
# In subject we have alert details such as serviceID
# TODO: Alert Detail should be part of Message key
subject = data['Subject']
service_id = subject.split('ALARM: "')[1].split(
'-awsroute53')[0]
# call alert handler for further handling of service alerts
alert_handler(service_id)
return make_response("SNS Request Received")
else:
api_exceptions.BadRequestData("SNS event type is not defined")
else:
alert_logger.info("No data is received in SNS notfication")
return make_response("No data received in SNS Notification")
except KeyError as e:
alert_logger.error(str(e))
raise api_exceptions.BadRequestData(str(e))
def prev_verse(request):
schema = VerseSchema()
verse_id = request.GET.get("verse_id")
if not verse_id:
raise api_exceptions.BadRequestData(
errors="verse_id is a mandatory parameter")
if verse_id == "1.1.1":
raise api_exceptions.BadRequestData(
errors="This is the beginning of knowledge")
canto, chapter, verse = verse_id.split(".")
prev = None
if "-" in verse:
prev = int(verse.split('-')[1]) - 1
else:
prev = int(verse) - 1
verse_id = ".".join([canto, chapter, str(prev)])
filter_params = {"verse_id": verse_id}
verse_obj = get_verse(filter_params)
queryset = Verse.objects.values('canto_num', 'chapter_num', 'verse_id',
'verse_num')
print(verse_id)
if not verse_obj:
try:
last_verse = queryset.filter(
canto_num=canto, chapter_num=int(chapter) -
1).order_by("-verse_num")[0]["verse_id"]
filter_params = {"verse_id": last_verse}
verse_obj = get_verse(filter_params)
except:
verse_obj = None
if not verse_obj:
last_verse = queryset.filter(canto_num=int(canto) - 1).order_by(
"-chapter_num", "-verse_num")[0]["verse_id"]
filter_params = {"verse_id": last_verse}
verse_obj = get_verse(filter_params)
resp_data = schema.dump(verse_obj, many=True)
return JsonResponse(
make_response(resp_data,
message="Successfully fetched next verse",
code=GET_SUCCESS_CODE))
def register(request):
"""
This API is used to register the user to system.
"""
schema = RegisterSchema()
# validate request data
try:
data = schema.loads(request.body)
except ValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
user_type_dict = {"user": 1, "tagger": 2, "reviewer": 3}
data["user_type"] = user_type_dict[data["user_type"]]
try:
password = data.pop("password")
user = Account.objects.create(**data)
user.set_password(password)
user.save()
except (IntegrityError, DjangoValidationError) as e:
raise api_exceptions.BadRequestData(errors=e.messages)
return JsonResponse(make_response({},
"Successfully registered user",
code=201),
status=201)
def post(self, *args, **kwargs):
"""
POST USER Request
"""
data, errors = self.schema_class().load(request.json)
if errors:
raise api_exceptions.BadRequestData(errors)
service = Service.query.filter_by(
service_id=data['service_id']).first()
for user in data['users']:
self.model.register_user(user, service)
return self.jsonResponse(
{
"message": "Users are registered successfully with level ids",
"status_code": HTTPStatus.CREATED
}, HTTPStatus.CREATED)
def get(self, request):
filter_params = {}
filters = ["verse_id", "canto_num", "chapter_num"]
for key in filters:
if request.GET.get(key):
filter_params[key] = request.GET.get(key)
verses = get_verse(filter_params)
schema = (self.schema)()
resp_data = None
if verses:
data = schema.dump(verses, many=True)
resp_data = make_response(data,
message="Successfully fetched verses",
code=GET_SUCCESS_CODE)
else:
raise api_exceptions.BadRequestData(
errors="Doesn't match with any existing verses")
return JsonResponse(resp_data)
def put(self, email):
if self.model.userExists(email):
data, errors = self.schema_class(partial=True).load(request.json)
if errors or not data:
raise api_exceptions.BadRequestData(errors)
self.model.update_user_details(existing_email=email,
updated_fields=data)
return self.jsonResponse(
{
"message": "User is successfully updated",
"status_code": HTTPStatus.ACCEPTED
}, HTTPStatus.ACCEPTED)
else:
return self.jsonResponse(
{
"error": "User doesn't exist",
"status_code": HTTPStatus.BAD_REQUEST
}, HTTPStatus.BAD_REQUEST)
def post(self, request):
# TODO :- Need to handle validation of verse_id in POST and PUT updates
req_data = json.loads(request.body)
schema = (self.schema)()
try:
additional_details = schema.load(req_data)
except MarshmallowValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
verse_id = additional_details.pop("verse_id")
try:
Verse.objects.filter(verse_id=verse_id).update(
**additional_details)
except (DjangoValidationError, IntegrityError) as e:
raise api_exceptions.ValidationError(errors=e.message_dict)
resp_data = make_response(
{},
message="Successfully added verse context and title",
code=POST_SUCCESS_CODE)
return JsonResponse(resp_data)
def post(self, request):
req_data = json.loads(request.body)
schema = (self.schema)()
resp_data = []
verse_id = req_data["verse_id"]
for req in req_data["translationtags"]:
try:
req['verse_id'] = verse_id
new_translation_tag = schema.load(req)
print(new_translation_tag)
except MarshmallowValidationError as e:
raise api_exceptions.BadRequestData(errors=e.messages)
new_translation_tag["verse"] = Verse.objects.get(
verse_id=new_translation_tag["verse_id"])
new_translation_tag["tag"] = Tag3.objects.get(
name=new_translation_tag["tag"])
new_translation_tag["tagger"] = request.user
try:
translation_tags = self.schema.model.objects.create(
**new_translation_tag)
except DjangoValidationError as e:
raise api_exceptions.ValidationError(errors=e.message_dict)
except IntegrityError as e:
if new_translation_tag.get("tagger_remark"):
t_tag = self.schema.model.objects.filter(
verse_id=new_translation_tag["verse_id"],
tag=new_translation_tag["tag"])
t_tag.update(
tagger_remark=new_translation_tag["tagger_remark"])
t_tag[0].save()
resp_data.append(schema.dump(t_tag[0]))
continue
else:
raise api_exceptions.ValidationError(
errors="DB Integrity error")
resp_data.append(schema.dump(translation_tags))
return JsonResponse(
make_response(resp_data, "Successfully added translation tags",
POST_SUCCESS_CODE))
def put(self, service_id):
if self.model.serviceExists(service_id):
data, errors = self.schema_class().load(request.json)
if errors:
raise api_exceptions.BadRequestData(str(errors))
self.model.update_service_name(
service_id=service_id,
updated_name=data['name'],
updated_service_id=data['service_id'])
return self.jsonResponse(
{
"message": "Service is sucessfully updated",
"service_id": data['service_id'],
"name": data['name'],
"status_code": HTTPStatus.ACCEPTED
}, HTTPStatus.ACCEPTED)
else:
return self.jsonResponse(
{
"error": "Service doesn't exist",
"status_code": HTTPStatus.BAD_REQUEST
}, HTTPStatus.BAD_REQUEST)