redtile 0.0.17__py3-none-any.whl

redi/api/attachment.py

@@ -0,0 +1,110 @@
+import json
+import mimetypes
+import os
+
+import requests
+
+from redi.client import client
+from redi.config import redmine_url
+
+
+def upload_file(file_path: str) -> dict:
+    if not os.path.isfile(file_path):
+        print(f"ファイルが見つかりません: {file_path}")
+        exit(1)
+    filename = os.path.basename(file_path)
+    content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    with open(file_path, "rb") as f:
+        response = client.post(
+            "/uploads.json",
+            headers={"Content-Type": "application/octet-stream"},
+            data=f,
+        )
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print(f"ファイルのアップロードに失敗しました: {file_path}")
+        exit(1)
+    token = response.json()["upload"]["token"]
+    return {
+        "token": token,
+        "filename": filename,
+        "content_type": content_type,
+    }
+
+
+def fetch_attachment(attachment_id: str) -> dict:
+    response = client.get(f"/attachments/{attachment_id}.json")
+    if response.status_code == 404:
+        print(f"添付ファイルが見つかりません: #{attachment_id}")
+        exit(1)
+    response.raise_for_status()
+    return response.json()["attachment"]
+
+
+def read_attachment(attachment_id: str, full: bool = False) -> None:
+    attachment = fetch_attachment(attachment_id)
+    if full:
+        print(json.dumps(attachment, ensure_ascii=False))
+        return
+    lines = [
+        f"{attachment['id']} {attachment['filename']}",
+        f"サイズ: {attachment.get('filesize', '')}",
+        f"種別: {attachment.get('content_type', '')}",
+    ]
+    author = attachment.get("author") or {}
+    if author:
+        lines.append(f"作成者: {author.get('name', '')}")
+    if attachment.get("created_on"):
+        lines.append(f"作成日時: {attachment['created_on']}")
+    if attachment.get("description"):
+        lines.append(f"説明: {attachment['description']}")
+    if attachment.get("content_url"):
+        lines.append(f"URL: {attachment['content_url']}")
+    print("\n".join(lines))
+
+
+def delete_attachment(attachment_id: str) -> None:
+    response = client.delete(f"/attachments/{attachment_id}.json")
+    if response.status_code == 404:
+        print(f"添付ファイルが見つかりません: #{attachment_id}")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("添付ファイルの削除に失敗しました")
+        exit(1)
+    print(f"添付ファイルを削除しました: #{attachment_id}")
+
+
+def update_attachment(
+    attachment_id: str,
+    filename: str | None = None,
+    description: str | None = None,
+) -> None:
+    data: dict = {}
+    if filename is not None:
+        data["filename"] = filename
+    if description is not None:
+        data["description"] = description
+    if not data:
+        print("更新をキャンセルしました")
+        exit()
+    response = client.patch(
+        f"/attachments/{attachment_id}.json", json={"attachment": data}
+    )
+    if response.status_code == 404:
+        print(f"添付ファイルが見つかりません: #{attachment_id}")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("添付ファイルの更新に失敗しました")
+        exit(1)
+    print(f"添付ファイルを更新しました: {redmine_url}/attachments/{attachment_id}")

redi/api/custom_field.py

@@ -0,0 +1,72 @@
+import json
+
+from redi import cache
+from redi.client import client
+
+CACHE_KEY = "custom_fields"
+
+
+def fetch_custom_fields() -> list[dict] | None:
+    cached = cache.load(CACHE_KEY)
+    if cached is not None:
+        return cached
+    response = client.get("/custom_fields.json")
+    if response.status_code == 403:
+        # https://www.redmine.org/projects/redmine/wiki/Rest_CustomFields
+        # https://www.redmine.org/issues/18875
+        return
+    response.raise_for_status()
+    data = response.json()["custom_fields"]
+    cache.save(CACHE_KEY, data)
+    return data
+
+
+def list_custom_fields(full: bool = False) -> None:
+    custom_fields = fetch_custom_fields()
+    if custom_fields is None:
+        print("カスタムフィールドの取得には管理者権限が必要です")
+        exit(1)
+    if full:
+        print(json.dumps(custom_fields, ensure_ascii=False))
+    else:
+        for cf in custom_fields:
+            print(f"{cf['id']} {cf['name']}")
+
+
+def fetch_project_issue_custom_field_ids(project_id: str) -> set[int]:
+    """プロジェクトで有効なイシュー用カスタムフィールドのIDを取得する。"""
+    response = client.get(
+        f"/projects/{project_id}.json", params={"include": "issue_custom_fields"}
+    )
+    response.raise_for_status()
+    project = response.json()["project"]
+
+    return {cf["id"] for cf in project.get("issue_custom_fields") or []}
+
+
+def filter_required_issue_custom_fields(
+    custom_fields: list[dict],
+    project_cf_ids: set[int],
+    tracker_id: str | None,
+) -> list[dict]:
+    """
+    入力必須・初期値なし・プロジェクト/トラッカーに該当する
+    イシュー用カスタムフィールドを抽出する。
+    """
+    result = []
+    for cf in custom_fields:
+        if cf.get("customized_type") != "issue":
+            continue
+        if not cf.get("is_required"):
+            continue
+        if cf.get("default_value"):
+            continue
+        if cf["id"] not in project_cf_ids:
+            continue
+        trackers = cf.get("trackers") or []
+        if trackers and tracker_id is not None:
+            tracker_ids = {str(t["id"]) for t in trackers}
+            if str(tracker_id) not in tracker_ids:
+                continue
+        result.append(cf)
+    return result

redi/api/enumeration.py

@@ -0,0 +1,44 @@
+import json
+
+from redi import cache
+from redi.client import client
+
+
+def _fetch_enumeration(resource: str) -> list[dict]:
+    cached = cache.load(resource)
+    if cached is not None:
+        return cached
+    response = client.get(f"/enumerations/{resource}.json")
+    response.raise_for_status()
+    data = response.json()[resource]
+    cache.save(resource, data)
+    return data
+
+
+def _list_enumeration(resource: str, full: bool = False) -> None:
+    items = _fetch_enumeration(resource)
+    if full:
+        print(json.dumps(items, ensure_ascii=False))
+    else:
+        for item in items:
+            print(f"{item['id']} {item['name']}")
+
+
+def fetch_issue_priorities() -> list[dict]:
+    return _fetch_enumeration("issue_priorities")
+
+
+def list_issue_priorities(full: bool = False) -> None:
+    _list_enumeration("issue_priorities", full)
+
+
+def fetch_time_entry_activities() -> list[dict]:
+    return _fetch_enumeration("time_entry_activities")
+
+
+def list_time_entry_activities(full: bool = False) -> None:
+    _list_enumeration("time_entry_activities", full)
+
+
+def list_document_categories(full: bool = False) -> None:
+    _list_enumeration("document_categories", full)

redi/api/file.py

@@ -0,0 +1,55 @@
+import json
+
+import requests
+
+from redi.api.attachment import upload_file
+from redi.client import client
+
+
+def list_files(project_id: str, full: bool = False) -> None:
+    response = client.get(f"/projects/{project_id}/files.json")
+    if response.status_code == 404:
+        print(f"プロジェクトが見つかりません: {project_id}")
+        exit(1)
+    response.raise_for_status()
+    files = response.json()["files"]
+    if full:
+        print(json.dumps(files, ensure_ascii=False))
+        return
+    for f in files:
+        version = f.get("version") or {}
+        version_label = f" [{version.get('name')}]" if version else ""
+        size = f.get("filesize", "")
+        print(f"{f['id']} {f['filename']} ({size}B){version_label}")
+
+
+def create_file(
+    project_id: str,
+    file_path: str,
+    version_id: int | None = None,
+    description: str | None = None,
+) -> None:
+    upload = upload_file(file_path)
+    file_data: dict = {
+        "token": upload["token"],
+        "filename": upload["filename"],
+        "content_type": upload["content_type"],
+    }
+    if version_id is not None:
+        file_data["version_id"] = version_id
+    if description is not None:
+        file_data["description"] = description
+    response = client.post(
+        f"/projects/{project_id}/files.json", json={"file": file_data}
+    )
+    if response.status_code == 404:
+        print(f"プロジェクトが見つかりません: {project_id}")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("ファイルのアップロードに失敗しました")
+        exit(1)
+    print(f"ファイルをアップロードしました: {upload['filename']}")

redi/api/group.py

@@ -0,0 +1,166 @@
+import json
+
+import requests
+
+from redi.client import client
+from redi.config import redmine_url
+
+
+def list_groups(full: bool = False) -> None:
+    response = client.get("/groups.json")
+    response.raise_for_status()
+    groups = response.json()["groups"]
+    if full:
+        print(json.dumps(groups, ensure_ascii=False))
+    else:
+        for group in groups:
+            print(f"{group['id']} {group['name']}")
+
+
+def fetch_group(group_id: str, include: str = "") -> dict:
+    params: dict = {}
+    if include:
+        params["include"] = include
+    response = client.get(f"/groups/{group_id}.json", params=params)
+    if response.status_code == 404:
+        print(f"グループが見つかりません: #{group_id}")
+        exit(1)
+    if response.status_code == 403:
+        print("グループの取得には管理者権限が必要です")
+        exit(1)
+    response.raise_for_status()
+    return response.json()["group"]
+
+
+def read_group(group_id: str, full: bool = False) -> None:
+    group = fetch_group(group_id, include="users,memberships")
+    if full:
+        print(json.dumps(group, ensure_ascii=False))
+        return
+    lines = [f"{group['id']} {group['name']}"]
+    users = group.get("users") or []
+    if users:
+        lines.append("")
+        lines.append("ユーザー:")
+        for u in users:
+            lines.append(f"  {u['id']} {u['name']}")
+    memberships = group.get("memberships") or []
+    if memberships:
+        lines.append("")
+        lines.append("メンバーシップ:")
+        for m in memberships:
+            project = m.get("project") or {}
+            roles = m.get("roles") or []
+            role_names = ", ".join(r.get("name", "") for r in roles)
+            lines.append(
+                f"  {project.get('id')} {project.get('name', '')} [{role_names}]"
+            )
+    print("\n".join(lines))
+
+
+def update_group(
+    group_id: str,
+    name: str | None = None,
+    user_ids: list[int] | None = None,
+) -> None:
+    data: dict = {}
+    if name is not None:
+        data["name"] = name
+    if user_ids is not None:
+        data["user_ids"] = user_ids
+    if len(data) == 0:
+        print("更新をキャンセルしました")
+        exit()
+    response = client.put(f"/groups/{group_id}.json", json={"group": data})
+    if response.status_code == 404:
+        print(f"グループが見つかりません: #{group_id}")
+        exit(1)
+    if response.status_code == 403:
+        print("グループの更新には管理者権限が必要です")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("グループの更新に失敗しました")
+        exit(1)
+    print(f"グループを更新しました: {group_id}")
+
+
+def add_group_user(group_id: str, user_id: int) -> None:
+    response = client.post(
+        f"/groups/{group_id}/users.json",
+        json={"user_id": user_id},
+    )
+    if response.status_code == 404:
+        print(f"グループが見つかりません: #{group_id}")
+        exit(1)
+    if response.status_code == 403:
+        print("グループへのユーザー追加には管理者権限が必要です")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("グループへのユーザー追加に失敗しました")
+        exit(1)
+    print(f"グループ {group_id} にユーザー {user_id} を追加しました")
+
+
+def remove_group_user(group_id: str, user_id: int) -> None:
+    response = client.delete(f"/groups/{group_id}/users/{user_id}.json")
+    if response.status_code == 404:
+        print(f"グループまたはユーザーが見つかりません: #{group_id} / #{user_id}")
+        exit(1)
+    if response.status_code == 403:
+        print("グループからのユーザー削除には管理者権限が必要です")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("グループからのユーザー削除に失敗しました")
+        exit(1)
+    print(f"グループ {group_id} からユーザー {user_id} を削除しました")
+
+
+def delete_group(group_id: str) -> None:
+    response = client.delete(f"/groups/{group_id}.json")
+    if response.status_code == 404:
+        print(f"グループが見つかりません: #{group_id}")
+        exit(1)
+    if response.status_code == 403:
+        print("グループの削除には管理者権限が必要です")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("グループの削除に失敗しました")
+        exit(1)
+    print(f"グループを削除しました: {group_id}")
+
+
+def create_group(name: str, user_ids: list[int] | None = None) -> None:
+    group_data: dict = {"name": name}
+    if user_ids:
+        group_data["user_ids"] = user_ids
+    response = client.post("/groups.json", json={"group": group_data})
+    if response.status_code == 403:
+        print("グループの作成には管理者権限が必要です")
+        exit(1)
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        print(e)
+        print(e.response.text)
+        print("グループの作成に失敗しました")
+        exit(1)
+    created = response.json()["group"]
+    print(
+        f"グループを作成しました: {created['id']} {created['name']} {redmine_url}/groups/{created['id']}"
+    )