|Bookshelf Home | Contents | Index | PDF|
Provide and consume constraints positively or negatively increment the amount of the target operand each time the specified item is added to the solution. Provide constraints contribute a positive amount; that is, they increase the amount of the target. Consume constraints contribute a negative amount; that is, they reduce the amount of the target.
Contrast this behavior with the behavior of the require constraints. For example, Item A requires Item B. The first time the user picks Item A, if no item B is in the solution, the Siebel Configurator engine adds at least one Item B. The second time the user picks Item A, the engine does not increment Item B because the require constraint does not consider the quantity of Item A in the solution, only that Item A is present.
Now consider the constraint Item A provides 1 to Item B. Each time the user picks Item A, the Siebel Configurator engine increments the number of Item B in the solution by 1. This constraint ties the quantities of Item A and Item B together so that each Item A requires an Item B. Provide and consume constraints work directly with quantities expressed as resource or attribute values, while require constraints consider only the presence or absence of an item.
NOTE: Provide and Consume constraints work properly when the resource is defined in the parent product. For modeling scenarios that require embedding resources in the child product, use attributes of type Integer instead.
The Item operand can be a product, a relationship, a product class within a relationship, a resource or an attribute. If the item is a relationship or class, the constraint applies to all the items in the relationship or class. For example, Relationship A provides 1 to Item B. Each time an item from Relationship A is added to the solution, Item B is added to the solution.
When the target operand is a product, the quantity of the product is incremented. For example, Product A provides 2 to Product B. This constraint means that each Product A added to the solution increases the quantity of Product B (the target) by 2.
The consume constraint works the same way. For example, Product A consumes 2 from Product B. This constraint means that each Product A added to the solution decreases the quantity of Product B (the target) by 2.
Resources keep track of configuration variables that increase or decrease as the user makes selections. For example, suppose you are creating a customizable product rule for configuring desktop computers. Your product includes several types of chassis. Each chassis has a different number of slots for expansion cards. The product also includes several types of expansion cards, such as disk controllers, and graphics cards.
You do not know in advance which chassis the customer will select or how many expansion cards. However, you do know you must keep track of the number of slots available in a chassis during the configuration process to verify that the computer is configured correctly.
When the user selects a chassis, the provide constraint increases the Slots Available resource by the number of slots in the chassis. Each time the user selects an expansion card, the consume constraint decreases the Slots Available resource by one. Thus, the Slots Available resource maintains a record of how many slots are available in the chassis during the configuration session.
If a resource has the same name in two different customizable products, the Siebel Configurator engines treats them as the same resource. You can take advantage of this in cases where one product with components is contained within another. For example, product with components CP2 is contained within product with components CP1. You define resource R1 in both products. Constraints in either product with components that contribute to R1, affect the value of R1 in both products. Use this behavior to allow a parent product with components to contribute to a resource in a child product with components.
When the target is an attribute, the value of the attribute is incremented. Attribute targets are very similar in behavior and use as resource targets. There are several restrictions on using provide and consume constraints to manipulate attribute values:
Use attributes as targets instead of defining multiple resources that keep track of similar variables. This ties the variables directly to a class and makes it easier to keep track of the variables' roles.
|Siebel Product Administration Guide||Copyright © 2010, Oracle and/or its affiliates. All rights reserved. Legal Notices.|