> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Actorok: mintafolyamatok

> Mintafolyamatok életciklus-kezelőkhöz, időzítőkhöz, kapcsolatokhoz, hívható metódusokhoz, tároláshoz, entitásokhoz és backend-függvényekhez

Ön a fejlesztői dokumentációt nézi

Ez a dokumentáció a Base44 fejlesztői
platformmal dolgozó fejlesztőknek szól.

Használja ezeket a mintafolyamatokat kiindulópontként a megvalósításhoz.

## Kliens csatlakoztatása egy munkamenethez

Ha a frontendnek csatlakoznia kell egy élő munkamenethez, üzeneteket kell fogadnia az actortól és üzeneteket kell küldenie neki, csatlakoztasson egy klienst egy actor-munkamenethez.

**Kliens csatlakoztatása egy munkamenethez:**

1. Hívja meg a [`base44.actors.ActorName(sessionId)`](https://docs.base44.com/developers/references/sdk/docs/type-aliases/actors) metódust a munkamenet kiválasztásához.
2. Hívja meg a [`.connect()`](https://docs.base44.com/developers/references/sdk/docs/type-aliases/actors#connect) metódust a WebSocket-kapcsolat megnyitásához.
3. Hívja meg a [`conn.subscribe()`](https://docs.base44.com/developers/references/sdk/docs/type-aliases/actors#subscribe) metódust egy figyelő regisztrálásához az actortól érkező üzenetekhez.
4. Hívja meg a [`conn.send()`](https://docs.base44.com/developers/references/sdk/docs/type-aliases/actors#send) metódust üzenet küldéséhez az actornak.

A következő példa egy `chatRoom` actor-munkamenethez csatlakozik, figyeli az üzeneteket, és üzenetet küld:

```typescript theme={null}
const conn = base44.actors.chatRoom("lobby-1").connect();

conn.subscribe((msg) => {
  if (msg.type === "message") console.log(msg.text);
});

conn.send({ type: "message", text: "Hello" });
```

A kapcsolatokról további információt a [kapcsolatok](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#connections) részben talál.

## Tickek futtatása

Ha egy munkát meghatározott időközönként kell ismételni, amíg kliensek vannak a munkamenetben, futtasson tickeket. Ilyen például a játékállapot szétküldése vagy egy kör időzítőjének frissítése.

**Tickek futtatása:**

1. Állítsa a [`tickIntervalMs`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) értékét az időköz ezredmásodpercben megadott hosszára.
2. Valósítsa meg a [`shouldTick()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) metódust úgy, hogy `true` értéket adjon vissza a tickek folytatásához, és `false` értéket a leállításhoz.
3. A [`handleTick()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) metódusban futtassa az egyes időközök munkáját.

A következő példa másodpercenként tickel, amíg legalább két kliens van a munkamenetben, és minden ticknél visszaszámlálást küld szét:

```typescript theme={null}
export default class Game extends Actor<Incoming, Outgoing> {
  tickIntervalMs = 1000;
  countdown = 60;

  shouldTick() {
    return this.getConnections().length >= 2;
  }

  async handleTick() {
    this.countdown--;
    this.broadcast({ type: "tick", countdown: this.countdown });
  }
}
```

A tickekről további információt az [időzítőkezelők és -beállítások](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#timer-handlers-and-settings) részben talál.

## Ébresztések ütemezése

Ha egy munkát egyszer, egy adott időpontban kell futtatni, függetlenül attól, hogy a munkamenet aktív vagy tétlen, ütemezzen ébresztést. Ilyen például egy kör lezárása 30 másodperc után vagy egy üres váróterem bezárása.

**Ébresztés ütemezése:**

1. Hívja meg a [`schedule()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) metódust egy kulccsal és egy időponttal az ébresztés élesítéséhez.
2. A [`handleWake()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) metódusban ellenőrizze a kulcsot, és futtassa az adott ébresztés munkáját.
3. Ha az ébresztés már nem érvényes, hívja meg a [`cancelSchedule()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#timer-handlers-and-settings) metódust a kulccsal.

A következő példa egy kör kezdetekor időtúllépést ütemez, és az időtúllépés bekövetkezésekor üzenetet küld szét:

```typescript theme={null}
export default class Game extends Actor<Incoming, Outgoing> {
  async handleMessage(_conn, msg) {
    if (msg.type === "start-turn") {
      await this.schedule("turn-timeout", Date.now() + 30_000);
    }
    if (msg.type === "end-turn") {
      await this.cancelSchedule("turn-timeout");
    }
  }

  async handleWake(key: string) {
    if (key === "turn-timeout") {
      this.broadcast({ type: "timeout" });
    }
  }
}
```

Az ébresztésekről további információt az [időzítőkezelők és -beállítások](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#timer-handlers-and-settings) részben talál.

## A klienskapcsolatok kezelése

Ha el kell döntenie, ki csatlakozhat egy munkamenethez, egy adott kliensnek kell válaszolnia, és a munkamenet minden kliensét el kell érnie, kezelje a klienskapcsolatokat.

**A klienskapcsolatok kezelése:**

1. A [`handleConnect()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#lifecycle-handlers) metódusban ellenőrizze a [`conn.identity`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) értékét, és egy kliens elutasításához hívja meg a [`conn.reject()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) metódust.
2. Hívja meg a [`conn.send()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) metódust, ha csak annak a kliensnek szeretne válaszolni.
3. A [`handleMessage()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#lifecycle-handlers) metódusban hívja meg a [`broadcast()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) metódust az összes csatlakozott kliens eléréséhez. A küldő azonosításához tegye bele az üzenetbe a `conn` mezőit.

A következő példa elutasítja a névtelen klienseket, előzményeket küld a csatlakozó kliensnek, és a küldő felhasználói azonosítójával küldi szét az üzeneteket:

```typescript theme={null}
async handleConnect(conn) {
  if (conn.identity.type === "anonymous") {
    conn.reject(401, "Login required");
    return;
  }
  conn.send({ type: "history", messages: this.messages });
}

async handleMessage(conn, msg) {
  this.broadcast({ type: "message", from: conn.identity.userId, text: msg.text });
}
```

A kapcsolatokról további információt a [kapcsolatok](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#connections) részben talál.

## Egy munkamenet metódusának hívása

Ha a szerverkódnak frissítést kell küldenie egy munkamenetbe, vagy egy oldalnak műveletet kell végeznie egy munkamenetben anélkül, hogy élőben megjelenítené, csatlakozás helyett hívja meg az actor egyik metódusát. A hívás nem foglal helyet a munkamenetben, és akkor is működik, ha egyetlen kliens sincs csatlakozva.

**Egy munkamenet metódusának hívása:**

1. Az actorban írja meg a metódust, és adja meg a nevét a [`static callable`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#callable-methods) listában.
2. A metódusban ellenőrizze az `identity` értékét, és egy hívó elutasításához dobjon [`ActorError`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#callable-methods) hibát. Ha a hívó nevében szeretne eljárni, adja át a `request` értéket a [`createClientFromRequest()`](https://docs.base44.com/developers/references/sdk/docs/functions/createClientFromRequest) függvénynek.
3. Módosítsa a munkamenetet, és hívja meg a [`broadcast()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) metódust a csatlakozott kliensek frissítéséhez. Adja vissza a hívónak szánt választ.
4. Hívja meg a metódust egy oldalról a `base44.actors.ActorName(sessionId).methodName(args)`, szerverkódból pedig a `base44.asServiceRole.actors.ActorName(sessionId).methodName(args)` formában.

A következő példában csak egy adminisztrátor vagy az alkalmazás szerverkódja törölheti egy tábla tartalmát:

```typescript theme={null}
// base44/actors/BoardRoom/entry.ts
import { Actor, ActorError } from "base44:runtime/actors";
import { createClientFromRequest } from "npm:@base44/sdk";

export default class BoardRoom extends Actor<Incoming, Outgoing> {
  static callable = ["clear"];

  async clear(_args, { identity, request }) {
    if (identity.type === "anonymous") throw new ActorError(401, "Login required");
    if (identity.type === "authenticated") {
      const user = await createClientFromRequest(request).auth.me();
      if (user.role !== "admin") throw new ActorError(403, "Admins only");
    }
    this.items = [];
    await this.storage.put("items", []);
    this.broadcast({ type: "state", items: [] });
    return { cleared: true };
  }
}
```

A következő példák egy oldalról és egy backend-függvényből hívják meg a metódust:

```typescript theme={null}
// A page
const { cleared } = await base44.actors.BoardRoom(boardId).clear();

// A backend function
const base44 = createClientFromRequest(req);
await base44.asServiceRole.actors.BoardRoom(boardId).clear();
```

> [!NOTE]
>
> Szerverkódban a munkamenet-azonosítót megbízható adatból vegye, például egy ellenőrzött rekordból, ne a kliens nyers bemenetéből.

## A munkamenetadatok megőrzése

Ha az értékeknek túl kell élniük egy tétlen időszakot, őrizze meg a munkamenetadatokat. Ilyen például egy játéktábla, egy előzménylista vagy az aktuális kör.

**A munkamenetadatok megőrzése:**

1. A [`handleStart()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#lifecycle-handlers) metódusban töltse be az értékeket a [`this.storage`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#storage) tárolóból az osztálymezőkbe.
2. Minden módosítás után hívja meg a [`this.storage.put()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#storage) metódust a frissített érték mentéséhez.
3. A munkamenet alaphelyzetbe állításához hívja meg a [`this.storage.delete()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#storage) vagy a [`this.storage.deleteAll()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#storage) metódust.

A következő példa indításkor betölt egy táblát, minden lépés után menti, és törli a tárolót, amikor az utolsó kliens is lecsatlakozik:

```typescript theme={null}
async handleStart() {
  this.board = (await this.storage.get<Board>("board")) ?? newBoard();
}

async handleMessage(_conn, msg) {
  applyMove(this.board, msg.move);
  await this.storage.put("board", this.board);
}

async handleClose(_conn) {
  if (this.getConnections().length === 0) {
    await this.storage.deleteAll();
  }
}
```

A tárolásról további információt a [tárolás](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#storage) részben talál.

## Entitásadatok írása egy munkamenetből

Ha a munkamenetnek alkalmazásrekordokat kell létrehoznia vagy frissítenie, írjon entitásadatokat. Ilyen például egy végső pontszám vagy egy teljesített rendelés.

**Entitásadatok írása egy munkamenetből:**

1. Írás előtt validálja a beérkező üzenetet.
2. Olvassa ki a felhasználói azonosítót a [`conn.identity.userId`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#connections) értékből.
3. Emelt szintű hozzáféréshez használja a [`this.client.asServiceRole`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#entity-access) klienst. Stabil kulccsal, például a munkamenet-azonosítóval írjon, hogy egy ismételten lefutó kezelő ugyanazt a rekordot frissítse.

A következő példa elmenti a hitelesített kliens végső pontszámát. Ugyanannak a munkamenetnek egy későbbi mentése ezt a rekordot frissíti:

```typescript theme={null}
async handleMessage(conn, msg) {
  if (msg.type !== "save-score" || conn.identity.type !== "authenticated") return;
  if (typeof msg.score !== "number") return;

  const fields = {
    sessionId: this.instanceId,
    userId: conn.identity.userId,
    score: msg.score,
  };
  const [existing] = await this.client.asServiceRole.entities.Score.filter({
    sessionId: this.instanceId,
  });

  if (existing) {
    await this.client.asServiceRole.entities.Score.update(existing.id, fields);
  } else {
    await this.client.asServiceRole.entities.Score.create(fields);
  }
}
```

Az entitáshozzáférésről további információt az [entitáshozzáférés](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md#entity-access) részben talál.

## Backend-függvény hívása titkos adatot igénylő munkához

Az actorok a [`secrets.get()`](https://docs.base44.com/hu/developers/backend/resources/actors/reference#read-secrets) segítségével olvashatják az alkalmazás titkos adatait. Ha egy kezelőnek titkos adatot igénylő munkát kell végeznie, például API-kulccsal kell meghívnia egy külső API-t, javasoljuk, hogy hívjon meg egy [backend-függvényt](https://docs.base44.com/hu/developers/backend/resources/backend-functions/overview.md). A függvény kiolvassa a titkos adatot, és az eredményt adja vissza, soha nem magát a titkos adatot.

**Backend-függvény hívása egy actorból:**

1. Hozzon létre egy backend-függvényt, amely a `secrets.get()` segítségével kiolvassa a titkos adatot, elvégzi a munkát, és visszaadja az eredményt.
2. Egy kezelőben hívja meg a [`this.client.functions.invoke()`](https://docs.base44.com/developers/references/sdk/docs/interfaces/functions#invoke) metódust a függvény nevével és a küldendő adatokkal.
3. Használja az eredményt a munkamenetben, például küldje szét a csatlakozott klienseknek.

A következő példa egy backend-függvényt mutat, amely kiolvas egy API-kulcsot, és fordítást ad vissza:

```typescript theme={null}
// base44/functions/translateText/entry.ts
import { secrets } from "base44:runtime";

export default async function (req: Request): Promise<Response> {
  const { text } = await req.json();
  const apiKey = secrets.get("TRANSLATE_API_KEY");

  const res = await fetch("https://api.example.com/translate", {
    method: "POST",
    headers: { Authorization: `Bearer ${apiKey}` },
    body: JSON.stringify({ text }),
  });
  const { translation } = await res.json();

  return Response.json({ translation });
}
```

A következő példa egy actorból hívja meg ezt a függvényt, és szétküldi az eredményt:

```typescript theme={null}
export default class ChatRoom extends Actor<Incoming, Outgoing> {
  async handleMessage(_conn, msg) {
    const result = await this.client.functions.invoke("translateText", { text: msg.text });
    this.broadcast({ type: "message", text: result.data.translation });
  }
}
```

## Lásd még

* [Az actorok áttekintése](https://docs.base44.com/hu/developers/backend/resources/actors/overview.md): Fogalmak és terminológia
* [Actor létrehozása](https://docs.base44.com/hu/developers/backend/resources/actors/create-actor.md): Actorfájlok és egy minimális osztály
* [Actorfájlok és -kód](https://docs.base44.com/hu/developers/backend/resources/actors/reference.md): A teljes backend-osztály API-ja
* [`actors deploy`](https://docs.base44.com/developers/references/cli/commands/actors-deploy): Helyi actorok telepítése

> [!NOTE]
>
> Ezt az oldalt MI segítségével fordítottuk. A legpontosabb és legfrissebb információkért tekintse meg az [angol nyelvű változatot](https://docs.base44.com/index.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.