ເຜີຍແຜ່ຜ່ານ 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 ອັນດຽວກັນນີ້ ແຕ່ຕົວ request ສັ້ນກວ່າ — ເບິ່ງໃນຫົວຂໍ້ຂອງແຕ່ລະອັນຢູ່ລຸ່ມນີ້.

ຊ່ອງທີ່ບໍ່ບັງຄັບຈະຫາຍໄປທັງ 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 ຫຼື ຕອບດ້ວຍຕົວທີ່ບໍ່ແມ່ນ object JSON ທີ່ມີຊ່ອງ url, Orova ຈະຖືວ່າການເຜີຍແຜ່ລົ້ມເຫຼວ ແລະ ໝາຍບົດຄວາມໄວ້ໃຫ້ທ່ານລອງໃໝ່ໄດ້. ຕອບກັບພາຍໃນ 60 ວິນາທີ — ເກີນກວ່ານັ້ນ Orova ຈະຕັດ request ຖິ້ມ (ໃຊ້ກັບທັງການເຜີຍແຜ່ ການອັບເດດ ແລະ ການລຶບຄືກັນ).

/ ຕົວຢ່າງ

ຕົວຢ່າງໂຄ້ດ

endpoint ຮັບບົດຄວາມແບບຫຍໍ້ທີ່ສຸດດ້ວຍ Node.js ກັບ Express. ຂັ້ນຕອນອັນດຽວກັນນີ້ — ກວດ token, ແຍກທາງຕາມ action (update / delete), ສ້າງ ຫຼື ແກ້ບົດຄວາມ, ຕອບ URL ກັບ — ໃຊ້ໄດ້ກັບທຸກພາສາ ແລະ ທຸກເຟຣມເວີກ.

// 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 ອັນເກົ່າ — ຕ່າງກັນແຕ່ຕົວ request:

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 ສາທາລະນະຂອງມັນຈະໄຫຼກັບເຂົ້າສູ່ ລາຍງານ ແລະ ການວິເຄາະ ເພື່ອໃຫ້ທ່ານຕິດຕາມຜົນໄດ້.