147 lines
5.3 KiB
Python
147 lines
5.3 KiB
Python
from typing import Annotated, Any, cast
|
|
|
|
from arcade.sdk import ToolContext, tool
|
|
from arcade.sdk.auth import Atlassian
|
|
from arcade.sdk.errors import ToolExecutionError
|
|
|
|
import arcade_jira.cache as cache
|
|
from arcade_jira.client import JiraClient
|
|
from arcade_jira.exceptions import NotFoundError
|
|
from arcade_jira.utils import build_file_data, clean_attachment_dict
|
|
|
|
|
|
@tool(requires_auth=Atlassian(scopes=["write:jira-work"]))
|
|
async def attach_file_to_issue(
|
|
context: ToolContext,
|
|
issue: Annotated[str, "The issue ID or key to add the attachment to"],
|
|
filename: Annotated[
|
|
str,
|
|
"The name of the file to add as an attachment. The filename should contain the "
|
|
"file extension (e.g. 'test.txt', 'report.pdf'), but it is not mandatory.",
|
|
],
|
|
file_content_str: Annotated[
|
|
str | None,
|
|
"The string content of the file to attach. Use this if the file is a text file. "
|
|
"Defaults to None.",
|
|
] = None,
|
|
file_content_base64: Annotated[
|
|
str | None,
|
|
"The base64-encoded binary contents of the file. "
|
|
"Use this for binary files like images or PDFs. Defaults to None.",
|
|
] = None,
|
|
file_encoding: Annotated[
|
|
str,
|
|
"The encoding of the file to attach. Only used with file_content_str. Defaults to 'utf-8'.",
|
|
] = "utf-8",
|
|
file_type: Annotated[
|
|
str | None,
|
|
"The type of the file to attach. E.g. 'application/pdf', 'text', 'image/png'. "
|
|
"If not provided, the tool will try to infer the type from the filename. "
|
|
"If the filename is not recognized, it will attach the file without specifying a type. "
|
|
"Defaults to None (infer from filename or attach without type).",
|
|
] = None,
|
|
) -> Annotated[dict[str, Any], "Metadata about the attachment"]:
|
|
"""Add an attachment to an issue.
|
|
|
|
Must provide exactly one of file_content_str or file_content_base64.
|
|
"""
|
|
file_contents = [file_content_str, file_content_base64]
|
|
|
|
if not any(file_contents) or all(file_contents):
|
|
raise ToolExecutionError(
|
|
"Must provide exactly one of file_content_str or file_content_base64."
|
|
)
|
|
|
|
if not filename:
|
|
raise ToolExecutionError("Must provide a filename.")
|
|
|
|
client = JiraClient(context.get_auth_token_or_empty())
|
|
|
|
response = await client.post(
|
|
f"/issue/{issue}/attachments",
|
|
headers={
|
|
"X-Atlassian-Token": "no-check",
|
|
},
|
|
files=build_file_data(
|
|
filename=filename,
|
|
file_content_str=file_content_str,
|
|
file_content_base64=file_content_base64,
|
|
file_type=file_type,
|
|
file_encoding=file_encoding,
|
|
),
|
|
)
|
|
cloud_name = cache.get_cloud_name(context.get_auth_token_or_empty())
|
|
return {
|
|
"status": {
|
|
"success": True,
|
|
"message": f"Attachment '{filename}' successfully added to the issue '{issue}'",
|
|
},
|
|
"attachment": clean_attachment_dict(response[0], cloud_name),
|
|
}
|
|
|
|
|
|
@tool(requires_auth=Atlassian(scopes=["read:jira-work"]))
|
|
async def list_issue_attachments_metadata(
|
|
context: ToolContext,
|
|
issue: Annotated[str, "The ID or key of the issue to retrieve"],
|
|
) -> Annotated[dict, "Information about the issue"]:
|
|
"""Get the metadata about the files attached to an issue.
|
|
|
|
This tool does NOT return the actual file contents. To get a file content,
|
|
use the `Jira.DownloadAttachment` tool.
|
|
"""
|
|
from arcade_jira.tools.issues import get_issue_by_id # Avoid circular imports
|
|
|
|
response = await get_issue_by_id(context, issue)
|
|
if response.get("error"):
|
|
return cast(dict, response)
|
|
return {
|
|
"issue": {
|
|
"id": response["issue"]["id"],
|
|
"key": response["issue"]["key"],
|
|
"attachments": response["issue"]["attachments"],
|
|
}
|
|
}
|
|
|
|
|
|
@tool(requires_auth=Atlassian(scopes=["read:jira-work"]))
|
|
async def get_attachment_metadata(
|
|
context: ToolContext,
|
|
attachment_id: Annotated[str, "The ID of the attachment to retrieve"],
|
|
) -> Annotated[dict[str, Any], "The metadata of the attachment"]:
|
|
"""Get the metadata of an attachment."""
|
|
client = JiraClient(context.get_auth_token_or_empty())
|
|
try:
|
|
response = await client.get(f"/attachment/{attachment_id}")
|
|
except NotFoundError:
|
|
return {"error": f"Attachment not found with ID '{attachment_id}'."}
|
|
cloud_name = cache.get_cloud_name(context.get_auth_token_or_empty())
|
|
return {"attachment": clean_attachment_dict(response, cloud_name)}
|
|
|
|
|
|
@tool(requires_auth=Atlassian(scopes=["read:jira-work"]))
|
|
async def download_attachment(
|
|
context: ToolContext,
|
|
attachment_id: Annotated[str, "The ID of the attachment to download"],
|
|
) -> Annotated[dict[str, Any], "The content of the attachment"]:
|
|
"""Download the contents of an attachment associated with an issue."""
|
|
client = JiraClient(context.get_auth_token_or_empty())
|
|
|
|
attachment = await get_attachment_metadata(context, attachment_id)
|
|
|
|
if attachment.get("error"):
|
|
return cast(dict, attachment)
|
|
|
|
try:
|
|
content = await client.get(
|
|
f"/attachment/content/{attachment_id}",
|
|
params={
|
|
"redirect": False,
|
|
},
|
|
)
|
|
except NotFoundError:
|
|
return {"error": f"Attachment not found with ID '{attachment_id}'."}
|
|
|
|
attachment["attachment"]["content"] = content["text"]
|
|
|
|
return cast(dict, attachment)
|