def push_visit(self,
visit_id,
created=False,
auth_header=None,
task_name_ids=[]):
# logger.info(f"Pushing visit {visit_id} to AZA")
capture_message(f"Pushing visit {visit_id} to AZA")
assert_allow_push()
url = f"{settings.ZAKEN_API_URL}/visits/"
if not created:
logger.info("AZA does not support updating visits anymore.")
return f"AZA does not support updating visits anymore: visit_id: {visit_id}, created: {created}"
data = get_serialized_visit(visit_id)
try:
response = requests.post(
url,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
json=data,
headers=get_headers(auth_header),
)
response.raise_for_status()
except Exception as exception:
self.retry(exc=exception)
return f"visit_id: {visit_id}, created: {created}"
def fetch_team_state_types(self, auth_header=None):
url = f"{settings.ZAKEN_API_URL}/themes/{self.team_settings.zaken_team_name}/state-types/?role=toezichthouder"
response = requests.get(
url,
timeout=5,
headers=get_headers(auth_header),
)
response.raise_for_status()
return response.json().get("results", [])
def fetch_team_schedules(self, auth_header=None):
url = f"{settings.ZAKEN_API_URL}/themes/{self.team_settings.zaken_team_name}/schedule-types/"
response = requests.get(
url,
timeout=5,
headers=get_headers(auth_header),
)
response.raise_for_status()
return response.json()
def fetch_events(self):
url = f"{settings.ZAKEN_API_URL}/cases/{self.case_id}/events/"
response = requests.get(
url,
timeout=5,
headers=get_headers(),
)
response.raise_for_status()
return response.json()
def fetch_team_reasons(self, auth_header=None):
if settings.USE_ZAKEN_MOCK_DATA:
return get_team_reasons()
url = f"{settings.ZAKEN_API_URL}/themes/{self.zaken_team_name}/reasons/"
response = requests.get(
url,
timeout=5,
headers=get_headers(auth_header),
)
response.raise_for_status()
return response.json().get("results", [])
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=0.5,
headers=get_headers(),
)
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 update_external_state(self, state_id, team_member_emails):
logger.info(f"Updating external state {state_id} in zaken")
assert_allow_push()
url = f"{settings.ZAKEN_API_URL}/case-states/{state_id}/update-from-top/"
data = {"user_emails": team_member_emails}
try:
response = requests.post(
url,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
json=data,
headers=get_headers(),
)
response.raise_for_status()
except Exception as exception:
self.retry(exc=exception)
logger.info(f"Finished updating external state {state_id}")
def push_visit(self, visit_id, created=False):
logger.info(f"Pushing visit {visit_id} to zaken")
assert_allow_push()
url = f"{settings.ZAKEN_API_URL}/visits/"
if not created:
logger.info("Zaken does not support updating visits anymore.")
data = get_serialized_visit(visit_id)
try:
response = requests.post(
url,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
json=data,
headers=get_headers(),
)
response.raise_for_status()
except Exception as exception:
self.retry(exc=exception)
return response
def get_eligible_cases_v2(generator):
logger.info("v2 __get_eligible_cases__")
if settings.USE_ZAKEN_MOCK_DATA:
cases = get_zaken_case_list()
team_schedules = get_team_schedules()
reasons = get_team_reasons()
state_types = get_team_state_types()
else:
url = f"{settings.ZAKEN_API_URL}/cases/"
queryParams = {
"openCases": "true",
"team":
generator.settings.day_settings.team_settings.zaken_team_name,
"startDate": generator.settings.opening_date.strftime("%Y-%m-%d"),
"noPagination": "true",
}
response = requests.get(
url,
params=queryParams,
timeout=5,
headers=get_headers(),
)
response.raise_for_status()
cases = response.json()
team_schedules = generator.settings.day_settings.fetch_team_schedules()
reasons = generator.settings.day_settings.fetch_team_reasons()
state_types = generator.settings.day_settings.fetch_team_state_types()
logger.info("validate team_schedules")
team_schedules = dict((
k,
[
s for s in getattr(generator.settings, k)
if s in [ss.get("id", 0) for ss in v]
],
) for k, v in team_schedules.items() if hasattr(generator.settings, k))
logger.info("validate reasons")
reasons = [
r for r in generator.settings.reasons
if r in [reason.get("id", 0) for reason in reasons]
]
logger.info("validate state_types")
state_types = [state.get("id", 0) for state in state_types]
state_types_selected = [
st for st in generator.settings.state_types if st in state_types
]
logger.info("selected algorithm states")
logger.info(state_types_selected)
logger.info("initial case count")
logger.info(len(cases))
cases = filter_out_incompatible_cases(cases)
logger.info("after filter_out_incompatible_cases")
logger.info(len(cases))
cases = filter_schedules(cases, team_schedules)
logger.info("after filter_schedules")
logger.info(len(cases))
cases = filter_state_types(cases, state_types)
logger.info("after filter_state_types")
logger.info(len(cases))
cases = filter_cases_with_postal_code(cases, generator.postal_code_ranges)
logger.info("after filter_cases_with_postal_code")
logger.info(len(cases))
cases = [
c for c in cases if str(c.get("id")) not in
[str(case.get("id")) for case in generator.exclude_cases]
]
"start_date": start_date,
"states": states,
"users": users,
}
if end_date:
data["end_date"] = end_date
url = f"{settings.ZAKEN_API_URL}/push/"
try:
response = requests.post(
url,
timeout=(CONNECT_TIMEOUT, READ_TIMEOUT),
json=data,
headers=get_headers(),
)
response.raise_for_status()
response_json = response.json()
itinerary_item.external_state_id = response_json["state"]["id"]
itinerary_item.save()
logger.info(f"Finished pushing case {case_id}")
return response
except Exception as exception:
self.retry(exc=exception)
def get_eligible_cases_v2(generator):
logger.info("v2 __get_eligible_cases__")
if settings.USE_ZAKEN_MOCK_DATA:
cases = get_zaken_case_list()
team_schedules = get_team_schedules()
reasons = get_team_reasons()
state_types = get_team_state_types()
else:
logger.info("Get from AZA: state_types")
state_types = generator.settings.day_settings.fetch_team_state_types(
generator.auth_header)
logger.info("Get from AZA: team_schedules")
team_schedules = generator.settings.day_settings.fetch_team_schedules(
generator.auth_header)
logger.info("Get from AZA: reasons")
reasons = generator.settings.day_settings.fetch_team_reasons(
generator.auth_header)
logger.info("Get from AZA: cases")
url = f"{settings.ZAKEN_API_URL}/cases/"
queryParams = {
"open_cases": "true",
"state_types": [state.get("id", 0) for state in state_types],
"theme":
generator.settings.day_settings.team_settings.zaken_team_name,
"from_start_date":
generator.settings.opening_date.strftime("%Y-%m-%d"),
"page_size": 1000,
}
logger.info("With queryParams")
logger.info(queryParams)
now = datetime.datetime.now()
response = requests.get(
url,
params=queryParams,
timeout=60,
headers=get_headers(generator.auth_header),
)
response.raise_for_status()
logger.info("Request duration")
logger.info(datetime.datetime.now() - now)
cases = response.json().get("results")
logger.info("initial case count")
logger.info(len(cases))
logger.info("validate team_schedules")
team_schedules = (dict((
k,
[
s for s in getattr(generator.settings, k)
if s in [ss.get("id", 0) for ss in v]
],
) for k, v in team_schedules.items() if k in [
"day_segments",
"week_segments",
]) if team_schedules else {})
logger.info("validate reasons")
reasons = [
r for r in generator.settings.reasons
if r in [reason.get("id", 0) for reason in reasons]
]
logger.info("validate state_types")
state_types = [state.get("id", 0) for state in state_types]
state_types_selected = [
st for st in generator.settings.state_types if st in state_types
]
logger.info("selected algorithm states")
logger.info(state_types_selected)
cases = filter_out_incompatible_cases(cases)
logger.info("after filter_out_incompatible_cases")
logger.info(len(cases))
cases = filter_schedules(cases, team_schedules)
logger.info("after filter_schedules")
logger.info(len(cases))
cases = filter_state_types(cases, state_types)
logger.info("after filter_state_types")
logger.info(len(cases))
cases = filter_cases_with_postal_code(cases, generator.postal_code_ranges)
logger.info("after filter_cases_with_postal_code")
logger.info(len(cases))
cases = [
c for c in cases if str(c.get("id")) not in
[str(case.get("id")) for case in generator.exclude_cases]
]