src/ApplicationBundle/Modules/AiEmployee/Controller/WhatsAppWebhookController.php line 58

Open in your IDE?
  1. <?php
  3. namespace ApplicationBundle\Modules\AiEmployee\Controller;
  5. use ApplicationBundle\Controller\GenericController;
  6. use ApplicationBundle\Helper\WhatsAppConfig;
  7. use ApplicationBundle\Interfaces\PublicApiInterface;
  8. use ApplicationBundle\Modules\AiEmployee\Service\CommIngestService;
  9. use ApplicationBundle\Modules\AiEmployee\Service\InboundReplyService;
  10. use ApplicationBundle\Modules\AiEmployee\Service\RelayVaultSink;
  11. use ApplicationBundle\Modules\AiEmployee\Service\WhatsAppInboundService;
  12. use ApplicationBundle\Modules\AiEmployee\Support\WhatsAppPolicyCore;
  13. use CompanyGroupBundle\Entity\BusinessPersona;
  14. use CompanyGroupBundle\Entity\ChannelIdentity;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\Response;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  19. /**
  20.  * AIE AE7 — the WhatsApp Cloud API webhook (constitution §5 AE7). Sessionless (PublicApiInterface):
  21.  * the signature IS the credential, exactly like the EB ingress. Two jobs on one URL:
  22.  *   GET  — Meta's subscription handshake: echo `hub.challenge` when `hub.verify_token` matches ③.
  23.  *   POST — inbound messages: verify `X-Hub-Signature-256` (HMAC-SHA256 over the raw body with the
  24.  *          app secret ④), then hand each message to WhatsAppInboundService, which resolves the
  25.  *          number → employee → tenant and lands it through AE2 (external posture).
  26.  * FAIL-CLOSED: no verify token / app secret configured → the endpoint refuses (nothing runs under
  27.  * a guessed identity). Always answers Meta with 200 once verified — the AE2 DLQ (comm_failed_event)
  28.  * captures a tenant-DB hiccup for replay, so a message is never lost, and Meta never retry-storms.
  29.  */
  30. class WhatsAppWebhookController extends GenericController implements PublicApiInterface
  31. {
  32.     const MAX_BYTES = 3145728; // 3 MB cap (DoS guard)
  34.     public function webhookAction(Request $request)
  35.     {
  36.         if ($request->getMethod() === 'GET') {
  37.             return $this->verify($request);
  38.         }
  39.         return $this->receive($request);
  40.     }
  42.     /** Meta subscription verification: echo the challenge iff the verify token matches. */
  43.     private function verify(Request $request)
  44.     {
  45.         $verifyToken = WhatsAppConfig::verifyToken();
  46.         if ($verifyToken === '') {
  47.             return new Response('whatsapp webhook not configured', 503);
  48.         }
  49.         if ($request->query->get('hub_mode', $request->query->get('hub.mode')) === 'subscribe'
  50.             && hash_equals($verifyToken, (string) $request->query->get('hub_verify_token', $request->query->get('hub.verify_token', '')))) {
  51.             $challenge = (string) $request->query->get('hub_challenge', $request->query->get('hub.challenge', ''));
  52.             return new Response($challenge, 200, array('Content-Type' => 'text/plain'));
  53.         }
  54.         return new Response('forbidden', 403);
  55.     }
  57.     /** Inbound messages: verify signature, then land each message through AE7 → AE2. */
  58.     private function receive(Request $request)
  59.     {
  60.         $raw = (string) $request->getContent();
  61.         if (strlen($raw) > self::MAX_BYTES) {
  62.             return new JsonResponse(array('error' => 'payload too large'), 413);
  63.         }
  64.         $secret = WhatsAppConfig::appSecret();
  65.         if ($secret === '') {
  66.             return new JsonResponse(array('error' => 'whatsapp webhook not configured'), 503);
  67.         }
  68.         $sig = (string) $request->headers->get('X-Hub-Signature-256', '');
  69.         $expected = 'sha256=' . hash_hmac('sha256', $raw, $secret);
  70.         if (!hash_equals($expected, $sig)) {
  71.             return new JsonResponse(array('error' => 'bad signature'), 401);
  72.         }
  74.         $payload = json_decode($raw, true);
  75.         if (!is_array($payload)) {
  76.             return new JsonResponse(array('error' => 'malformed'), 400);
  77.         }
  79.         $cem = $this->getDoctrine()->getManager('company_group');
  80.         $ingest = new CommIngestService($cem);
  81.         $inbound = new WhatsAppInboundService($cem, $ingest);
  82.         $reply = new InboundReplyService($cem, $this->container);
  83.         $replyNotes = array();
  85.         $attempted = 0;
  86.         $landed = 0;
  87.         $failed = 0;
  88.         $errors = array();
  89.         foreach ($this->extractMessages($payload) as $event) {
  90.             $attempted++;
  91.             $sink = $this->vaultSinkFor($cem, $event['business_number']);
  92.             try {
  93.                 $res = $inbound->ingestWebhook($event, $sink);
  94.                 // Durably stored, or already stored (dedupe) — both are honest to acknowledge.
  95.                 if (!empty($res['ok']) || (isset($res['receipt']) && !empty($res['receipt']['deduped']))) {
  96.                     $landed++;
  97.                     // THE REPLY TRIGGER — only after the body is DURABLY stored. Drafts only; nothing
  98.                     // is sent. Its failure is reported, never fatal: the message is already stored, so
  99.                     // letting a drafting error reach the ack would make Meta retry a message we hold.
  100.                     // NOT on a deduped receipt: Meta documents that retries cause duplicate deliveries,
  101.                     // and drafting again for a message we already answered would reply twice.
  102.                     if (!empty($res['ok']) && empty($res['receipt']['deduped'])) {
  103.                         $d = $reply->draftReplyTo(array(
  104.                             'app_id' => isset($res['app_id']) ? $res['app_id'] : null,
  105.                             'conversation_id' => isset($res['conversation_id']) ? $res['conversation_id'] : (isset($res['receipt']['conversation_id']) ? $res['receipt']['conversation_id'] : null),
  106.                             'persona_id' => isset($res['persona_id']) ? $res['persona_id'] : null,
  107.                             'body' => isset($event['body']) ? $event['body'] : '',
  108.                             'sender_ref' => isset($event['from']) ? $event['from'] : '',
  109.                             'message_id' => isset($event['message_id']) ? $event['message_id'] : '',
  110.                             'subject' => 'your WhatsApp message',
  111.                         ));
  112.                         if (empty($d['drafted'])) { $replyNotes[] = $d['reason']; }
  113.                     }
  114.                 } else {
  115.                     $failed++;
  116.                     $errors[] = isset($res['reason']) ? (string) $res['reason'] : 'ingest did not land the message';
  117.                 }
  118.             } catch (\Throwable $e) {
  119.                 // We do NOT swallow this. The old code caught it and still answered 200 — that is how
  120.                 // the body was destroyed while we told Meta "ok". Count it, and refuse to acknowledge.
  121.                 $failed++;
  122.                 $errors[] = $e->getMessage();
  123.             }
  124.         }
  126.         // ★ THE ACK LAW: never acknowledge what we have not durably stored. A 200 makes Meta drop the
  127.         // message forever; a non-2xx makes Meta RETAIN it and retry — Meta is the durable buffer, and
  128.         // no PII has to rest on central for that (R6 intact). See WhatsAppPolicyCore::ackStatus().
  129.         $status = WhatsAppPolicyCore::ackStatus($attempted, $landed, $failed);
  130.         if ($status !== 200) {
  131.             return new JsonResponse(array(
  132.                 'status' => 'error',
  133.                 'error' => 'not stored — retry required',
  134.                 'attempted' => $attempted,
  135.                 'landed' => $landed,
  136.                 'failed' => $failed,
  137.                 'reasons' => array_slice($errors, 0, 5),
  138.             ), $status);
  139.         }
  140.         $ok = array('status' => 'ok', 'attempted' => $attempted, 'landed' => $landed);
  141.         if ($replyNotes) { $ok['reply_notes'] = array_slice($replyNotes, 0, 5); } // reported, never fatal
  142.         return new JsonResponse($ok, 200);
  143.     }
  145.     /** Flatten a Cloud API webhook payload into AE7 events (text messages; others recorded as type). */
  146.     private function extractMessages(array $payload)
  147.     {
  148.         $events = array();
  149.         foreach (isset($payload['entry']) && is_array($payload['entry']) ? $payload['entry'] : array() as $entry) {
  150.             foreach (isset($entry['changes']) && is_array($entry['changes']) ? $entry['changes'] : array() as $change) {
  151.                 $value = isset($change['value']) && is_array($change['value']) ? $change['value'] : array();
  152.                 if (empty($value['messages']) || !is_array($value['messages'])) {
  153.                     continue; // status callbacks etc. — ignore
  154.                 }
  155.                 $business = isset($value['metadata']['display_phone_number']) ? (string) $value['metadata']['display_phone_number'] : '';
  156.                 foreach ($value['messages'] as $m) {
  157.                     $type = isset($m['type']) ? (string) $m['type'] : 'unknown';
  158.                     $body = '';
  159.                     if ($type === 'text' && isset($m['text']['body'])) {
  160.                         $body = (string) $m['text']['body'];
  161.                     } elseif (isset($m['button']['text'])) {
  162.                         $body = (string) $m['button']['text'];
  163.                     } elseif (isset($m[$type]['caption'])) {
  164.                         $body = (string) $m[$type]['caption'];
  165.                     } else {
  166.                         $body = '[' . $type . ']';
  167.                     }
  168.                     $ts = isset($m['timestamp']) && ctype_digit((string) $m['timestamp']) ? (int) $m['timestamp'] : time();
  169.                     $events[] = array(
  170.                         'business_number' => $business,
  171.                         'from' => isset($m['from']) ? (string) $m['from'] : '',
  172.                         'message_id' => isset($m['id']) ? (string) $m['id'] : '',
  173.                         'body' => $body,
  174.                         'group_id' => isset($value['metadata']['group_id']) ? (string) $value['metadata']['group_id'] : (isset($m['group_id']) ? (string) $m['group_id'] : ''),
  175.                         'occurred_at' => date('Y-m-d H:i:s', $ts),
  176.                         'sender_display' => isset($value['contacts'][0]['profile']['name']) ? (string) $value['contacts'][0]['profile']['name'] : null,
  177.                     );
  178.                 }
  179.             }
  180.         }
  181.         return $events;
  182.     }
  184.     /**
  185.      * CC7 Finding-A FIX: resolve the number → tenant, then return the SIGNED-HTTP RELAY sink for that
  186.      * tenant's box. The previous implementation (tenantConnFor) opened a LIVE central→tenant DBAL
  187.      * connection off the registry creds — which the CC7 law forbids (localhost-scoped creds +
  188.      * credential blast radius), which is impossible when the tenant DB is on another server, and which
  189.      * silently destroyed every inbound message on distributed prod. It is deleted, not deprecated.
  190.      *
  191.      * Returns null when the number is unknown. A null sink makes ingest fail → the ACK LAW returns
  192.      * non-2xx → Meta RETAINS the body and retries. We never ack a message we could not place.
  193.      */
  194.     private function vaultSinkFor($cem, $businessNumber)
  195.     {
  196.         try {
  197.             $num = WhatsAppPolicyCore::normalizeNumber($businessNumber);
  198.             $digits = preg_replace('/\D+/', '', (string) $num);
  199.             $identity = null;
  200.             foreach (array_unique(array($num, '+' . $digits, $digits)) as $candidate) {
  201.                 if ($candidate === '') { continue; }
  202.                 $identity = $cem->getRepository(ChannelIdentity::class)->findOneBy(array('channel' => 'whatsapp', 'address' => $candidate, 'active' => 1));
  203.                 if ($identity) { break; }
  204.             }
  205.             if (!$identity) {
  206.                 return null;
  207.             }
  208.             $persona = $cem->getRepository(BusinessPersona::class)->find((int) $identity->getPersonaId());
  209.             if (!$persona) {
  210.                 return null;
  211.             }
  212.             $company = $cem->getRepository('CompanyGroupBundle\Entity\CompanyGroup')->findOneBy(array('appId' => (int) $persona->getAppId()));
  213.             if (!$company) {
  214.                 return null;
  215.             }
  216.             return RelayVaultSink::fromCompany($company);
  217.         } catch (\Throwable $e) {
  218.             return null;
  219.         }
  220.     }
  221. }