slack ¤

def get_blocks(self) -> list[Block]:
    """Returns the blocks of the message.

    Returns:
        list[Block]: List of Slack Blocks for the message. Default is the text as a SectionBlock.
    """
    return [SectionBlock(text=self.get_text())]

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

@abstractmethod
def get_text(self) -> str:
    """Returns the text of the message."""
    raise NotImplementedError

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

def get_text(self) -> str:
    """Generate text with links to all available post-mortems."""
    parts = ["📔 The post-mortem has been created:"]

    # Add Confluence link if available
    if getattr(settings, "ENABLE_CONFLUENCE", False) and hasattr(self.incident, "postmortem_for"):
        parts.append(f"• Confluence: {self.incident.postmortem_for.page_url}")

    # Add Jira link if available
    if hasattr(self.incident, "jira_postmortem_for"):
        jira_pm = self.incident.jira_postmortem_for
        parts.append(f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})")

    return "\n".join(parts)

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

def get_text(self) -> str:
    """Generate announcement text for critical incidents channel."""
    return f"📔 Post-mortem created for {self.incident.priority} incident #{self.incident.id}: {self.incident.title}"

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

def get_metadata(self) -> Metadata:
    """The value of `event_type` should be an alphanumeric string, and human-readable. The value of this field may appear in the UI to developers, so keep this in mind when choosing a value. Developers should make an effort to name with the pattern <resource_name_singular> and <action_in_past_tense>
    See more https://api.slack.com/reference/metadata.

    Returns:
        Metadata: Slack Metadata for the message.
    """
    return Metadata(event_type=self.id, event_payload={"ff_type": self.id})

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

@slack_client
def post_message(
    self,
    conversation_id: str,
    client: WebClient = DefaultWebClient,
    **kwargs: Never,
) -> SlackResponse:
    """Deprecated. Only use for Global Channel, until the global channel is set in DB."""
    return client.chat_postMessage(
        channel=conversation_id,
        **self.get_slack_message_params(),
    )

@slack_client
def add_bookmark(
    self,
    title: str,
    _type: str = "link",
    emoji: str | None = None,
    entity_id: str | None = None,
    link: str | None = None,  # include when type is 'link'
    parent_id: str | None = None,
    client: WebClient = DefaultWebClient,
    **kwargs: Any,
) -> None:
    """Convenience method to add a bookmark on this conversation."""
    client.bookmarks_add(
        channel_id=self.channel_id,
        title=title,
        link=link,
        emoji=emoji,
        type=_type,
        entity_id=entity_id,
        parent_id=parent_id,
        **kwargs,
    )

@slack_client
def send_message(
    self,
    text: str | None = None,
    blocks: Sequence[dict[str, Any] | Block] | None = None,
    client: WebClient = DefaultWebClient,
    **kwargs: Any,
) -> None:
    """Convenience method to send a message on this conversation."""
    if kwargs.get("channel"):
        raise ValueError(
            "You can't set the channel when using send_message on a conversation!"
        )

    client.chat_postMessage(
        channel=self.channel_id, text=text, blocks=blocks, **kwargs
    )

@slack_client
def send_message_and_save(
    self,
    message: SlackMessageSurface,
    client: WebClient = DefaultWebClient,
    strategy: SlackMessageStrategy | None = None,
    strategy_args: dict[str, Any] | None = None,
    *,
    pin: bool = False,
) -> SlackResponse:
    """Convenience method to send a message on this conversation."""
    if strategy is None:
        strategy = message.strategy

    kwargs = {}
    # XXX Get save context?
    if hasattr(message, "incident"):
        kwargs["incident"] = message.incident
    if hasattr(message, "incident_update"):
        kwargs["incident_update"] = message.incident_update
    kwargs["ff_type"] = message.id
    if strategy == SlackMessageStrategy.APPEND:
        strategy_res = self._send_message_strategy_append(message, client, kwargs)
    elif strategy == SlackMessageStrategy.UPDATE:
        strategy_res = self._send_message_strategy_update(
            message, client, kwargs, strategy_args
        )
    elif strategy == SlackMessageStrategy.REPLACE:
        strategy_res = self._send_message_strategy_replace(
            message, client, strategy_args, kwargs
        )
    if pin:
        self._pin_message(
            res=strategy_res,
            client=client,
        )
    return strategy_res

@slack_client
def send_message_ephemeral(
    self,
    message: SlackMessageSurface,
    user: SlackUser | str,
    client: WebClient = DefaultWebClient,
    **kwargs: Any,
) -> None:
    """Convenience method to send an ephemeral message on this conversation.
    `user`, `channel`, `blocks`, `text` and `metadata` should not be passed in kwargs.
    """
    user_id = user.slack_id if isinstance(user, SlackUser) else user

    client.chat_postEphemeral(
        user=user_id,
        channel=self.channel_id,
        **(kwargs | message.get_slack_message_params()),
    )

@slack_client
def add_bookmark(
    self,
    title: str,
    _type: str = "link",
    emoji: str | None = None,
    entity_id: str | None = None,
    link: str | None = None,  # include when type is 'link'
    parent_id: str | None = None,
    client: WebClient = DefaultWebClient,
    **kwargs: Any,
) -> None:
    """Convenience method to add a bookmark on this conversation."""
    client.bookmarks_add(
        channel_id=self.channel_id,
        title=title,
        link=link,
        emoji=emoji,
        type=_type,
        entity_id=entity_id,
        parent_id=parent_id,
        **kwargs,
    )

@slack_client
def invite_users(
    self, users_mapped: list[User], client: WebClient = DefaultWebClient
) -> None:
    """Invite users to the conversation, if they have a Slack user linked and are active.

    Try to invite all users as batch, but if some fail, continue individually.
    """
    users_with_slack: list[User] = self._get_active_slack_users(users_mapped)
    users_with_slack = list(set(users_with_slack))  # Remove duplicates

    user_id_list: set[str] = self._get_slack_id_list(users_with_slack)
    if not user_id_list:
        logger.info(f"No users to invite to the conversation {self}.")
        return

    logger.info(f"Inviting users with SlackIDs: {user_id_list}")

    invited_slack_user_ids = self._invite_users_to_conversation(
        user_id_list, client
    )
    invited_users = {
        u
        for u in users_with_slack
        if u.slack_user and u.slack_user.slack_id in invited_slack_user_ids
    }

    if invited_slack_user_ids != set(user_id_list):
        logger.warning(
            f"Could not invite all users to the conversation {self}. Missing users: {user_id_list - invited_slack_user_ids}"
        )

    self.incident.members.add(*invited_users)

@slack_client
def send_message(
    self,
    text: str | None = None,
    blocks: Sequence[dict[str, Any] | Block] | None = None,
    client: WebClient = DefaultWebClient,
    **kwargs: Any,
) -> None:
    """Convenience method to send a message on this conversation."""
    if kwargs.get("channel"):
        raise ValueError(
            "You can't set the channel when using send_message on a conversation!"
        )

    client.chat_postMessage(
        channel=self.channel_id, text=text, blocks=blocks, **kwargs
    )

@slack_client
def send_message_and_save(
    self,
    message: SlackMessageSurface,
    client: WebClient = DefaultWebClient,
    strategy: SlackMessageStrategy | None = None,
    strategy_args: dict[str, Any] | None = None,
    *,
    pin: bool = False,
) -> SlackResponse:
    """Convenience method to send a message on this conversation."""
    if strategy is None:
        strategy = message.strategy

    kwargs = {}
    # XXX Get save context?
    if hasattr(message, "incident"):
        kwargs["incident"] = message.incident
    if hasattr(message, "incident_update"):
        kwargs["incident_update"] = message.incident_update
    kwargs["ff_type"] = message.id
    if strategy == SlackMessageStrategy.APPEND:
        strategy_res = self._send_message_strategy_append(message, client, kwargs)
    elif strategy == SlackMessageStrategy.UPDATE:
        strategy_res = self._send_message_strategy_update(
            message, client, kwargs, strategy_args
        )
    elif strategy == SlackMessageStrategy.REPLACE:
        strategy_res = self._send_message_strategy_replace(
            message, client, strategy_args, kwargs
        )
    if pin:
        self._pin_message(
            res=strategy_res,
            client=client,
        )
    return strategy_res