ទទួលការបង្ហោះពី Orova Social តាម Webhook។

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

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

អ្នកចុះបញ្ជីអាសយដ្ឋានទទួល (https://) និងសោសម្ងាត់មួយនៅឆានែល API របស់គម្រោង។ Orova ផ្ញើ request POST ជាមួយតួ JSON ទៅទីនោះ ព្រមទាំងបឋមកថា X-Orova-Signature — ជា HMAC-SHA256 នៃបៃតឹងរបស់តួនោះ ដោយប្រើសោរបស់អ្នក។ endpoint របស់អ្នកផ្ទៀងផ្ទាត់ហត្ថលេខា ទទួលការបង្ហោះ រួចឆ្លើយតបលេខស្ថានភាព 2xx។

• អាសយដ្ឋានទទួលត្រូវជា https. បើអាសយដ្ឋានមិនមែន https:// ឬគ្មានឈ្មោះម៉ាស៊ីន Orova មិនរក្សាទុកឆានែលទេ ហើយរាយការណ៍កូដ api_url។
• អាសយដ្ឋានមួយ ឆានែលមួយ. Orova សម្គាល់ឆានែលតាមអាសយដ្ឋានទទួលនោះឯង។ រក្សាទុកអាសយដ្ឋានដដែលម្តងទៀត គឺសរសេរជាន់លើឆានែលចាស់ មិនបង្កើតឆានែលស្ទួនទេ។
• មានប៊ូតុងផ្ញើសាកល្បង. ពេលភ្ជាប់រួច ឆានែលនឹងមានប៊ូតុង Send test៖ Orova បាញ់ទិន្នន័យ orova.test ទៅ endpoint របស់អ្នកភ្លាម ហើយបង្ហាញលេខស្ថានភាព HTTP ដែលទទួលបាន ព្រមទាំងរយៈពេលទៅមកគិតជាមិល្លីវិនាទី។

/ ការកំណត់

កំណត់ក្នុង Orova

បើក Social → គម្រោង → ជ្រើសគម្រោង → ផ្ទាំង ឆានែល រួចរកប្រអប់ API។ វាមានប្រអប់បញ្ចូលពីរ និងប៊ូតុងមួយ។

• 1

  URL ទទួល (webhook). អាសយដ្ឋាន endpoint របស់អ្នក ចាប់ផ្តើមដោយ https://។ គ្រប់ request ទាំងអស់មកទីនេះ។

• 2

  សោសម្ងាត់. ខ្សែអក្សរដែលប្រើចុះហត្ថលេខា។ ទុកទទេ Orova នឹងបង្កើតដោយចៃដន្យ — ប៉ុន្តែអេក្រង់មិនបង្ហាញវាវិញឡើយ ដូច្នេះគួរបង្កើតខ្សែអក្សរវែងដោយខ្លួនឯង បិទភ្ជាប់ចូល ហើយរក្សាច្បាប់ចម្លងនៅខាងអ្នក។

• 3

  ចុច Save channel. ឆានែលនឹងលេចក្នុងបញ្ជីជាមួយអាសយដ្ឋានទទួល។ សោសម្ងាត់មិនបង្ហាញម្តងទៀតទេ។

• 4

  ចុច Send test. Orova ផ្ញើទិន្នន័យគំរូ orova.test។ បើ endpoint ឆ្លើយ 2xx Orova រាយការណ៍ថា “Webhook ឆ្លើយ 200 ក្នុង … ms”។ លេខផ្សេងទៀតបង្ហាញជាមួយកូដនោះ។ បើទៅមិនដល់ នឹងរាយការណ៍ជាកំហុសបណ្តាញ។

/ កិច្ចសន្យា

កិច្ចសន្យានៃ request

រាល់ការផ្ញើមកដល់ជា request មានរូបរាងបែបនេះ៖

POST <your receiving URL>

Headers:
  Content-Type: application/json
  X-Orova-Signature: sha256=<hex HMAC-SHA256 of the raw body>
  X-Orova-Event: orova.test
  User-Agent: Orova-Social/1.0

Body (JSON):
  {
    "event": "orova.test",
    "workspace_id": 12,
    "project_id": 34,
    "post": {
      "title": "...",
      "content": "...",
      "media": [],
      "channels": ["api"]
    },
    "sent_at": "2026-08-23T01:25:00Z"
  }

តួជា JSON UTF-8 បង្រួម មួយបន្ទាត់។ សូមអាន event ដើម្បីបែងចែកប្រភេទ — ទិន្នន័យពីប៊ូតុងផ្ញើសាកល្បងមានតម្លៃ orova.test ហើយបឋមកថា X-Orova-Event ក៏ជាតម្លៃដដែល។ endpoint របស់អ្នកគួរមិនរវល់នឹងវាលដែលមិនស្គាល់ ជាជាងបដិសេធ ដើម្បីកុំឲ្យការបន្ថែមនាពេលក្រោយធ្វើឲ្យខូចខាងអ្នក។

/ ការផ្ទៀងផ្ទាត់

ផ្ទៀងផ្ទាត់ហត្ថលេខា

បឋមកថា X-Orova-Signature មានទម្រង់ sha256=<hex> ដែល <hex> គឺ HMAC-SHA256 នៃបៃតឹង របស់តួ request ដោយប្រើសោសម្ងាត់របស់ឆានែល។ សូមគណនាឡើងវិញលើបៃដែលទទួលបានផ្ទាល់ — បើញែក JSON រួចបង្កើតខ្សែអក្សរឡើងវិញនឹងមិនត្រូវគ្នាទេ ព្រោះខុសគ្នាត្រឹមដកឃ្លាមួយ ហត្ថលេខាក៏ប្រែ។

Node.js

// Node.js / Express — verify X-Orova-Signature, then answer fast
import express from "express";
import crypto from "node:crypto";

const app = express();
const OROVA_SECRET = process.env.OROVA_SECRET;   // the key you saved in Orova

// Keep the RAW bytes: the signature covers them, not re-serialized JSON.
app.post(
  "/orova/social",
  express.raw({ type: "application/json", limit: "5mb" }),
  (req, res) => {
    const sent = req.get("x-orova-signature") || "";
    const mine =
      "sha256=" +
      crypto.createHmac("sha256", OROVA_SECRET).update(req.body).digest("hex");

    // Constant-time compare — never use ===.
    const a = Buffer.from(sent);
    const b = Buffer.from(mine);
    if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
      return res.status(401).json({ error: "bad signature" });
    }

    const payload = JSON.parse(req.body.toString("utf8"));
    if (payload.event === "orova.test") {
      return res.status(200).json({ ok: true });   // the Send test button
    }

    // Real post: hand the work to a queue and reply straight away.
    queuePost(payload).catch(console.error);
    return res.status(200).json({ ok: true });
  },
);

app.listen(3000);

Python

# Python / Flask — same check, same rules
import hashlib
import hmac
import json
import os

from flask import Flask, request

app = Flask(__name__)
OROVA_SECRET = os.environ["OROVA_SECRET"].encode("utf-8")

@app.post("/orova/social")
def orova_social():
    raw = request.get_data()                       # bytes, exactly as sent
    mine = "sha256=" + hmac.new(OROVA_SECRET, raw, hashlib.sha256).hexdigest()
    sent = request.headers.get("X-Orova-Signature", "")
    if not hmac.compare_digest(mine, sent):        # constant-time compare
        return {"error": "bad signature"}, 401

    payload = json.loads(raw)
    if payload.get("event") == "orova.test":
        return {"ok": True}, 200

    queue_post(payload)                            # do the slow work later
    return {"ok": True}, 200

សូមប្រៀបធៀបដោយអនុគមន៍ពេលវេលាថេរ (crypto.timingSafeEqual, hmac.compare_digest) កុំប្រើការប្រៀបធៀបស្មើធម្មតា។ បើហត្ថលេខាមិនត្រូវគ្នា សូមឆ្លើយ 401 រួចឈប់ — កុំដំណើរការទិន្នន័យនោះ។

/ ការឆ្លើយតប

ឆ្លើយតបយ៉ាងណា

Orova មើលតែលេខស្ថានភាព HTTP។ លេខក្នុងក្រុម 2xx រាប់ជាជោគជ័យ។ តួឆ្លើយតបនឹងជាអ្វីក៏បាន។

• ឆ្លើយឲ្យលឿន. ប៊ូតុងផ្ញើសាកល្បងរង់ចាំយ៉ាងយូរ 10 វិនាទី។ ការងារធ្ងន់ ដូចជាទាញយកមេឌៀ ឬហៅ API ភាគីទីបី សូមដាក់ចូលជួរ រួចឆ្លើយ 2xx ភ្លាមៗ។
• Orova មិនព្យាយាមផ្ញើឡើងវិញដោយខ្លួនឯង. នេះជាចេតនា៖ ការព្យាយាមឡើងវិញដោយស្វ័យប្រវត្តិទៅ API បង្ហោះ គឺជាមូលហេតុនៃការបង្ហោះពីរដង។ ការផ្ញើបរាជ័យធ្វើឲ្យការបង្ហោះមានស្ថានភាព failed ជាមួយមូលហេតុ ហើយអ្នកប្រើចុចបង្ហោះម្តងទៀតក្នុង Orova។
• ត្រូវទប់ទល់នឹងទិន្នន័យស្ទួន. ពេលអ្នកប្រើចុចបង្ហោះម្តងទៀត ទិន្នន័យដដែលមកម្តងទៀត។ សូមច្រោះស្ទួននៅខាងអ្នក ឧទាហរណ៍ចងចាំគូ workspace_id និង sent_at ដែលបានដោះស្រាយរួច។

/ សុវត្ថិភាព

សុវត្ថិភាព

• ផ្ទៀងផ្ទាត់ហត្ថលេខាជានិច្ច. endpoint របស់អ្នកជា URL សាធារណៈ អ្នកណាក៏ហៅបាន។ ហត្ថលេខាជារបស់តែមួយគត់ដែលបញ្ជាក់ថាទិន្នន័យមកពី Orova ពិតប្រាកដ។
• កុំដាក់សោសម្ងាត់ក្នុងកូដ. រក្សាទុកក្នុងអថេរបរិស្ថាន ឬកម្មវិធីគ្រប់គ្រងសម្ងាត់ កុំសរសេរជាប់ក្នុងឯកសារដែលអ្នក commit។
• ប្តូរសោដោយរក្សាទុកម្តងទៀត. បញ្ចូលអាសយដ្ឋានទទួលដដែលជាមួយសោថ្មី រួចចុច Save channel — Orova សរសេរជាន់លើឆានែលចាស់។ កុំភ្លេចធ្វើបច្ចុប្បន្នភាព endpoint ក្នុងពេលតែមួយ។
• ផ្តាច់ឆានែលគឺលុបសោ. ពេលអ្នកផ្តាច់ឆានែល Orova លុបសោសម្ងាត់ដែលរក្សាទុក និងឈប់ផ្ញើទៅអាសយដ្ឋាននោះ។

/ សរុប

កិច្ចសន្យាមានតែប៉ុណ្ណេះ

អាសយដ្ឋាន https មួយ សោសម្ងាត់មួយ ការផ្ទៀងផ្ទាត់ហត្ថលេខាម្តង និងលេខ 2xx មួយ — គ្រាន់តែប៉ុណ្ណេះ ការបង្ហោះពី Orova Social ក៏ហូរចូលប្រព័ន្ធរបស់អ្នក។ អ្វីបន្តទៅ — បង្ហោះទៅណា រក្សាទុកនៅណា កត់ត្រាយ៉ាងណា — គឺអ្នកជាអ្នកសម្រេច។