Appendices & Checklists

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 * @NModuleScope SameAccount
 */
define(['N/record', 'N/log'], (record, log) => {

    /** Before record is loaded (view, edit, copy) */
    const beforeLoad = (context) => {
        const { type, newRecord, form } = context;

        if (type === context.UserEventType.CREATE) {
            // Set defaults on new records
            newRecord.setValue({
                fieldId: 'custbody_custom_field',
                value: 'Default Value'
            });
        }
    };

    /** Before record is saved to database */
    const beforeSubmit = (context) => {
        const { type, newRecord, oldRecord } = context;

        if (type === context.UserEventType.CREATE ||
            type === context.UserEventType.EDIT) {
            const amount = newRecord.getValue('total');
            if (amount > 10000) {
                newRecord.setValue({
                    fieldId: 'custbody_requires_approval',
                    value: true
                });
            }
        }
    };

    /** After record is saved to database */
    const afterSubmit = (context) => {
        const { type, newRecord } = context;

        if (type === context.UserEventType.CREATE) {
            log.audit({
                title: 'Record Created',
                details: `ID: ${newRecord.id}`
            });
        }
    };

    return { beforeLoad, beforeSubmit, afterSubmit };
});

/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 * @NModuleScope SameAccount
 */
define(['N/currentRecord', 'N/dialog'], (currentRecord, dialog) => {

    /** Page load - runs once when form loads */
    const pageInit = (context) => {
        const rec = context.currentRecord;
        console.log('Form loaded, mode:', context.mode);
    };

    /** Field changed - runs when any field value changes */
    const fieldChanged = (context) => {
        const rec = context.currentRecord;
        const fieldId = context.fieldId;

        if (fieldId === 'entity') {
            const customerId = rec.getValue('entity');
            // Perform lookup or update related fields
        }
    };

    /** Validate line - runs before line is committed */
    const validateLine = (context) => {
        const rec = context.currentRecord;

        if (context.sublistId === 'item') {
            const qty = rec.getCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'quantity'
            });

            if (qty <= 0) {
                dialog.alert({ message: 'Quantity must be positive' });
                return false;
            }
        }
        return true;
    };

    /** Save record - runs before record is saved */
    const saveRecord = (context) => {
        const rec = context.currentRecord;
        const lineCount = rec.getLineCount({ sublistId: 'item' });

        if (lineCount === 0) {
            dialog.alert({ message: 'Please add at least one item' });
            return false;
        }
        return true;
    };

    return { pageInit, fieldChanged, validateLine, saveRecord };
});

/**
 * @NApiVersion 2.1
 * @NScriptType MapReduceScript
 * @NModuleScope SameAccount
 */
define(['N/search', 'N/record', 'N/log'], (search, record, log) => {

    /** Get input data to process */
    const getInputData = () => {
        return search.create({
            type: 'salesorder',
            filters: [
                ['status', 'anyof', 'SalesOrd:B'],  // Pending Fulfillment
                'AND',
                ['mainline', 'is', 'T']
            ],
            columns: ['entity', 'total', 'trandate']
        });
    };

    /** Process each result (runs in parallel) */
    const map = (context) => {
        const searchResult = JSON.parse(context.value);
        const orderId = searchResult.id;
        const customerId = searchResult.values.entity.value;

        context.write({
            key: customerId,
            value: { orderId, total: searchResult.values.total }
        });
    };

    /** Aggregate mapped results by key */
    const reduce = (context) => {
        const customerId = context.key;
        const orders = context.values.map(v => JSON.parse(v));

        const totalAmount = orders.reduce((sum, o) => sum + parseFloat(o.total), 0);

        log.audit({
            title: `Customer ${customerId}`,
            details: `Orders: ${orders.length}, Total: ${totalAmount}`
        });
    };

    /** Final summary of execution */
    const summarize = (summary) => {
        log.audit('Summary', `Processed in ${summary.seconds} seconds`);

        summary.mapSummary.errors.iterator().each((key, error) => {
            log.error('Map Error', `Key: ${key}, Error: ${error}`);
            return true;
        });
    };

    return { getInputData, map, reduce, summarize };
});

/**
 * @NApiVersion 2.1
 * @NScriptType Restlet
 * @NModuleScope SameAccount
 */
define(['N/record', 'N/search', 'N/log'], (record, search, log) => {

    /** GET - Retrieve data */
    const get = (requestParams) => {
        try {
            const { type, id } = requestParams;
            if (!type || !id) return { error: 'Missing type or id parameter' };

            const rec = record.load({ type, id });
            return {
                success: true,
                data: {
                    id: rec.id,
                    type: rec.type,
                    name: rec.getValue('entityid') || rec.getValue('name')
                }
            };
        } catch (e) {
            log.error('GET Error', e.message);
            return { error: e.message };
        }
    };

    /** POST - Create record */
    const post = (requestBody) => {
        try {
            const { type, values } = requestBody;
            const rec = record.create({ type });

            for (const [fieldId, value] of Object.entries(values)) {
                rec.setValue({ fieldId, value });
            }

            const id = rec.save();
            return { success: true, id };
        } catch (e) {
            log.error('POST Error', e.message);
            return { error: e.message };
        }
    };

    /** PUT - Update record */
    const put = (requestBody) => {
        try {
            const { type, id, values } = requestBody;
            const updatedId = record.submitFields({ type, id, values });
            return { success: true, id: updatedId };
        } catch (e) {
            log.error('PUT Error', e.message);
            return { error: e.message };
        }
    };

    /** DELETE - Delete record */
    const doDelete = (requestParams) => {
        try {
            const { type, id } = requestParams;
            record.delete({ type, id });
            return { success: true, message: `Deleted ${type} ${id}` };
        } catch (e) {
            log.error('DELETE Error', e.message);
            return { error: e.message };
        }
    };

    return { get, post, put, 'delete': doDelete };
});

// Create and run a search
const customerSearch = search.create({
    type: search.Type.CUSTOMER,
    filters: [
        ['isinactive', 'is', 'F'],
        'AND',
        ['balance', 'greaterthan', 0]
    ],
    columns: [
        search.createColumn({ name: 'entityid', sort: search.Sort.ASC }),
        'email',
        'balance',
        search.createColumn({ name: 'lastorderdate' })
    ]
});

// Run and process results
customerSearch.run().each((result) => {
    const name = result.getValue('entityid');
    const email = result.getValue('email');
    const balance = result.getValue('balance');
    log.debug(name, `Balance: ${balance}`);
    return true; // Continue to next result
});

// For large result sets, use paged execution
const pagedData = customerSearch.runPaged({ pageSize: 1000 });

pagedData.pageRanges.forEach((pageRange) => {
    const page = pagedData.fetch({ index: pageRange.index });
    page.data.forEach((result) => {
        // Process each result
    });
});

// Amount greater than threshold
{total} > 10000

// Date is in the past
{duedate} < {today}

// Days until due date
{duedate} - {today}

// Field is not empty
NOT ISEMPTY({custbody_approval_notes})

// User is in specific role
{currentrole} = 3  // Administrator role ID

// Multiple conditions
{status} = 'Pending' AND {total} > 5000

// Check subsidiary
{subsidiary} = 2  // Subsidiary internal ID

// Date within range
{trandate} >= '1/1/2025' AND {trandate} <= '12/31/2025'