Automation

const { Automation } = require('@orbito/api-lib');

{
  nazwaParametru: {
    type: Automation.PropertyType.STRING,       // wymagane – typ wartości
    of: Automation.PropertyType.STRING,         // wymagane gdy type === ARRAY – typ elementów tablicy
    format: Automation.DisplayFormat.EMAIL,     // opcjonalne – wskazówka UI/walidacyjna

    // opcjonalne – lista opcji (dropdown)
    options: {
      // opcje statyczne
      values: [
        { id: 'value1', label: 'Etykieta 1' },
        { id: 'value2', label: 'Etykieta 2' }
      ],

      // opcje dynamiczne (ładowane z API modułu)
      module: 'core/orders',       // moduł dostarczający opcje
      method: 'status.search',     // metoda do wywołania
      params: { onlyActive: true }, // dodatkowe parametry zapytania
      responsePath: 'results',     // ścieżka do tablicy wyników w odpowiedzi API
      idKey: '_id',                // klucz identyfikatora opcji (domyślnie 'id')
      labelKey: 'name'             // klucz etykiety opcji (domyślnie 'label')
    },

    name: { en: 'Parameter name', pl: 'Nazwa parametru' }, // lub string
    required: true
  }
}

params: {
    templateId: {
        type: Automation.PropertyType.STRING,
        format: Automation.DisplayFormat.MESSAGE_TEMPLATE,
        name: { en: 'Message template', pl: 'Szablon wiadomości' },
        required: true
    },
    customerEmail: {
        type: Automation.PropertyType.TEMPLATE_VAR,
        name: { en: 'Customer e-mail', pl: 'E-mail klienta' }
    }
}

// core/shipping – id zamówienia należy do core/orders, id przesyłki jest własne
Automation.registerTrigger('shipment_created', {
    displayName: 'Nowa przesyłka',
    emits: {
        'core/orders:ORDER_ID': { type: 'ObjectId', name: 'Zamówienie' },
        SHIPMENT_ID:            { type: 'ObjectId', name: 'Przesyłka' }
    },
    enable, disable, clear
});

// core/wfirma – akcja potrzebuje klucza z core/orders
Automation.registerAction('issue_document', {
    displayName: 'Wystaw dokument',
    requires: ['core/orders:ORDER_ID'],
    execute: async (params, ctx) => issue(ctx.event.params['core/orders:ORDER_ID'])
});

Automation.registerAction(actionCode, definition)

outputs: [
    { branch: 'true',  label: 'Tak' },
    { branch: 'false', label: 'Nie' }
]

return 'true';  // wybierz gałąź "Tak"
return 'false'; // wybierz gałąź "Nie"

execute: async (params, ctx) => { ... }

nameGenerator: async (lang, params) => {
    // zwróć string z nazwą lub null/undefined gdy nie można wygenerować
}

const { Log, Core, Automation, DB } = require('@orbito/api-lib');
const OrderStatus = require('./src/models/OrderStatus');
const Order = require('./src/models/Order');

Automation.registerAction('change_status', {
    displayName: "Zmień status zamówienia",
    desc: "Użyj tej akcji, aby zmienić status zamówienia na inny",

    params: {
        newStatusId: {
            type: Automation.PropertyType.STRING,
            options: {
                module: 'core/orders',
                method: 'status.search',
                params: { onlyActive: true },
                responsePath: 'results',
                idKey: '_id',
                labelKey: 'name'
            },
            name: { en: 'New Status', pl: 'Nowy status' },
            required: true
        }
    },

    requires: ['ORDER_ID'],

    execute: async (params, ctx) => {
        if (!params.newStatusId) {
            throw new Error('Missing values');
        }

        const orderId = ctx.event.params.ORDER_ID || ctx.event.params.orderId || ctx.event.params._id;
        const order = await Order.findOne({ _id: orderId });
        if (!order) {
            throw new Error('Order not found');
        }

        if (order.statusId + '' == params.newStatusId + '') {
            return null; // status już ustawiony, nic nie rób
        }

        return await Core.callModule('core/orders', 'updateStatus',
            { orderId: order._id, statusId: params.newStatusId },
            { automationId: ctx.automationId }
        );
    },

    nameGenerator: async (lang, params) => {
        const { newStatusId } = params;
        if (!newStatusId) return 'Invalid parameters';

        const status = await OrderStatus.findOne({ _id: newStatusId });
        if (!status) return 'Status not found';

        return `Change order status to ${status.name}`;
    }
});

Automation.registerAction('check_variable', {
    displayName: "Warunek zmiennej automatyzacji",
    desc: "Sprawdza wartość zmiennej automatyzacji",

    outputs: [
        { branch: 'true',  label: 'Tak' },
        { branch: 'false', label: 'Nie' }
    ],

    params: {
        key: {
            type: Automation.PropertyType.STRING,
            name: "Klucz zmiennej do sprawdzenia",
            required: true
        },
        checkOperation: {
            type: Automation.PropertyType.STRING,
            name: "Operacja sprawdzania",
            required: true,
            options: {
                values: [
                    { id: 'equals',     label: 'Musi być takie samo' },
                    { id: 'includes',   label: 'Musi zawierać słowo' },
                    { id: 'not_equals', label: 'Nie może być takie samo' }
                ]
            }
        },
        valueToCheck: {
            type: Automation.PropertyType.STRING,
            name: "Wartość do sprawdzenia",
            required: true
        }
    },

    nameGenerator: async (lang, params) => {
        let operationLabel = 'jest taka sama jak';
        if (params.checkOperation === 'includes')   operationLabel = 'zawiera frazę';
        if (params.checkOperation === 'not_equals') operationLabel = 'jest inna niż';
        return `Czy zmienna "${params.key}" ${operationLabel} "${params.valueToCheck}"?`;
    },

    execute: async (params, ctx) => {
        if (!params.key || !params.valueToCheck) {
            throw new Error('Missing key or value to check');
        }

        const record = await AutomationVariable.findOne({ key: params.key.trim() });
        const varValue = record ? record.value : '';

        let conditionMet = false;
        if (params.checkOperation === 'equals') {
            conditionMet = (varValue === params.valueToCheck);
        } else if (params.checkOperation === 'includes') {
            conditionMet = varValue && varValue.includes(params.valueToCheck);
        } else if (params.checkOperation === 'not_equals') {
            conditionMet = (varValue !== params.valueToCheck);
        }

        return conditionMet ? 'true' : 'false';
    }
});

const { Automation } = require('@orbito/api-lib');

Automation.waitAndRetry(seconds); // pauza + ponowne uruchomienie TEJ SAMEJ akcji
Automation.delay(seconds);        // pauza + przejście do kolejnego kroku

const waitingSince = Date.now() - new Date(ctx.createdAt).getTime();
if (waitingSince > 6 * 60 * 60 * 1000) { // 6h
    throw new Error('Shipment did not appear in time');
}

const { Automation } = require('@orbito/api-lib');
const Shipment = require('./models/Shipment');

const RETRY_INTERVAL_SECONDS = 30;

function resolveOrderId(ctx) {
    // id zamówienia należy do core/orders, więc w core/shipping czytamy go z prefiksem
    const p = (ctx && ctx.event && ctx.event.params) || {};
    return p['core/orders:ORDER_ID'] || null;
}

Automation.registerAction('wait_for_shipment', {
    displayName: 'Czekaj na przesyłkę',
    desc: 'Wstrzymuje automatyzację, dopóki do zamówienia nie powstanie przesyłka',
    icon: 'truck',
    outputs: ['next'],
    requires: ['core/orders:ORDER_ID'],

    execute: async (params, ctx) => {
        const orderId = resolveOrderId(ctx);
        if (!orderId) throw new Error('Missing core/orders:ORDER_ID');

        // Sam warunek, żadnego efektu ubocznego - `execute` musi być idempotentne.
        const shipmentCount = await Shipment.count({ orderId: String(orderId) });
        if (!shipmentCount) {
            Automation.waitAndRetry(RETRY_INTERVAL_SECONDS); // sprawdź ponownie za 30 sekund
        }

        return true;
    },

    nameGenerator: async (lang) => (
        lang === 'pl' ? 'Czekaj na przesyłkę' : 'Wait for a shipment'
    )
});

Automation.registerTrigger(triggerCode, definition)

emits: {
    ORDER_ID:     { type: 'ObjectId', name: 'Identyfikator zamówienia' },
    ORDER_STATUS: { type: 'ObjectId', name: 'Identyfikator statusu zamówienia' },
}

enable(params, actionId) { ... }

disable(actionId) { ... }

clear() { ... }

const { Log, Automation } = require('@orbito/api-lib');

// słownik aktywnych listenerów: { [actionId]: { statuses: [...] } }
const statusChangeListeners = {};

Automation.registerTrigger('status_changed', {
    displayName: "Status zamówienia zmieniony",
    desc: "Ten trigger uruchomi się, gdy status zamówienia zostanie zmieniony",

    emits: {
        ORDER_ID:     { type: 'ObjectId', name: 'Identyfikator zamówienia' },
        ORDER_STATUS: { type: 'ObjectId', name: 'Identyfikator statusu zamówienia' },
    },

    params: {
        statuses: {
            type: Automation.PropertyType.ARRAY,
            of: Automation.PropertyType.STRING,
            options: {
                module: 'core/orders',
                method: 'status.search',
                params: { onlyActive: true },
                responsePath: 'results',
                idKey: '_id',
                labelKey: 'name'
            },
            name: "Statusy powodujące wywołanie akcji",
            required: true
        }
    },

    enable(params, actionId) {
        if (!params.statuses) {
            throw new Error(`Missing statuses param for ${actionId}`);
        }

        Log.debug("Adding status change listener", { actionId, statuses: params.statuses });

        statusChangeListeners[actionId + ''] = {
            statuses: params.statuses,
        };
    },

    disable(actionId) {
        if (statusChangeListeners[actionId + '']) {
            Log.info("Removing status change listener", { actionId });
            delete statusChangeListeners[actionId + ''];
        }
    },

    clear() {
        for (const actionId of Object.keys(statusChangeListeners)) {
            delete statusChangeListeners[actionId];
        }
    },
});

await Automation.callTrigger(triggerCode, actionId, eventKey, eventParams)

const { Core, Log, Automation } = require('@orbito/api-lib');

Core.registerHook('event:order:status_changed', async (payload) => {
    for (const actionId of Object.keys(statusChangeListeners)) {
        const listener = statusChangeListeners[actionId];

        if (listener.statuses.includes(payload.statusId + '')) {
            Log.info("Triggering automation for order status change", { actionId, payload });

            const eventKey = `ORDER_STATUS_${payload.statusId}${Date.now()}`;
            await Automation.callTrigger('status_changed', actionId, eventKey, {
                ORDER_ID:     payload.orderId,
                ORDER_STATUS: payload.statusId
            });
        }
    }
});

const { Log, Core, Automation } = require('@orbito/api-lib');
const OrderStatus = require('./src/models/OrderStatus');
const Order = require('./src/models/Order');

// --- AKCJA ---

Automation.registerAction('change_status', {
    displayName: "Zmień status zamówienia",
    desc: "Użyj tej akcji, aby zmienić status zamówienia na inny",
    requires: ['ORDER_ID'],

    params: {
        newStatusId: {
            type: Automation.PropertyType.STRING,
            options: {
                module: 'core/orders',
                method: 'status.search',
                params: { onlyActive: true },
                responsePath: 'results',
                idKey: '_id',
                labelKey: 'name'
            },
            name: { en: 'New Status', pl: 'Nowy status' },
            required: true
        }
    },

    execute: async (params, ctx) => {
        if (!params.newStatusId) throw new Error('Missing values');

        const orderId = ctx.event.params.ORDER_ID;
        const order = await Order.findOne({ _id: orderId });
        if (!order) throw new Error('Order not found');

        if (order.statusId + '' == params.newStatusId + '') return null;

        return await Core.callModule('core/orders', 'updateStatus',
            { orderId: order._id, statusId: params.newStatusId },
            { automationId: ctx.automationId }
        );
    },

    nameGenerator: async (lang, params) => {
        const status = await OrderStatus.findOne({ _id: params.newStatusId });
        return status ? `Change order status to ${status.name}` : 'Invalid parameters';
    }
});

// --- TRIGGER ---

const statusChangeListeners = {};

Automation.registerTrigger('status_changed', {
    displayName: "Status zamówienia zmieniony",
    emits: {
        ORDER_ID:     { type: 'ObjectId', name: 'Identyfikator zamówienia' },
        ORDER_STATUS: { type: 'ObjectId', name: 'Identyfikator statusu zamówienia' },
    },
    params: {
        statuses: {
            type: Automation.PropertyType.ARRAY,
            of: Automation.PropertyType.STRING,
            options: {
                module: 'core/orders',
                method: 'status.search',
                params: { onlyActive: true },
                responsePath: 'results',
                idKey: '_id',
                labelKey: 'name'
            },
            name: "Statusy powodujące wywołanie akcji",
            required: true
        }
    },
    enable(params, actionId) {
        if (!params.statuses) throw new Error(`Missing statuses param for ${actionId}`);
        statusChangeListeners[actionId + ''] = { statuses: params.statuses };
    },
    disable(actionId) {
        delete statusChangeListeners[actionId + ''];
    },
    clear() {
        for (const actionId of Object.keys(statusChangeListeners)) {
            delete statusChangeListeners[actionId];
        }
    },
});

// --- HOOK wywołujący trigger ---

Core.registerHook('event:order:status_changed', async (payload) => {
    for (const actionId of Object.keys(statusChangeListeners)) {
        const listener = statusChangeListeners[actionId];
        if (listener.statuses.includes(payload.statusId + '')) {
            const eventKey = `ORDER_STATUS_${payload.statusId}${Date.now()}`;
            await Automation.callTrigger('status_changed', actionId, eventKey, {
                ORDER_ID:     payload.orderId,
                ORDER_STATUS: payload.statusId
            });
        }
    }
});