def create_tactical_report(user_id: str,
user_email: str,
incident_id: int,
action: dict,
db_session=None):
"""Creates and sends a new tactical report to a conversation."""
conditions = action["submission"]["conditions"]
actions = action["submission"]["actions"]
needs = action["submission"]["needs"]
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we create a new tactical report
details = {"conditions": conditions, "actions": actions, "needs": needs}
tactical_report_in = ReportCreate(details=details,
type=ReportTypes.tactical_report)
tactical_report = create(db_session=db_session,
report_in=tactical_report_in)
# we load the participant
participant = participant_service.get_by_incident_id_and_email(
db_session=db_session, incident_id=incident_id, email=user_email)
# we save the tactical report
participant.reports.append(tactical_report)
incident.reports.append(tactical_report)
db_session.add(participant)
db_session.add(incident)
db_session.commit()
event_service.log(
db_session=db_session,
source="Incident Participant",
description=
f"{participant.individual.name} created a new tactical report",
details={
"conditions": conditions,
"actions": actions,
"needs": needs
},
incident_id=incident_id,
individual_id=participant.individual.id,
)
# we send the tactical report to the conversation
send_tactical_report_to_conversation(incident_id, conditions, actions,
needs, db_session)
return tactical_report
def send_welcome_ephemeral_message_to_participant(
participant_email: str, incident_id: int, db_session: SessionLocal
):
"""Sends an ephemeral message to the participant."""
# we load the incident instance
plugin = plugin_service.get_active(db_session=db_session, plugin_type="conversation")
if not plugin:
log.warning("Incident welcome message not sent, not conversation plugin enabled.")
return
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
# we send the ephemeral message
message_kwargs = {
"name": incident.name,
"title": incident.title,
"status": incident.status,
"type": incident.incident_type.name,
"type_description": incident.incident_type.description,
"priority": incident.incident_priority.name,
"priority_description": incident.incident_priority.description,
"commander_fullname": incident.commander.individual.name,
"commander_weblink": incident.commander.individual.weblink,
"document_weblink": resolve_attr(incident, "incident_document.weblink"),
"storage_weblink": resolve_attr(incident, "storage.weblink"),
"ticket_weblink": resolve_attr(incident, "ticket.weblink"),
"conference_weblink": resolve_attr(incident, "conference.weblink"),
"conference_challenge": resolve_attr(incident, "conference.conference_challenge"),
}
faq_doc = document_service.get_incident_faq_document(db_session=db_session)
if faq_doc:
message_kwargs.update({"faq_weblink": faq_doc.weblink})
conversation_reference = document_service.get_conversation_reference_document(
db_session=db_session
)
if conversation_reference:
message_kwargs.update(
{"conversation_commands_reference_document_weblink": conversation_reference.weblink}
)
plugin.instance.send_ephemeral(
incident.conversation.channel_id,
participant_email,
"Incident Welcome Message",
INCIDENT_PARTICIPANT_WELCOME_MESSAGE,
MessageType.incident_participant_welcome,
**message_kwargs,
)
log.debug(f"Welcome ephemeral message sent to {participant_email}.")
def create(*, db_session, feedback_in: FeedbackCreate) -> Feedback:
"""Creates a new piece of feedback."""
incident = incident_service.get(
db_session=db_session,
incident_id=feedback_in.incident.id,
)
feedback = Feedback(
**feedback_in.dict(exclude={"incident"}),
incident=incident,
)
db_session.add(feedback)
db_session.commit()
return feedback
def incident_active_flow(incident_id: int,
command: Optional[dict] = None,
db_session=None):
"""Runs the incident active flow."""
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we remind the incident commander to write a tactical report
send_incident_report_reminder(incident, ReportTypes.tactical_report)
# we update the status of the external ticket
update_external_incident_ticket(incident, db_session)
def add_user_to_conversation(user_email: str,
incident_id: int,
action: dict,
db_session=None):
"""Adds a user to a conversation."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
user_id = dispatch_slack_service.resolve_user(slack_client,
user_email)["id"]
dispatch_slack_service.add_users_to_conversation(
slack_client, incident.conversation.channel_id, user_id)
def has_required_permissions(
self,
request: Request,
) -> bool:
current_incident = incident_service.get(
db_session=request.state.db, incident_id=request.path_params.id)
if current_incident.visibility == Visibility.restricted:
return any(
AdminPermission(request=request),
IncidentCommanderPermission(request=request),
IncidentReporterPermission(request=request),
)
return True
def get_or_create(
*,
db_session,
incident_id: int,
individual_id: int,
service_id: int,
participant_roles: List[ParticipantRoleCreate],
) -> Participant:
"""Gets an existing participant object or creates a new one."""
participant = (db_session.query(Participant).filter(
Participant.incident_id == incident_id).filter(
Participant.individual_contact_id == individual_id).one_or_none())
if not participant:
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# We get information about the individual
individual_contact = individual_service.get(
db_session=db_session, individual_contact_id=individual_id)
individual_info = {}
contact_plugin = plugin_service.get_active_instance(
db_session=db_session,
project_id=incident.project.id,
plugin_type="contact")
if contact_plugin:
individual_info = contact_plugin.instance.get(
individual_contact.email, db_session=db_session)
location = individual_info.get("location", "Unknown")
team = individual_info.get("team", "Unknown")
department = individual_info.get("department", "Unknown")
participant_in = ParticipantCreate(
participant_roles=participant_roles,
team=team,
department=department,
location=location,
)
if service_id:
participant_in.service = {"id": service_id}
participant = create(db_session=db_session,
participant_in=participant_in)
else:
participant.participant_roles += participant_roles
participant.service_id = service_id
return participant
def run_workflow_submitted_form(action: dict, db_session=None):
"""Runs an external flow."""
submitted_form = action.get("view")
parsed_form_data = parse_submitted_form(submitted_form)
params = {}
named_params = []
for i in parsed_form_data.keys():
if i.startswith(RunWorkflowBlockFields.param):
key = i.split("-")[1]
value = parsed_form_data[i]
params.update({key: value})
named_params.append({"key": key, "value": value})
workflow_id = parsed_form_data.get(
RunWorkflowBlockFields.workflow_select)["value"]
incident_id = action["view"]["private_metadata"]["incident_id"]
run_reason = parsed_form_data.get(RunWorkflowBlockFields.run_reason)
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
workflow = workflow_service.get(db_session=db_session,
workflow_id=workflow_id)
creator_email = get_user_email(slack_client, action["user"]["id"])
instance = workflow_service.create_instance(
db_session=db_session,
instance_in=WorkflowInstanceCreate(
workflow={"id": workflow.id},
incident={"id": incident.id},
creator={"email": creator_email},
run_reason=run_reason,
parameters=named_params,
),
)
params.update({
"incident_id": incident.id,
"incident_name": incident.name,
"instance_id": instance.id
})
workflow.plugin.instance.run(workflow.resource_id, params)
send_workflow_notification(
incident.conversation.channel_id,
INCIDENT_WORKFLOW_CREATED_NOTIFICATION,
db_session,
instance_creator_name=instance.creator.individual.name,
workflow_name=instance.workflow.name,
workflow_description=instance.workflow.description,
)
def after_hours(user_email: str, incident_id: int, db_session=None):
"""Notifies the user that this incident is current in after hours mode."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
user_id = dispatch_slack_service.resolve_user(slack_client,
user_email)["id"]
# NOTE Limitations: Does not sync across instances. Does not survive webserver restart
cache_key = create_cache_key(user_id, incident.conversation.channel_id)
try:
once_a_day_cache[cache_key]
return
except Exception:
pass # we don't care if there is nothing here
# bail early if we don't care for a given severity
priority_types = [
IncidentPriorityType.info,
IncidentPriorityType.low,
IncidentPriorityType.medium,
]
if incident.incident_priority.name.lower() not in priority_types:
return
# get their timezone from slack
commander_info = dispatch_slack_service.get_user_info_by_email(
slack_client, email=incident.commander.email)
commander_tz = commander_info["tz"]
if not is_business_hours(commander_tz):
# send ephermal message
blocks = [{
"type": "section",
"text": {
"type":
"mrkdwn",
"text":
((f"Responses may be delayed. The current incident severity is *{incident.incident_severity.name}*"
f" and your message was sent outside of the incident commander's working hours (Weekdays, 9am-5pm, {commander_tz})."
)),
},
}]
dispatch_slack_service.send_ephemeral_message(
slack_client,
incident.conversation.channel_id,
user_id,
"",
blocks=blocks)
once_a_day_cache[cache_key] = True
def create_update_participant_modal(
user_id: str,
user_email: str,
channel_id: str,
incident_id: int,
command: dict,
db_session=None,
slack_client=None,
):
"""Creates a modal for updating a participant."""
trigger_id = command["trigger_id"]
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
modal_create_template = update_participant(incident=incident)
open_modal_with_user(client=slack_client, trigger_id=trigger_id, modal=modal_create_template)
def send_incident_resources_ephemeral_message_to_participant(
user_id: str, incident_id: int, db_session: SessionLocal
):
"""Sends the list of incident resources to the participant via an ephemeral message."""
# we load the incident instance
plugin = plugin_service.get_active(db_session=db_session, plugin_type="conversation")
if not plugin:
log.warning("Incident resource message not sent, no conversation plugin enabled.")
return
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
message_kwargs = {
"commander_fullname": incident.commander.individual.name,
"commander_weblink": incident.commander.individual.weblink,
"document_weblink": resolve_attr(incident, "incident_document.weblink"),
"storage_weblink": resolve_attr(incident, "storage.weblink"),
"ticket_weblink": resolve_attr(incident, "ticket.weblink"),
"conference_weblink": resolve_attr(incident, "conference.weblink"),
"conference_challenge": resolve_attr(incident, "conference.conference_challenge"),
}
if incident.incident_review_document:
message_kwargs.update(
{"review_document_weblink": incident.incident_review_document.weblink}
)
faq_doc = document_service.get_incident_faq_document(db_session=db_session)
if faq_doc:
message_kwargs.update({"faq_weblink": faq_doc.weblink})
conversation_reference = document_service.get_conversation_reference_document(
db_session=db_session
)
if conversation_reference:
message_kwargs.update(
{"conversation_commands_reference_document_weblink": conversation_reference.weblink}
)
# we send the ephemeral message
plugin.instance.send_ephemeral(
incident.conversation.channel_id,
user_id,
"Incident Resources Message",
INCIDENT_RESOURCES_MESSAGE,
MessageType.incident_resources_message,
**message_kwargs,
)
log.debug(f"List of incident resources sent to {user_id} via ephemeral message.")
def send_welcome_ephemeral_message_to_participant(participant_email: str,
incident_id: int,
db_session: SessionLocal):
"""Sends an ephemeral message to the participant."""
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we send the ephemeral message
convo_plugin = plugins.get(INCIDENT_PLUGIN_CONVERSATION_SLUG)
message_kwargs = {
"name": incident.name,
"title": incident.title,
"status": incident.status,
"type": incident.incident_type.name,
"type_description": incident.incident_type.description,
"priority": incident.incident_priority.name,
"priority_description": incident.incident_priority.description,
"commander_fullname": incident.commander.name,
"commander_weblink": incident.commander.weblink,
"document_weblink": incident.incident_document.weblink,
"storage_weblink": incident.storage.weblink,
"ticket_weblink": incident.ticket.weblink,
"conference_weblink": incident.conference.weblink,
"conference_challenge": incident.conference.conference_challenge,
}
faq_doc = document_service.get_incident_faq_document(db_session=db_session)
if faq_doc:
message_kwargs.update({"faq_weblink": faq_doc.weblink})
conversation_reference = document_service.get_conversation_reference_document(
db_session=db_session)
if conversation_reference:
message_kwargs.update({
"conversation_commands_reference_document_weblink":
conversation_reference.weblink
})
convo_plugin.send_ephemeral(
incident.conversation.channel_id,
participant_email,
"Incident Welcome Message",
INCIDENT_PARTICIPANT_WELCOME_MESSAGE,
MessageType.incident_participant_welcome,
**message_kwargs,
)
log.debug(f"Welcome ephemeral message sent to {participant_email}.")
def create_add_timeline_event_modal(incident_id: int,
command: dict,
db_session=None):
"""Creates a modal for adding events to the incident timeline."""
trigger_id = command["trigger_id"]
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
modal_create_template = build_add_timeline_event_blocks(incident=incident)
dispatch_slack_service.open_modal_with_user(client=slack_client,
trigger_id=trigger_id,
modal=modal_create_template)
def create_update_participant_modal(incident_id: int,
command: dict,
db_session=None):
"""Creates a modal for updating a participant."""
trigger_id = command["trigger_id"]
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
modal_create_template = build_update_participant_blocks(incident=incident)
dispatch_slack_service.open_modal_with_user(client=slack_client,
trigger_id=trigger_id,
modal=modal_create_template)
def create_add_timeline_event_modal(
user_id: str,
user_email: str,
channel_id: str,
incident_id: int,
command: dict,
db_session=None,
slack_client=None,
):
"""Creates a modal for adding events to the incident timeline."""
trigger_id = command["trigger_id"]
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
modal_create_template = add_timeline_event(incident=incident)
open_modal_with_user(client=slack_client, trigger_id=trigger_id, modal=modal_create_template)
def has_required_permissions(
self,
request: Request,
) -> bool:
current_user = get_current_user(db_session=request.state.db,
request=request)
current_incident = incident_service.get(
db_session=request.state.db,
incident_id=request.path_params["incident_id"])
if not current_incident:
return False
if current_incident.commander.individual.email == current_user.email:
return True
def send_welcome_email_to_participant(participant_email: str, incident_id: int,
db_session: SessionLocal):
"""Sends a welcome email to the participant."""
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we get the incident documents
incident_document = get_document(
db_session=db_session,
incident_id=incident_id,
resource_type=INCIDENT_RESOURCE_INVESTIGATION_DOCUMENT,
)
incident_faq = get_document(db_session=db_session,
incident_id=incident_id,
resource_type=INCIDENT_RESOURCE_FAQ_DOCUMENT)
incident_conversation_commands_reference_document = get_document(
db_session=db_session,
incident_id=incident_id,
resource_type=
INCIDENT_RESOURCE_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT,
)
email_plugin = plugins.get(INCIDENT_PLUGIN_EMAIL_SLUG)
email_plugin.send(
participant_email,
INCIDENT_PARTICIPANT_WELCOME_MESSAGE,
MessageType.incident_participant_welcome,
name=incident.name,
title=incident.title,
status=incident.status,
type=incident.incident_type.name,
type_description=incident.incident_type.description,
priority=incident.incident_priority.name,
priority_description=incident.incident_priority.description,
commander_fullname=incident.commander.name,
commander_weblink=incident.commander.weblink,
document_weblink=incident_document.weblink,
storage_weblink=incident.storage.weblink,
ticket_weblink=incident.ticket.weblink,
faq_weblink=incident_faq.weblink,
conference_weblink=incident.conference.weblink,
conference_challenge=incident.conference.conference_challenge,
conversation_commands_reference_document_weblink=
incident_conversation_commands_reference_document.weblink,
)
log.debug(f"Welcome email sent to {participant_email}.")
def handle_reaction_added_event(
config: SlackConversationConfiguration,
user_id: str,
user_email: str,
channel_id: str,
incident_id: int,
event: EventEnvelope = None,
db_session=None,
slack_client=None,
):
"""Handles an event where a reaction is added to a message."""
reaction = event.event.reaction
if reaction == config.timeline_event_reaction:
conversation_id = event.event.item.channel
message_ts = event.event.item.ts
message_ts_utc = datetime.datetime.utcfromtimestamp(float(message_ts))
# we fetch the message information
response = dispatch_slack_service.list_conversation_messages(
slack_client,
conversation_id,
latest=message_ts,
limit=1,
inclusive=1)
message_text = response["messages"][0]["text"]
message_sender_id = response["messages"][0]["user"]
# we fetch the incident
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we fetch the individual who sent the message
message_sender_email = get_user_email(client=slack_client,
user_id=message_sender_id)
individual = individual_service.get_by_email_and_project(
db_session=db_session,
email=message_sender_email,
project_id=incident.project.id)
# we log the event
event_service.log(
db_session=db_session,
source="Slack Plugin - Conversation Management",
description=f'"{message_text}," said {individual.name}',
incident_id=incident_id,
individual_id=individual.id,
started_at=message_ts_utc,
)
def after_hours(
config: SlackConversationConfiguration,
user_id: str,
user_email: str,
channel_id: str,
incident_id: int,
event: EventEnvelope = None,
db_session=None,
slack_client=None,
):
"""Notifies the user that this incident is current in after hours mode."""
# we ignore user channel and group join messages
if event.event.subtype in ["channel_join", "group_join"]:
return
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# get their timezone from slack
commander_info = dispatch_slack_service.get_user_info_by_email(
slack_client, email=incident.commander.individual.email)
commander_tz = commander_info["tz"]
if not is_business_hours(commander_tz):
# send ephermal message
blocks = [{
"type": "section",
"text": {
"type":
"mrkdwn",
"text":
((f"Responses may be delayed. The current incident priority is *{incident.incident_priority.name}*"
f" and your message was sent outside of the Incident Commander's working hours (Weekdays, 9am-5pm, {commander_tz} timezone)."
)),
},
}]
participant = participant_service.get_by_incident_id_and_email(
db_session=db_session, incident_id=incident_id, email=user_email)
if not participant.after_hours_notification:
dispatch_slack_service.send_ephemeral_message(slack_client,
channel_id,
user_id,
"",
blocks=blocks)
participant.after_hours_notification = True
db_session.add(participant)
db_session.commit()
def create_update_notifications_group_modal(incident_id: int,
command: dict,
db_session=None):
"""Creates a modal for editing members of the notifications group."""
trigger_id = command["trigger_id"]
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
modal_create_template = build_update_notifications_group_blocks(
incident=incident, db_session=db_session)
dispatch_slack_service.open_modal_with_user(client=slack_client,
trigger_id=trigger_id,
modal=modal_create_template)
def add_user_to_conversation(
user_id: str, user_email: str, incident_id: int, action: dict, db_session=None
):
"""Adds a user to a conversation."""
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
if incident.status == IncidentStatus.closed:
message = f"Sorry, we cannot add you to a closed incident. Please reach out to the incident commander ({incident.commander.name}) for details."
dispatch_slack_service.send_ephemeral_message(
slack_client, action["container"]["channel_id"], user_id, message
)
else:
dispatch_slack_service.add_users_to_conversation(
slack_client, incident.conversation.channel_id, [user_id]
)
def list_workflows(
user_id: str,
user_email: str,
channel_id: str,
incident_id: int,
command: dict = None,
db_session=None,
slack_client=None,
):
"""Returns the list of incident workflows to the user as an ephemeral message."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
blocks = []
blocks.append({
"type": "section",
"text": {
"type": "mrkdwn",
"text": "*Incident Workflows*"
}
})
for w in incident.workflow_instances:
artifact_links = ""
for a in w.artifacts:
artifact_links += f"- <{a.weblink}|{a.name}> \n"
blocks.append({
"type": "section",
"text": {
"type":
"mrkdwn",
"text": (f"*Name:* <{w.weblink}|{w.workflow.name}>\n"
f"*Workflow Description:* {w.workflow.description}\n"
f"*Run Reason:* {w.run_reason}\n"
f"*Creator:* {w.creator.individual.name}\n"
f"*Status:* {w.status}\n"
f"*Artifacts:* \n {artifact_links}"),
},
})
blocks.append({"type": "divider"})
dispatch_slack_service.send_ephemeral_message(
slack_client,
channel_id,
user_id,
"Incident Workflow List",
blocks=blocks,
)
def send_incident_resources_ephemeral_message_to_participant(
user_id: str, incident_id: int, db_session: SessionLocal):
"""Sends the list of incident resources to the participant via an ephemeral message."""
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
message_kwargs = {
"commander_fullname": incident.commander.name,
"commander_weblink": incident.commander.weblink,
"document_weblink": incident.incident_document.weblink,
"storage_weblink": incident.storage.weblink,
"ticket_weblink": incident.ticket.weblink,
"conference_weblink": incident.conference.weblink,
"conference_challenge": incident.conference.conference_challenge,
}
if incident.incident_review_document:
message_kwargs.update({
"review_document_weblink":
incident.incident_review_document.weblink
})
faq_doc = document_service.get_incident_faq_document(db_session=db_session)
if faq_doc:
message_kwargs.update({"faq_weblink": faq_doc.weblink})
conversation_reference = document_service.get_conversation_reference_document(
db_session=db_session)
if conversation_reference:
message_kwargs.update({
"conversation_commands_reference_document_weblink":
conversation_reference.weblink
})
# we send the ephemeral message
convo_plugin = plugins.get(INCIDENT_PLUGIN_CONVERSATION_SLUG)
convo_plugin.send_ephemeral(
incident.conversation.channel_id,
user_id,
"Incident Resources Message",
INCIDENT_RESOURCES_MESSAGE,
MessageType.incident_resources_message,
**message_kwargs,
)
log.debug(
f"List of incident resources sent to {user_id} via ephemeral message.")
def reactivate_participant(user_email: str, incident_id: int,
db_session: SessionLocal):
"""Reactivates a participant."""
# We load the incident
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# We get information about the individual
contact_plugin = plugin_service.get_active(db_session=db_session,
plugin_type="contact")
individual_info = contact_plugin.instance.get(user_email)
individual_fullname = individual_info["fullname"]
log.debug(
f"Reactivating {individual_fullname} on incident {incident.name}...")
participant = get_by_incident_id_and_email(db_session=db_session,
incident_id=incident_id,
email=user_email)
if not participant:
log.debug(
f"{individual_fullname} is not an inactive participant of incident {incident.name}."
)
return False
# We mark the participant as active
participant.is_active = True
# We create a role for the participant
participant_role_in = ParticipantRoleCreate(
role=ParticipantRoleType.participant)
participant_role = participant_role_service.create(
db_session=db_session, participant_role_in=participant_role_in)
participant.participant_roles.append(participant_role)
# We add and commit the changes
db_session.add(participant)
db_session.commit()
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"{individual_fullname} reactivated",
incident_id=incident_id,
)
return True
def add_participant(
user_email: str,
incident_id: id,
db_session: SessionLocal,
service: Service = None,
role: ParticipantRoleType = None,
):
"""Adds a participant."""
# We load the incident
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# We get or create a new individual
individual = individual_service.get_or_create(db_session=db_session,
email=user_email)
# We create a role for the participant
participant_role_in = ParticipantRoleCreate(role=role)
participant_role = participant_role_service.create(
db_session=db_session, participant_role_in=participant_role_in)
# We get or create a new participant
participant = get_or_create(
db_session=db_session,
incident_id=incident.id,
individual_id=individual.id,
service=service,
participant_roles=[participant_role],
)
individual.participant.append(participant)
incident.participants.append(participant)
# We add and commit the changes
db_session.add(individual)
db_session.add(incident)
db_session.commit()
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=
f"{individual.name} added to incident with {participant_role.role} role",
incident_id=incident_id,
)
return participant
def remove_participant(user_email: str, incident_id: int,
db_session: SessionLocal):
"""Removes a participant."""
# We load the incident
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# We get information about the individual
contact_plugin = plugin_service.get_active(db_session=db_session,
plugin_type="contact")
individual_info = contact_plugin.instance.get(user_email)
individual_fullname = individual_info["fullname"]
log.debug(
f"Removing {individual_fullname} from incident {incident.name}...")
participant = get_by_incident_id_and_email(db_session=db_session,
incident_id=incident_id,
email=user_email)
if not participant:
log.debug(
f"Can't remove {individual_fullname}. They're not an active participant of incident {incident.name}."
)
return False
# We mark the participant as inactive
participant.is_active = False
# We make the participant renounce to their active roles
participant_active_roles = participant_role_service.get_all_active_roles(
db_session=db_session, participant_id=participant.id)
for participant_active_role in participant_active_roles:
participant_role_service.renounce_role(
db_session=db_session, participant_role=participant_active_role)
# We add and commit the changes
db_session.add(participant)
db_session.commit()
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"{participant.individual.name} removed from incident",
incident_id=incident_id,
)
return True
def incident_remove_participant_flow(
user_email: str, incident_id: int, event: dict = None, db_session=None
):
"""Runs the remove participant flow."""
# we load the incident instance
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
if user_email == incident.commander.email:
# we add the incident commander to the conversation again
add_participant_to_conversation(user_email, incident_id, db_session)
# we send a notification to the channel
send_incident_commander_readded_notification(incident_id, db_session)
else:
# we remove the participant from the incident
participant_flows.remove_participant(user_email, incident_id, db_session)
def create_rating_feedback_modal(user_id: str,
user_email: str,
incident_id: int,
action: dict,
db_session=None):
"""Creates a modal for rating and providing feedback about an incident."""
trigger_id = action["trigger_id"]
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
modal_create_template = build_rating_feedback_blocks(incident=incident)
dispatch_slack_service.open_modal_with_user(client=slack_client,
trigger_id=trigger_id,
modal=modal_create_template)
def incident_create_closed_flow(*, incident_id: int, checkpoint: str = None, db_session=None):
"""Creates all resources necessary when an incident is created as 'closed'."""
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
ticket = create_incident_ticket(incident, db_session)
if ticket:
incident.ticket = ticket_service.create(
db_session=db_session, ticket_in=TicketCreate(**ticket)
)
incident.name = ticket["resource_id"]
update_external_incident_ticket(incident, db_session)
db_session.add(incident)
db_session.commit()
return
def incident_engage_oncall_flow(user_id: str,
user_email: str,
incident_id: int,
action: dict,
db_session=None):
"""Runs the incident engage oncall flow."""
oncall_service_id = action["submission"]["oncall_service_id"]
page = action["submission"]["page"]
# we load the incident instance
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# we resolve the oncall service
oncall_service = service_service.get_by_external_id(
db_session=db_session, external_id=oncall_service_id)
oncall_plugin = plugins.get(oncall_service.type)
oncall_email = oncall_plugin.get(service_id=oncall_service_id)
# we add the oncall to the incident
incident_add_or_reactivate_participant_flow(oncall_email,
incident.id,
db_session=db_session)
# we load the individual
individual = individual_service.get_by_email(db_session=db_session,
email=user_email)
event_service.log(
db_session=db_session,
source=oncall_plugin.title,
description=
f"{individual.name} engages oncall service {oncall_service.name}",
incident_id=incident.id,
)
if page == "Yes":
# we page the oncall
oncall_plugin.page(oncall_service_id, incident.name, incident.title,
incident.description)
event_service.log(
db_session=db_session,
source=oncall_plugin.title,
description=f"{oncall_service.name} on-call paged",
incident_id=incident.id,
)
