PythonでnoteをAPI経由で公開する｜フルペイロード方式の落とし穴

"""
これは「やってはいけない例」です。
タイトルだけ変えるつもりで送ると、他の設定がすべて消えます。
"""

# NG: これを送ると…
payload = {
    "status": "published",
    "name": "新しいタイトル",
}

# 結果:
#   本文が消える
#   ハッシュタグが全部消える
#   価格設定が消える（有料記事が無料になる）
#   マガジンから外れる
#
# 「タイトルだけ更新される」わけではない。

"""
記事の現在値を、編集者視点で取得する。
draft=true を付けると下書きの内容も取得できる。
"""
from note_auth_client import NoteAuthClient, CookieExpiredError


def fetch_editable(client: NoteAuthClient, note_key: str) -> dict:
    """編集用の記事データを取得する"""
    data = client.get_json(
        f"/api/v3/notes/{note_key}",
        params={"draft": "true", "draft_reedit": "false"},
    )

    if not data:
        raise RuntimeError(f"記事を取得できません: {note_key}")

    return data


def show_current(data: dict):
    print("=== 現在の状態 ===")
    print("  id       :", data.get("id"))
    print("  key      :", data.get("key"))
    print("  status   :", data.get("status"))
    print("  タイトル :", data.get("name"))
    print("  価格     :", data.get("price"))
    print("  separator:", data.get("separator"))

    body = data.get("body") or ""
    free_body = data.get("free_body") or ""
    pay_body = data.get("pay_body") or ""

    print(f"  body     : {len(body)} 文字")
    print(f"  free_body: {len(free_body)} 文字")
    print(f"  pay_body : {len(pay_body)} 文字")

    tags = data.get("hashtags") or []
    print(f"  タグ     : {len(tags)} 個")

    print("  自分の記事:", data.get("is_my_note"))


if __name__ == "__main__":
    try:
        client = NoteAuthClient()
        client.verify()

        # 自分の記事キーを指定する
        note = fetch_editable(client, "nXXXXXXXXXXXX")
        show_current(note)

    except CookieExpiredError as e:
        print("認証エラー:", e)

"""
noteの公開・編集を安全に行うクラス。
必ず現在値を取得してからマージして送る。
"""
import logging

from note_auth_client import NoteAuthClient

logger = logging.getLogger(__name__)

# PUTで送るべきフィールドの一覧
PAYLOAD_FIELDS = [
    "status", "name", "free_body", "pay_body", "separator",
    "price", "hashtags", "magazine_ids", "disable_comment",
    "is_refund", "circle_permissions", "limited_note",
]


class NotePublisher:

    def __init__(self, client: NoteAuthClient):
        self.client = client

    # ---- 取得 ----

    def fetch(self, note_key: str) -> dict:
        """編集用のデータを取得する"""
        data = self.client.get_json(
            f"/api/v3/notes/{note_key}",
            params={"draft": "true", "draft_reedit": "false"},
        )
        if not data:
            raise RuntimeError(f"記事を取得できません: {note_key}")
        if not data.get("is_my_note", True):
            raise PermissionError("自分の記事ではありません")
        return data

    # ---- ペイロード構築 ----

    def build_payload(self, current: dict, **changes) -> dict:
        """
        現在値をベースに、変更したい項目だけ上書きした
        フルペイロードを作る。
        """
        payload = {}

        for field in PAYLOAD_FIELDS:
            if field in current and current[field] is not None:
                payload[field] = current[field]

        # 本文の扱い（bodyしか無い場合はfree_bodyへ回す）
        if "free_body" not in payload:
            payload["free_body"] = current.get("body") or ""
        payload.setdefault("pay_body", "")
        payload.setdefault("price", 0)
        payload.setdefault("hashtags", [])
        payload.setdefault("magazine_ids", [])
        payload.setdefault("disable_comment", False)

        # 呼び出し側の指定で上書き
        payload.update(changes)

        return payload

    # ---- 更新 ----

    def update(self, note_key: str, dry_run: bool = True,
               **changes) -> dict:
        """
        記事を更新する。
        dry_run=True のときは送信内容を表示するだけ。
        """
        current = self.fetch(note_key)
        note_id = current.get("id")
        payload = self.build_payload(current, **changes)

        self._describe(current, payload)

        if dry_run:
            print("\n[確認モード] 実際には送信していません")
            return {"dry_run": True, "payload": payload}

        res = self.client.request(
            "PUT", f"/api/v1/text_notes/{note_id}", json=payload
        )

        if res.status_code not in (200, 201):
            logger.error("更新失敗 HTTP %s: %s",
                         res.status_code, res.text[:300])
            return {"ok": False, "status": res.status_code}

        print("\n更新しました")
        return {"ok": True, "key": note_key}

    def publish(self, note_key: str, dry_run: bool = True,
                **changes) -> dict:
        """下書きを公開する"""
        changes["status"] = "published"
        return self.update(note_key, dry_run=dry_run, **changes)

    def unpublish(self, note_key: str) -> bool:
        """
        公開記事を下書きに戻す。
        有料・販売実績あり・メンバーシップ紐付きの場合は403。
        """
        res = self.client.request(
            "POST",
            f"/api/v2/notes/{note_key}/change_status",
            json={"status": "draft"},
        )

        if res.status_code == 403:
            print("下書きに戻せません（有料記事・販売実績などの制約）")
            return False
        if res.status_code not in (200, 201, 204):
            print(f"失敗: HTTP {res.status_code}")
            return False

        print("下書きに戻しました")
        return True

    # ---- 表示 ----

    def _describe(self, current: dict, payload: dict):
        print("=== 送信内容の確認 ===")
        print("  記事    :", current.get("name"))
        print("  現在    :", current.get("status"))
        print("  送信後  :", payload.get("status"))
        print("  価格    :", payload.get("price"))

        free_len = len(payload.get("free_body") or "")
        pay_len = len(payload.get("pay_body") or "")
        print(f"  無料部分: {free_len} 文字")
        print(f"  有料部分: {pay_len} 文字")

        tags = payload.get("hashtags") or []
        print(f"  タグ    : {len(tags)} 個")

        # 消えるフィールドがないか警告する
        for field in ("free_body", "name"):
            if not payload.get(field):
                print(f"  警告: {field} が空です")


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)

    client = NoteAuthClient()
    client.verify()

    pub = NotePublisher(client)

    # まずは確認モードで実行する
    pub.publish("nXXXXXXXXXXXX", dry_run=True)

"""
Markdownファイルから下書きを作り、確認後に公開する。

    python 02_draft_to_publish.py article.md          # 下書きまで
    python 02_draft_to_publish.py article.md --publish # 公開まで
"""
import os
import sys
import time

from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft
from note_publisher import NotePublisher
from simple_md import convert
from frontmatter import parse, extract_title, strip_title_heading


def load_article(path: str) -> dict:
    with open(path, encoding="utf-8") as f:
        content = f.read()

    meta, body = parse(content)
    fallback = os.path.splitext(os.path.basename(path))[0]

    return {
        "title": extract_title(meta, body, fallback),
        "html": convert(strip_title_heading(body)),
        "tags": meta.get("tags") or [],
        "price": int(meta.get("price") or 0),
    }


def main(path: str, do_publish: bool):
    if not os.path.exists(path):
        print(f"ファイルがありません: {path}")
        return

    article = load_article(path)

    print("=== 読み込んだ内容 ===")
    print("  タイトル:", article["title"])
    print(f"  本文    : {len(article['html'])} 文字（HTML）")
    print("  タグ    :", ", ".join(article["tags"]) or "なし")
    print("  価格    :", article["price"])

    try:
        client = NoteAuthClient()
        client.verify()
    except CookieExpiredError as e:
        print("認証エラー:", e)
        return

    draft = NoteDraft(client)

    # 重複チェック
    if draft.find_by_title(article["title"]):
        print("同名の下書きが既にあります。中止します")
        return

    result = draft.create(article["title"], article["html"])
    print(f"\n下書きを作成しました: {result['edit_url']}")

    if not do_publish:
        print("公開する場合は --publish を付けて実行してください")
        return

    time.sleep(2.0)

    pub = NotePublisher(client)
    pub.publish(
        result["key"],
        dry_run=False,
        name=article["title"],
        free_body=article["html"],
        pay_body="",
        price=article["price"],
        hashtags=article["tags"],
    )

    print(f"公開URL: https://note.com/notes/{result['key']}")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("使い方: python 02_draft_to_publish.py article.md [--publish]")
        sys.exit(1)

    main(sys.argv[1], "--publish" in sys.argv)

"""
有料記事を作成する。
本文を区切り文字で分割し、無料部分と有料部分に振り分ける。
"""
from note_auth_client import NoteAuthClient, CookieExpiredError
from note_draft import NoteDraft
from note_publisher import NotePublisher
from simple_md import convert

# 原稿内でこの行を境に、無料部分と有料部分を分ける
SPLIT_MARKER = "<!-- paywall -->"


def split_body(md_text: str) -> tuple:
    """原稿を無料部分と有料部分に分割する"""
    if SPLIT_MARKER not in md_text:
        return convert(md_text), ""

    free_md, pay_md = md_text.split(SPLIT_MARKER, 1)
    return convert(free_md.strip()), convert(pay_md.strip())


def create_paid_note(client: NoteAuthClient, title: str,
                     md_text: str, price: int,
                     tags: list = None, dry_run: bool = True) -> dict:
    """有料記事を作成する"""
    free_html, pay_html = split_body(md_text)

    if not pay_html:
        raise ValueError(
            f"有料部分がありません。原稿に {SPLIT_MARKER} を入れてください"
        )

    print("=== 作成する有料記事 ===")
    print("  タイトル  :", title)
    print("  価格      :", f"{price:,} 円")
    print(f"  無料部分  : {len(free_html)} 文字")
    print(f"  有料部分  : {len(pay_html)} 文字")

    ratio = len(free_html) / (len(free_html) + len(pay_html)) * 100
    print(f"  無料の割合: {ratio:.1f}%")

    if ratio < 20:
        print("  注意: 無料部分が少なすぎます。購入判断ができません")
    if ratio > 80:
        print("  注意: 無料部分が多すぎます。購入の動機が弱くなります")

    if dry_run:
        print("\n[確認モード] 実際には作成していません")
        return {"dry_run": True}

    draft = NoteDraft(client)
    result = draft.create(title, free_html + pay_html)

    pub = NotePublisher(client)
    pub.publish(
        result["key"],
        dry_run=False,
        name=title,
        free_body=free_html,
        pay_body=pay_html,
        price=price,
        hashtags=tags or [],
    )

    return result


if __name__ == "__main__":
    sample = """## この記事について

ここは誰でも読める無料部分です。
何が書いてあるかを説明します。

<!-- paywall -->

## 本編

ここから先は購入した人だけが読めます。
"""

    try:
        client = NoteAuthClient()
        client.verify()

        create_paid_note(
            client,
            title="有料記事のテスト",
            md_text=sample,
            price=500,
            tags=["テスト"],
            dry_run=True,   # 実際に作るときは False
        )

    except CookieExpiredError as e:
        print("認証エラー:", e)

"""
公開後に内容が正しく反映されたかを検証する。
公開直後は一時的に本文がnullになることがあるため、
リトライしながら確認する。
"""
import time

from note_auth_client import NoteAuthClient


def verify_published(client: NoteAuthClient, note_key: str,
                     expected_title: str = "",
                     max_retry: int = 5,
                     wait_sec: float = 3.0) -> bool:
    """公開結果を検証する"""
    for attempt in range(1, max_retry + 1):
        data = client.get_json(f"/api/v3/notes/{note_key}")

        status = data.get("status")
        name = data.get("name") or ""
        body = data.get("body") or ""

        print(f"  試行 {attempt}: status={status} / "
              f"title={len(name)}文字 / body={len(body)}文字")

        if status == "published" and body:
            if expected_title and name.strip() != expected_title.strip():
                print("  警告: タイトルが想定と違います")
                print(f"    想定: {expected_title}")
                print(f"    実際: {name}")
            print("  → 公開を確認しました")
            return True

        if attempt < max_retry:
            time.sleep(wait_sec)

    print("  → 確認できませんでした。画面で直接確認してください")
    return False


if __name__ == "__main__":
    client = NoteAuthClient()
    client.verify()

    print("=== 公開の検証 ===")
    verify_published(client, "nXXXXXXXXXXXX")

"""
公開済み記事の一部だけを安全に編集する。
現在値を保持したまま、指定した項目だけ変更する。
"""
from note_auth_client import NoteAuthClient, CookieExpiredError
from note_publisher import NotePublisher


def add_tags(pub: NotePublisher, note_key: str,
             new_tags: list, dry_run: bool = True):
    """既存のタグを保持したまま、タグを追加する"""
    current = pub.fetch(note_key)

    existing = []
    for h in current.get("hashtags") or []:
        if isinstance(h, str):
            existing.append(h)
        elif isinstance(h, dict):
            inner = h.get("hashtag", h)
            name = inner.get("name")
            if name:
                existing.append(name)

    merged = existing[:]
    for t in new_tags:
        if t not in merged:
            merged.append(t)

    print("既存タグ:", existing)
    print("追加後  :", merged)

    return pub.update(note_key, dry_run=dry_run, hashtags=merged)


def append_text(pub: NotePublisher, note_key: str,
                html_to_append: str, dry_run: bool = True):
    """本文の末尾に追記する（追記のお知らせなど）"""
    current = pub.fetch(note_key)

    free_body = current.get("free_body") or current.get("body") or ""
    new_body = free_body + html_to_append

    print(f"本文: {len(free_body)} 文字 → {len(new_body)} 文字")

    return pub.update(note_key, dry_run=dry_run, free_body=new_body)


def change_title(pub: NotePublisher, note_key: str,
                 new_title: str, dry_run: bool = True):
    """タイトルだけを変更する（他の設定は保持される）"""
    current = pub.fetch(note_key)
    print(f"タイトル: {current.get('name')} → {new_title}")

    return pub.update(note_key, dry_run=dry_run, name=new_title)


if __name__ == "__main__":
    try:
        client = NoteAuthClient()
        client.verify()
        pub = NotePublisher(client)

        key = "nXXXXXXXXXXXX"

        # いずれも確認モードで実行される
        add_tags(pub, key, ["Python", "自動化"], dry_run=True)

    except CookieExpiredError as e:
        print("認証エラー:", e)