netsuite
Benutzerereignis: Vorher und Nachher Ereignisse senden

Syntax

• beforeSubmit (type) // Vor dem Senden 1.0
• beforeSubmit (scriptContext) // Vor dem Senden 2.0
• afterSubmit (type) // Nach dem Senden 1.0
• afterSubmit (scriptContext) // Nach dem Senden 2.0

Parameter

Bemerkungen

Minimal: Eine Nachricht protokollieren

// 1.0, Revealing Module pattern
var myNamespace = myNamespace || {};

myNamespace.example = (function () {

    /**
     * User Event 1.0 example detailing usage of the Submit events
     *
     * @appliedtorecord employee
     */
    var exports = {};

    function beforeSubmit(type) {
        nlapiLogExecution("DEBUG", "Before Submit", "action=" + type);
    }

    function afterSubmit(type) {
        nlapiLogExecution("DEBUG", "After Submit", "action=" + type);
    }

    exports.beforeSubmit = beforeSubmit;
    exports.afterSubmit = afterSubmit;
    return exports;
})();

// 2.0
define(["N/log"], function (log) {

    /**
     * User Event 2.0 example showing usage of the Submit events
     *
     * @NApiVersion 2.x
     * @NModuleScope SameAccount
     * @NScriptType UserEventScript
     * @appliedtorecord employee
     */
    var exports = {};

    function beforeSubmit(scriptContext) {
        log.debug({
            "title": "Before Submit",
            "details": "action=" + scriptContext.type
        });
    }

    function afterSubmit(scriptContext) {
        log.debug({
            "title": "After Submit",
            "details": "action=" + scriptContext.type
        });
    }

    exports.beforeSubmit = beforeSubmit;
    exports.afterSubmit = afterSubmit;
    return exports;
});

Vor dem Senden: Überprüfen Sie den Datensatz, bevor er an die Datenbank übergeben wird

In diesem Beispiel möchten wir sicherstellen, dass jeder Mitarbeiter, der als Projektressource gekennzeichnet ist, über geeignete Arbeitskosten verfügt .

// 1.0, Revealing Module pattern
var myNamespace = myNamespace || {};
myNamespace.example = (function () {

    /**
     * User Event 1.0 example detailing usage of the Submit events
     *
     * @appliedtorecord employee
     */
    var exports = {};

    function beforeSubmit(type) {
        if (!isEmployeeValid(nlapiGetNewRecord())) {
            throw nlapiCreateError("STOIC_ERR_INVALID_DATA", "Employee data is not valid", true);
        }
    }

    function isEmployeeValid(employee) {
        return (!isProjectResource(employee) || hasValidLaborCost(employee));
    }

    function isProjectResource(employee) {
        return (employee.getFieldValue("isjobresource") === "T");
    }

    function hasValidLaborCost(employee) {
        var laborCost = parseFloat(employee.getFieldValue("laborcost"));

        return (Boolean(laborCost) && (laborCost > 0));
    }

    exports.beforeSubmit = beforeSubmit;
    return exports;
})();

// 2.0
define(["N/error"], function (err) {

    var exports = {};

    /**
     * User Event 2.0 example detailing usage of the Submit events
     *
     * @NApiVersion 2.x
     * @NModuleScope SameAccount
     * @NScriptType UserEventScript
     * @appliedtorecord employee
     */
    function beforeSubmit(scriptContext) {
        if (!isEmployeeValid(scriptContext)) {
            throw err.create({
                "name": "STOIC_ERR_INVALID_DATA",
                "message": "Employee data is not valid",
                "notifyOff": true
            });
        }
    }

    function isEmployeeValid(scriptContext) {
        return (!isProjectResource(scriptContext.newRecord) || hasValidLaborCost(scriptContext.newRecord));
    }

    function isProjectResource(employee) {
        return (employee.getValue({"fieldId" : "isjobresource"}));
    }

    function hasValidLaborCost(employee) {
        var laborCost = employee.getValue({"fieldId" : "laborcost"});

        return (Boolean(laborCost) && (laborCost > 0));
    }

    exports.beforeSubmit = beforeSubmit;
    return exports;
});

Beachten Sie, dass wir Verweise auf den neuen Datensatz in unsere Validierung übergeben, da uns die alten Werte nicht wichtig sind. es geht uns nur um die Werte, die in die Datenbank geschrieben werden sollen. In 2.0 machen wir das über die scriptContext.newRecord Referenz, und in 1.0 rufen wir die globale Funktion nlapiGetNewRecord .

Wenn die übermittelten Daten nicht gültig sind, erstellen wir einen Fehler und geben ihn aus. In einem beforeSubmit Ereignis, um die Änderungen zu verhindern , dass in die Datenbank geschrieben werden, müssen Ihre Funktion throw eine Ausnahme. Oft versuchen Entwickler, return false von ihrer Funktion zurückzukehren, und erwarten, dass dies ausreichend ist, aber das reicht nicht aus. Fehlerobjekte werden in 2.0 mit dem Modul N/error und in 1.0 mit der globalen Funktion nlapiCreateError . Wir lösen dann eine Exception aus, indem wir unser erstelltes Fehlerobjekt mit dem Schlüsselwort throw .

Nach Absenden: Stellen Sie fest, ob ein Feld geändert wurde

Nachdem der Datensatz in der Datenbank gespeichert wurde, möchten wir untersuchen, was in dem Datensatz geändert wurde. Wir führen diese Überprüfung durch, indem wir Werte zwischen den alten und neuen Datensatzinstanzen vergleichen.

// 1.0, Revealing Module pattern
var myNamespace = myNamespace || {};
myNamespace.example = (function () {

    /**
     * User Event 1.0 example detailing usage of the Submit events
     *
     * @appliedtorecord employee
     */
    var exports = {};

    function afterSubmit(type) {
        notifySupervisor();
    }

    function notifySupervisor() {
        // Old and New record instances are retrieved from global functions
        var employee = nlapiGetNewRecord();
        var prevEmployee = nlapiGetOldRecord();

        // If Employee Status didn't change, there's nothing to do
        if (!didStatusChange(employee, prevEmployee)) {
            return;
        }

        // Otherwise, continue with business logic...
    }

    function didStatusChange(employee, prevEmployee) {
        var status = employee.getFieldValue("employeestatus");
        var prevStatus = prevEmployee.getFieldValue("employeestatus");

        /* !! Caution !!
         * Empty fields from the Old record come back as `null`
         * Empty fields from the New record come back as an empty String
         * This means  you cannot simply compare the old and new
         */
        return ((prevStatus || status) && (status !== prevStatus));
    }

    exports.afterSubmit = afterSubmit;
    return exports;
})();

// 2.0
define(["N/runtime"], function (runtime) {

    /**
     * User Event 2.0 example detailing usage of the Submit events
     *
     * @NApiVersion 2.x
     * @NModuleScope SameAccount
     * @NScriptType UserEventScript
     * @appliedtorecord employee
     */
    var exports = {};

    function afterSubmit(scriptContext) {
        notifySupervisor(scriptContext);
    }

    function notifySupervisor(scriptContext) {
        // Old and New records are simply properties on scriptContext
        var employee = scriptContext.newRecord;
        var prevEmployee = scriptContext.oldRecord;

        // If Employee Status didn't change, there's nothing to do
        if (!didStatusChange(employee, prevEmployee)) {
            return;
        }

        // Otherwise, continue with business logic...
    }

    function didStatusChange(employee, prevEmployee) {
        var status = employee.getValue({"fieldId" : "employeestatus"});
        var prevStatus = prevEmployee.getValue({"fieldId" : "employeestatus"});

        /* !! Caution !!
         * Empty fields from the Old record come back as `null`
         * Empty fields from the New record come back as an empty String
         * This means  you cannot simply compare the old and new
         */
        return ((prevStatus || status) && (status !== prevStatus));
    }

    exports.afterSubmit = afterSubmit;
    return exports;
});

Seien Sie sehr vorsichtig, wenn Sie Werte zwischen alten und neuen Datensätzen vergleichen. Leere Felder aus dem alten Datensatz werden als null , während leere Felder aus dem neuen Datensatz als leerer String zurückgegeben werden. Das bedeutet, dass Sie das Alte nicht einfach mit dem Neuen vergleichen können. Andernfalls erhalten Sie falsch positive Ergebnisse. Jede Logik, die Sie schreiben, muss den Fall behandeln, in dem eine null und eine leere Zeichenfolge.