def create(self, request):
serializer = ItinerarySerializer(data=request.data)
if not serializer.is_valid():
raise APIException(
"Could not create itinerary (serializer): {}".format(
serializer.errors))
# Create the itinerary
try:
itinerary = serializer.create(request.data)
cases = itinerary.get_cases_from_settings(
get_keycloak_auth_header_from_request(request))
except Exception as e:
raise APIException(
"Could not create itinerary from settings: {}".format(e))
if not len(cases):
raise NotFound(ITINERARY_NOT_ENOUGH_CASES)
# Populate the itinerary with cases
for case in cases:
case_id = case.get("id")
itinerary.add_case(case_id)
# Serialize the itinerary again
serializer = ItinerarySerializer(itinerary,
context={"request": request})
return Response(serializer.data)
def schedule_types(self, request, pk):
team_settings = self.get_object()
data = {}
if team_settings.use_zaken_backend:
serializer = TeamScheduleTypesSerializer(
team_settings.fetch_team_schedules(
get_keycloak_auth_header_from_request(request)))
data = serializer.data
return Response(data)
def events(self, request, pk):
"""
Lists all events for this case
"""
case = Case.get(case_id=pk, is_top_bwv_case=False)
serializer = CaseEventSerializer(case.fetch_events(
get_keycloak_auth_header_from_request(request)),
many=True)
return Response(serializer.data)
def _complete_visit_and_update_aza(self, instance, created):
from apps.itinerary.tasks import push_visit
instance.capture_visit_meta_data()
auth_header = get_keycloak_auth_header_from_request(
self.context.get("request"))
task = push_visit.s(
visit_id=instance.id,
created=created,
auth_header=auth_header,
).delay
transaction.on_commit(task)
def reasons(self, request, pk):
team_settings = self.get_object()
data = []
if team_settings.use_zaken_backend:
serializer = CaseReasonSerializer(
team_settings.fetch_team_reasons(
get_keycloak_auth_header_from_request(request)),
many=True,
)
data = serializer.data
return Response(data)
def list(self, request):
"""
Returns a list of cases found with the given parameters
"""
if request.version == "v1":
# TODO: Replace query parameter strings with constants
postal_code = request.GET.get("postalCode", None)
street_name = request.GET.get("streetName", "")
street_number = request.GET.get("streetNumber", None)
suffix = request.GET.get("suffix", "")
if postal_code is None and street_name == "":
return HttpResponseBadRequest(
"Missing postal code or street name is required")
elif not street_number:
return HttpResponseBadRequest(
"Missing street number is required")
else:
cases = q.get_search_results(postal_code, street_number,
suffix, street_name)
cases = self.__add_fraud_prediction__(cases)
cases = self.__add_teams__(cases, datetime.now())
return JsonResponse({"cases": cases})
else:
if settings.USE_ZAKEN_MOCK_DATA:
result = get_zaken_case_list()
else:
url = f"{settings.ZAKEN_API_URL}/cases/search/"
queryParams = {}
queryParams.update(request.GET)
response = requests.get(
url,
params=queryParams,
timeout=30,
headers=get_headers(
get_keycloak_auth_header_from_request(request)),
)
response.raise_for_status()
result = response.json().get("results", [])
for case in result:
Case.get(case_id=case.get("id"), is_top_bwv_case=False)
cases = self.__add_fraud_prediction__(result)
cases = self.__add_teams__(cases, datetime.now())
return JsonResponse({"cases": cases})
def suggestions(self, request, pk):
""" Returns a list of suggestions for the given itinerary """
itinerary = self.get_object()
cases = itinerary.get_suggestions(
get_keycloak_auth_header_from_request(request))
return JsonResponse({"cases": cases})
