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)