def cancel_registration(): if request.headers['Content-Type'] != "application/json": logging.error('Content-Type is not JSON') return Response(status=415) suppress = False if 'suppress_queue' in request.args: logging.info(format_message('Queue suppressed')) suppress = True json_data = json.loads(request.data.decode('utf-8')) if 'dev_date' in request.args and app.config['ALLOW_DEV_ROUTES']: logging.warning(format_message('Overriding date')) json_data['dev_registration'] = {'date': request.args['dev_date']} logging.debug("Received: %s", json_data) reg = json_data['registration'] logging.debug("Reg: %s", reg) rows, nos, canc_request_id = insert_cancellation(json_data, get_username()) if rows == 0: return Response(status=404) else: data = {"cancellations": nos, "request_id": canc_request_id} if not suppress: publish_cancellation(producer, nos) return Response(json.dumps(data), status=200, mimetype='application/json')
def registration(date, reg_no): if "class_of_charge" in request.args: class_of_charge = request.args["class_of_charge"] else: class_of_charge = None cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve entry details for %s, %s"), reg_no, date) details = get_registration_details(cursor, reg_no, date, class_of_charge) if details is not None: addl_info = get_additional_info(cursor, details) if addl_info is not None: details['additional_information'] = addl_info finally: complete(cursor) if details is None: logging.warning( format_message("Returning 404 for /registrations/{}/{}".format( date, reg_no))) return Response(status=404) else: return Response(json.dumps(details), status=200, mimetype='application/json')
def reprints(reprint_type): request_id = '' if reprint_type == 'registration': registration_no = request.args['registration_no'] registration_date = request.args['registration_date'] url = app.config['LAND_CHARGES_URI'] + '/request_details?reprint_type=' + reprint_type url += '®istration_no=' + registration_no + '®istration_date=' + registration_date response = requests.get(url, headers=get_headers()) data = json.loads(response.content.decode('utf-8')) if "request_id" not in data: return "invalid request_id for " + registration_no + ' ' + registration_date request_id = data['request_id'] elif reprint_type == 'search': request_id = request.args['request_id'] if not request_id: datetime.strptime(registration_date, '%Y-%m-%d') formatted_registration_date = datetime.strptime(registration_date, '%Y-%m-%d').strftime('%d/%m/%Y') err = "Could not find request for {} of {}.".format(registration_no, formatted_registration_date) logging.error(format_message(err)) return Response(err, status=400) logging.audit(format_message("Request reprint for %s"), request_id) # for the time being call reprint on result-generate. this probably needs moving into casework-api url = app.config['RESULT_GENERATE_URI'] + '/reprints?request=' + str(request_id) response = requests.get(url, headers=get_headers()) if response.headers['content-type'] == 'application/pdf': return send_file(BytesIO(response.content), as_attachment=False, attachment_filename='reprint.pdf', mimetype='application/pdf') else: err = "An error occured {}.".format(response.text) logging.error(format_message(err)) return Response(err, status=405)
def unlock_application(appn_id): logging.info(format_message("Unlock application")) logging.audit(format_message("Unlock application")) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: clear_lock_ind(cursor, appn_id) finally: complete(cursor) return Response(status=200)
def lock_application(appn_id): logging.info(format_message("Lock application")) logging.audit(format_message("Lock application")) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: locked = set_lock_ind(cursor, appn_id) if locked is None: # Selected application already locked or no longer on work list return Response(status=404) else: return Response(status=200) finally: complete(cursor)
def remove_application(appn_id): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: if 'reject' in request.args: logging.audit(format_message("Reject application")) else: logging.audit(format_message("Remove application")) rows = delete_application(cursor, appn_id) finally: complete(cursor) if rows == 0: return Response(status=404) return Response(status=204, mimetype='application/json')
def all_registrations(): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve all registrations")) details = get_all_registrations(cursor) finally: complete(cursor) if details is None: logging.warning(format_message("Returning 404 for /registrations")) return Response(status=404) else: return Response(json.dumps(details), status=200, mimetype='application/json')
def registrations_by_date(date): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve registrations dated %s"), date) details = get_registrations_by_date(cursor, date) finally: complete(cursor) if details is None: logging.warning( format_message("Returning 404 for date {}".format(date))) return Response(status=404) else: return Response(json.dumps(details), status=200, mimetype='application/json')
def get_searches(): logging.audit(format_message("Search reprints")) search_data = request.data response = requests.post(app.config['LAND_CHARGES_URI'] + '/request_search_details', data=search_data, headers=get_headers({'Content-Type': 'application/json'})) data = json.loads(response.content.decode('utf-8')) return Response(json.dumps(data), status=200, mimetype='application/json')
def get_searches_by_date(date): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: data = get_search_ids_by_date(cursor, date) finally: logging.audit(format_message("Retrieve searches for date: %s"), date) complete(cursor) if data is None: logging.warning( format_message("Returning 404 for date {}".format(date))) return Response(status=404) else: return Response(json.dumps(data), status=200, mimetype='application/json')
def load_counties(): # pragma: no cover if not app.config['ALLOW_DEV_ROUTES']: # and is_dev_VM()): return Response(status=403) if request.headers['Content-Type'] != "application/json": logging.error(format_message('Content-Type is not JSON')) return Response(status=415) json_data = request.get_json(force=True) cursor = connect() try: for item in json_data: if 'cym' not in item: item['cym'] = None cursor.execute( 'INSERT INTO COUNTY (name, welsh_name) VALUES (%(e)s, %(c)s)', { 'e': item['eng'], 'c': item['cym'] }) complete(cursor) except: rollback(cursor) raise return Response(status=200)
def get_request_id(): if 'registration_no' in request.args: reg_no = request.args['registration_no'] else: return Response(json.dumps({'error': 'no registration_no'}), status=400) if 'registration_date' in request.args: reg_date = request.args['registration_date'] else: return Response(json.dumps({'error': 'no registration_date'}), status=400) if 'reprint_type' in request.args: reprint_type = request.args['reprint_type'] else: return Response("no reprint_type specified", status=400) logging.audit( format_message("Retrieve request details for registration %s of %s"), reg_no, reg_date) request_id = 0 if reprint_type == 'registration': request_id = get_k22_request_id(reg_no, reg_date) elif reprint_type == 'search': request_id = 0 # write method to get k17/18 request ids return Response(json.dumps(request_id), status=200, mimetype='application/json')
def create_search(): if request.headers['Content-Type'] != "application/json": logging.error(format_message('Content-Type is not JSON')) return Response(status=415) data = request.get_json(force=True) logging.debug('this is search data: %s', json.dumps(data)) errors = validate(data, SEARCH_SCHEMA) if errors is not None: return Response(json.dumps(errors), status=400) logging.debug(data['parameters']['search_type']) if data['parameters']['search_type'] not in ['full', 'banks']: message = "Invalid search type supplied: {}".format( data['parameters']['search_type']) logging.error(format_message(message)) return Response(message, status=400) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: # Store the search request if 'X-LC-Username' in request.headers: data['user_id'] = request.headers['X-LC-Username'] search_request_id, search_details_id, search_data = store_search_request( cursor, data) # Run the queries results = perform_search(cursor, search_data['parameters'], search_data['search_date']) for item in results: store_search_result(cursor, search_request_id, search_details_id, item['name_id'], item['name_result']) logging.audit(format_message("Submit search request: %d, ID: %d"), search_request_id, search_details_id) complete(cursor) logging.info(format_message("Search request and result committed")) except: rollback(cursor) raise results = [search_request_id] if len(results) == 0: return Response(status=404) else: return Response(json.dumps(results, ensure_ascii=False), status=200, mimetype='application/json')
def error_handler(err): logging.error(format_message('Unhandled exception: ' + str(err))) call_stack = traceback.format_exc() lines = call_stack.split("\n") for line in lines: logging.error(format_message(line)) error = {"type": "F", "stack": lines[0:-2]} try: error["dict"] = json.loads(str(err)) except ValueError as e: error["text"] = str(err) logging.debug(json.dumps(error, indent=4)) raise_error(error) return Response(json.dumps(error), status=500)
def submit_lc_cancellation(data): cust_address = data['customer_address'].replace("\r\n", ", ").strip() application = { 'update_registration': { 'type': 'Cancellation' }, 'applicant': { 'key_number': data['key_number'], 'name': data['customer_name'], 'address': cust_address, 'address_type': data['address_type'], 'reference': data['customer_ref'] }, 'registration_no': session['regn_no'], 'document_id': session['document_id'], 'registration': { 'date': session['reg_date'] }, 'fee_details': { 'type': data['payment'], 'fee_factor': 1, 'delivery': session['application_dict']['delivery_method'] } } if "class_of_charge" in session: application["class_of_charge"] = session["class_of_charge"] # if plan attached selected then pass the part_cans_text into that field if 'cancellation_type' in session: application['update_registration'] = { 'type': session['cancellation_type'] } if 'plan_attached' in session: if session['plan_attached'] == 'true': application['update_registration']['plan_attached'] = session[ 'part_cans_text'] elif 'part_cans_text' in session: application['update_registration']['part_cancelled'] = session[ 'part_cans_text'] url = app.config['CASEWORK_API_URL'] + '/applications/' + session[ 'worklist_id'] + '?action=cancel' headers = get_headers({'Content-Type': 'application/json'}) response = requests.put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Cancellation submitted to CASEWORK_API")) data = response.json() if 'cancellations' in data: reg_list = [] for item in data['cancellations']: reg_list.append(item['number']) session['confirmation'] = {'reg_no': reg_list} else: session['confirmation'] = {'reg_no': []} return response
def synchronise(): # pragma: no cover if not app.config['ALLOW_DEV_ROUTES']: # and is_dev_VM()): return Response(status=403) if request.headers['Content-Type'] != "application/json": logging.error(format_message('Content-Type is not JSON')) return Response(status=415) json_data = request.get_json(force=True) publish_new_bankruptcy(producer, json_data) return Response(status=200)
def get_searches(): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: if 'name' in request.args: name = request.args['name'] result = read_searches(cursor, name) elif 'id' in request.args: result = get_search_by_request_id(cursor, request.args['id']) else: result = [] data = [] for results in result: for ids in results['result']: reg_data = get_registration(cursor, ids, None) data.append({ 'reg_id': ids, 'reg_no': reg_data['registration_no'], 'reg_date': reg_data['registration_date'], 'class': reg_data['class_of_charge'] }) finally: if 'name' in request.args: logging.audit( format_message("Retrieve search results by name: %s"), request.args['name']) elif 'id' in request.args: logging.audit(format_message("Retrieve search results by ID: %s"), request.args['id']) else: logging.audit(format_message("Retrieve search results")) complete(cursor) return Response(json.dumps(data), status=200, mimetype='application/json')
def update_request_fee(request_id, transaction_fee): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) cursor.execute( 'UPDATE request SET transaction_fee = %(fee)s ' 'WHERE id = %(request_id)s', { 'request_id': request_id, 'fee': transaction_fee }) logging.audit(format_message("Set transaction fee to %s for request %s"), transaction_fee, request_id) complete(cursor) return Response(status=200)
def registration_by_id(reg_id): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve entry details for %s"), reg_id) details = get_registration_details_by_register_id(cursor, reg_id) if details is not None: addl_info = get_additional_info(cursor, details) if addl_info is not None: details['additional_information'] = addl_info finally: complete(cursor) if details is None: logging.warning( format_message( "Returning 404 for /registrations/{}".format(reg_id))) return Response(status=404) else: return Response(json.dumps(details), status=200, mimetype='application/json')
def register_correction(): logging.info(session['original_regns']['applicant']) applicant = { 'name': session['original_regns']['applicant']['name'], 'address': session['original_regns']['applicant']['address'], 'key_number': session['original_regns']['applicant']['key_number'], 'reference': session['original_regns']['applicant']['reference'], 'address_type': session['original_regns']['applicant']['address_type'], } registration = { 'parties': session['parties'], 'class_of_charge': session['original_regns']['class_of_charge'], 'applicant': applicant, 'update_registration': { 'type': 'Correction' } } application = { 'registration': registration, 'orig_regn': session['details_entered'], 'update_registration': { 'type': 'Correction' } } if request.form['generate_K22'] == 'yes': application['k22'] = True else: application['k22'] = False url = app.config[ 'CASEWORK_API_URL'] + '/applications/0' + '?action=correction' headers = get_headers({'Content-Type': 'application/json'}) headers['X-Transaction-ID'] = session['transaction_id'] logging.debug("bankruptcy details: " + json.dumps(application)) response = http_put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info( format_message("Registration (bank) submitted to CASEWORK_API")) data = response.json() reg_list = [] for item in data['new_registrations']: reg_list.append(item['number']) session['confirmation'] = {'reg_no': reg_list} return response
def save_request_fee(id, fee): assert (fee is not None and fee != ''), "Fee is missing" # Add transaction fee to the associated request url = app.config['LAND_CHARGES_URI'] + '/request/' + id + "/" + fee response = requests.put(url, headers=get_headers()) if response.status_code != 200: err = 'Failed to store fee against request ' + id + '. Error code:' \ + str(response.status_code) logging.error(format_message(err)) raise RuntimeError(err) return Response(status=response.status_code, mimetype='application/json')
def get_registration(reg_date, reg_name): if "class_of_charge" in request.args: class_of_charge = request.args["class_of_charge"] else: class_of_charge = None logging.audit(format_message("Retrieve registration details for %s / %s"), reg_date, reg_name) response = get_registration_details(reg_date, reg_name, class_of_charge) logging.debug(response['data']) if response['status'] != 200: return Response(json.dumps(response['data']), status=response['status'], mimetype='application/json') else: return Response(json.dumps(response['data']), status=200, mimetype='application/json')
def registration_history(date, reg_no): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve entry history for %s, %s"), reg_no, date) details = get_registration_history(cursor, reg_no, date) finally: complete(cursor) if details is None: logging.warning("Returning 404") return Response(status=404) else: return Response(json.dumps(details), status=200, mimetype='application/json')
def error_handler(err): logging.debug('-----------------') logging.error(str(err)) logging.error(format_message('Unhandled exception: ' + str(err))) call_stack = traceback.format_exc() lines = call_stack.split("\n") for line in lines[0:-2]: logging.error(format_message(line)) error = { "type": "F", "stack": lines[0:-2] } try: error["dict"] = json.loads(str(err)) except ValueError as e: error["text"] = str(err) logging.error(json.dumps(error, indent=2)) raise_error(error) return Response(json.dumps(error), status=500)
def reclassify_form(): data = request.get_json(force=True) appn_id = data['appn_id'] form_type = data['form_type'] logging.info("T:%s Reclassify as a %s Application ", str(appn_id), str(form_type)) logging.audit(format_message("Reclassify %s as %s"), str(appn_id), str(form_type)) work_type = get_work_type(form_type) logging.info("move to %s", work_type["list_title"]) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: unlock_application(appn_id) reclassify_appn(cursor, appn_id, form_type, work_type["work_type"]) finally: complete(cursor) return Response(json.dumps(work_type), status=200, mimetype='application/json')
def submit_lc_rectification(form): rect_details = (session['rectification_details']) if 'instrument' in rect_details['update_registration']: orig_date = rect_details['update_registration']['instrument']['original'] orig_date = datetime.strptime(orig_date, "%d/%m/%Y").strftime("%Y-%m-%d") cur_date = rect_details['update_registration']['instrument']['current'] cur_date = datetime.strptime(cur_date, "%d/%m/%Y").strftime("%Y-%m-%d") rect_details['update_registration']['instrument']['original'] = orig_date rect_details['update_registration']['instrument']['current'] = cur_date cust_address = form['customer_address'].replace("\r\n", ", ").strip() application = {'update_registration': {'type': 'Rectification'}, 'applicant': { 'key_number': form['key_number'], 'name': form['customer_name'], 'address': cust_address, 'address_type': form['address_type'], 'reference': form['customer_ref']}, 'parties': [get_party_name(rect_details)], 'particulars': {'counties': rect_details['county'], 'district': rect_details['district'], 'description': rect_details['short_description']}, 'class_of_charge': convert_class_of_charge(rect_details['class']), 'regn_no': session['regn_no'], 'registration': {'date': session['reg_date']}, 'document_id': session['document_id'], 'additional_information': rect_details['additional_info'], 'fee_details': {'type': form['payment'], 'fee_factor': 1, 'delivery': session['application_dict']['delivery_method']} } if "update_registration" in rect_details: application["update_registration"] = rect_details["update_registration"] url = app.config['CASEWORK_API_URL'] + '/applications/' + session['worklist_id'] + '?action=rectify' headers = get_headers({'Content-Type': 'application/json'}) response = http_put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Rectification submitted to CASEWORK_API")) data = response.json() if 'new_registrations' in data: reg_list = [] for item in data['new_registrations']: reg_list.append(item['number']) session['confirmation'] = {'reg_no': reg_list} else: session['confirmation'] = {'reg_no': []} return Response(status=200)
def retrieve_office_copy(): class_of_charge = request.args['class'] reg_no = request.args['reg_no'] date = request.args['date'] cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: data = get_ins_office_copy(cursor, class_of_charge, reg_no, date) finally: logging.audit(format_message("Retrieve office copy for %s, %s (%s)"), reg_no, date, class_of_charge) complete(cursor) if data is None: return Response(data, status=404, mimetype='application/json') else: return Response(data, status=200, mimetype='application/json')
def register_correction(): logging.info(session["original_regns"]["applicant"]) applicant = { "name": session["original_regns"]["applicant"]["name"], "address": session["original_regns"]["applicant"]["address"], "key_number": session["original_regns"]["applicant"]["key_number"], "reference": session["original_regns"]["applicant"]["reference"], "address_type": session["original_regns"]["applicant"]["address_type"], } registration = { "parties": session["parties"], "class_of_charge": session["original_regns"]["class_of_charge"], "applicant": applicant, "update_registration": {"type": "Correction"}, } application = { "registration": registration, "orig_regn": session["details_entered"], "update_registration": {"type": "Correction"}, } if request.form["generate_K22"] == "yes": application["k22"] = True else: application["k22"] = False url = app.config["CASEWORK_API_URL"] + "/applications/0" + "?action=correction" headers = get_headers({"Content-Type": "application/json"}) headers["X-Transaction-ID"] = session["transaction_id"] logging.debug("bankruptcy details: " + json.dumps(application)) response = http_put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Registration (bank) submitted to CASEWORK_API")) data = response.json() reg_list = [] for item in data["new_registrations"]: reg_list.append(item["number"]) session["confirmation"] = {"reg_no": reg_list} return response
def get_search_type(request_id): cursor = connect(cursor_factory=psycopg2.extras.DictCursor) # get all rows for this request id, if none contain results then search type is 'search_nr' try: sql = "Select result from search_results where request_id = %(request_id)s" cursor.execute(sql, {"request_id": request_id}) rows = cursor.fetchall() finally: logging.audit( format_message("Retrieve search results for request: %s"), request_id) complete(cursor) search_type = {'search_type': 'search nr'} for row in rows: if row['result']: search_type = {'search_type': 'search'} return Response(json.dumps(search_type), status=200, mimetype='application/json')
def get_request_details(request_id): request_type = get_request_type(request_id) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: if request_type.lower() == 'search': data = get_search_request_details(request_id) else: # not a search - reg register details data = get_register_request_details(request_id) for index, row in enumerate( data): # Each AKA registration needs populating revealable = get_most_recent_revealable( cursor, row["registration_no"], row["registration_date"]) if revealable: if index < len(revealable['registrations']): details = get_registration_details( cursor, revealable['registrations'][index]['number'], revealable['registrations'][index]['date']) else: # if nothing came back from revealable details = get_registration_details( cursor, row["registration_no"], row["registration_date"]) if details is not None: if 'particulars' in details: if 'counties' in details['particulars']: if len(details['particulars']['counties']) > 1: county = get_county(cursor, row['registration_no'], row['registration_date']) details['particulars']['counties'] = county addl_info = get_additional_info(cursor, details) if addl_info is not None: details['additional_information'] = addl_info row['details'] = details finally: logging.audit(format_message("Retrieve request details for ID: %s"), request_id) complete(cursor) return Response(json.dumps(data), status=200, mimetype='application/json')
def get_applications(): list_type = 'all' state = 'all' if 'type' in request.args: list_type = request.args['type'] if 'state' in request.args: state = request.args['state'].upper() if list_type not in valid_types: return Response("Error: '" + list_type + "' is not one of the accepted work list types", status=400) logging.info(format_message('Get worklist %s'), list_type) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: applications = get_application_list(cursor, list_type, state) finally: complete(cursor) data = json.dumps(applications, ensure_ascii=False) return Response(data, status=200, mimetype='application/json')
def submit_lc_cancellation(data): cust_address = data['customer_address'].replace("\r\n", ", ").strip() application = {'update_registration': {'type': 'Cancellation'}, 'applicant': { 'key_number': data['key_number'], 'name': data['customer_name'], 'address': cust_address, 'address_type': data['address_type'], 'reference': data['customer_ref']}, 'registration_no': session['regn_no'], 'document_id': session['document_id'], 'registration': {'date': session['reg_date']}, 'fee_details': {'type': data['payment'], 'fee_factor': 1, 'delivery': session['application_dict']['delivery_method']}} if "class_of_charge" in session: application["class_of_charge"] = session["class_of_charge"] # if plan attached selected then pass the part_cans_text into that field if 'cancellation_type' in session: application['update_registration'] = {'type': session['cancellation_type']} if 'plan_attached' in session: if session['plan_attached'] == 'true': application['update_registration']['plan_attached'] = session['part_cans_text'] elif 'part_cans_text' in session: application['update_registration']['part_cancelled'] = session['part_cans_text'] url = app.config['CASEWORK_API_URL'] + '/applications/' + session['worklist_id'] + '?action=cancel' headers = get_headers({'Content-Type': 'application/json'}) response = requests.put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Cancellation submitted to CASEWORK_API")) data = response.json() if 'cancellations' in data: reg_list = [] for item in data['cancellations']: reg_list.append(item['number']) session['confirmation'] = {'reg_no': reg_list} else: session['confirmation'] = {'reg_no': []} return response
def submit_lc_registration(cust_fee_data): application = session['application_dict'] application['class_of_charge'] = convert_application_type(session['application_type']) application['application_ref'] = cust_fee_data['application_reference'] application['key_number'] = cust_fee_data['key_number'] application['customer_name'] = cust_fee_data['customer_name'] application['customer_address'] = cust_fee_data['customer_address'] application['address_type'] = cust_fee_data['address_type'] today = datetime.now().strftime('%Y-%m-%d') application['date'] = today application['residence_withheld'] = False #application['date_of_birth'] = "1980-01-01" # DONE?: what are we doing about the DOB?? application['document_id'] = session['document_id'] application['fee_details'] = {'type': cust_fee_data['payment'], 'fee_factor': 1, 'delivery': session['application_dict']['delivery_method']} if session['application_dict']['form'] == 'K6': application['priority_notice_ind'] = True result_string = 'priority_notices' else: result_string = 'new_registrations' session['register_details']['estate_owner']['estate_owner_ind'] = session['register_details']['estate_owner_ind'] # convert_estate_owner_ind(session['register_details']['estate_owner_ind']) application['lc_register_details'] = session['register_details'] url = app.config['CASEWORK_API_URL'] + '/applications/' + session['worklist_id'] + '?action=complete' headers = get_headers({'Content-Type': 'application/json'}) response = http_put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Registration submitted to CASEWORK_API")) data = response.json() reg_list = [] for item in data[result_string]: reg_list.append(item['number']) session['confirmation'] = {'reg_no': reg_list} return response
def court_ref_existence_check(ref): logging.debug("Court existence checking") cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: logging.audit(format_message("Retrieve details by court: %s"), ref) cursor.execute( "SELECT registration_no, date FROM register r, register_details rd " + "WHERE UPPER(rd.legal_body_ref)=%(body_ref)s " + "AND rd.id=r.details_id " "AND (r.expired_on is NULL OR r.expired_on > current_date) " "AND rd.cancelled_by is NULL " + "AND (UPPER(rd.amendment_type)!='CANCELLATION' or rd.amendment_type is NULL) ", {"body_ref": ref.upper()}) rows = cursor.fetchall() results = [] if len(rows) > 0: status_code = 200 for row in rows: details = get_registration_details(cursor, row['registration_no'], row['date']) debtor_name = details['parties'][0]['names'][0]['private'] name_string = " ".join( debtor_name['forenames']) + " " + debtor_name['surname'] results.append({ 'reg_no': details['registration']['number'], 'date': details['registration']['date'], 'class_of_charge': details['class_of_charge'], 'name': name_string }) else: status_code = 404 finally: complete(cursor) return Response(json.dumps(results), status=status_code, mimetype='application/json')
def associate_image(): data = request.get_json(force=True) logging.debug(json.dumps(data)) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) logging.audit(format_message("Link image to registration %s of %s"), data['reg_no'], data['date']) try: cursor.execute("UPDATE registered_documents SET doc_id = %(doc_id)s " + "WHERE number=%(reg)s and date=%(date)s", { "doc_id": data['document_id'], "reg": int(data['reg_no']), "date": data['date'] }) rows = cursor.rowcount if rows == 0: status_code = 404 else: delete_application(cursor, data['appn_id']) status_code = 200 complete(cursor) except: rollback(cursor) raise return Response(status=status_code, mimetype='application/json')
def get_multi_reg_check(reg_date, reg_no): logging.audit(format_message("Check multiple registration for %s %s"), reg_no, reg_date) url = app.config['LAND_CHARGES_URI'] + '/multi_reg_check/' + reg_date + "/" + reg_no data = requests.get(url, headers=get_headers()) return Response(data, status=200, mimetype='application/json')
def get_keyholder(key_number): logging.audit(format_message("Get keyholder details")) uri = app.config['LEGACY_ADAPTER_URI'] + '/keyholders/' + key_number response = requests.get(uri, headers=get_headers()) return Response(response.text, status=response.status_code, mimetype='application/json')
def update_application(appn_id): # TODO: validate action = 'store' if 'action' in request.args: action = request.args['action'] logging.debug(request.headers) data = request.get_json(force=True) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) # store fee info for later use. Quick fix because of data structure in rectifications if 'fee_details' in data: fee_ind = True fee_details = data['fee_details'] else: fee_ind = False fee_details = {} try: if action == 'store': logging.info(format_message("Store application")) logging.audit(format_message("Store application")) # logging.debug(data) # update_application_details(cursor, appn_id, data) store_application(cursor, appn_id, data) appn = get_application_by_id(cursor, appn_id) elif action == 'complete': logging.info(format_message("Complete registration")) logging.audit(format_message("Complete application")) appn = complete_application(cursor, appn_id, data) elif action == 'amend' or action == 'rectify': logging.info(format_message("Complete update")) logging.audit(format_message("Complete update application")) appn = amend_application(cursor, appn_id, data) elif action == 'cancel': logging.info(format_message("Complete cancellation")) logging.audit(format_message("Complete cancellation application")) appn = cancel_application(cursor, appn_id, data) elif action == 'renewal': logging.info(format_message("Complete renewal")) logging.audit(format_message("Complete renewal application")) appn = renew_application(cursor, appn_id, data) elif action == 'correction': logging.info(format_message("Complete correction")) logging.audit(format_message("Complete correction")) appn = correct_application(cursor, data) else: return Response("Invalid action", status=400) # sort out the fee # everything but searches if fee_ind is True: logging.debug("fee selected" + json.dumps(fee_details)) if fee_details['type'] == 'wf' or fee_details['type'] == 'nf': save_request_fee(str(appn['request_id']), str(0)) else: # build the fee details to pass to legacy_adapter build_fee_data(data, appn, fee_details, action) complete(cursor) status = 200 except ValidationError as e: rollback(cursor) error_str = str(e) error_dict = json.loads(error_str[1:-1]) # Exception seems to add quotes, annoyingly appn = {"ValidationError": error_dict} status = 400 except: rollback(cursor) raise return Response(json.dumps(appn), status=status)
def post_search(): data = request.get_json(force=True) logging.debug(json.dumps(data)) logging.audit("Submit search") today = datetime.now().strftime('%Y-%m-%d') date_uri = app.config['LEGACY_ADAPTER_URI'] + '/dates/' + today date_response = requests.get(date_uri, headers=get_headers()) if date_response.status_code != 200: raise CaseworkAPIError(json.dumps({ "message": "Unexpected response from legacy_adapter/dates: " + str(date_response.status_code), "response": date_response.text })) # call legacy_adapter to retrieve the next search number url = app.config['LEGACY_ADAPTER_URI'] + '/search_number' response = requests.get(url, headers=get_headers()) if response.status_code == 200: cert_no = response.text else: err = 'Failed to call search_number. Error code: {}'.format(str(response.status_code)) logging.error(format_message(err)) raise CaseworkAPIError(json.dumps({ "message": err, "response": response.text })) date_info = date_response.json() data['expiry_date'] = date_info['search_expires'] data['search_date'] = date_info['prev_working'] data['cert_no'] = cert_no uri = app.config['LAND_CHARGES_URI'] + '/searches' response = requests.post(uri, data=json.dumps(data), headers=get_headers({'Content-Type': 'application/json'})) if response.status_code != 200: raise CaseworkAPIError(json.dumps(response.text)) logging.info('POST {} -- {}'.format(uri, response.text)) # store result response_data = response.json() logging.debug(json.dumps(response_data)) cursor = connect(cursor_factory=psycopg2.extras.DictCursor) try: # process fee info if data['fee_details']['type'] == 'wf' or data['fee_details']['type'] == 'nf': save_request_fee(str(response_data[0]), str(0)) else: # build the fee details to pass to legacy_adapter build_fee_data(data, response_data, data['fee_details'], 'search') store_image_for_later(cursor, data['document_id'], None, None, response_data[0]) complete(cursor) except: rollback(cursor) raise cursor = connect() for req_id in response_data: uri = app.config['LAND_CHARGES_URI'] + '/search_type/' + str(req_id) response = requests.get(uri, headers=get_headers()) resp_data = response.json() res_type = resp_data['search_type'] insert_result_row(cursor, req_id, res_type) complete(cursor) return Response(response.text, status=response.status_code, mimetype='application/json')
def build_fee_data(data, appn, fee_details, action): if action == 'complete': fee = {'transaction_code': 'RN', 'key_number': data['key_number'], 'reference': data['application_ref'], 'class_of_charge': data['lc_register_details']['class']} reg_type = 'new_registrations' elif action == 'rectify': fee = {'transaction_code': 'RN', 'key_number': data['applicant']['key_number'], 'reference': data['applicant']['reference'], 'class_of_charge': data['class_of_charge']} reg_type = 'new_registrations' elif action == 'renewal': fee = {'transaction_code': 'RN', 'key_number': data['applicant']['key_number'], 'reference': data['applicant']['reference'], 'class_of_charge': data['class_of_charge']} reg_type = 'new_registrations' elif action == 'cancel': fee = {'transaction_code': 'CN', 'key_number': data['applicant']['key_number'], 'reference': data['applicant']['reference']} reg_type = 'cancellations' date = data['registration']['date'] number = data['registration_no'] url = app.config['LAND_CHARGES_URI'] + '/registrations/' + date + '/' + number response = requests.get(url, headers=get_headers()) if response.status_code == 200: result = (json.loads(response.text)) fee['class_of_charge'] = result['class_of_charge'] else: err = "Failed to get registration {} of {}. Code: {}".format( number, date, response.status_code ) logging.error(format_message(err)) raise CaseworkAPIError(json.dumps({ "message": err, "response": response.text })) elif action == 'search': if fee_details['delivery'] == 'Postal': transaction_code = 'PS' else: transaction_code = 'XS' fee = {'transaction_code': transaction_code, 'key_number': data['customer']['key_number'], 'reference': data['customer']['reference'], 'class_of_charge': ' ', 'method_of_payment': fee_details['type']} fee_data = {'fee_info': fee, 'reg_no': ' ', 'appn_no': data['cert_no'], 'fee_factor': fee_details['fee_factor']} # call legacy_adapter to process fee for search and return logging.debug("fee information" + json.dumps(fee_data)) url = app.config['LEGACY_ADAPTER_URI'] + '/fee_process' response = requests.post(url, data=json.dumps(fee_data), headers=get_headers()) if response.status_code == 200: fee = response.text save_request_fee(str(appn[0]), fee) return response.status_code else: err = "Failed to call fee_process for {}. Code: {}".format( data["cert_no"], response.status_code ) logging.error(format_message(err)) raise CaseworkAPIError(json.dumps({ "message": err, "response": response.text })) else: err = "The fee action is incorrect: {}".format(action) logging.error(format_message(err)) raise CaseworkAPIError(json.dumps({ "message": err })) # call legacy_adapter for each registration number if 'priority_notices' in appn: reg_type = 'priority_notices' fee['method_of_payment'] = fee_details['type'] fee_data = {'fee_info': fee} print(appn[reg_type]) if action == 'cancel': fee_data['reg_no'] = number fee_data['appn_no'] = str(appn[reg_type][0]['number']) else: fee_data['reg_no'] = str(appn[reg_type][0]['number']) fee_data['appn_no'] = str(appn[reg_type][0]['number']) fee_data['fee_factor'] = fee_details['fee_factor'] logging.debug("fee information " + json.dumps(fee_data)) url = app.config['LEGACY_ADAPTER_URI'] + '/fee_process' response = requests.post(url, data=json.dumps(fee_data), headers=get_headers()) if response.status_code != 200: err = "Failed to call fee_process for {}. Code: {}".format( fee_data['appn_no'], response.status_code ) logging.error(format_message(err)) raise CaseworkAPIError(json.dumps({ "message": err })) else: fee = response.text save_request_fee(str(appn['request_id']), fee) return
def process_search_criteria(data, search_type): logging.debug("process search data") counties = [] parameters = { "counties": counties, "search_type": "banks" if search_type == "search_bank" else "full", "search_items": [], } counter = 1 while True: name_type = "nameType_{}".format(counter) if name_type not in data: break name_extracted = False if data[name_type] == "privateIndividual" and data["surname_{}".format(counter)] != "": forename = "forename_{}".format(counter) surname = "surname_{}".format(counter) search_item = { "name_type": "Private Individual", "name": {"forenames": data[forename], "surname": data[surname]}, } name_extracted = True elif data[name_type] == "limitedCompany" and data["company_{}".format(counter)] != "": company = "company_{}".format(counter) search_item = {"name_type": "Limited Company", "name": {"company_name": data[company]}} name_extracted = True elif ( data[name_type] == "countyCouncil" and data["loc_auth_{}".format(counter)] != "" and data["loc_auth_area_{}".format(counter)] != "" ): loc_auth = "loc_auth_{}".format(counter) loc_auth_area = "loc_auth_area_{}".format(counter) search_item = { "name_type": "County Council", "name": {"local_authority_name": data[loc_auth], "local_authority_area": data[loc_auth_area]}, } name_extracted = True elif ( data[name_type] == "ruralCouncil" and data["loc_auth_{}".format(counter)] != "" and data["loc_auth_area_{}".format(counter)] != "" ): loc_auth = "loc_auth_{}".format(counter) loc_auth_area = "loc_auth_area_{}".format(counter) search_item = { "name_type": "Rural Council", "name": {"local_authority_name": data[loc_auth], "local_authority_area": data[loc_auth_area]}, } name_extracted = True elif ( data[name_type] == "parishCouncil" and data["loc_auth_{}".format(counter)] != "" and data["loc_auth_area_{}".format(counter)] != "" ): loc_auth = "loc_auth_{}".format(counter) loc_auth_area = "loc_auth_area_{}".format(counter) search_item = { "name_type": "Parish Council", "name": {"local_authority_name": data[loc_auth], "local_authority_area": data[loc_auth_area]}, } name_extracted = True elif ( data[name_type] == "otherCouncil" and data["loc_auth_{}".format(counter)] != "" and data["loc_auth_area_{}".format(counter)] != "" ): loc_auth = "loc_auth_{}".format(counter) loc_auth_area = "loc_auth_area_{}".format(counter) search_item = { "name_type": "Other Council", "name": {"local_authority_name": data[loc_auth], "local_authority_area": data[loc_auth_area]}, } name_extracted = True elif data[name_type] == "codedName" and data["other_name_{}".format(counter)] != "": other_name = "other_name_{}".format(counter) search_item = {"name_type": "Coded Name", "name": {"other_name": data[other_name]}} name_extracted = True elif ( data[name_type] == "complexName" and data["complex_name_{}".format(counter)] != "" and data["complex_number_{}".format(counter)] != "" ): complex_name = "complex_name_{}".format(counter) complex_number = "complex_number_{}".format(counter) search_item = { "name_type": "Complex Name", "name": { "complex_name": data[complex_name], "complex_number": int(data[complex_number]), "complex_variations": [], }, } url = app.config["CASEWORK_API_URL"] + "/complex_names/search" headers = get_headers({"Content-Type": "application/json"}) comp_name = {"name": data[complex_name], "number": int(data[complex_number])} response = http_post(url, data=json.dumps(comp_name), headers=headers) logging.info(format_message("POST {} -- {}".format(url, response))) result = response.json() for item in result: search_item["name"]["complex_variations"].append({"name": item["name"], "number": int(item["number"])}) name_extracted = True elif data[name_type] == "developmentCorporation" and data["other_name_{}".format(counter)] != "": # name_type is other other_name = "other_name_{}".format(counter) search_item = {"name_type": "Development Corporation", "name": {"other_name": data[other_name]}} name_extracted = True elif data[name_type] == "other" and data["other_name_{}".format(counter)] != "": # name_type is other other_name = "other_name_{}".format(counter) search_item = {"name_type": "Other", "name": {"other_name": data[other_name]}} name_extracted = True if search_type == "search_full" and name_extracted: logging.debug("Getting year stuff") search_item["year_to"] = int(data["year_to_{}".format(counter)]) search_item["year_from"] = int(data["year_from_{}".format(counter)]) if name_extracted: parameters["search_items"].append(search_item) counter += 1 result = {} if search_type == "search_full": if "all_counties" in data and data["all_counties"] == "yes": result["county"] = ["ALL"] else: add_counties(result, data) else: result["county"] = [] parameters["counties"] = result["county"] session["application_dict"]["search_criteria"] = parameters return
def register_bankruptcy(key_number): url = app.config["CASEWORK_API_URL"] + "/keyholders/" + key_number response = http_get(url, headers={"X-Transaction-ID": session["transaction_id"]}) text = json.loads(response.text) if response.status_code == 200: cust_address = ", ".join(text["address"]["address_lines"]) + ", " + text["address"]["postcode"] address_type = "RM" if ("dx_number" in text) and ("dx_exchange" in text): if text["dx_number"]: # switch to dx address if available if text["dx_exchange"]: dx_no = str(text["dx_number"]).upper() if not dx_no.startswith("DX"): dx_no = "DX " + dx_no cust_address = dx_no + ", " + text["dx_exchange"] address_type = "DX" cust_name = text["name"] applicant = { "name": cust_name, "address": cust_address.upper(), "key_number": key_number, "reference": " ", "address_type": address_type, } else: return response if session["application_type"] == "bank_amend": class_of_charge = session["original_regns"]["class_of_charge"] elif session["application_dict"]["form"] == "PA(B)": class_of_charge = "PAB" elif session["application_dict"]["form"] == "WO(B)": class_of_charge = "WOB" else: class_of_charge = session["application_dict"]["form"] registration = {"parties": session["parties"], "class_of_charge": class_of_charge, "applicant": applicant} application = { "registration": registration, "application_data": session["application_dict"]["application_data"], "form": session["application_dict"]["form"], } if session["application_type"] == "bank_amend": # TODO: update registration added twice to get around bad structure for rectifications which needs changing! application["update_registration"] = {"type": "Amendment"} application["registration"]["update_registration"] = {"type": "Amendment"} if "wob_entered" in session: application["wob_original"] = session["wob_entered"] if "pab_entered" in session: application["pab_original"] = session["pab_entered"] url = app.config["CASEWORK_API_URL"] + "/applications/" + session["worklist_id"] + "?action=amend" else: url = app.config["CASEWORK_API_URL"] + "/applications/" + session["worklist_id"] + "?action=complete" headers = get_headers({"Content-Type": "application/json"}) logging.debug("bankruptcy details: " + json.dumps(application)) response = http_put(url, data=json.dumps(application), headers=headers) if response.status_code == 200: logging.info(format_message("Registration (bank) submitted to CASEWORK_API")) data = response.json() reg_list = [] for item in data["new_registrations"]: reg_list.append(item["number"]) session["confirmation"] = {"reg_no": reg_list} return response