# Webhook {#webhook}

Webhook trimite un eveniment GAMEMONITORING către sistemul dvs. după o acțiune pe platformă. Este o cerere obișnuită `POST` cu body JSON, astfel încât site-ul, panoul sau serviciul de joc să poată reacționa automat.

Dacă setați recompense pentru voturi, conectați mai întâi Webhook-ul după acest ghid, apoi folosiți fluxul dedicat: [Recompense pentru voturi](https://gamemonitoring.ro/developers/docs/webhook/vote#flow).

## Conectare {#connect}

Această configurare leagă un proiect GAMEMONITORING de handlerul dvs. și oferă tokenul de semnare pentru verificarea cererilor primite.

1. Deschideți [Proiectele mele](https://gamemonitoring.ro/projects/my), creați un proiect sau alegeți unul existent, apoi mergeți la setările Webhook.
2. Creați un endpoint HTTPS public care acceptă `POST` cu `Content-Type: application/json` și nu redirecționează cererile.
3. În setările Webhook, introduceți URL-ul complet al handlerului, de exemplu `https://panel.example.com/gamemonitoring-webhook`, și salvați-l.
4. Copiați tokenul de semnare din același bloc și introduceți-l în scriptul handlerului.
5. În handler, verificați `signature`, procesați `event_type` necesar și returnați un răspuns `2xx` reușit doar după procesarea evenimentului.

Pentru testare locală, puteți rula handlerul pe computerul dvs. și îl puteți expune printr-un URL HTTPS public. Folosiți [ngrok](https://ngrok.com) sau un alt serviciu de tunelare, apoi introduceți URL-ul public generat în setările Webhook.

După configurare, trimiteți un Webhook de test din interfață și verificați statusul livrării. Pentru URL-ul din exemplu, serverul trebuie să accepte `POST` pe `/gamemonitoring-webhook`.

Dacă testul eșuează, începeți cu răspunsul handlerului: `401` înseamnă eroare de semnătură, `403` sau o pagină HTML de verificare indică de obicei WAF ori bot protection, iar timeout-ul înseamnă că URL-ul nu este accesibil din internet sau răspunde prea lent.

## Cerințe pentru handler {#handler-requirements}

- URL-ul trebuie să fie accesibil din internet. Adresele locale, rețelele private și URL-urile cu login sau parolă nu sunt potrivite.
- HTTPS este recomandat pentru producție. HTTP este acceptat, dar protejează mai slab datele în tranzit.
- Handlerul trebuie să accepte metoda `POST` și body JSON fără redirectări.
- Returnați `2xx` doar după ce sistemul dvs. a procesat evenimentul. De obicei `204 No Content` este suficient.
- Dacă evenimentul nu poate fi procesat în siguranță, returnați un cod de eroare. `3xx`, `4xx`, `5xx`, timeout-ul și eroarea de conexiune sunt tratate ca livrare eșuată.
- Dacă folosiți firewall, bot protection sau allowlist, adăugați [IP-urile GAMEMONITORING](https://gamemonitoring.ro/developers/docs/ips) în excepții.
- Nu returnați în răspuns tokenuri, stack trace, erori SQL sau alte detalii interne. Răspunsul handlerului este afișat în interfață, deci textul erorii trebuie să fie sigur și clar.

## Datele evenimentului {#event-data}

Fiecare Webhook vine cu body JSON și câmpuri de bază:

- `event_type` — ce eveniment trebuie procesat.
- `event_id` — ID-ul unic al evenimentului. Folosiți-l împreună cu `event_type` pentru idempotency și protecție împotriva livrării repetate.
- `is_test` — indică o livrare de test din interfață.
- `signature` — semnătura body-ului evenimentului.

**Exemplu de eveniment Webhook**

```json
{
  "event_id": "9824cabb-2203-437e-9b6c-aba43dde3e4b",
  "event_type": "example.event",
  "is_test": false,
  "signature": "0ac4c97a5d934599dbd78985c4bcbb6926e77b4809d2be56333b1b25f638f064"
}
```

Cum citiți exemplul: `event_type` arată ce eveniment trebuie procesat; `event_id` este necesar pentru idempotency înainte de schimbări de stare; `is_test: true` înseamnă o verificare tehnică a livrării; `signature` nu este dată de business și se folosește doar pentru autentificarea cererii.

Logica de procesare depinde de `event_type`. Pentru `server.vote` și `project.vote`, folosiți fluxul separat: [Recompense pentru voturi](https://gamemonitoring.ro/developers/docs/webhook/vote#flow).

Dacă `is_test` este `true`, verificați semnătura și returnați `2xx`, dar nu modificați balanța, nu acordați obiecte și nu porniți operații de producție.

## Exemplu de răspuns al handlerului {#response-example}

Finalizați fiecare eveniment primit cu un singur rezultat clar:

- `204 No Content` — semnătura este corectă, iar evenimentul a fost procesat sau omis în siguranță. Returnați același răspuns pentru o livrare de test și pentru un eveniment deja procesat.
- `400 Bad Request` — lipsesc câmpuri obligatorii. Aceasta înseamnă o eroare în handler sau un body de cerere neașteptat; nu porniți logica de business.
- `401 Unauthorized` — semnătura este invalidă. Nu faceți cereri API, nu modificați baza de date și nu acordați recompense.
- `500 Internal Server Error` — baza, coada sau un sistem intern este temporar indisponibil. Livrarea rămâne eșuată și poate fi retrimisă după remedierea cauzei.

Exemplu: dacă handlerul a primit evenimentul, a verificat semnătura, a salvat `event_type` + `event_id` și a procesat evenimentul, poate returna `204`. Dacă baza este indisponibilă și evenimentul nu poate fi salvat, este mai bine să returnați `500`, ca livrarea să nu fie marcată prea devreme ca reușită.

## Verificarea semnăturii {#signature}

Semnătura se află în câmpul `signature`. Verificați-o înainte de orice logică de business, cereri API și modificări în baza de date.

Pentru verificare, luați toate câmpurile body-ului în afară de `signature`, sortați cheile alfabetic și construiți un șir `key=value` unit prin `&`. Valorile boolean se scriu ca `true` sau `false`.

**Șir pentru semnătură**

```text
event_id=9824cabb-2203-437e-9b6c-aba43dde3e4b&event_type=example.event&is_test=false
```

Pentru exemplul de mai sus, șirul de semnare se construiește doar din `event_id`, `event_type` și `is_test`. Apoi calculați `HMAC-SHA256` cu tokenul de semnare din setările Webhook și comparați rezultatul cu `signature` din cerere.

Semnăturile precalculate din exemple folosesc tokenul demonstrativ `paste-webhook-token-here`. În handlerul dvs., folosiți tokenul din setările Webhook.

În handlerul dvs.:

- construiți șirul pentru semnătură din chei sortate;
- calculați `HMAC-SHA256` cu tokenul de semnare;
- comparați rezultatul cu `signature` folosind o funcție cu timp constant de comparare: `hash_equals` în PHP, `timingSafeEqual` în Node.js sau `compare_digest` în Python;
- returnați `401` dacă semnătura este invalidă.

## Pasul 1. Handler de bază {#minimal-handler}

Începeți cu un handler care poate primi orice Webhook: citește JSON, verifică `signature`, procesează livrarea de test, verifică câmpurile de bază și returnează `204`. În acest pas, handlerul doar confirmă că livrarea este acceptată corect. Adăugați logica specifică evenimentului după ce acest flux de bază funcționează.

### PHP

```php
<?php
// Replace this token with the signing token from your GAMEMONITORING webhook settings.
$secret = 'paste-webhook-token-here';

// Read and decode the JSON body sent by GAMEMONITORING.
$event = json_decode(file_get_contents('php://input'), true) ?: [];

// Test deliveries are signed too. Normalize the boolean value to the lowercase
// string used by GAMEMONITORING when the signature is calculated.
$isTest = ($event['is_test'] ?? false) === true;
$signingData = array_replace($event, ['is_test' => $isTest ? 'true' : 'false']);

// Build the exact signing string: all body fields except signature,
// sorted by key and joined as key=value pairs with &.
$fields = array_values(array_filter(array_keys($event), fn($field) => $field !== 'signature'));
sort($fields, SORT_STRING);

// Calculate HMAC-SHA256 with the webhook token from your settings.
$signing = implode('&', array_map(fn($field) => $field . '=' . (string) ($signingData[$field] ?? ''), $fields));
$expected = hash_hmac('sha256', $signing, $secret);
$actual = (string) ($event['signature'] ?? '');

// Reject the request before doing any work when the signature is invalid.
if (!hash_equals($expected, $actual)) {
    http_response_code(401);
    exit;
}

// Test deliveries must not change balance, inventory, roles, or production data.
if ($isTest) {
    http_response_code(204);
    exit;
}

// Real deliveries must include an event type and a stable event id.
$eventType = (string) ($event['event_type'] ?? '');
$eventId = (string) ($event['event_id'] ?? '');

if ($eventType === '' || $eventId === '') {
    http_response_code(400);
    exit;
}

// At this point the webhook is trusted. Add event-specific logic here.
syslog(LOG_INFO, 'Accepted webhook event ' . $eventType . ' #' . $eventId);

// 204 tells GAMEMONITORING that the delivery was accepted successfully.
http_response_code(204);
```

### JavaScript

```javascript
const crypto = require('node:crypto')
const express = require('express')

const app = express()
// Replace this token with the signing token from your GAMEMONITORING webhook settings.
const secret = 'paste-webhook-token-here'

// GAMEMONITORING sends JSON with Content-Type: application/json.
app.use(express.json())

function isValidSignature(event) {
  // Build the exact signing string: all body fields except signature,
  // sorted by key and joined as key=value pairs with &.
  const fields = Object.keys(event).filter((field) => field !== 'signature').sort()
  const signing = fields.map((field) => field + '=' + String(event[field] ?? '')).join('&')

  // Calculate HMAC-SHA256 with the webhook token from your settings.
  const expected = crypto.createHmac('sha256', secret).update(signing).digest('hex')
  const actual = String(event.signature || '')

  // timingSafeEqual requires buffers with the same length.
  const expectedBuffer = Buffer.from(expected)
  const actualBuffer = Buffer.from(actual)

  return expectedBuffer.length === actualBuffer.length && crypto.timingSafeEqual(expectedBuffer, actualBuffer)
}

app.post('/gamemonitoring-webhook', (req, res) => {
  // Read the webhook payload parsed by express.json().
  const event = req.body || {}

  // Reject the request before doing any work when the signature is invalid.
  if (!isValidSignature(event)) {
    return res.sendStatus(401)
  }

  // Test deliveries must not change balance, inventory, roles, or production data.
  if (event.is_test === true) {
    return res.sendStatus(204)
  }

  // Real deliveries must include an event type and a stable event id.
  const eventType = String(event.event_type || '')
  const eventId = String(event.event_id || '')

  if (!eventType || !eventId) {
    return res.sendStatus(400)
  }

  // At this point the webhook is trusted. Add event-specific logic here.
  console.log('Accepted webhook event ' + eventType + ' #' + eventId)

  // 204 tells GAMEMONITORING that the delivery was accepted successfully.
  return res.sendStatus(204)
})

app.listen(3000)
```

### Python

```python
import hashlib
import hmac

from flask import Flask, abort, request

app = Flask(__name__)
# Replace this token with the signing token from your GAMEMONITORING webhook settings.
secret = b'paste-webhook-token-here'

def stringify(value):
    # GAMEMONITORING signs booleans as lowercase true/false strings.
    if isinstance(value, bool):
        return 'true' if value else 'false'

    return '' if value is None else str(value)

def is_valid_signature(event):
    # Build the exact signing string: all body fields except signature,
    # sorted by key and joined as key=value pairs with &.
    fields = sorted(field for field in event.keys() if field != 'signature')
    signing = '&'.join(f'{field}={stringify(event.get(field))}' for field in fields)

    # Calculate HMAC-SHA256 with the webhook token from your settings.
    expected = hmac.new(secret, signing.encode(), hashlib.sha256).hexdigest()
    actual = str(event.get('signature') or '')

    return hmac.compare_digest(expected, actual)

@app.post('/gamemonitoring-webhook')
def gamemonitoring_webhook():
    # Read and decode the JSON body sent by GAMEMONITORING.
    event = request.get_json(silent=True) or {}

    # Reject the request before doing any work when the signature is invalid.
    if not is_valid_signature(event):
        abort(401)

    # Test deliveries must not change balance, inventory, roles, or production data.
    if event.get('is_test') is True:
        return '', 204

    # Real deliveries must include an event type and a stable event id.
    event_type = str(event.get('event_type') or '')
    event_id = str(event.get('event_id') or '')

    if not event_type or not event_id:
        abort(400)

    # At this point the webhook is trusted. Add event-specific logic here.
    app.logger.info('Accepted webhook event %s #%s', event_type, event_id)

    # 204 tells GAMEMONITORING that the delivery was accepted successfully.
    return '', 204
```

## Pasul 2. Adăugați deduplicarea {#deduplication}

Webhook folosește modelul at-least-once: același eveniment poate ajunge de mai multe ori. Înainte ca handlerul să schimbe starea sistemului dvs., faceți operația idempotentă pe baza `event_type` + `event_id`.

Creați mai întâi un tabel care salvează perechea `event_type` și `event_id` cu cheie unică. Dacă înregistrarea există deja, evenimentul a fost procesat.

**Tabel cu evenimente Webhook procesate**

```sql
CREATE TABLE gamemonitoring_webhooks (
  event_type varchar(64) NOT NULL,
  event_id varchar(100) NOT NULL,
  created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (event_type, event_id)
);
```

Apoi extindeți handlerul de bază: după verificarea semnăturii și a câmpurilor de bază, salvați `event_type` + `event_id` și executați schimbările de stare în aceeași tranzacție.

### PHP

```php
<?php
// Replace this token with the signing token from your GAMEMONITORING webhook settings.
$secret = 'paste-webhook-token-here';

// Read and decode the JSON body sent by GAMEMONITORING.
$event = json_decode(file_get_contents('php://input'), true) ?: [];

// Test deliveries are signed too. Normalize the boolean value to the lowercase
// string used by GAMEMONITORING when the signature is calculated.
$isTest = ($event['is_test'] ?? false) === true;
$signingData = array_replace($event, ['is_test' => $isTest ? 'true' : 'false']);

// Build the exact signing string: all body fields except signature,
// sorted by key and joined as key=value pairs with &.
$fields = array_values(array_filter(array_keys($event), fn($field) => $field !== 'signature'));
sort($fields, SORT_STRING);

// Calculate HMAC-SHA256 with the webhook token from your settings.
$signing = implode('&', array_map(fn($field) => $field . '=' . (string) ($signingData[$field] ?? ''), $fields));
$expected = hash_hmac('sha256', $signing, $secret);
$actual = (string) ($event['signature'] ?? '');

// Reject the request before doing any work when the signature is invalid.
if (!hash_equals($expected, $actual)) {
    http_response_code(401);
    exit;
}

// Test deliveries must not change balance, inventory, roles, or production data.
if ($isTest) {
    http_response_code(204);
    exit;
}

// Real deliveries must include an event type and a stable event id.
$eventType = (string) ($event['event_type'] ?? '');
$eventId = (string) ($event['event_id'] ?? '');

if ($eventType === '' || $eventId === '') {
    http_response_code(400);
    exit;
}

// At this point the webhook is trusted. Deduplicate it before event-specific logic.
$pdo = null;

try {
    // Add your local database connection for deduplication and event-specific work.
    $pdo = new PDO('mysql:host=127.0.0.1;dbname=game;charset=utf8mb4', 'game', 'password', [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    ]);

    // Keep deduplication and the real state change in one transaction.
    // If any step fails, return 500 so the delivery can be retried.
    $pdo->beginTransaction();

    // Store the event once. This requires the table to have a unique key on
    // (event_type, event_id). Duplicate deliveries affect zero rows.
    $deduplicate = $pdo->prepare('INSERT IGNORE INTO gamemonitoring_webhooks (event_type, event_id) VALUES (?, ?)');
    $deduplicate->execute([$eventType, $eventId]);

    // The event was already processed earlier. Return success without changing
    // state again, because duplicate delivery is expected.
    if ($deduplicate->rowCount() === 0) {
        $pdo->commit();
        http_response_code(204);
        exit;
    }

    // Add event-specific database changes here. Keep them after the
    // deduplication insert and inside this same transaction.

    // Commit only after deduplication and event-specific work both succeed.
    $pdo->commit();

    // Log only newly processed real events after the transaction succeeds.
    syslog(LOG_INFO, 'Accepted webhook event ' . $eventType . ' #' . $eventId);

    http_response_code(204);
} catch (Throwable $error) {
    // Roll back partial database work so the event can be retried safely.
    if ($pdo instanceof PDO && $pdo->inTransaction()) {
        $pdo->rollBack();
    }

    // 500 keeps the delivery failed instead of marking unfinished work as done.
    http_response_code(500);
}
```

### JavaScript

```javascript
const crypto = require('node:crypto')
const express = require('express')
const mysql = require('mysql2/promise')

const app = express()
// Replace this token with the signing token from your GAMEMONITORING webhook settings.
const secret = 'paste-webhook-token-here'

// Add your local database connection for deduplication and event-specific work.
const db = mysql.createPool({
  database: 'game',
  host: '127.0.0.1',
  password: 'password',
  user: 'game',
})

// GAMEMONITORING sends JSON with Content-Type: application/json.
app.use(express.json())

function isValidSignature(event) {
  // Build the exact signing string: all body fields except signature,
  // sorted by key and joined as key=value pairs with &.
  const fields = Object.keys(event).filter((field) => field !== 'signature').sort()
  const signing = fields.map((field) => field + '=' + String(event[field] ?? '')).join('&')

  // Calculate HMAC-SHA256 with the webhook token from your settings.
  const expected = crypto.createHmac('sha256', secret).update(signing).digest('hex')
  const actual = String(event.signature || '')

  // timingSafeEqual requires buffers with the same length.
  const expectedBuffer = Buffer.from(expected)
  const actualBuffer = Buffer.from(actual)

  return expectedBuffer.length === actualBuffer.length && crypto.timingSafeEqual(expectedBuffer, actualBuffer)
}

app.post('/gamemonitoring-webhook', async (req, res) => {
  // Read the webhook payload parsed by express.json().
  const event = req.body || {}

  // Reject the request before doing any work when the signature is invalid.
  if (!isValidSignature(event)) {
    return res.sendStatus(401)
  }

  // Test deliveries must not change balance, inventory, roles, or production data.
  if (event.is_test === true) {
    return res.sendStatus(204)
  }

  // Real deliveries must include an event type and a stable event id.
  const eventType = String(event.event_type || '')
  const eventId = String(event.event_id || '')

  if (!eventType || !eventId) {
    return res.sendStatus(400)
  }

  // At this point the webhook is trusted. Deduplicate it before event-specific logic.
  let connection

  try {
    connection = await db.getConnection()

    // Keep deduplication and the real state change in one transaction.
    // If any step fails, return 500 so the delivery can be retried.
    await connection.beginTransaction()

    // Store the event once. This requires the table to have a unique key on
    // (event_type, event_id). Duplicate deliveries affect zero rows.
    const [deduplicate] = await connection.execute(
      'INSERT IGNORE INTO gamemonitoring_webhooks (event_type, event_id) VALUES (?, ?)',
      [eventType, eventId],
    )

    // The event was already processed earlier. Return success without changing
    // state again, because duplicate delivery is expected.
    if (deduplicate.affectedRows === 0) {
      await connection.commit()
      return res.sendStatus(204)
    }

    // Add event-specific database changes here. Keep them after the
    // deduplication insert and inside this same transaction.

    // Commit only after deduplication and event-specific work both succeed.
    await connection.commit()

    // Log only newly processed real events after the transaction succeeds.
    console.log('Accepted webhook event ' + eventType + ' #' + eventId)

    return res.sendStatus(204)
  } catch (error) {
    // Roll back partial database work so the event can be retried safely.
    if (connection) {
      await connection.rollback()
    }

    // 500 keeps the delivery failed instead of marking unfinished work as done.
    return res.sendStatus(500)
  } finally {
    // Return the connection to the pool.
    if (connection) {
      connection.release()
    }
  }
})

app.listen(3000)
```

### Python

```python
import hashlib
import hmac

import pymysql
from flask import Flask, abort, request

app = Flask(__name__)
# Replace this token with the signing token from your GAMEMONITORING webhook settings.
secret = b'paste-webhook-token-here'

# Add your local database connection for deduplication and event-specific work.
db_config = {
    'database': 'game',
    'host': '127.0.0.1',
    'password': 'password',
    'user': 'game',
}

def stringify(value):
    # GAMEMONITORING signs booleans as lowercase true/false strings.
    if isinstance(value, bool):
        return 'true' if value else 'false'

    return '' if value is None else str(value)

def is_valid_signature(event):
    # Build the exact signing string: all body fields except signature,
    # sorted by key and joined as key=value pairs with &.
    fields = sorted(field for field in event.keys() if field != 'signature')
    signing = '&'.join(f'{field}={stringify(event.get(field))}' for field in fields)

    # Calculate HMAC-SHA256 with the webhook token from your settings.
    expected = hmac.new(secret, signing.encode(), hashlib.sha256).hexdigest()
    actual = str(event.get('signature') or '')

    return hmac.compare_digest(expected, actual)

@app.post('/gamemonitoring-webhook')
def gamemonitoring_webhook():
    # Read and decode the JSON body sent by GAMEMONITORING.
    event = request.get_json(silent=True) or {}

    # Reject the request before doing any work when the signature is invalid.
    if not is_valid_signature(event):
        abort(401)

    # Test deliveries must not change balance, inventory, roles, or production data.
    if event.get('is_test') is True:
        return '', 204

    # Real deliveries must include an event type and a stable event id.
    event_type = str(event.get('event_type') or '')
    event_id = str(event.get('event_id') or '')

    if not event_type or not event_id:
        abort(400)

    # At this point the webhook is trusted. Deduplicate it before event-specific logic.
    connection = None

    try:
        connection = pymysql.connect(**db_config)
        connection.begin()

        # Keep deduplication and the real state change in one transaction.
        # If any step fails, return 500 so the delivery can be retried.
        with connection.cursor() as cursor:
            # Store the event once. This requires the table to have a unique key
            # on (event_type, event_id). Duplicate deliveries affect zero rows.
            cursor.execute(
                'INSERT IGNORE INTO gamemonitoring_webhooks (event_type, event_id) VALUES (%s, %s)',
                (event_type, event_id),
            )

            # The event was already processed earlier. Return success without
            # changing state again, because duplicate delivery is expected.
            if cursor.rowcount == 0:
                connection.commit()
                return '', 204

            # Add event-specific database changes here. Keep them after the
            # deduplication insert and inside this same transaction.

        # Commit only after deduplication and event-specific work both succeed.
        connection.commit()

        # Log only newly processed real events after the transaction succeeds.
        app.logger.info('Accepted webhook event %s #%s', event_type, event_id)

        return '', 204
    except Exception:
        # Roll back partial database work so the event can be retried safely.
        if connection:
            connection.rollback()

        # 500 keeps the delivery failed instead of marking unfinished work as done.
        abort(500)
    finally:
        # Close the database connection.
        if connection:
            connection.close()
```

Nu folosiți nickname-ul, ID-ul utilizatorului sau ID-ul serverului ca cheie de deduplicare: un utilizator poate declanșa evenimente diferite sau poate repeta mai târziu o acțiune permisă. Cheia trebuie să fie `event_type` + `event_id`.

Exemplu: handlerul a schimbat starea sistemului dvs., dar conexiunea s-a întrerupt înainte ca GAMEMONITORING să primească `204`. Mai târziu livrarea este retrimisă și același eveniment sosește din nou. Handlerul trebuie să găsească `event_type` + `event_id` salvate, să sară schimbarea de stare repetată și să returneze `204`.

Dacă handlerul nu poate procesa temporar evenimentul, returnați un răspuns cu eroare. După remedierea cauzei, livrarea poate fi retrimisă din interfață, dacă retrimiterea este disponibilă pentru acel eveniment.

## Teste și retrimitere {#tests-resend}

O livrare de test (`is_test: true`) verifică URL-ul, semnătura și răspunsul HTTP al handlerului. Handlerul trebuie să treacă prin același flux de procesare: citește JSON, verifică `signature`, recunoaște `is_test` și returnează un răspuns `2xx` reușit.

Un eveniment de test nu trebuie să modifice balanța, inventarul, rolurile, abonamentele sau alte date de producție. Pentru test sunt suficiente un log tehnic și răspunsul `204`.

Dacă livrarea eșuează, interfața arată statusul, codul HTTP și răspunsul handlerului. După remedierea cauzei, livrarea eșuată poate fi retrimisă dacă retrimiterea este disponibilă pentru acel eveniment.
