def delete_requests(self, request_ids: list[int]) -> None:
row_index = self.get_index_of(request_ids[0])
row_index2 = self.get_index_of(request_ids[-1])
self.beginRemoveRows(QtCore.QModelIndex(), row_index, row_index2) # type: ignore
HttpFlow.destroy(*request_ids)
self.flows = list(filter(lambda r: r.id not in request_ids, self.flows))
self.endRemoveRows()
def select_request(self, selected, deselected):
if (len(selected.indexes()) > 0):
selected_id_cols = list(
filter(lambda i: i.column() == 0, selected.indexes()))
selected_id = selected_id_cols[0].data()
flow = HttpFlow.find(selected_id)
self.ui.requestViewWidget.set_flow(flow)
def __init__(self, *args, **kwargs):
super(HttpPage, self).__init__(*args, **kwargs)
self.ui = Ui_HttpPage()
self.ui.setupUi(self)
# Setup the request model
http_flows = HttpFlow.find_for_table()
self.table_model = RequestsTableModel(http_flows)
self.ui.requestsTableWidget.setTableModel(self.table_model)
self.ui.requestsTableWidget.request_selected.connect(
self.select_request)
self.ui.requestsTableWidget.delete_requests.connect(
self.delete_requests)
self.ui.requestsTableWidget.search_text_changed.connect(
self.search_requests)
self.ui.requestsTableWidget.send_flow_to_editor.connect(
self.send_flow_to_editor)
self.ui.toggleButton.clicked.connect(self.toggle_page)
self.ui.requestViewWidget.set_show_rendered(True)
self.ui.requestViewWidget.set_save_as_example_visible(False)
self.ui.requestViewWidget.show_modified_dropdown()
self.restore_layout_state()
def save(self, *args, **kwargs):
item_id = getattr(self, 'item_id', None)
if self.item_type == self.TYPE_HTTP_FLOW and item_id is None:
flow = HttpFlow.create_for_editor()
self.item_id = flow.id
return super(EditorItem, self).save(*args, **kwargs)
def response_status_sort_key(self, flow: HttpFlow) -> tuple[int, int]:
# TODO: Fix this:
response = flow.response
if response is not None and flow.has_response():
status = response.status_code
else:
status = 0
return (status, flow.id)
def request(self, request_state):
http_request = HttpRequest.from_state(request_state)
http_request.save()
http_flow = HttpFlow()
http_flow.uuid = request_state['flow_uuid']
http_flow.client_id = request_state['client_id']
http_flow.request_id = http_request.id
http_flow.type = HttpFlow.TYPE_PROXY
http_flow.save()
cast(QtCore.SignalInstance, self.signals.flow_created).emit(http_flow)
if request_state['intercepted']:
cast(QtCore.SignalInstance,
self.signals.flow_intercepted).emit(http_flow)
def save(self):
self.request.save()
saved_flow = HttpFlow()
saved_flow.type = self.type
saved_flow.request_id = self.request.id
saved_flow.save()
return saved_flow
def websocket_message(self, message_state):
http_flow = HttpFlow.where('uuid', '=',
message_state['flow_uuid']).first()
websocket_message = WebsocketMessage.from_state(message_state)
websocket_message.http_flow_id = http_flow.id
websocket_message.save()
cast(QtCore.SignalInstance,
self.signals.websocket_message_created).emit(websocket_message)
if message_state['intercepted']:
http_flow.intercept_websocket_message = True
cast(QtCore.SignalInstance,
self.signals.flow_intercepted).emit(http_flow)
def response(self, response_state):
http_response = HttpResponse.from_state(response_state)
http_response.save()
http_flow = HttpFlow.where('uuid', '=',
response_state['flow_uuid']).first()
if http_flow is None:
return
http_flow.response_id = http_response.id
http_flow.save()
cast(QtCore.SignalInstance, self.signals.flow_updated).emit(http_flow)
if response_state['intercepted']:
cast(QtCore.SignalInstance,
self.signals.flow_intercepted).emit(http_flow)
def test_create_for_editor(self, database, cleanup_database):
flow = HttpFlow.create_for_editor()
assert flow.request is not None
assert flow.type == HttpFlow.TYPE_EDITOR
def test_save(self, database, cleanup_database):
item = factory(EditorItem, 'request').make(item_id=None)
item.save()
flow = HttpFlow.where('id', '=', item.id).first()
assert flow is not None
def reload(self):
self.ui.requestViewWidget.clear_request()
http_flows = HttpFlow.find_for_table()
self.table_model = RequestsTableModel(http_flows)
self.ui.requestsTableWidget.setTableModel(self.table_model)
def item(self):
if self.item_type == self.TYPE_HTTP_FLOW:
return HttpFlow.where('id', '=', self.item_id).first()