Managing Data In A Business Object Behavior

Business object behaviors add business logic to your object. Beyond simple cases like setting defaults or last modified, the logic usually needs to reference and update other information. This page shows you how to do that.

Reading Information

Before we get into all the details, here is an example of reading information:

let filter = {
	where: {
		supplierId: supplier.id
	},
	include: {
		contacts: {}
	}
};

let locations = await Location.find(filter, options);

Here are the highlights:

• filter.where narrows the locations to the ones for a specific supplier
• filter.include pulls the contacts for those locations in as well
• await says to wait for the Location.find operation to complete and then put the results in locations
• options passes the current context (see Using Options in Business Object Behaviors for more details)

Read Methods

Each business object have 5 methods to read information:

Remember that all of these methods are available in autocomplete while editing so you don't have to memorize this stuff :).

Filter

The filter is a powerful way to define what information should be read. It is an object that can contain the following keys:

Where Filter

The where filter object is an implicit "and" of conditions (this example finds suppliers with name "Dave" and code "47"):

{ name: 'Dave', code: 47 }

You can specify "or" conditions like this:

{
  or: [
    {name: 'Dave'},
    {name: 'Steve'}
  ]
}

The conditions in the examples above are implicitly equivalence. You can also use operators like this:

{
  weight: {
    gt: 1500
  }
}

Here is the full list of where filter operators:

{ weight: { gt: 1500 }}

{ weight: { lt: 1500 }}

{ weight: { gte: 1500 }}

{ weight: { lte: 1500 }}

{ weight: { between: [750,1500] }}

{ status: { neq: 'Draft' }}

{ name: { like:'%Dave%' }}

{ name: { nlike:'%Dave%' }}

{ name: { ilike:'%dave%' }}

{ name: { nilike:'%dave%' }}

{ status: { inq: ['Draft', 'Published']}}

{ status: { ninq: ['Draft', 'Published']}}

Include Filter

The include filter lets you define related items that should be included in the results. This example reads a location and includes the supplier (a belongs to relationship) and the contacts (a has many relationship):

let filter = {
  include: {
    supplier:{},
    contacts:{}
  }
}

let location = await Location.findById(47, filter);

debug('location.supplier.name',location.supplier.name);

debug('location.contacts[0].firstName',location.contacts[0].firstName);

An include is actually a nested filter where you can apply all the filter keys. This example reduces the fields returned for supplier and filters and orders the contacts:

let filter = {
  include: {
    supplier: {
      fields: {code: false}
    },
    contacts: {
      where: {
        status: 'Active'
      },
      order: 'lastName, firstName'
    }
  }
}

Create Information

Here is a simple example of creating an object:

let supplier = await Supplier.create({ name: 'Dave', code: 47 });

Here are the three different methods to create objects:

The last one is super cool because you can create a whole tree of information:

let data = [
  {
    name: 'WATD',
    code: 47,
    locations: [
      {
        name: 'Madison',
        contacts: [
          {
            firstName: 'Dave',
            lastName: 'Knapp'
          }
        ]
      }
    ]
  }, {
    name: 'Nick Co',
    code: 74,
    locations: [
      {
        name: 'Detroit',
        contacts: [
          {
            firstName: 'Nick',
            lastName: 'Laughton'
          }
        ]
      }
    ]
  }
]

Update Information

Updating information is super easy too:

let updatedSupplier = await Supplier.updateById(47, {status: 'Active'}, options);

There are two methods for performing updates:

Delete Information

Delete is also super easy:

let result = await Supplier.deleteById(47, options);

There are two methods for deleting information: