Omni Generic Menu Data Components

The following topics describe the point of sale SQL data that can be made into an Omni Generic Menu through ETL. These are the JSON components that integrators must use to construct their menu. Integrators can retrieve the components needed for a specific menu using the Get Menu operation.

Integrators who wish to avoid more complicated upcharge pricing and taxing logic can take advantage of the OMNI Order Injection API's Price Order operation, which will return the correctly priced upcharges, taxes, subtotal, and/or total for the provided items.

See the Menu Construction topic for best-practices instructions for building a menu from these components.

See the Important Notes topic for additional information on constructing menus from these components.

plus

The plus table is a collection of all products, discounts, etc. in a site's database.

Field	Type	Description
`plunum`	integer	A unique product identifier.
`category_uid`	integer	The uid of the product category. Can be mapped to the "category_uid" column of the "plu_categories" table.
`name`	string	The long name of the product.
`type_uid`	integer	The uid for the plu type. Can be mapped to the "plu_type_uid" column of the "plu_types" table.
`available`	boolean	A boolean value that represents if the item is available to be sold at the restaurant.
`is_non_food`	boolean	A boolean value that represents if the item is considered "non food."
`price`	integer	An integer price representation of the lowest denomination of the local currency. The last two numbers of the price will always be a decimal. Example: If the store's local currency is USD, then 499 represents 499 pennies or $4.99 and 1299 represents 1299 pennies or $12.99. In countries that do not have fractional currencies like pennies, the last two numbers will still be treated as a decimal and can be ignored if it is not applicable (e.g. 60000 COP would be 600 COP).
`flag_1`	integer	A bitmask value that corresponds to the applicable product taxes defined in the tax_headers table. After unmasking the bit value, reverse the resulting array and add +1 to the index value of any array elements that equal 1 in order to retrieve the corresponding tax_header_uid from the tax_headers table. Only 3 tax_headers will ever exist, so only the first 3 elements of the resulting unmasked array will be used. For example, a "flag_1" value of 3 would result in [1,1,0,0,0,0,0,0] after the unmasked array is reversed. Adding +1 to the array index value for elements with a value of 1 would mean that tax_header_uid 1 and 2 apply to this product.
`vat_1`	integer	Is used to check if an item is discountable. It is also used to check if a vat tax plu from the "vat_plus" table is meant to be calculated on Net after a discount. It is also used in conjunction with "plus.ll" (lower limit) to check if enough items are on the ticket to allow discounting.
`vat_2`	integer	Is used to decide whether an order which would normally be able to be rounded would otherwise not be rounded.
`ll`	integer	An integer value representing the lower limit of items that must be present in an order for this item to be discountable.

bom

The bom (build of materials) table is a collection of all value meals, discounts, and the default items included in the bom, as well as any applicable substitution rules and lists for bom items.

Field	Type	Description
`bom_plunum`	integer	The `plunum` for the value meal or discount. This `plunum` directly maps to the `plunum` from the "plus" table.
`item_plunum`	integer	The default item that is included in the value meal or discount. This plunum directly maps to the plunum from the "plus" table.
`quantity`	integer	The quantity of this item that is included in the bom.
`substitution_rule`	integer	Determines if the bom item is able to be substituted. 0 means the item can be substituted with anything, 1 means the item is not allowed to be substituted at all. This maps to the "substitution_rule_uid" column in the "substitution_rules" table.
`substitution_list_num`	string	If a value meal has explicit prices for specific item substitution items, this value will directly map to the "list_num" column in the "list_headers" table.

list_headers

A reference table for the items that are substitutable in a bom.

Field	Type	Description
`list_header_uid`	integer	The unique ID for this list. This directly maps to the "list_header_uid" column in the "list_details" table. There can be multiple `list_detail` records for a single `list_header_uid`.
`list_num`	string	The list number associated with this list. This directly maps to the "substitution_list_num" column in the "bom" table.
`name`	string	The name of the list.

list_details

A collection of items and explicit substitution price overrides associated with a list_header record.

Field	Type	Description
`list_header_uid`	integer	The `uid` of the corresponding "list_headers" table record.
`list_item`	string	The item ID. This typically maps to the "plunum" column in the "plus" table.
`value`	string	This is typically the price of an item when a default bom item is substituted for this item.
`from_quantity`	string	The minimum quantity of this item that must be present in the bom in order for this substitution value (price) to apply.
`to_quantity`	string	The maximum quantity of this item that can be present in the bom in order for this substitution value (price) to apply.

plu_categories

A collection of plu categories.

Field	Type	Description
`plu_categories_uid`	integer	The unique ID of the category. Directly maps to the "category_uid" column in the "plus" table.
`name`	string	The name of the category.

plu_types

A list of plu types.

Field	Type	Description
`plu_type_uid`	integer	The `uid` for a plu type.
`name`	string	The name of the plu type.

smart_products

A list of products (PLUs) that are automatically transformed into a new product when the specified qualifier PLU is applied. Example, a Burger will automatically be transformed into a Bacon Burger when the "add bacon" qualifier is added to a regular Burger. Since franchisees can price a "Bacon Burger" differently than a "Burger" with an "add bacon" qualifier, it is necessary to transform the product into a different PLU. Not all qualifiers result in a smart_product transformation. Qualifiers like "add bacon" and "add cheese" typically do. NOTE: It is possible for a newly transformed product to undergo yet another smart_products transformation if a specific qualifier is added. An example of this would be a "Bacon Burger" that has the "add cheese" qualifier added and then the smart_product transformation would result in a "Bacon Burger w/ Cheese".

Field	Type	Description
`base_plu`	integer	The corresponding `plunum` from the "plus" table that represents the base product before it is transformed (e.g. "Burger").
`qualifier_plu`	integer	The corresponding qualifier `plunum`from the "plus" table that results in a `smart_product` transformation if applied to the `base_plu`. E.g. "add bacon". NOTE: Most qualifiers will have a `type_uid` of 2 in the "plus" table.
`result_plu`	integer	The new product PLU that is to be used after the specified `qualifier_plu` is applied to the `base_plu`. E.g. a "Burger" PLU with the "add bacon" qualifier results in the "Bacon Burger" PLU.

smart_value_meals

This table is similar to the "smart_products" table except that the transformation rules here apply specifically to value meals. Value meals are identified by a type_uid of 18 in the "plus" table.

Field	Type	Description
`vm_base_plu`	integer	The corresponding "plunum" from the "plus" table that represents the base value meal before it is transformed (e.g. "Burger Meal").
`item_base_plu`	integer	The corresponding `item_plunum` from the "bom" table that must be modified before a `smart_value_meal` transformation is applied. i.e. the actual "Burger" in the "Burger Meal" must be modified with a qualifier like "add bacon" or "add cheese" in order for the value meal to be transformed into a "Bacon Burger Meal").
`qualifier_plu`	integer	The corresponding qualifier `plunum` from the "plus" table that results in a `smart_value_meals` transformation if applied to the `item_base_plu`. E.g. "add bacon". NOTE: Most qualifiers will have a `type_uid`of 2 in the "plus" table.
`item_result_plu`	integer	The new bom item PLU that is to be used after the specified `qualifier_plu` is applied to the `item_base_plu`. E.g. a "Burger" PLU with the "add bacon" qualifier results in the "Bacon Burger" PLU.
`vm_result_plu`	integer	The new value meal PLU that is to be used after the `item_result_plu` transformation is applied.

product_sizes

A list of applicable product sizes.

Field	Type	Description
`product_sizes_uid`	integer	The `uid` of the product size.
`name`	string	The name of the size (e.g. "small", "medium", "large", etc.)

plu_sizes

A list of sizing rules for either a product or a value meal. This is a programmatic way of determining the applicable sizes for any product.

Field	Type	Description
`plunum`	integer	The corresponding product `plunum` from the "plus" table that is meant to be sized.
`size_uid`	integer	The corresponding `product_sizes_uid` from the "product_sizes" table.
`item_plu`	integer	The product `plunum` from the "plus" table that is sized according to the `size_uid`. This column is only populated for non-value meal items. E.g.: if the `plunum` above were for "Small Fries" and the `size_uid` was for a medium, the `item_plu` would contain the product `plunum` for "Medium Fries".
`vm_plu`	integer	Similar to the `item_plu` except this will only be populated for value meal items. E.g. if the `plunum` were for a "Small Burger Meal" and the `size_uid` was a medium, the `vm_plu` would contain the product `plunum` for "Medium Burger Meal".

payments

A list of payment PLUs with a type_uid of 5. This will contain the same columns as the "plus" table.

pickup_locations

A list of pickup locations.

Field	Type	Description
`pickup_locations_uid`	integer	The unique ID of the location.
`location`	string	The text ID of the location. This is the value that must be used when defining the `pickupLocation` value in the order injection payload.
`display_name`	string	The display name of the location.

substitution_rules

A list of substitution rules.

Field	Type	Description
`substitution_rule_uid`	integer	The unique ID of the substitution rule.
`name`	string	The name of the substitution rule.

Important Notes

In order for a value meal or "bom" to be successfully injected, the injected "bom" must contain all of the expected item_plunum quantities after substitutions are applied. i.e. if a bom_plunum for a "Medium Burger Meal" contains a burger, a medium soda and a medium fry, the injected value meal must contain 3 child items. If a substituted item like "medium onion rings" instead of "medium fries" is allowed then that will still count towards the number of child items in the value meal. Defer to the "bom" table for a list of applicable items and substitution rules.
When calculating upcharges for item substitutions, defer to the explicit substitution pricing rules in list_detail first. If no explicit rule exists for a substitution item, then calculate the difference between the default item_plunum price from the "plus" table with the substitution item's PLU price. The result is the upcharge that is to be applied for the substitution item. A "default" bom item refers to the default item_plunums associated with a bom_plunum in the "bom" table.
"Qualifier" PLUs like "add lettuce" or "add ranch sauce" must be applied as a modifier to a specific item. Unless there is a corresponding list_detail upcharge price for the qualifier in question, the price of a qualifier PLU is always the "price" of the qualifier plunum from the "plus" table. E.g. If the customer opts to "add ranch" to the actual "Burger" in a "Burger Meal" and the PLU for "add ranch" costs 15 cents, then 15 cents will be added to the order total.
- A "qualifier" is identified by a type_uid of 2 in the "plus" table.