បោះពុម្ពផ្សាយតាម API ទៅគេហទំព័រណាក៏បាន

/ ទិដ្ឋភាពរួម

របៀបដំណើរការ

ពេល Orova សរសេរអត្ថបទសម្រាប់ពាក្យគន្លឹះមួយរួច វាផ្ញើ request HTTP POST តែមួយទៅ endpoint URL ដែលអ្នកបានចុះបញ្ជី។ តួ request ជា JSON ហើយផ្ទុកអត្ថបទទាំងមូល។ endpoint របស់អ្នកបង្កើតអត្ថបទនៅខាងអ្នក រួចឆ្លើយតបមកវិញនូវ URL សាធារណៈចុងក្រោយរបស់អត្ថបទនោះ។ Orova រក្សាទុក URL នោះជាតំណដែលបានផ្សាយ ដូចករណីអត្ថបទ WordPress ដែរ។ ប្រើវិធីនេះពេលអ្នកចង់ឱ្យការផ្សាយដើរដោយខ្លួនឯងលើគេហទំព័រដែលមិនមែន WordPress ឬពេលអ្នកចង់គ្រប់គ្រងវិធីរក្សាទុកអត្ថបទដោយខ្លួនឯងទាំងស្រុង។

/ ការតម្លើង

ការតម្លើង — ប្រាំមួយជំហាន

• 1

  បើក “តភ្ជាប់តាម API” ក្នុងគម្រោងរបស់អ្នក. បើកគម្រោងរបស់អ្នក (គម្រោង → គម្រោងរបស់អ្នក → ការតភ្ជាប់)។ ក្បែរកាត WordPress មានកាត តភ្ជាប់តាម API។ បញ្ចូល URL នៃ endpoint របស់អ្នកនៅទីនោះ។ ប្រអប់សោសម្ងាត់មិនចាំបាច់ទេ៖ ទុកទទេ Orova បង្កើតឱ្យមួយ ឬបិទភ្ជាប់សោដែលគេហទំព័ររបស់អ្នកកំពុងប្រើក៏បាន។ ពេលរក្សាទុករួច សោបង្ហាញនៅលើកាតជាមួយប៊ូតុងចម្លង។ គម្រោងមួយផ្សាយទៅកន្លែងតែមួយប៉ុណ្ណោះ — តភ្ជាប់តាម API នោះប៊ូតុង WordPress ត្រូវចាក់សោ ហើយផ្ទុយមកវិញក៏ដូចគ្នា។

• 2

  សាងសង់ endpoint ដែលទទួល POST. នៅលើគេហទំព័រ ឬម៉ាស៊ីនមេផ្ទាល់ខ្លួន បង្កើត route មួយដែលស្តាប់ HTTP POST ជាមួយតួ JSON។ នេះជា URL ដែលអ្នកបិទភ្ជាប់ត្រឡប់ចូលអេក្រង់ ការតភ្ជាប់ របស់គម្រោង។ រាល់អត្ថបទដែលសរសេររួច Orova ហៅវាម្តង។

• 3

  ផ្ទៀងផ្ទាត់ Bearer token គ្រប់ request. រាល់ request ពី Orova មាន header Authorization ក្នុងទម្រង់ “Bearer <secret>” ដែលជាសោសម្ងាត់ដូចបង្ហាញក្នុងគម្រោងរបស់អ្នកបេះបិទ។ ប្រៀបធៀបនឹងច្បាប់ចម្លងដែលអ្នករក្សាទុក ហើយបដិសេធអ្វីៗដែលមិនត្រូវគ្នា — នេះជារបស់តែមួយគត់ដែលរារាំងមិនឱ្យអ្នកដទៃផ្សាយអត្ថបទឡើងគេហទំព័ររបស់អ្នក។

• 4

  បង្កើតអត្ថបទពី payload. អានតួ JSON រួចបង្កើតអត្ថបទក្នុង CMS ឬមូលដ្ឋានទិន្នន័យរបស់អ្នក៖ ប្រើ title, slug និង content_html សម្រាប់តួអត្ថបទ, excerpt ជា meta description, featured_image_url ជារូបភាពគម្រប ចំណែក keyword / lang / published_at ជាទិន្នន័យអម។

• 5

  ឆ្លើយតបនឹង URL ពិតរបស់អត្ថបទ. ឆ្លើយតបនឹង HTTP 200 ឬ 201 ជាមួយតួ JSON { "url": "https://yoursite.com/the-new-article" }។ Orova រក្សាទុក URL នោះជាតំណដែលបានផ្សាយរបស់អត្ថបទ។ បើអ្នកឆ្លើយតបនឹងស្ថានភាពដែលមិនស្ថិតក្នុងក្រុម 2xx ឬខ្វះវាល url នោះ Orova ចាត់ទុកការផ្សាយលើកនោះថាបរាជ័យ។

• 6

  ដោះស្រាយ request ធ្វើបច្ចុប្បន្នភាពពីម៉ាស៊ីនបង្កើនប្រសិទ្ធភាព. ពេលតួ request មាន action = "update" សូមស្វែងរកអត្ថបទចាស់តាម target_url (ឬ slug) រួចសរសេរជាន់លើ title, content_html និង excerpt នៅនឹងកន្លែង — រក្សា URL ដដែល។ ឆ្លើយតប 200 ជាមួយ { "url": ... } ដែលចង្អុលទៅអត្ថបទដដែល។ endpoint ដែលមិនទាន់ដោះស្រាយផ្នែកនេះ គ្រាន់តែធ្វើឱ្យ Orova រាយការណ៍ថាការបង្កើនប្រសិទ្ធភាពលើកនោះបរាជ័យ ការផ្សាយអត្ថបទថ្មីនៅតែដំណើរការដដែល។

/ កិច្ចសន្យា

request ដែល Orova ផ្ញើមក

អត្ថបទនីមួយៗដែលសរសេររួច មកដល់ជា request មួយមានរូបរាងបែបនេះ៖

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>     # the secret key shown in Project -> Connections
  User-Agent: Orova-SEO

Body (JSON):
  {
    "title": "...",                  # article headline
    "slug": "...",                   # URL-friendly identifier
    "content_html": "...",           # full article HTML
    "excerpt": "...",                # meta description
    "featured_image_url": "..." | null,
    "keyword": "...",                # target keyword
    "lang": "en",                    # ISO language code
    "published_at": "2026-05-17T09:00:00.482913",  # ISO 8601, UTC, no offset suffix
    "status": "draft"                # optional: "draft" keeps it unpublished
  }
  # Optional fields are left out of the body when empty — never sent as null.

/ ឯកសារយោង

វាលក្នុង payload

វាលនៃ request ផ្សាយ (អត្ថបទថ្មី)។ request លុប និង request ធ្វើបច្ចុប្បន្នភាព ប្រើ endpoint ដដែល តែតួខ្លីជាង — មើលក្នុងផ្នែករៀងៗខ្លួនខាងក្រោម។

វាលជាជម្រើសនឹងបាត់ទាំង key ពេលគ្មានតម្លៃត្រូវផ្ញើ — Orova មិនដែលផ្ញើ null ទេ ដូច្នេះសូមអានវាលទាំងនោះដោយប្រុងប្រយ័ត្ន។ status ក៏ជាជម្រើសដែរ៖ "draft" បង្កើតអត្ថបទជាសេចក្ដីព្រាង រីឯ "publish" ឬគ្មាន status នឹងផ្សាយភ្លាម។

/ កិច្ចសន្យា

response ដែលអ្នកត្រូវឆ្លើយតប

ពេលបង្កើតអត្ថបទរួច សូមឆ្លើយតបនឹងស្ថានភាព HTTP 200 ឬ 201 ជាមួយតួ JSON បែបនេះ៖

HTTP 200 (or 201)
Content-Type: application/json

{
  "url": "https://yoursite.com/published-article"
}

Orova រក្សាទុក url នោះជាតំណដែលបានផ្សាយរបស់អត្ថបទ។ បើ endpoint របស់អ្នកឆ្លើយតបនឹងស្ថានភាពណាដែលមិនស្ថិតក្នុងក្រុម 2xx ឬតួដែលមិនមែនជាវត្ថុ JSON មានវាល url នោះ Orova ចាត់ទុកការផ្សាយថាបរាជ័យ ហើយដាក់សញ្ញាលើអត្ថបទ ដើម្បីឱ្យអ្នកសាកម្តងទៀតបាន។ សូមឆ្លើយតបក្នុងរយៈពេល 60 វិនាទី — ហួសពីនោះ Orova កាត់ផ្តាច់ request (អនុវត្តដូចគ្នាទាំងការផ្សាយ ការធ្វើបច្ចុប្បន្នភាព និងការលុប)។

/ ឧទាហរណ៍

ឧទាហរណ៍កូដ

endpoint ទទួលអត្ថបទបែបសាមញ្ញបំផុតដោយ Node.js ជាមួយ Express។ ជំហានដដែលនេះ — ផ្ទៀងផ្ទាត់ token, បែងចែកតាម action (update / delete), បង្កើត ឬកែអត្ថបទ, ឆ្លើយតប URL — ប្រើបានគ្រប់ភាសា និងគ្រប់ framework។

// Node.js / Express — a minimal receiving endpoint
import express from "express";

const app = express();
app.use(express.json({ limit: "5mb" }));

// The secret Orova generated for this project.
const OROVA_SECRET = process.env.OROVA_SECRET;

app.post("/orova/publish", async (req, res) => {
  // 1. Verify the Bearer token.
  const auth = req.get("authorization") || "";
  if (auth !== "Bearer " + OROVA_SECRET) {
    return res.status(401).json({ error: "unauthorized" });
  }

  // 2. Visual Editor: list your articles. action = "list".
  if (req.body.action === "list") {
    const posts = await listPosts(req.body.limit || 500); // newest first, 500 max
    return res.status(200).json({ ok: true, posts });
  }

  // 3. Visual Editor: read one article in full. action = "get".
  if (req.body.action === "get") {
    const post = await findPost(req.body.id, req.body.target_url, req.body.slug);
    if (!post) return res.status(404).json({ ok: false, err: "not_found" });
    return res.status(200).json({ ok: true, post });
  }

  // 4. Visual Editor: store an image, answer with its absolute URL.
  if (req.body.action === "upload_image") {
    const { filename, mime, data_base64 } = req.body;
    if (!String(mime || "").startsWith("image/")) {
      return res.status(422).json({ error: "image files only" });
    }
    const bytes = Buffer.from(data_base64, "base64");
    if (bytes.length > 15 * 1024 * 1024) {
      return res.status(413).json({ error: "image too large" });
    }
    return res.status(200).json({ ok: true, url: await saveImage(filename, bytes) });
  }

  // 5. Delete requests: body carries action = "delete".
  if (req.body.action === "delete") {
    const removed = await deletePostByUrl(req.body.url, req.body.slug);
    if (!removed) return res.status(404).json({ deleted: true }); // already gone
    return res.status(200).json({ deleted: true });
  }

  // 6. Update requests: action = "update". Optional fields may be absent.
  if (req.body.action === "update") {
    const updated = await updatePost(req.body.id, req.body.target_url, {
      title: req.body.title,
      html: req.body.content_html,
      metaDescription: req.body.excerpt,
      coverImage: req.body.featured_image_url,  // optional
      status: req.body.status,                  // optional: "publish" | "draft"
    });
    if (!updated) return res.status(404).json({ error: "post not found" });
    return res.status(200).json({ url: updated.url });
  }

  // 7. New article: read the payload Orova sent.
  const {
    title, slug, content_html, excerpt,
    featured_image_url, keyword, lang, published_at, status,
  } = req.body;

  // 8. Create the article in your own CMS or database.
  const post = await createPost({
    title,
    slug,
    html: content_html,
    metaDescription: excerpt,
    coverImage: featured_image_url,
    keyword,
    lang,
    publishedAt: published_at,
    draft: status === "draft",   // status is optional; absent means publish now
  });

  // 9. Return 200/201 with the live URL.
  return res.status(201).json({
    url: "https://yoursite.com/" + post.slug,
  });
});

app.listen(3000);

/ កិច្ចសន្យា — ធ្វើបច្ចុប្បន្នភាព

ការធ្វើបច្ចុប្បន្នភាពអត្ថបទ (បង្កើនប្រសិទ្ធភាព)

ម៉ាស៊ីនបង្កើនប្រសិទ្ធភាព របស់ Orova សរសេរអត្ថបទដែលផ្សាយរួចហើយឡើងវិញ — ព័ត៌មានថ្មីជាង ចំណងជើងល្អជាង ខ្លឹមសារបញ្ចូលគ្នា — រួចសរសេរជាន់លើអត្ថបទចាស់ នៅនឹងកន្លែង ដោយរក្សា URL ដដែល។ request ទៅកាន់ endpoint URL ដដែល ជា POST ជាមួយ Bearer token ដដែល៖

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>
  User-Agent: Orova-SEO

Body (JSON):
  {
    "action": "update",          # always the literal string "update"
    "id": 123,                   # optional: post id, match on this first
    "target_url": "...",         # public URL of the post to overwrite (match next)
    "title": "...",              # new headline
    "slug": "...",               # slug fallback for matching, may be empty
    "content_html": "...",       # full new article body as HTML
    "excerpt": "...",            # new meta description
    "featured_image_url": "...", # optional: new cover image
    "status": "publish"          # optional: "publish" or "draft"
  }
  # Optional fields are left out of the body when empty — never sent as null.

ស្វែងរកអត្ថបទតាម target_url (បើរកមិនឃើញ ប្រើ slug) ជំនួសចំណងជើង តួអត្ថបទ និង meta description រក្សា URL ដដែល រួចឆ្លើយតប 200 ជាមួយ { "url": "<URL អត្ថបទដដែល>" }។ ស្ថានភាពណាដែលមិនស្ថិតក្នុងក្រុម 2xx ឬតួដែលគ្មាន url ធ្វើឱ្យ Orova កត់ត្រាថាការបង្កើនប្រសិទ្ធភាពលើកនោះបរាជ័យ (Orova មិនដែលបង្កើតអត្ថបទស្ទួនទេ)។ endpoint ដែលមិនទាន់ធ្វើផ្នែកនេះ នៅតែផ្សាយអត្ថបទថ្មីបានដដែល — ការដោះស្រាយ update ចាំបាច់តែពេលអ្នកចាប់ផ្តើមប្រើអេក្រង់បង្កើនប្រសិទ្ធភាព។

ចាប់ពី 29/8 body នៃពាក្យបញ្ជាធ្វើបច្ចុប្បន្នភាពអាចមាន id (ស្វែងរកតាម id មុន target_url), featured_image_url សម្រាប់ប្ដូររូបគម្រប និង status ដែលទទួល "publish" ឬ "draft"។ ទាំងបីជាជម្រើស; ពេលគ្មានតម្លៃ គេកាត់ចេញទាំង key ហើយមិនផ្ញើជា null ទេ។

/ កិច្ចសន្យា — Visual Editor

អានអត្ថបទ (Visual Editor)

Visual Editor បើកអត្ថបទដែលមានស្រាប់នៅលើគេហទំព័ររបស់អ្នក ដូច្នេះវាត្រូវអានអត្ថបទបានជាមុនសិន។ នេះជា action ពីរបន្ថែម នៅលើ endpoint URL តែមួយ និង Bearer token តែមួយ៖ list ត្រឡប់បញ្ជីអត្ថបទ ហើយ get ត្រឡប់អត្ថបទមួយពេញលេញ។

POST <your endpoint URL>     # same endpoint, same Bearer secret

Body (JSON):
  {
    "action": "list",            # always the literal string "list"
    "limit": 500                 # newest article first, 500 maximum
  }

Response — HTTP 200:
  {
    "ok": true,
    "posts": [
      {
        "id": 123,               # your own post id, reused by "get" and "update"
        "title": "...",
        "slug": "...",
        "link": "https://yoursite.com/the-article",
        "date": "2026-08-29",    # published date, YYYY-MM-DD
        "modified": "2026-08-29",
        "status": "publish",     # "publish" or "draft"
        "author": "..."
      }
    ]
  }

POST <your endpoint URL>

Body (JSON):
  {
    "action": "get",             # always the literal string "get"
    "id": 123,                   # match on this first
    "target_url": "...",         # then the public URL
    "slug": "..."                # then the slug
  }

Response — HTTP 200:
  {
    "ok": true,
    "post": {
      "id": 123,
      "title": "...",
      "slug": "...",
      "link": "https://yoursite.com/the-article",
      "content_html": "...",     # full article body as HTML
      "excerpt": "...",
      "featured_image_url": "...",
      "status": "publish"        # "publish" or "draft"
    }
  }

No such post — HTTP 404:
  { "ok": false, "err": "not_found" }

limit អតិបរមា 500 ហើយអត្ថបទថ្មីបំផុតមកមុន។ សម្រាប់ get Orova ផ្ញើ id, target_url និង slug មកជាមួយគ្នា — សូមស្វែងរកតាមអ្វីដែលអ្នកស្គាល់ តាមលំដាប់នេះ។ បើរកមិនឃើញ សូមឆ្លើយ 404 ជាមួយ { "ok": false, "err": "not_found" }។ action ទាំងពីរនេះត្រូវការតែពេលអ្នកចង់កែអត្ថបទលើគេហទំព័រដោយ Visual Editor — ការផ្សាយ និងការបង្កើនប្រសិទ្ធភាពស្វ័យប្រវត្តិមិនត្រូវការទេ។

/ កិច្ចសន្យា — Visual Editor

ផ្ទុករូបភាពឡើង (Visual Editor)

ពេលអ្នកដាក់រូបភាពចូល Visual Editor, Orova ផ្ញើរូបនោះទៅ endpoint URL តែមួយ ជា base64 ក្នុង JSON body — មិនប្រើ multipart ហើយក៏គ្មាន URL ថ្មីត្រូវការពារដែរ។

POST <your endpoint URL>

Body (JSON):
  {
    "action": "upload_image",    # always the literal string "upload_image"
    "filename": "cover.png",     # original file name, extension included
    "mime": "image/png",         # image/* only
    "data_base64": "iVBORw0KGgo..."   # file bytes, base64, 15 MB maximum
  }

Response — HTTP 200 (or 201):
  {
    "ok": true,
    "url": "https://yoursite.com/uploads/cover.png"   # absolute URL
  }

ទទួលតែ image/* ហើយបដិសេធឯកសារធំជាង 15 MB។ រក្សាទុកឯកសាររួច សូមឆ្លើយតបជា URL ពេញលេញ របស់រូបភាព៖ ផ្លូវមិនពេញនឹងធ្វើឲ្យអត្ថបទខូចពេលបង្ហាញនៅកន្លែងផ្សេង។ action នេះត្រូវការតែសម្រាប់ Visual Editor។

/ កិច្ចសន្យា — លុប

ការលុបអត្ថបទ

ពេលអ្នកប្រើលុបអត្ថបទដែលផ្សាយរួចនៅក្នុង Orova (ពីអេក្រង់សរសេរ ឬអេក្រង់របាយការណ៍) Orova សុំឱ្យគេហទំព័ររបស់អ្នកលុបវាដែរ។ request ទៅកាន់ endpoint URL ដដែល ជា POST ជាមួយ Bearer token ដដែល — ខុសគ្នាតែតួប៉ុណ្ណោះ៖

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>
  User-Agent: Orova-SEO

Body (JSON):
  {
    "action": "delete",          # always the literal string "delete"
    "url": "...",                # public URL of the article to remove (match on this first)
    "slug": "...",               # slug fallback, may be empty
    "keyword": "..."             # the article's target keyword, for your logs
  }

ស្វែងរកអត្ថបទតាម url (បើរកមិនឃើញ ប្រើ slug) លុប ឬដកចេញពីការផ្សាយ រួចឆ្លើយតប 200 ជាមួយ { "deleted": true } — ឆ្លើយ 204 ទទេក៏បាន។ បើអត្ថបទលែងមានហើយ សូមឆ្លើយ 404 នោះ Orova ចាត់ទុកថាបានលុបរួច។ ការឆ្លើយ { "deleted": false } ប្រាប់ Orova ថាអត្ថបទមិនត្រូវបានលុប។ request ផ្សាយធម្មតាមិនដែលមានវាល action ទេ ដូច្នេះ endpoint ចាស់នៅតែដំណើរការដដែល — ការដោះស្រាយការលុបមិនបង្ខំទេ តែណែនាំឱ្យធ្វើ។

/ សុវត្ថិភាព

ចំណាំអំពីសុវត្ថិភាព

• ផ្ទៀងផ្ទាត់ Bearer token ជានិច្ច. endpoint របស់អ្នកជា URL សាធារណៈ — នរណាក៏ហៅបាន។ header Authorization ជារបស់តែមួយគត់ដែលបញ្ជាក់ថា request នោះមកពី Orova ពិតមែន ដូច្នេះសូមបដិសេធរាល់ request ដែល token មិនត្រូវនឹងសោសម្ងាត់ដែលអ្នករក្សាទុកបេះបិទ។
• បម្រើ endpoint តាម HTTPS. សោសម្ងាត់ធ្វើដំណើរក្នុង header។ HTTPS ការពារកុំឱ្យអ្នកណាអានវាបានតាមផ្លូវ។
• កុំទុកសោសម្ងាត់ក្នុងកូដ. រក្សាទុកក្នុងអថេរបរិស្ថាន ឬប្រព័ន្ធគ្រប់គ្រងសោសម្ងាត់ កុំសរសេរជាប់ក្នុងឯកសារដែលអ្នក commit។ បើវាធ្លាយចេញពេលណា សូមបង្កើតសោថ្មីពី គម្រោង → ការតភ្ជាប់។
• ចាត់ទុក content_html ជាខ្លឹមសារ មិនមែនជា markup ដែលទុកចិត្តបាន. រក្សាទុក និងបង្ហាញវាដោយប្រុងប្រយ័ត្នដូចតួអត្ថបទផ្សេងទៀតក្នុង CMS របស់អ្នក។

/ សរុបសេចក្តី

កិច្ចសន្យាទាំងមូលមានតែប៉ុណ្ណេះ

ពេល endpoint ដំណើរការ ហើយបានចុះបញ្ជីក្នុងគម្រោងរួច Orova ផ្សាយឡើងគេហទំព័ររបស់អ្នកដោយស្វ័យប្រវត្តិ — ដូចអ្នកប្រើ WordPress បេះបិទ។ អត្ថបទនីមួយៗដែលសរសេររួច ចុះមកដល់ម៉ាស៊ីនមេរបស់អ្នក ក្លាយជាអត្ថបទមួយ ហើយ URL សាធារណៈរបស់វាហូរត្រឡប់ចូល របាយការណ៍ និង ការវិភាគ ដើម្បីឱ្យអ្នកតាមដានលទ្ធផលបាន។