def test_create(session, incident_type, incident_priority, individual_contact):
from dispatch.ticket.service import create
from dispatch.ticket.models import TicketCreate
resource_id = "XXX"
resource_type = "XXX"
weblink = "https://example.com/"
ticket_in = TicketCreate(resource_id=resource_id,
resource_type=resource_type,
weblink=weblink)
ticket = create(db_session=session, ticket_in=ticket_in)
assert ticket
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_create_flow(*, incident_id: int, checkpoint: str = None, db_session=None):
"""Creates all resources required for new incidents."""
incident = incident_service.get(db_session=db_session, incident_id=incident_id)
# create the incident ticket
ticket = create_incident_ticket(incident, db_session)
if ticket:
incident.ticket = ticket_service.create(
db_session=db_session, ticket_in=TicketCreate(**ticket)
)
# we set the incident name
incident.name = ticket["resource_id"]
# get the incident participants based on incident type and priority
individual_participants, team_participants = get_incident_participants(incident, db_session)
# add individuals to incident
for individual in individual_participants:
participant_flows.add_participant(
user_email=individual.email, incident_id=incident.id, db_session=db_session
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident participants added to incident",
incident_id=incident.id,
)
# we create the participant groups (tactical and notification)
individual_participants = [x.individual for x in incident.participants]
participant_emails = [x.individual.email for x in incident.participants]
group_plugin = plugin_service.get_active(db_session=db_session, plugin_type="participant-group")
tactical_group = None
notification_group = None
if group_plugin:
try:
tactical_group, notification_group = create_participant_groups(
incident, individual_participants, team_participants, db_session
)
for g in [tactical_group, notification_group]:
group_in = GroupCreate(
name=g["name"],
email=g["email"],
resource_type=g["resource_type"],
resource_id=g["resource_id"],
weblink=g["weblink"],
)
incident.groups.append(
group_service.create(db_session=db_session, group_in=group_in)
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Tactical and notification groups added to incident",
incident_id=incident.id,
)
except Exception as e:
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"Creation of tactical and notification groups failed. Reason: {e}",
incident_id=incident.id,
)
log.exception(e)
storage_plugin = plugin_service.get_active(db_session=db_session, plugin_type="storage")
if storage_plugin:
# we create storage resource
if group_plugin:
storage = create_incident_storage(
incident, [tactical_group["email"], notification_group["email"]], db_session
)
else:
# we don't have a group so add participants directly
storage = create_incident_storage(incident, participant_emails, db_session)
incident.storage = storage_service.create(
db_session=db_session,
resource_id=storage["resource_id"],
resource_type=storage["resource_type"],
weblink=storage["weblink"],
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Storage added to incident",
incident_id=incident.id,
)
# we create collaboration documents, don't fail the whole flow if this fails
try:
collab_documents = create_collaboration_documents(incident, db_session)
for d in collab_documents:
document_in = DocumentCreate(
name=d["name"],
resource_id=d["resource_id"],
resource_type=d["resource_type"],
weblink=d["weblink"],
)
incident.documents.append(
document_service.create(db_session=db_session, document_in=document_in)
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Documents added to incident",
incident_id=incident.id,
)
except Exception as e:
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"Creation of incident documents failed. Reason: {e}",
incident_id=incident.id,
)
log.exception(e)
conference_plugin = plugin_service.get_active(db_session=db_session, plugin_type="conference")
if conference_plugin:
try:
participants = participant_emails
if group_plugin:
# we use the tactical group email if the group plugin is enabled
participants = [tactical_group["email"]]
conference = create_conference(incident, participants, db_session)
conference_in = ConferenceCreate(
resource_id=conference["resource_id"],
resource_type=conference["resource_type"],
weblink=conference["weblink"],
conference_id=conference["id"],
conference_challenge=conference["challenge"],
)
incident.conference = conference_service.create(
db_session=db_session, conference_in=conference_in
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conference added to incident",
incident_id=incident.id,
)
except Exception as e:
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"Creation of incident conference failed. Reason: {e}",
incident_id=incident.id,
)
log.exception(e)
# we create the conversation for real-time communications
conversation_plugin = plugin_service.get_active(
db_session=db_session, plugin_type="conversation"
)
if conversation_plugin:
try:
conversation = create_conversation(incident, participant_emails, db_session)
conversation_in = ConversationCreate(
resource_id=conversation["resource_id"],
resource_type=conversation["resource_type"],
weblink=conversation["weblink"],
channel_id=conversation["id"],
)
incident.conversation = conversation_service.create(
db_session=db_session, conversation_in=conversation_in
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conversation added to incident",
incident_id=incident.id,
)
# we set the conversation topic
set_conversation_topic(incident, db_session)
except Exception as e:
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"Creation of incident conversation failed. Reason: {e}",
incident_id=incident.id,
)
log.exception(e)
db_session.add(incident)
db_session.commit()
# we update the incident ticket
update_external_incident_ticket(incident, db_session)
# we update the investigation document
document_plugin = plugin_service.get_active(db_session=db_session, plugin_type="document")
if document_plugin:
if incident.incident_document:
try:
document_plugin.instance.update(
incident.incident_document.resource_id,
name=incident.name,
priority=incident.incident_priority.name,
status=incident.status,
type=incident.incident_type.name,
title=incident.title,
description=incident.description,
commander_fullname=incident.commander.name,
conversation_weblink=resolve_attr(incident, "conversation.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.challendge"),
)
except Exception as e:
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description=f"Incident documents rendering failed. Reason: {e}",
incident_id=incident.id,
)
log.exception(e)
if incident.visibility == Visibility.open:
send_incident_notifications(incident, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident notifications sent",
incident_id=incident.id,
)
suggested_document_items = get_suggested_document_items(incident.id, db_session)
for participant in incident.participants:
# we announce the participant in the conversation
# should protect ourselves from failures of any one participant
try:
send_incident_participant_announcement_message(
participant.individual.email, incident.id, db_session
)
# we send the welcome messages to the participant
send_incident_welcome_participant_messages(
participant.individual.email, incident.id, db_session
)
send_incident_suggested_reading_messages(
incident.id, suggested_document_items, participant.individual.email, db_session
)
except Exception as e:
log.exception(e)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Participants announced and welcome messages sent",
incident_id=incident.id,
)
def incident_create_flow(*,
incident_id: int,
checkpoint: str = None,
db_session=None):
"""Creates all resources required for new incidents."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# get the incident participants based on incident type and priority
individual_participants, team_participants = get_incident_participants(
incident, db_session)
# add individuals to incident
for individual in individual_participants:
participant_flows.add_participant(user_email=individual.email,
incident_id=incident.id,
db_session=db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident participants added to incident",
incident_id=incident.id,
)
# create the incident ticket
ticket = create_incident_ticket(incident, db_session)
incident.ticket = ticket_service.create(db_session=db_session,
ticket_in=TicketCreate(**ticket))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="External ticket added to incident",
incident_id=incident.id,
)
# we set the incident name
name = ticket["resource_id"]
incident.name = name
# we create the participant groups (tactical and notification)
individual_participants = [x.individual for x in incident.participants]
tactical_group, notification_group = create_participant_groups(
incident, individual_participants, team_participants, db_session)
for g in [tactical_group, notification_group]:
group_in = GroupCreate(
name=g["name"],
email=g["email"],
resource_type=g["resource_type"],
resource_id=g["resource_id"],
weblink=g["weblink"],
)
incident.groups.append(
group_service.create(db_session=db_session, group_in=group_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Tactical and notification groups added to incident",
incident_id=incident.id,
)
# we create storage resource
storage = create_incident_storage(
incident, [tactical_group["email"], notification_group["email"]],
db_session)
incident.storage = storage_service.create(
db_session=db_session,
resource_id=storage["resource_id"],
resource_type=storage["resource_type"],
weblink=storage["weblink"],
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Storage added to incident",
incident_id=incident.id,
)
# we create the incident documents
incident_document, incident_sheet = create_collaboration_documents(
incident, db_session)
# TODO: we need to delineate between the investigation document and suggested documents
# # get any additional documentation based on priority or terms
# incident_documents = get_incident_documents(
# db_session, incident.incident_type, incident.incident_priority, incident.description
# )
#
# incident.documents = incident_documents
faq_document = {
"name": "Incident FAQ",
"resource_id": INCIDENT_FAQ_DOCUMENT_ID,
"weblink":
f"https://docs.google.com/document/d/{INCIDENT_FAQ_DOCUMENT_ID}",
"resource_type": INCIDENT_RESOURCE_FAQ_DOCUMENT,
}
conversation_commands_reference_document = {
"name":
"Incident Conversation Commands Reference Document",
"resource_id":
INCIDENT_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT_ID,
"weblink":
f"https://docs.google.com/document/d/{INCIDENT_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT_ID}",
"resource_type":
INCIDENT_RESOURCE_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT,
}
for d in [
incident_document,
incident_sheet,
faq_document,
conversation_commands_reference_document,
]:
document_in = DocumentCreate(
name=d["name"],
resource_id=d["resource_id"],
resource_type=d["resource_type"],
weblink=d["weblink"],
)
incident.documents.append(
document_service.create(db_session=db_session,
document_in=document_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Documents added to incident",
incident_id=incident.id,
)
conference = create_conference(incident, [tactical_group["email"]],
db_session)
conference_in = ConferenceCreate(
resource_id=conference["resource_id"],
resource_type=conference["resource_type"],
weblink=conference["weblink"],
conference_id=conference["id"],
conference_challenge=conference["challenge"],
)
incident.conference = conference_service.create(
db_session=db_session, conference_in=conference_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conference added to incident",
incident_id=incident.id,
)
# we create the conversation for real-time communications
participant_emails = [x.individual.email for x in incident.participants]
conversation = create_conversation(incident, participant_emails,
db_session)
conversation_in = ConversationCreate(
resource_id=conversation["resource_id"],
resource_type=conversation["resource_type"],
weblink=conversation["weblink"],
channel_id=conversation["id"],
)
incident.conversation = conversation_service.create(
db_session=db_session, conversation_in=conversation_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conversation added to incident",
incident_id=incident.id,
)
db_session.add(incident)
db_session.commit()
# we set the conversation topic
set_conversation_topic(incident)
# we update the incident ticket
update_incident_ticket(
incident.ticket.resource_id,
title=incident.title,
description=incident.description,
incident_type=incident.incident_type.name,
priority=incident.incident_priority.name,
status=incident.status,
commander_email=incident.commander.email,
reporter_email=incident.reporter.email,
conversation_weblink=incident.conversation.weblink,
document_weblink=incident_document["weblink"],
storage_weblink=incident.storage.weblink,
conference_weblink=incident.conference.weblink,
visibility=incident.visibility,
)
# we update the investigation document
update_document(
incident_document["id"],
incident.name,
incident.incident_priority.name,
incident.status,
incident.incident_type.name,
incident.title,
incident.description,
incident.commander.name,
incident.conversation.weblink,
incident_document["weblink"],
incident.storage.weblink,
incident.ticket.weblink,
incident.conference.weblink,
incident.conference.conference_challenge,
)
for participant in incident.participants:
# we announce the participant in the conversation
send_incident_participant_announcement_message(
participant.individual.email, incident.id, db_session)
# we send the welcome messages to the participant
send_incident_welcome_participant_messages(
participant.individual.email, incident.id, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Participants announced and welcome messages sent",
incident_id=incident.id,
)
if incident.visibility == Visibility.open:
send_incident_notifications(incident, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident notifications sent",
incident_id=incident.id,
)
def incident_create_flow(*,
incident_id: int,
checkpoint: str = None,
db_session=None):
"""Creates all resources required for new incidents."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# get the incident participants based on incident type and priority
individual_participants, team_participants = get_incident_participants(
db_session, incident.incident_type, incident.incident_priority,
incident.description)
# add individuals to incident
for individual in individual_participants:
participant_flows.add_participant(db_session=db_session,
user_email=individual.email,
incident_id=incident.id)
log.debug(f"Added {len(individual_participants)} to incident.")
# create the incident ticket
ticket = create_incident_ticket(
incident.title,
incident.incident_type.name,
incident.incident_priority.name,
incident.commander.email,
incident.reporter.email,
)
incident.ticket = ticket_service.create(db_session=db_session,
ticket_in=TicketCreate(**ticket))
log.debug("Added ticket to incident.")
# we set the incident name
name = ticket["resource_id"]
incident.name = name
log.debug("Added name to incident.")
# we create the participant groups (tactical and notification)
tactical_group, notification_group = create_participant_groups(
name, team_participants, [x.individual for x in incident.participants])
for g in [tactical_group, notification_group]:
group = group_service.create(
db_session=db_session,
name=g["name"],
email=g["email"],
resource_type=g["resource_type"],
resource_id=g["resource_id"],
weblink=g["weblink"],
)
incident.groups.append(group)
log.debug("Added groups to incident.")
# we create storage resource
storage = create_incident_storage(
name, [tactical_group["email"], notification_group["email"]])
incident.storage = storage_service.create(
db_session=db_session,
resource_id=storage["resource_id"],
resource_type=storage["resource_type"],
weblink=storage["weblink"],
)
# we create the incident documents
incident_document, incident_sheet = create_collaboration_documents(
incident.name,
incident.incident_type.name,
incident.storage.resource_id,
incident.incident_type.template_document.resource_id,
)
# TODO: we need to delineate between the investigation document and suggested documents
# # get any additional documentation based on priority or terms
# incident_documents = get_incident_documents(
# db_session, incident.incident_type, incident.incident_priority, incident.description
# )
#
# incident.documents = incident_documents
faq_document = {
"name": "Incident FAQ",
"resource_id": INCIDENT_FAQ_DOCUMENT_ID,
"weblink":
f"https://docs.google.com/document/d/{INCIDENT_FAQ_DOCUMENT_ID}",
"resource_type": INCIDENT_RESOURCE_FAQ_DOCUMENT,
}
for d in [incident_document, incident_sheet, faq_document]:
document_in = DocumentCreate(
name=d["name"],
resource_id=d["resource_id"],
resource_type=d["resource_type"],
weblink=d["weblink"],
)
incident.documents.append(
document_service.create(db_session=db_session,
document_in=document_in))
log.debug("Added documents to incident.")
# we create the conversation for real-time communications
conversation = create_conversation(
incident, [x.individual.email for x in incident.participants])
log.debug("Conversation created. Participants and bots added.")
incident.conversation = conversation_service.create(
db_session=db_session,
resource_id=conversation["resource_id"],
resource_type=conversation["resource_type"],
weblink=conversation["weblink"],
channel_id=conversation["id"],
)
db_session.add(incident)
db_session.commit()
log.debug("Added conversation to incident.")
# we set the conversation topic
set_conversation_topic(incident)
update_incident_ticket(
incident.ticket.resource_id,
incident.title,
incident.description,
incident.incident_type.name,
incident.incident_priority.name,
incident.status,
incident.commander.email,
incident.reporter.email,
incident.conversation.weblink,
incident_document["weblink"],
incident.storage.weblink,
)
log.debug("Updated incident ticket.")
update_document(
incident_document["id"],
incident.name,
incident.incident_priority.name,
incident.status,
incident.title,
incident.description,
incident.commander.name,
incident.conversation.weblink,
incident_document["weblink"],
incident.storage.weblink,
incident.ticket.weblink,
)
log.debug("Updated incident document.")
for participant in incident.participants:
# we announce the participant in the conversation
send_incident_participant_announcement_message(
participant.individual.email, incident, db_session)
# we send the welcome messages to the participant
send_incident_welcome_participant_messages(
participant.individual.email, incident, db_session)
log.debug("Sent incident welcome and announcement notifications.")
send_incident_notifications(incident, db_session)
log.debug("Sent incident notifications.")
def incident_create_flow(*,
incident_id: int,
checkpoint: str = None,
db_session=None):
"""Creates all resources required for new incidents."""
incident = incident_service.get(db_session=db_session,
incident_id=incident_id)
# get the incident participants based on incident type and priority
individual_participants, team_participants = get_incident_participants(
incident, db_session)
# add individuals to incident
for individual in individual_participants:
participant_flows.add_participant(user_email=individual.email,
incident_id=incident.id,
db_session=db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident participants added to incident",
incident_id=incident.id,
)
# create the incident ticket
ticket = create_incident_ticket(incident, db_session)
incident.ticket = ticket_service.create(db_session=db_session,
ticket_in=TicketCreate(**ticket))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="External ticket added to incident",
incident_id=incident.id,
)
# we set the incident name
name = ticket["resource_id"]
incident.name = name
# we create the participant groups (tactical and notification)
individual_participants = [x.individual for x in incident.participants]
tactical_group, notification_group = create_participant_groups(
incident, individual_participants, team_participants, db_session)
for g in [tactical_group, notification_group]:
group_in = GroupCreate(
name=g["name"],
email=g["email"],
resource_type=g["resource_type"],
resource_id=g["resource_id"],
weblink=g["weblink"],
)
incident.groups.append(
group_service.create(db_session=db_session, group_in=group_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Tactical and notification groups added to incident",
incident_id=incident.id,
)
# we create storage resource
storage = create_incident_storage(
incident, [tactical_group["email"], notification_group["email"]],
db_session)
incident.storage = storage_service.create(
db_session=db_session,
resource_id=storage["resource_id"],
resource_type=storage["resource_type"],
weblink=storage["weblink"],
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Storage added to incident",
incident_id=incident.id,
)
# we create the incident documents
collab_documents = create_collaboration_documents(incident, db_session)
for d in collab_documents:
document_in = DocumentCreate(
name=d["name"],
resource_id=d["resource_id"],
resource_type=d["resource_type"],
weblink=d["weblink"],
)
incident.documents.append(
document_service.create(db_session=db_session,
document_in=document_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Documents added to incident",
incident_id=incident.id,
)
conference = create_conference(incident, [tactical_group["email"]],
db_session)
conference_in = ConferenceCreate(
resource_id=conference["resource_id"],
resource_type=conference["resource_type"],
weblink=conference["weblink"],
conference_id=conference["id"],
conference_challenge=conference["challenge"],
)
incident.conference = conference_service.create(
db_session=db_session, conference_in=conference_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conference added to incident",
incident_id=incident.id,
)
# we create the conversation for real-time communications
participant_emails = [x.individual.email for x in incident.participants]
conversation = create_conversation(incident, participant_emails,
db_session)
conversation_in = ConversationCreate(
resource_id=conversation["resource_id"],
resource_type=conversation["resource_type"],
weblink=conversation["weblink"],
channel_id=conversation["id"],
)
incident.conversation = conversation_service.create(
db_session=db_session, conversation_in=conversation_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conversation added to incident",
incident_id=incident.id,
)
db_session.add(incident)
db_session.commit()
# we set the conversation topic
set_conversation_topic(incident)
# we update the incident ticket
update_external_incident_ticket(incident, db_session)
# we update the investigation document
update_document(
incident.incident_document.resource_id,
incident.name,
incident.incident_priority.name,
incident.status,
incident.incident_type.name,
incident.title,
incident.description,
incident.commander.name,
incident.conversation.weblink,
incident.incident_document.weblink,
incident.storage.weblink,
incident.ticket.weblink,
incident.conference.weblink,
incident.conference.conference_challenge,
)
if incident.visibility == Visibility.open:
send_incident_notifications(incident, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Incident notifications sent",
incident_id=incident.id,
)
suggested_document_items = get_suggested_document_items(
incident, db_session)
for participant in incident.participants:
# we announce the participant in the conversation
# should protect ourselves from failures of any one participant
try:
send_incident_participant_announcement_message(
participant.individual.email, incident.id, db_session)
# we send the welcome messages to the participant
send_incident_welcome_participant_messages(
participant.individual.email, incident.id, db_session)
send_incident_suggested_reading_messages(incident,
suggested_document_items,
participant.email)
except Exception as e:
log.exception(e)
sentry_sdk.capture_exception(e)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Participants announced and welcome messages sent",
incident_id=incident.id,
)
def job_create_flow(*, job_id: int, checkpoint: str = None, db_session=None):
"""Creates all resources required for new jobs."""
job = job_service.get(db_session=db_session, job_id=job_id)
# get the job participants based on job type and priority
worker_participants, team_participants = get_job_participants(
job, db_session)
# add workers to job
for worker in worker_participants:
participant_flows.add_participant(user_code=worker.code,
job_id=job.id,
db_session=db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Job participants added to job",
job_id=job.id,
)
# create the job ticket
ticket = create_job_ticket(job, db_session)
job.ticket = ticket_service.create(db_session=db_session,
ticket_in=TicketCreate(**ticket))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="External ticket added to job",
job_id=job.id,
)
# we set the job name
name = ticket["resource_id"]
job.name = name
# we create the participant groups (tactical and notification)
try:
worker_participants = [x.worker for x in job.participants]
tactical_group, notification_group = create_participant_groups(
job, worker_participants, team_participants, db_session)
for g in [tactical_group, notification_group]:
group_in = GroupCreate(
name=g["name"],
code=g["email"],
resource_type=g["resource_type"],
resource_id=g["resource_id"],
weblink=g["weblink"],
)
job.groups.append(
group_service.create(db_session=db_session, group_in=group_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Tactical and notification groups added to job",
job_id=job.id,
)
# we create storage resource
storage = create_job_storage(
job, [tactical_group["email"], notification_group["email"]],
db_session)
job.storage = storage_service.create(
db_session=db_session,
resource_id=storage["resource_id"],
resource_type=storage["resource_type"],
weblink=storage["weblink"],
)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Storage added to job",
job_id=job.id,
)
# we create the job documents
job_document, job_sheet = create_collaboration_documents(
job, db_session)
faq_document = {
"name": "Job FAQ",
"resource_id": INCIDENT_FAQ_DOCUMENT_ID,
"weblink":
f"https://docs.google.com/document/d/{INCIDENT_FAQ_DOCUMENT_ID}",
"resource_type": INCIDENT_RESOURCE_FAQ_DOCUMENT,
}
conversation_commands_reference_document = {
"name":
"Job Conversation Commands Reference Document",
"resource_id":
INCIDENT_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT_ID,
"weblink":
f"https://docs.google.com/document/d/{INCIDENT_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT_ID}",
"resource_type":
INCIDENT_RESOURCE_CONVERSATION_COMMANDS_REFERENCE_DOCUMENT,
}
for d in [
job_document,
job_sheet,
faq_document,
conversation_commands_reference_document,
]:
document_in = DocumentCreate(
name=d["name"],
resource_id=d["resource_id"],
resource_type=d["resource_type"],
weblink=d["weblink"],
)
job.documents.append(
document_service.create(db_session=db_session,
document_in=document_in))
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Documents added to job",
job_id=job.id,
)
conference = create_conference(job, [tactical_group["email"]],
db_session)
conference_in = ConferenceCreate(
resource_id=conference["resource_id"],
resource_type=conference["resource_type"],
weblink=conference["weblink"],
conference_id=conference["id"],
conference_challenge=conference["challenge"],
)
job.conference = conference_service.create(db_session=db_session,
conference_in=conference_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conference added to job",
job_id=job.id,
)
# we create the conversation for real-time communications
participant_emails = [x.worker.code for x in job.participants]
conversation = create_conversation(job, participant_emails, db_session)
conversation_in = ConversationCreate(
resource_id=conversation["resource_id"],
resource_type=conversation["resource_type"],
weblink=conversation["weblink"],
channel_id=conversation["id"],
)
job.conversation = conversation_service.create(
db_session=db_session, conversation_in=conversation_in)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Conversation added to job",
job_id=job.id,
)
except Exception as e:
log.warn("failed to create ... , job_id ={}".format(job_id), e)
db_session.add(job)
db_session.commit()
try:
# we set the conversation topic
set_conversation_topic(job)
# we update the job ticket
update_external_job_ticket(job, db_session)
# we update the investigation document
update_document(
job_document["id"],
job.name,
job.job_priority.name,
job.planning_status,
job.job_type.name,
job.job_code,
job.description,
job.commander.name,
job.conversation.weblink,
job_document["weblink"],
job.storage.weblink,
job.ticket.weblink,
job.conference.weblink,
job.conference.conference_challenge,
)
for participant in job.participants:
# we announce the participant in the conversation
send_job_participant_announcement_message(participant.worker.code,
job.id, db_session)
# we send the welcome messages to the participant
send_job_welcome_participant_messages(participant.worker.code,
job.id, db_session)
send_job_suggested_reading_messages(participant.worker.code,
job.id, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Participants announced and welcome messages sent",
job_id=job.id,
)
if job.visibility == Visibility.open:
send_job_notifications(job, db_session)
event_service.log(
db_session=db_session,
source="Dispatch Core App",
description="Job notifications sent",
job_id=job.id,
)
except Exception as e:
log.warn("failed to create more ... , job_id ={}".format(job_id), e)
