Configuring FSM Asset Processing from Item Fulfillments

Configure the Create/Update Assets sublist on editable NetSuite item fulfillments for sales orders. This setup identifies equipment items and preserves the values used to create or update assets. You can also check the resulting asset records. For the processing lifecycle and limits, see FSM Asset Processing from Item Fulfillments.

Use the following sections to configure asset processing:

• Before You Begin

• Default Configuration and Settings

• Configure Items and the Fulfillment Form

• Choose Initial Fulfillment Quantities

• Preserve Asset Identity and Sourced Values

• Changing Asset Matching and Sourced Fields

• Change the Sublist Title or Validation Messages

• Processing Effects

• Disable or Restore the Configuration

Before You Begin

Use an account with Field Service Management (FSM) installed and access to edit the applicable items, prepare item fulfillments, and inspect field service assets. Changing custom JSON also requires access to the Field Service Configuration record.

Confirm the following prerequisites:

• The fulfillment form contains the configured transaction tab and the body fields used for the asset's customer, parent, and shipping address. FSM supplies the Field Service Item Fulfilment form (custform_nx_item_fulfillment). An alternative form must retain the required controls.

• The product-supplied Field Service Client Item Fulfillment deployment (customdeploy_nx_itemfulfill_client) and Field Service User Event Item Fulfillment deployment (customdeploy_nx_itemfulfill_userevent) are deployed. Field Service Scheduled (customscript_nx_scheduled) provides background asset processing. Use FSM Script Reference for deployment administration and monitoring.

• The sales order contains the equipment items, with quantities and inventory details that can be fulfilled under the account's NetSuite settings.

• The intended customer and shipping address are available. If the assets will be children of an existing asset, identify that parent and check its customer and location values first.

Default Configuration and Settings

The standard view is enabled. Custom JSON is not required for the standard sublist when the item and form prerequisites are met. Omitted custom properties retain their applicable standard values.

The following table lists the standard settings, defaults, and effects.

Setting	Location	Standard Value or Default	Effect
Field Service Asset (custitem_nx_asset)	Item record, Field Service subtab.	The supplied box is cleared by default.	Check for items whose fulfilled units must create or update assets.
Default Items to Zero Received/Fulfilled	Accounting Preferences, Order Management, Fulfillment.	Account preference. FSM does not supply its value.	Controls the initial fulfillment quantities and when asset rows are prepared.
hidden	Root property "views/itemfulfillment/assets".	false.	true hides the sublist and stops this component's asset validation and save handling.
element.list.parent	Inside "views/itemfulfillment/assets".	Derived from tab.transaction, normally the account's configured transaction tab, with Field Service as the fallback label.	The target tab must exist on the form. Use the account's tab rather than copying another account's internal tab ID.
element.serial.required	Inside "views/itemfulfillment/assets".	true.	Every staged asset row requires a Serial Number before the fulfillment can be saved.
uniqueFormula and uniqueTemplate	Directly inside root property "models/asset".	Paired definitions compare Item plus serial number, or Item plus address text when serial is empty. Apostrophes and line breaks are normalized.	Determine which existing asset a row matches. Keep the definitions consistent.
element and error	Inside "views/itemfulfillment/assets".	Standard sublist elements and translated validation messages.	Allow supported changes to presentation, sourcing, and messages. Preserve the list's structure and validation dependencies.

The two asset matching properties belong directly inside "models/asset", outside its prototype object. For model and view root placement, see Finding a Configuration Area.

For complete shared definitions, see models/asset and views/itemfulfillment/assets.

Important:

The empty-serial fallback in the matching definitions does not make Serial Number optional on the standard fulfillment sublist. Keep the standard requirement when using the standard setup.

Standard default JSON for the visibility and Serial Number controls:

            {
  "views/itemfulfillment/assets": {
    "hidden": false,
    "element": {
      "serial": {
        "required": true
      }
    }
  }
} 

          

Configure Items and the Fulfillment Form

Configure the equipment items first, then check the fulfillment form.

Configure Items and the Fulfillment Form

1. Go to Lists > Accounting > Items and edit the equipment item.

2. On the Field Service subtab, check Field Service Asset (custitem_nx_asset) and save the item. Repeat for each equipment item that requires asset processing. For item-type recommendations and other item settings, see Configuring Item Records for Field Service Management.

3. Open an editable item fulfillment for a sales order using the intended form. Confirm that Create/Update Assets is available on the configured transaction tab.

4. Verify the fulfillment's Field Service Customer (custbody_nx_customer) and shipping address.

5. (Optional) To create equipment assets as children of an existing asset, select the parent in Field Service Asset (custbody_nx_asset).

6. Select an eligible item for fulfillment with a nonzero quantity.

7. Verify that the sublist contains one asset row per fulfilled unit. For serialized items, verify the inventory-detail serial numbers.

   Warning:

   Selection, quantity, inventory-detail, and sourced-field changes rebuild the sublist and can replace manual asset-row changes. Complete those values before entering manual asset-row values, and review the rows again after a refresh.

8. After completing the fulfillment selection, quantities, and inventory detail, enter any missing Serial Number values.

Field Service Show on Mobile is a separate item setting for availability in FSM Mobile. Checking this box does not replace Field Service Asset for this sublist's item eligibility.

Choose Initial Fulfillment Quantities

The accounting preference affects initial page loading and how you select items for fulfillment.

Choose Initial Fulfillment Quantities

1. Go to Setup > Accounting > Accounting Preferences and click Order Management.

2. In the Fulfillment section, check or clear the Default Items to Zero Received/Fulfilled box:

   • Checked - Quantities start at zero. When you select the items and quantities to fulfill, FSM prepares the corresponding asset rows.

   • Cleared - NetSuite supplies default fulfillment quantities. FSM prepares and matches the selected eligible units before the editable fulfillment page is displayed.

3. Click Save.

4. Open an item fulfillment and verify its initial quantities.

This is an account-wide preference for fulfillment and receipt transactions. Fulfill Based on Commitment can also restrict the available items and quantities. See Order Management Accounting Preferences.

A large initial selection can delay page display or time out during asset-row preparation and matching. Consider the selection workflow when choosing the preference. For the observed limitation, see Fulfillment Volume and Timeouts. Checking the Default Items to Zero Received/Fulfilled box does not establish a safe processing volume.

Preserve Asset Identity and Sourced Values

The sublist's element keys connect staged values to the asset model. Retain the list, item, serial, and id keys, their standard types and parent relationships, and the required Item validation. Serial Number is required in the standard setup. For a customization that changes this requirement, see Example 2: Match Vehicles by Item and VIN. Item and the matched Asset are populated by FSM and are read-only in the standard sublist.

The following table shows the sources and configuration effects of the remaining standard values.

Staged Value	Fulfillment Source	Configuration Effect
element.customer	custbody_nx_customer.	Supplies the customer in a staged column that is hidden by default.
element.parent	custbody_nx_asset.	Supplies the parent asset in a staged column that is hidden by default.
element.addressbook	shipaddresslist.	Supplies the address selection. Custom or overridden shipping addresses clear this staged selection.
element.addresstext	shipaddress.	Supplies formatted shipping address text without Attention and Addressee, or the overridden address text. The staged column is read-only.

If changing a supported sourcefrom binding, keep a compatible field value and element type. Preserve the asset model's identity and relationship mappings, including the transaction mapping to custrecord_nx_asset_transaction.

When a parent is supplied, standard inheritance makes the child's Customer, Address Select, Address, and Region follow the parent. These inherited values take precedence over the corresponding staged values. Configured parent-only fields can also clear staged values on a child. Use Configuring FSM Asset Hierarchy and Inheritance to check both field lists.

Asset Matching Definitions

Both properties must produce the same text for the same asset identity. Each property uses different syntax:

• uniqueFormula: A JSON string beginning with formulatext:, followed by a NetSuite search formula using SQL syntax. It calculates the comparison text from saved asset fields, referenced in braces such as {custrecord_nx_asset_item.id}. The standard formula uses || to join text and nvl to use address text when the serial number is empty.

• uniqueTemplate: An FSM template string containing a JavaScript expression inside ${ ... }. It calculates the comparison text from proposed asset attributes, available directly as item, serial, and addresstext. The standard template uses JavaScript +, a conditional expression, and .replace() to produce the matching string.

Standard default JSON for the matching pair, directly inside "models/asset" and outside prototype:

              {
  "models/asset": {
    "uniqueFormula": "formulatext:regexp_replace({custrecord_nx_asset_item.id} || ' ' || nvl({custrecord_nx_asset_serial.id}, {custrecord_nx_asset_address_text}), '['||chr(13)||chr(10)||chr(39)||']+', ' ')",
    "uniqueTemplate": "${ ((item || '') + ' ' + (serial ? serial : addresstext || '')).replace(/['\\r\\n]+/g, ' ') }"
  }
} 

            

For example, Item ID 123 and Serial Number SN-001 produce 123 SN-001. When the serial number is empty, the address text supplies the second part. Both defaults replace consecutive apostrophes and carriage-return or line-feed characters with a space. Keep the double backslashes in the JSON template so its regular expression receives \r and \n.

Why the Definitions Must Agree

The formula and template are two implementations of one identity rule. FSM uses both definitions as follows:

1. uniqueTemplate calculates the comparison text from a proposed asset row.

2. FSM searches saved assets whose uniqueFormula result equals that text.

3. FSM evaluates uniqueTemplate against the returned assets' mapped values to identify the matching records. The template also supplies the comparison for other staged rows during row validation.

For Item ID 123 and Serial Number SN-001, the proposed row's template and the saved asset's formula must both produce 123 SN-001. If the formula includes Item plus Serial Number but the template produces only SN-001, the search does not find the existing asset. The row can then request creation of another asset instead of updating the intended record.

The following table lists matching configuration problems and possible consequences.

Configuration Problem	Possible Consequence
Different fields, separators, empty-value handling, or normalization in the two definitions.	Existing assets can be missed, causing duplicate creation or inconsistent duplicate detection.
A custom attribute is unavailable in the proposed row or the returned asset mapping.	Template evaluation can fail, or the comparison can use an incomplete value.
Both definitions agree, but the comparison does not distinguish the intended assets.	Different assets can match the same text. A fulfillment row can target an unintended existing asset, and row validation can reject distinct staged rows as duplicates.

Agreement alone is therefore insufficient: the chosen fields must distinguish the assets that the account treats as different. Matching changes affect duplicate detection beyond this fulfillment form, and a matched asset ID makes the submitted row an update request.

To change the matching identity, change the saved-field formula and the attribute-based JavaScript expression together. Use equivalent field values, including internal IDs where the formula uses IDs, and preserve consistent empty-value handling, separators, and character normalization.

A custom identity attribute needs a value on the proposed row and a corresponding asset model mapping for returned records. The Additional Fields and Matching section explains how those values pass through the fulfillment sublist.

For other asset model settings, see models/asset. For general template-tag syntax, see Using Template Tags.

Matching occurs when rows are prepared or validated. The submitted request contains the staged values and any matched asset ID. A later matching change does not reselect a different asset for that submitted row.

Additional Fields and Matching

Fulfillment matching uses the proposed asset row. Every attribute used by uniqueTemplate must be available when FSM prepares or validates that row, or be derived from attributes already available. A sourced identity field therefore needs a corresponding Create/Update Assets element. The element can be visible, read-only, or hidden. Visibility does not determine whether its value participates in matching.

Additional fields can also carry data to the asset without changing its identity. Configure the source, staged element, and asset destination with the same attribute name. The following table explains each configuration component's role.

Configuration	Fulfillment Role
"views/itemfulfillment/assets".element.<attribute>	Adds the staged field. Use parent: "list" and a compatible field type.
The element's sourcefrom	Supplies the proposed value from the fulfillment. A path beginning with item. reads the fulfillment's Items sublist, rather than the Item master record.
The element's source	Defines the selection source for a select field, such as the Asset Type list or asset records. It does not replace sourcefrom.
"models/asset".prototype.map.<attribute>	Maps the attribute to its saved asset field for reads and writes. Adding this mapping alone does not source a fulfillment value.
uniqueFormula and uniqueTemplate	Change these together only when the added attribute becomes part of the matching identity.

Create or reuse the required NetSuite fields before applying the JSON. The configuration does not create transaction columns or asset fields. FSM copies values from an Items sublist column to every asset row generated from that fulfillment line. Any value that identifies an individual unit must distinguish that unit.

Use models/asset and views/itemfulfillment/assets for the shared model and element definitions.

Changing Asset Matching and Sourced Fields

The following examples are alternative customizations. Merge the relevant fragment into existing custom configuration as described in Updating and Validating FSM Configuration. Preserve unrelated model and view properties. Use one matching pair. Combining the two pairs does not create a combined identity.

Note:

The field IDs illustrate the required connections. Substitute the IDs of compatible fields in the intended account consistently in the formula, model map, and sourcefrom bindings.

Both examples assume standalone assets without a parent overriding staged values. Parent and field inheritance still apply when configured.

If existing assets should be recognized by the revised matching identity, populate and reconcile their identifier values before changing the matching pair. Configuration does not backfill those fields. An existing asset without the expected Unique Identifier or VIN can be missed even when its Item or Serial Number matches.

The matching pair is an asset model rule used beyond this fulfillment form. Other asset-entry configurations must supply the attributes used by its template. The required settings in these examples enforce values on the fulfillment sublist. Other forms retain their own validation settings.

Example 1: Match by Unique Identifier and Serial Number

Objective: Identify equipment by an assigned Unique Identifier plus Serial Number, and carry Asset Type and Related Machine from the fulfillment line. Item remains required as asset data, but is removed from the matching identity.

Required field setup: Provide the following fulfillment columns and asset destinations. Reuse the existing standard Asset Type field and selection source. Related Machine is an additional relationship to an asset, separate from the standard parent relationship.

Staged Attribute	Items Sublist Column	Asset Field	Compatible Type
uniqueidentifier	custcol_nxc_asset_uid	custrecord_nxc_asset_uid	Text.
assettype	custcol_nxc_if_asset_type	custrecord_nx_asset_type	Select from customrecord_nx_asset_type.
relatedmachine	custcol_nxc_if_related_machine	custrecord_nxc_asset_related_machine	Select from customrecord_nx_asset.

Make the source columns available on the intended fulfillment form and enter values in those columns. Each fulfilled unit must have the intended Unique Identifier and its own Serial Number.

Changes and reasons:

1. Add all three attributes to models/asset.prototype.map. This supplies their saved values and maps staged values to their asset destinations.

2. Add the corresponding fulfillment elements, selection sources, and line-column bindings. These supply and retain the proposed values.

3. Make Unique Identifier required. Keep the inherited standard Item and Serial Number requirements. Requiring the identifier prevents an empty value from weakening this example's identity.

4. Change both matching definitions to Unique Identifier plus Serial Number, retaining equivalent normalization and the address fallback. Asset Type and Related Machine remain data fields outside the identity.

              {
  "models/asset": {
    "uniqueFormula": "formulatext:regexp_replace({custrecord_nxc_asset_uid} || ' ' || nvl({custrecord_nx_asset_serial}, {custrecord_nx_asset_address_text}), '['||chr(13)||chr(10)||chr(39)||']+', ' ')",
    "uniqueTemplate": "${ ((uniqueidentifier || '') + ' ' + (serial ? serial : addresstext || '')).replace(/['\\r\\n]+/g, ' ') }",
    "prototype": {
      "map": {
        "assettype": "custrecord_nx_asset_type",
        "relatedmachine": "custrecord_nxc_asset_related_machine",
        "uniqueidentifier": "custrecord_nxc_asset_uid"
      }
    }
  },
  "views/itemfulfillment/assets": {
    "element": {
      "assettype": {
        "label": "Asset Type",
        "type": "select",
        "parent": "list",
        "source": "customrecord_nx_asset_type",
        "sourcefrom": "item.custcol_nxc_if_asset_type"
      },
      "relatedmachine": {
        "label": "Related Machine",
        "type": "select",
        "parent": "list",
        "source": "customrecord_nx_asset",
        "sourcefrom": "item.custcol_nxc_if_related_machine"
      },
      "uniqueidentifier": {
        "label": "Unique Identifier",
        "type": "text",
        "parent": "list",
        "sourcefrom": "item.custcol_nxc_asset_uid",
        "required": true
      }
    }
  }
} 

            

Expected outcome: A row with Unique Identifier UID-A and Serial Number S-001 produces the key UID-A S-001. If a saved asset produces the same key, the row targets that asset for update, even when its Item differs. Changing either identity value prevents that match. If no other asset matches, the row requests creation. Asset Type and Related Machine are carried through their mappings in either case.

Warning:

Item and Customer are excluded from this identity. Reusing the same identifier and serial for different equipment can target an unintended existing asset and update its submitted values, including Item or Customer. The address fallback in the matching pair does not override the required Serial Number control on this fulfillment form.

Example 2: Match Vehicles by Item and VIN

Objective: Identify a vehicle by Item plus VIN, carry Asset Type from the fulfillment line, and allow Serial Number to be optional. This example uses one vehicle per fulfillment line, with quantity 1 and a populated VIN.

Required field setup: The following table lists the required VIN fields and Asset Type source column. Reuse the existing standard Asset Type destination and selection source.

Staged Attribute	Items Sublist Column	Asset Field	Compatible Type
vinnumber	custcol_nx_vin_number	custrecord_nx_vin_number	Text.
assettype	custcol_nxc_so_asset_type	custrecord_nx_asset_type	Select from customrecord_nx_asset_type.

Make the source columns available on the intended fulfillment form and enter values in those columns. Each vehicle needs a VIN that distinguishes it from other vehicles of the same Item.

Changes and reasons:

1. Add vinnumber and assettype to the asset model map and the fulfillment elements. This provides the values for matching and asset persistence.

2. Change both matching definitions to Item plus VIN. Asset Type and Serial Number remain outside the identity.

3. Set element.serial.required to false. Changing the matching definitions alone would leave the standard Serial Number requirement in place.

4. Set element.vinnumber.required to true. The required setting enforces the example's VIN identity on the fulfillment form. The matching pair retains an address fallback for other contexts or existing records with an empty VIN.

              {
  "models/asset": {
    "uniqueFormula": "formulatext:regexp_replace({custrecord_nx_asset_item.id} || ' ' || nvl({custrecord_nx_vin_number}, {custrecord_nx_asset_address_text}), '['||chr(13)||chr(10)||chr(39)||']+', ' ')",
    "uniqueTemplate": "${ ((item || '') + ' ' + (vinnumber ? vinnumber : addresstext || '')).replace(/['\\r\\n]+/g, ' ') }",
    "prototype": {
      "map": {
        "vinnumber": "custrecord_nx_vin_number",
        "assettype": "custrecord_nx_asset_type"
      }
    }
  },
  "views/itemfulfillment/assets": {
    "element": {
      "serial": {
        "required": false
      },
      "vinnumber": {
        "label": "VIN Number",
        "type": "text",
        "parent": "list",
        "sourcefrom": "item.custcol_nx_vin_number",
        "required": true
      },
      "assettype": {
        "label": "Asset Type",
        "type": "select",
        "parent": "list",
        "sourcefrom": "item.custcol_nxc_so_asset_type",
        "source": "customrecord_nx_asset_type"
      }
    }
  }
} 

            

Expected outcome: Item 100 and VIN VIN-001 produce the key 100 VIN-001. FSM selects a saved asset with the same Item and VIN for update, even if the proposed Serial Number differs or is empty. Changing Item or VIN prevents that match. If no other asset matches, the row requests creation. Asset Type is carried through its mapping without affecting the comparison.

Warning:

A line-level VIN is copied to every generated unit. This example assumes quantity 1 per vehicle line. Higher quantities repeat that VIN and can give several rows the same identity. A matched asset can have its serial changed or cleared by the submitted row. Customer is excluded from the identity. Where an empty VIN is permitted, the pair uses item and address text for matching and ignores Serial Number. Distinct vehicles at the same address can therefore match.

Change the Sublist Title or Validation Messages

The following fragment changes the list title and the two validation messages. Merge this fragment into the existing custom configuration. The fragment is not a complete replacement configuration.

            {
  "views/itemfulfillment/assets": {
    "element": {
      "list": {
        "label": "Delivered Equipment"
      }
    },
    "error": {
      "required": "Enter required asset values: ${ required }",
      "duplicate": "This asset row duplicates row ${ duplicate }."
    }
  }
} 

          

This customization preserves the inherited element types, mappings, sourcing, and validation. The validation messages use template tags: required supplies the missing field labels, and duplicate supplies the conflicting row number. A literal label such as Delivered Equipment replaces the translated standard label. See FSM Expressions and Template Tags for shared template syntax.

Apply and validate the revision as described in Updating and Validating FSM Configuration. Then reopen the fulfillment to verify the title and messages. Keep the internal scheduling definitions and callback functions supplied by FSM.

Processing Effects

Saving an item fulfillment with staged asset rows requests asset processing. An empty staged list requests no asset creation or updates. Editing an existing fulfillment can rebuild its staged rows from the fulfilled items.

The Pending Processes message appears when the script run is pending or processing. Failed Processes indicates a failed run. Both messages contain New Assets. Failed processing can leave some asset changes completed and others outstanding. The request is not an atomic operation. See Background Asset Processing, the Field Service Error Record topic, and FSM Script Reference for processing indicators and errors.

For performance measurement and data capture, see FSM Performance and Data Collection.

Disable or Restore the Configuration

For an individual item, clear Field Service Asset (custitem_nx_asset) to exclude it when FSM next prepares the asset rows. To stop this view's staging, validation, and save handling across the account, merge the following fragment into custom configuration and apply the revision:

            {
  "views/itemfulfillment/assets": {
    "hidden": true
  }
} 

          

This setting hides the sublist and stops the component's handlers. It does not cancel asset-processing requests already submitted or reverse assets already created or updated.

To restore standard view behavior, remove the custom hidden override or set it to false, and check Field Service Asset on the items that require processing. Restore matching definitions as a pair.

Restoring configuration does not automatically backfill historical fulfillments or reverse earlier asset updates.

Related Topics

• FSM Configuration Reference
• FSM Asset Processing from Item Fulfillments

General Notices