def post(self): url = request.get_json()["request_url"] host, path = self.parse_url(url) # Init managers and sessions hs_manager = HsManager() db_session = DatabaseManager().get_session() # Search try: start_search_time = time() search_data = hs_manager.search(domain=host, path=path, is_test=True) end_search_time = time() except AssertionError as e: Logger() \ .event(category="hyperscan", action="hyperscan search") \ .error(message=str(e)) \ .out(severity=Severity.ERROR) DatabaseManager().return_session(db_session) return api_error( message="Something went wrong during Hyperscan search!", errors=str(e), status_code=400) # Convert ids into models domain_rules_data = {} redirect_rules_data = {} d_r_map = search_data["domain_rule_map"] for domain_id in d_r_map.keys(): domain_rule = get_model_by_id(db_session, DomainRule, domain_id) domain_rules_data[domain_id] = db_encode_model(domain_rule) for rule_id in d_r_map[domain_id]: redirect_rule = get_model_by_id(db_session, RedirectRule, rule_id) redirect_rules_data[rule_id] = db_encode_model(redirect_rule, expand=True) # Get final result final_redirect_rule, is_ambiguous = HsManager.pick_result( db_session, list(redirect_rules_data.keys())) # Fill in test data search_data[ "final_result_id"] = final_redirect_rule.id if final_redirect_rule is not None else None search_data["is_ambiguous"] = is_ambiguous search_data["time"] = str(end_search_time - start_search_time) DatabaseManager().return_session(db_session) return make_response( jsonify({ "domain_rules": domain_rules_data, "redirect_rules": redirect_rules_data, "search_data": search_data }), 200)
def post(self): args = request.get_json() db_session = DatabaseManager().get_session() redirect_rule_instance = add_redirect_rule(db_session, **args) if isinstance(redirect_rule_instance, int): DatabaseManager().return_session(db_session) return api_error( message="Unable to add redirect rule", errors="A rule like this already exists" if redirect_rule_instance == 2 else "Invalid rule with rewrite! Check your path and destination fields.", status_code=400 ) if isinstance(redirect_rule_instance, RedirectRule): redirect_rule_data = db_encode_model(redirect_rule_instance, expand=True) DatabaseManager().return_session(db_session) # Metrics metric_update_rules_total() return make_response(jsonify({ "new_rule": redirect_rule_data, "status": "done" }), 200)
def post(self): args = request.get_json() db_session = DatabaseManager().get_session() updated_redirect_rule = update_redirect_rule(db_session, **args) if isinstance(updated_redirect_rule, int): DatabaseManager().return_session(db_session) metric_update_rules_total() # Metrics return api_error( message="Unable to update redirect rule", errors= f"Redirect rule with id: {args['redirect_rule_id']} does not exist" if updated_redirect_rule == 2 else "The update rules fails the validation for rewrite! Check your path and destination fields.", status_code=400) if updated_redirect_rule: serialized_updated_redirect_rule = db_encode_model( updated_redirect_rule, expand=True) DatabaseManager().return_session(db_session) metric_update_rules_total() # Metrics return make_response( jsonify({ "updated_rule": serialized_updated_redirect_rule, "status": "done" }), 200)
def test_encode_model(self, database_populated): """ Starts with an populated database with 5 redirect rules. Test the encode_model() function. Expected behaviour: 1. Converts a model to a JSON dict correctly 2. When the expand settings is used it actually expands the models """ # Get session from redirectory.libs_int.database import DatabaseManager db_session = DatabaseManager().get_session() # Import needed functions and classes from redirectory.libs_int.database import db_encode_model from redirectory.models import RedirectRule # Get a model and encode to Json (dict) model = db_session.query(RedirectRule).get(1) encoded = db_encode_model(model) # Check assert 'id' in encoded assert encoded['id'] == 1 assert 'weight' in encoded assert encoded['weight'] == 100 assert 'domain_rule' not in encoded # Encode with the expand property encoded_expanded = db_encode_model(model, expand=True) # Check assert 'domain_rule' in encoded_expanded assert encoded_expanded['domain_rule']['rule'] == 'asd.test.kumina.nl' assert 'path_rule' in encoded_expanded assert encoded_expanded['path_rule']['rule'] == '/test/path' assert 'destination_rule' in encoded_expanded assert encoded_expanded['destination_rule'][ 'destination_url'] == 'https://google.com' # Return session DatabaseManager().return_session(db_session)
def post(self): # Gather arguments args = request.get_json() page_number = args["page_number"] page_size = args["page_size"] # Get DB session db_session = DatabaseManager().get_session() start_process_time = time() # Generate query for pages query = db_session.query(RedirectRule) # Apply filters to query if needed if "filter" in args: query = self.apply_filters(query, args["filter"]) # Get the page page: Page = paginate(query, page_number, page_size) # Check if page exists if not page.items: # Release the DB session and return an api error DatabaseManager().return_session(db_session) return api_error( message="Unable to get specified page", errors=f"Page with number: {page_number} does not exist", status_code=404) # Get the data in json data = [] for redirect_rule in page.items: data.append(db_encode_model(redirect_rule, expand=True)) end_process_time = time() # Return DB session and return response DatabaseManager().return_session(db_session) # Metrics metric_update_rules_total() return make_response( jsonify({ "data": data, "page": { "total_items": page.total, "total_pages": page.pages, "has_previous": page.has_previous, "has_next": page.has_next }, "time": str(end_process_time - start_process_time) }), 200)
def post(self): new_request_url = request.get_json()["request"] db_session = DatabaseManager().get_session() # Delete the ambiguous entry and get bool if successful new_entry = add_ambiguous_request(db_session, new_request_url) # Release session DatabaseManager().return_session(db_session) if new_entry is not None: return make_response( jsonify({ "new_ambiguous_request": db_encode_model(new_entry), "status": "done" }), 200) else: return api_error( message="Unable to add new ambiguous request entry", errors=f"Ambiguous request like this already exist", status_code=400)
def post(self): rule_id = request.get_json()["rule_id"] db_session = DatabaseManager().get_session() redirect_instance = get_model_by_id(db_session, RedirectRule, rule_id) if redirect_instance: redirect_rule_data = db_encode_model(redirect_instance, expand=True) DatabaseManager().return_session(db_session) return make_response( jsonify({ "rule": redirect_rule_data, "status": "done" }), 200) else: DatabaseManager().return_session(db_session) return api_error(message="Unable to get redirect rule", errors=f"Redirect rule with id: {rule_id} do", status_code=404)