funifier-mcp 0.2.24 → 0.2.25

package/datasource-funifier-docs/.skills-map.json

@@ -3,7 +3,8 @@
     "knowledge/modules/trigger.md",
     "knowledge/guides/triggers-guide.md",
     "knowledge/guides/java-entities.md",
-    "knowledge/guides/java-managers.md"
+    "knowledge/guides/java-managers.md",
+    "knowledge/guides/trigger-examples.md"
   ],
   "funifier-create-scheduler": [
     "knowledge/modules/scheduler.md",
@@ -61,6 +62,7 @@
     "knowledge/guides/java-libraries.md",
     "knowledge/modules/trigger.md",
     "knowledge/guides/triggers-guide.md",
+    "knowledge/guides/trigger-examples.md",
     "knowledge/modules/scheduler.md",
     "knowledge/guides/aggregates.md",
     "knowledge/modules/public.md"

package/datasource-funifier-docs/knowledge/guides/trigger-examples.md

@@ -0,0 +1,511 @@
+# Trigger Examples — Padrões de Produção
+
+Referência prática de eventos, entidades, constantes e exemplos reais para criação de triggers no Funifier.
+
+---
+
+## Eventos Oficiais (dropdown do Studio)
+
+| Evento | Quando é acionado |
+|--------|-------------------|
+| `before_win` | Antes de registrar uma conquista (ponto, desafio, item) |
+| `after_win` | Depois de registrar uma conquista |
+| `before_lose` | Antes de remover uma conquista |
+| `after_lose` | Depois de remover uma conquista |
+| `before_create` | Antes de persistir um novo documento |
+| `after_create` | Depois de persistir um novo documento |
+| `before_update` | Antes de atualizar um documento existente |
+| `after_update` | Depois de atualizar um documento |
+| `before_delete` | Antes de deletar um documento |
+| `after_delete` | Depois de deletar um documento |
+
+---
+
+## Eventos Estendidos (free-text only — não aparecem no dropdown)
+
+| Evento | Quando é acionado |
+|--------|-------------------|
+| `before_bulk` | Antes de um insert/update em lote via API |
+| `after_bulk` | Depois de um insert/update em lote via API |
+| `csv_before_bulk` | Antes de processar um import CSV |
+| `csv_after_bulk` | Depois de processar um import CSV |
+
+> ⚠ Nesses eventos a variável `entity` recebe uma **List** (não um único documento). Itere com `for (Object item : entity)`.
+
+---
+
+## Entidades Disponíveis
+
+**Dropdown hardcoded do Studio:**
+`action`, `catalog`, `catalog_item`, `crown`, `leaderboard`, `level`, `player`, `team`, `challenge`, `point_category`, `character_star_stats_level`, `upload`, `mystery_box`, `lottery`
+
+**Entidades dinâmicas** (carregadas via `/v3/database/collections`):
+`achievement` e todas as coleções customizadas (`__c`) do projeto aparecem aqui.
+Excluídas: `action_log`, `challenge_progress`, `player_status`, `security`, `technique_field`, `join_log`.
+
+**Free-text**: o formulário do Studio permite digitar qualquer nome de entidade/evento não listado.
+
+---
+
+## Constantes de Achievement
+
+| Constante Java | Valor int | Descrição |
+|----------------|-----------|-----------|
+| `Achievement.TYPE_POINT` | `0` | Ponto acumulado |
+| `Achievement.TYPE_CHALLENGE` | `1` | Desafio completado |
+| `Achievement.TYPE_VIRTUAL_GOOD` | `2` | Item de catálogo comprado |
+| `Achievement.TYPE_LEVEL` | `3` | Nível alcançado |
+| `Achievement.TYPE_LOTTERY` | `5` | Loteria |
+| `Achievement.TYPE_COMPETITION` | `9` | Competição |
+
+---
+
+## Campos das Entidades Java nos Triggers
+
+### ActionLog (`entity` em triggers de `action`)
+```java
+entity.actionId    // String — ID da ação (ex: "complete_task")
+entity.userId      // String — ID do jogador que executou
+entity.attributes  // Map<String, Object> — atributos da ação
+entity.time        // Date — momento da execução
+entity.id          // String — alias para entity._id
+entity._id         // String — ID do registro de log
+```
+
+### Player (`entity` em triggers de `player`)
+```java
+entity._id / entity.id   // String — ID do jogador
+entity.name              // String
+entity.email             // String
+entity.extra             // Map<String, Object> — campos customizados
+entity.teams             // List<String> — IDs das equipes
+entity.image             // ImageSet — getOriginal().getUrl(), getMedium(), getSmall()
+```
+
+### Achievement (`entity` em triggers de `achievement` / `point_category`)
+```java
+entity._id / entity.id   // String
+entity.player            // String — ID do jogador
+entity.total             // double — quantidade
+entity.type              // int — ver tabela de constantes acima
+entity.item              // String — ID do ponto/desafio/item
+entity.time              // Date
+entity.extra             // Map<String, Object>
+```
+
+---
+
+## context.extra — Campos Disponíveis
+
+Disponível nos eventos `before_win`, `before_create`, `after_create` quando a trigger é acionada por uma cadeia de conquistas:
+
+```java
+context.extra.parentAchievement         // Achievement que gerou este evento
+context.extra.parentAchievement.id      // String
+context.extra.parentAchievement.type    // int (usar constantes acima)
+context.extra.parentAchievement.item    // String
+context.extra.parentAchievement.player  // String
+context.extra.parentAchievement.total   // double
+
+context.extra.parentActionLog           // ActionLog que originou a cadeia
+context.extra.parentActionLog.id        // String
+context.extra.parentActionLog.actionId  // String
+context.extra.parentActionLog.userId    // String
+context.extra.parentActionLog.attributes // Map
+
+context.extra.originActionLog           // ActionLog raiz (ponta da cadeia)
+```
+
+---
+
+## ⚠ Regra Crítica: Triggers NÃO impedem persistência via throw
+
+O Funifier **sempre salva o documento** antes de executar o trigger. Não é possível usar `throw` para cancelar a persistência.
+
+**Padrão correto para rejeitar uma criação:**
+1. Use `after_create` (não `before_create`)
+2. Valide no trigger; se inválido:
+   ```java
+   database.delete(entity._id, "collection__c");
+   entity.clear();
+   entity.put("message", "Motivo da rejeição");
+   return;
+   ```
+3. Para lógica complexa, use uma `BusinessException` interna para centralizar o cleanup:
+   ```java
+   // A exceção é capturada dentro do próprio trigger — não propaga para a plataforma
+   try {
+       if (condicaoInvalida) throw new BusinessException("Motivo");
+       // ... mais validações ...
+   } catch (BusinessException e) {
+       database.delete(entity._id, "collection__c");
+       entity.clear();
+       entity.put("message", e.getMessage());
+   }
+   
+   public class BusinessException extends Exception {
+       private String message;
+       public BusinessException(String message) { super(message); this.message = message; }
+       public String getMessage() { return this.message; }
+   }
+   ```
+
+**`before_create` é para enriquecimento apenas:** normalizar strings, preencher defaults, adicionar metadados.
+
+---
+
+## Exemplos Anotados
+
+### Exemplo 1 — `action | before_win`: Atualizar coleção relacionada
+
+Padrão: ler atributos da ActionLog, atualizar um documento em coleção customizada.
+
+```json
+{
+  "name": "Update Task Status on Action Win",
+  "entity": "action",
+  "event": "before_win",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    if (!entity.actionId.equals(\"complete_task\")) return;\n\n    String taskId = String.valueOf(entity.attributes.get(\"taskId\"));\n    if (taskId == null || taskId.equals(\"null\")) return;\n\n    HashMap<String, Object> task = manager.getJongoConnection()\n        .getCollection(\"task__c\")\n        .findOne(\"{_id:#}\", taskId).as(HashMap.class);\n\n    if (task != null) {\n        task.put(\"status\", \"done\");\n        task.put(\"completedAt\", new Date());\n        manager.getJongoConnection().getCollection(\"task__c\").save(task);\n        entity.attributes.put(\"status\", \"processed\");\n        println(\"task updated: \" + JsonUtil.toJson(task));\n    }\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    if (!entity.actionId.equals("complete_task")) return;
+
+    String taskId = String.valueOf(entity.attributes.get("taskId"));
+    if (taskId == null || taskId.equals("null")) return;
+
+    HashMap<String, Object> task = manager.getJongoConnection()
+        .getCollection("task__c")
+        .findOne("{_id:#}", taskId).as(HashMap.class);
+
+    if (task != null) {
+        task.put("status", "done");
+        task.put("completedAt", new Date());
+        manager.getJongoConnection().getCollection("task__c").save(task);
+        entity.attributes.put("status", "processed");
+        println("task updated: " + JsonUtil.toJson(task));
+    }
+}
+```
+
+---
+
+### Exemplo 2 — `achievement | before_create`: Enriquecer com origem
+
+Padrão: ler `context.extra` para saber qual action log ou achievement gerou este registro.
+
+```json
+{
+  "name": "Tag Achievement with Origin",
+  "entity": "achievement",
+  "event": "before_create",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    if (entity.type != Achievement.TYPE_POINT) return;\n\n    if (entity.extra == null) entity.extra = new HashMap<>();\n    if (context.extra == null) return;\n\n    if (context.extra.parentAchievement != null &&\n        context.extra.parentAchievement.type == Achievement.TYPE_CHALLENGE) {\n        entity.extra.put(\"originChallenge\", context.extra.parentAchievement.id);\n    }\n\n    if (context.extra.parentActionLog != null) {\n        entity.extra.put(\"originAction\", context.extra.parentActionLog.id);\n        entity.extra.put(\"originActionId\", context.extra.parentActionLog.actionId);\n    }\n\n    println(\"entity: \" + JsonUtil.toJson(entity));\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    if (entity.type != Achievement.TYPE_POINT) return;
+
+    if (entity.extra == null) entity.extra = new HashMap<>();
+    if (context.extra == null) return;
+
+    if (context.extra.parentAchievement != null &&
+        context.extra.parentAchievement.type == Achievement.TYPE_CHALLENGE) {
+        entity.extra.put("originChallenge", context.extra.parentAchievement.id);
+    }
+
+    if (context.extra.parentActionLog != null) {
+        entity.extra.put("originAction", context.extra.parentActionLog.id);
+        entity.extra.put("originActionId", context.extra.parentActionLog.actionId);
+    }
+
+    println("entity: " + JsonUtil.toJson(entity));
+}
+```
+
+---
+
+### Exemplo 3 — `action | after_win`: Criar Achievement programaticamente
+
+Padrão: creditar pontos para outro jogador como efeito colateral de uma ação.
+
+```json
+{
+  "name": "Credit Referrer Points on Invite Accept",
+  "entity": "action",
+  "event": "after_win",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    if (!entity.actionId.equals(\"accept_invite\")) return;\n\n    String referrerId = String.valueOf(entity.attributes.get(\"referrer\"));\n    if (referrerId == null || referrerId.equals(\"null\")) return;\n\n    Achievement credit = new Achievement();\n    credit.id = Guid.newShortGuid();\n    credit.type = Achievement.TYPE_POINT;\n    credit.player = referrerId;\n    credit.item = \"xp\";\n    credit.total = 50;\n    credit.time = new Date();\n    credit.extra = new HashMap();\n    credit.extra.put(\"origin\", entity.id);\n    credit.extra.put(\"originAction\", entity.actionId);\n\n    manager.getAchievementManager().addAchievement(credit);\n    println(\"credited: \" + JsonUtil.toJson(credit));\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    if (!entity.actionId.equals("accept_invite")) return;
+
+    String referrerId = String.valueOf(entity.attributes.get("referrer"));
+    if (referrerId == null || referrerId.equals("null")) return;
+
+    Achievement credit = new Achievement();
+    credit.id = Guid.newShortGuid();
+    credit.type = Achievement.TYPE_POINT;
+    credit.player = referrerId;
+    credit.item = "xp";
+    credit.total = 50;
+    credit.time = new Date();
+    credit.extra = new HashMap();
+    credit.extra.put("origin", entity.id);
+    credit.extra.put("originAction", entity.actionId);
+
+    manager.getAchievementManager().addAchievement(credit);
+    println("credited: " + JsonUtil.toJson(credit));
+}
+```
+
+---
+
+### Exemplo 4 — `player | after_create`: Inicializar dados do jogador
+
+Padrão: ao criar um jogador, buscar dados relacionados em coleção customizada e preencher `extra`.
+
+```json
+{
+  "name": "Initialize Player from Employee Data",
+  "entity": "player",
+  "event": "after_create",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    println(\"new player: \" + JsonUtil.toJson(entity));\n\n    HashMap<String, Object> employee = manager.getJongoConnection()\n        .getCollection(\"employee__c\")\n        .findOne(\"{email:#}\", entity.email).as(HashMap.class);\n\n    if (employee == null) return;\n\n    Player p = manager.getPlayerManager().findById(entity._id);\n    if (p == null) return;\n\n    if (p.extra == null) p.extra = new HashMap();\n    p.extra.put(\"department\", employee.get(\"department\"));\n    p.extra.put(\"role\", employee.get(\"role\"));\n    p.extra.put(\"employeeId\", employee.get(\"_id\"));\n\n    manager.getPlayerManager().insert(p);\n    println(\"player initialized: \" + p._id);\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    println("new player: " + JsonUtil.toJson(entity));
+
+    HashMap<String, Object> employee = manager.getJongoConnection()
+        .getCollection("employee__c")
+        .findOne("{email:#}", entity.email).as(HashMap.class);
+
+    if (employee == null) return;
+
+    Player p = manager.getPlayerManager().findById(entity._id);
+    if (p == null) return;
+
+    if (p.extra == null) p.extra = new HashMap();
+    p.extra.put("department", employee.get("department"));
+    p.extra.put("role", employee.get("role"));
+    p.extra.put("employeeId", employee.get("_id"));
+
+    manager.getPlayerManager().insert(p);
+    println("player initialized: " + p._id);
+}
+```
+
+---
+
+### Exemplo 5a — `custom__c | before_create`: Normalizar campos antes de persistir
+
+Padrão: `before_create` **não rejeita** — apenas enriquece/normaliza o `entity` antes de salvar.
+
+```json
+{
+  "name": "Normalize Employee Fields",
+  "entity": "employee__c",
+  "event": "before_create",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    entity.put(\"email\", normalizeEmail(entity.get(\"email\")));\n    entity.put(\"name\", normalizeName(entity.get(\"name\")));\n    entity.put(\"employeeId\", extractNumeric(entity.get(\"employeeId\")));\n}\n\nString normalizeEmail(Object value) {\n    if (value == null) return \"\";\n    String s = String.valueOf(value).replaceAll(\"\\\\s\", \"\");\n    return s.equals(\"null\") ? \"\" : s.toLowerCase();\n}\n\nString normalizeName(Object value) {\n    if (value == null) return \"\";\n    String s = String.valueOf(value).trim();\n    return s.equals(\"null\") ? \"\" : s;\n}\n\nString extractNumeric(Object value) {\n    if (value == null) return \"\";\n    try {\n        return String.valueOf(Long.parseLong(String.valueOf(value).replaceAll(\"\\\\s\", \"\")));\n    } catch (NumberFormatException e) {\n        return \"\";\n    }\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    entity.put("email", normalizeEmail(entity.get("email")));
+    entity.put("name", normalizeName(entity.get("name")));
+    entity.put("employeeId", extractNumeric(entity.get("employeeId")));
+}
+
+String normalizeEmail(Object value) {
+    if (value == null) return "";
+    String s = String.valueOf(value).replaceAll("\\s", "");
+    return s.equals("null") ? "" : s.toLowerCase();
+}
+
+String normalizeName(Object value) {
+    if (value == null) return "";
+    String s = String.valueOf(value).trim();
+    return s.equals("null") ? "" : s;
+}
+
+String extractNumeric(Object value) {
+    if (value == null) return "";
+    try {
+        return String.valueOf(Long.parseLong(String.valueOf(value).replaceAll("\\s", "")));
+    } catch (NumberFormatException e) {
+        return "";
+    }
+}
+```
+
+---
+
+### Exemplo 5b — `custom__c | after_create`: Validar e rejeitar criação
+
+Padrão: document já foi salvo — se inválido, deletar e retornar erro no `entity`.
+
+```json
+{
+  "name": "Validate Order on Create",
+  "entity": "order__c",
+  "event": "after_create",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    try {\n        if (player == null || player.isEmpty()) {\n            throw new BusinessException(\"Player obrigatório.\");\n        }\n\n        HashMap<String, Object> schedule = manager.getJongoConnection()\n            .getCollection(\"schedule__c\")\n            .findOne(\"{status:#}\", \"open\").as(HashMap.class);\n\n        if (schedule == null) {\n            throw new BusinessException(\"Nenhuma janela de cadastro aberta.\");\n        }\n\n        long existing = manager.getJongoConnection().getCollection(\"order__c\")\n            .count('{\"_id\":{\"$ne\":#},\"owner\":#,\"status\":{\"$ne\":\"cancelled\"}}',\n                entity._id, player);\n\n        if (existing >= 3) {\n            throw new BusinessException(\"Limite de cadastros atingido nesta janela.\");\n        }\n\n    } catch (BusinessException e) {\n        database.delete(entity._id, \"order__c\");\n        entity.clear();\n        entity.put(\"message\", e.getMessage());\n        println(\"rejected: \" + e.getMessage());\n        return;\n    }\n}\n\npublic class BusinessException extends Exception {\n    private String message;\n    public BusinessException(String msg) { super(msg); this.message = msg; }\n    public String getMessage() { return this.message; }\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    try {
+        if (player == null || player.isEmpty()) {
+            throw new BusinessException("Player obrigatório.");
+        }
+
+        HashMap<String, Object> schedule = manager.getJongoConnection()
+            .getCollection("schedule__c")
+            .findOne("{status:#}", "open").as(HashMap.class);
+
+        if (schedule == null) {
+            throw new BusinessException("Nenhuma janela de cadastro aberta.");
+        }
+
+        long existing = manager.getJongoConnection().getCollection("order__c")
+            .count('{"_id":{"$ne":#},"owner":#,"status":{"$ne":"cancelled"}}',
+                entity._id, player);
+
+        if (existing >= 3) {
+            throw new BusinessException("Limite de cadastros atingido nesta janela.");
+        }
+
+    } catch (BusinessException e) {
+        database.delete(entity._id, "order__c");
+        entity.clear();
+        entity.put("message", e.getMessage());
+        println("rejected: " + e.getMessage());
+        return;
+    }
+}
+
+public class BusinessException extends Exception {
+    private String message;
+    public BusinessException(String msg) { super(msg); this.message = msg; }
+    public String getMessage() { return this.message; }
+}
+```
+
+---
+
+### Exemplo 6 — `custom__c | after_bulk`: Processar import em lote
+
+Padrão: `entity` é uma **List** — itere e processe cada item.
+
+```json
+{
+  "name": "Process Imported Records",
+  "entity": "import__c",
+  "event": "after_bulk",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    if (entity == null || entity.isEmpty()) return;\n\n    println(\"bulk size: \" + entity.size());\n\n    for (Object raw : entity) {\n        HashMap<String, Object> item = (HashMap<String, Object>) raw;\n        if (item == null) continue;\n\n        String employeeId = String.valueOf(item.get(\"employeeId\"));\n        if (employeeId == null || employeeId.equals(\"null\")) continue;\n\n        HashMap<String, Object> employee = manager.getJongoConnection()\n            .getCollection(\"employee__c\")\n            .findOne(\"{_id:#}\", employeeId).as(HashMap.class);\n\n        if (employee != null) {\n            item.put(\"department\", employee.get(\"department\"));\n            item.put(\"processed\", true);\n            manager.getJongoConnection().getCollection(\"import__c\").save(item);\n        }\n    }\n\n    println(\"bulk processed: \" + entity.size() + \" records\");\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    if (entity == null || entity.isEmpty()) return;
+
+    println("bulk size: " + entity.size());
+
+    for (Object raw : entity) {
+        HashMap<String, Object> item = (HashMap<String, Object>) raw;
+        if (item == null) continue;
+
+        String employeeId = String.valueOf(item.get("employeeId"));
+        if (employeeId == null || employeeId.equals("null")) continue;
+
+        HashMap<String, Object> employee = manager.getJongoConnection()
+            .getCollection("employee__c")
+            .findOne("{_id:#}", employeeId).as(HashMap.class);
+
+        if (employee != null) {
+            item.put("department", employee.get("department"));
+            item.put("processed", true);
+            manager.getJongoConnection().getCollection("import__c").save(item);
+        }
+    }
+
+    println("bulk processed: " + entity.size() + " records");
+}
+```
+
+---
+
+### Exemplo 7 — Registrar uma ação programaticamente (`ActionManager.track`)
+
+Padrão: criar e disparar um ActionLog de dentro de um trigger, acionando as regras de gamificação normalmente.
+
+```json
+{
+  "name": "Track Secondary Action on Win",
+  "entity": "action",
+  "event": "after_win",
+  "active": true,
+  "script": "void trigger(event, entity, player, database) {\n    if (!entity.actionId.equals(\"complete_task\")) return;\n\n    ActionLog log = new ActionLog();\n    log.id = Guid.newShortGuid();\n    log.userId = entity.userId;\n    log.actionId = \"task_completed_by_team\";\n    log.time = new Date();\n    log.attributes = new HashMap();\n    log.attributes.put(\"taskId\", entity.attributes.get(\"taskId\"));\n    log.attributes.put(\"origin\", entity.id);\n    manager.getActionManager().track(log);\n    println(\"tracked async: \" + JsonUtil.toJson(log));\n}\n"
+}
+```
+
+```groovy
+void trigger(event, entity, player, database) {
+    if (!entity.actionId.equals("complete_task")) return;
+
+    // Async: dispara e não bloqueia — conquistas processadas em background
+    ActionLog log = new ActionLog();
+    log.id = Guid.newShortGuid();   // .id, não ._id
+    log.userId = entity.userId;
+    log.actionId = "task_completed_by_team";
+    log.time = new Date();
+    log.attributes = new HashMap();
+    log.attributes.put("taskId", entity.attributes.get("taskId"));
+    log.attributes.put("origin", entity.id);
+    manager.getActionManager().track(log);
+    println("tracked async: " + JsonUtil.toJson(log));
+}
+```
+
+Variante síncrona — use quando precisar saber quais conquistas foram geradas:
+
+```groovy
+void trigger(event, entity, player, database) {
+    // Add action filter: if (!entity.actionId.equals("your_action")) return;
+
+    ActionLog log = new ActionLog();
+    log.id = Guid.newShortGuid();
+    log.userId = entity.userId;
+    log.actionId = "referral_bonus";
+    log.time = new Date();
+    log.attributes = new HashMap();
+
+    // trackSynchonous bloqueia e retorna as conquistas geradas
+    List<Achievement> earned = manager.getActionManager().trackSynchonous(log);
+    if (earned != null) {
+        println("earned: " + earned.size() + " achievements");
+        for (Achievement a : earned) {
+            println("achievement: type=" + a.type + " item=" + a.item + " total=" + a.total);
+        }
+    }
+}
+```
+
+> ⚠ Nunca chame `track` ou `trackSynchonous` dentro de um trigger `before_win` / `after_win` para a **mesma entidade/ação** que disparou o trigger — causa loop infinito. Use uma action diferente ou verifique com `entity.actionId` antes.

package/datasource-funifier-docs/knowledge/guides/triggers-guide.md

@@ -109,7 +109,7 @@ manager.getPlayerManager().delete("john");
 ```java
 Action a = manager.getActionManager().findActionById("sell");
 manager.getActionManager().track(actionLog);
-List<Achievement> results = manager.getActionManager().trackSynchronous(actionLog);
+List<Achievement> results = manager.getActionManager().trackSynchonous(actionLog);
 ```
 
 ### CatalogManager