Loio
Loio
2020-06-30
1 Document History. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
● -pContextPropertyFile
● -pFunction
Introduced the SAP note for handling Uploading Knowledge Bases [page
loss of text during download using CU36 87]
utility.
Product Information
Release 3.0
Use
SAP Solution Sales Configuration (on-premise edition) is a system that helps customers to configure and sell
solutions made of complex product combinations. In addition to selling their own products, many businesses
also sell solutions that include products, services, and parts from other manufacturers. For example, many
technology companies sell solutions that include combinations of highly complex hardware, software, and
services, and each of these can have options or features that must be specified by a customer during the
ordering process.
From a modeling perspective, each individual product can be split into many different instances, and there are
many possible relationships and dependencies between the product instances. SAP Solution Sales
Configuration (on-premise edition) provides a flexible modeling environment, which in turn simplifies the
ordering and configuration process for the customer.
SAP Solution Sales Configuration (on-premise edition) includes a configuration engine that provides the ability
to perform bottom-up configuration as well as the normal top-down approach. The system offers innovations
that make it easier to maintain configuration model data. The system is designed to provide efficient
configuration execution performance and advanced integration capabilities.
Integration
SAP Solution Sales Configuration (on-premise edition) is integrated with the following systems:
Features
Use
The solution modeling environment is the part of SAP Solution Sales Configuration that is used to create
advanced solution models. It is integrated with SAP Customer Relationship Management (SAP CRM) and SAP
ERP Central Component (SAP ECC), where it is used to exchange configuration master data. You define and
test your solution model in the solution modeling environment before transporting it to the target system (SAP
ECC, SAP CRM, or Hybris), where it is integrated with the sales ordering process and used during solution
configuration.
Integration
● SAP CRM
● SAP ERP
Features
Constraints
● Certain modeling syntax that works in Variant Configuration (LO-VC) is not supported in the Internet
Pricing and Configurator (IPC) configuration engine. Since SAP Solution Sales Configuration is based on
the same IPC technology, those restrictions also apply to SAP Solution Sales Configuration. For more
information about the restrictions, refer to SAP Note 1819856 (Additions to IPC VC deltalist).
● Solution modeling can be very complex as the requirements and dependencies to be considered when you
assemble a solution can be both numerous and complex. While the configuration engine in SAP Solution
Sales Configuration is built specifically to handle these processing intensive requirements, the critical
factor in ensuring efficient processing is the definition of the model. Great care must be taken in developing
solution models. It is a similar process to any other application development and requires training, abstract
thought, sophistication, and elegance of design.
Definition
A solution model is a hierarchical decomposition of a solution. It defines the products (configurable materials
and the services) that can be contained within the solution. It also defines the relationships between the
various elements of the solution, including any dependencies (constraints and rules).
Structure
Definition
A knowledge base contains the master data for a solution model. The knowledge base is exported from the
solution modeling environment, initially to the test user interface and the test configuration engine to be
tested, and then to the target sales system where it is used by the configuration engine.
Structure
In the solution modeling environment, a knowledge base is defined with identifier, version, tasks, and profiles.
More Information
For information about defining knowledge bases, see Defining Knowledge Bases [page 11].
Use
You use this procedure to create a task, which is then used to define a knowledge base. You can define the task
in the same file as the knowledge base, or in a separate file.
Procedure
A knowledge base runtime version (kbrtv) is created from a knowledge base definition by invoking the Export
Knowledge Base function in the solution modeling environment.
● From the File menu, by choosing File Export SAP Solution Configuration Export Knowledge Base .
● From the Model Explorer, by right-clicking a knowledge base definition and choosing Export Knowledge
Base.
When you export a knowledge base, you can include variant table content in the kbrtv even though the
externalTable keyword is specified in the variant table definition. This is useful for testing the knowledge
base locally. If external content is available and content is also included in the knowledge base, the external
content is used at runtime.
To include local content in the kbrtv (from either “rows” values or “file” content), select the Include Local
Variant Table Content During Export option in the kb export dialog, or Local VT in the export multiple kbs dialog.
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
A knowledge base definition indicates the materials or classes for which the knowledge base will be used. It
also lists the dependencies to be included in the knowledge base runtime version. To define a knowledge base
definition, use the following syntax:
knowledgeBase identifier {
version kb-version
validFromdate
logsys logical-system
tasks task-id
profiles
Example
knowledgeBase PRODUCT_X_KB {
version "[Link]"
validFrom "2020-01-01" logsys "LOCAL"
tasks
PRODUCT_X_TSK
profiles
name 'PRODUCT_X_PRF_2' class PRODUCT_X
}
Use
After you have exported a knowledge base to the SAP back-end system, you can create or change the texts that
have been defined for each characteristic, characteristic value, class, or material. Editing the texts directly in
the back end means that you do not have to export your knowledge base again if you want to make changes.
A particularity of maintaining material texts externally is that if a material is also defined in the product
master in the SAP CRM back end, the text from the product master is taken automatically. This avoids the
need for double maintenance. If the material is not defined in the back end, you can maintain the texts
manually in the same way as all of the other objects.
Integration
You can maintain external texts manually in Customizing or you can export them from the Solution Modeling
Environment as follows:
Activities
You maintain the texts in Customizing for CRM under Basic Functions Solution Sales Configuration
Maintain External Texts .
You maintain the texts in Customizing for ECC under Logistics - General Solution Sales Configuration
Maintain External Texts .
Note
If you expect size of the external variant table to be large, consider the recommendations provided in SAP
Note 2428939 (Implement query caching to improve Variant Table access performance).
Example
In your knowledge base, you have a characteristic with the names COLOR and FARBE for English and German
respectively. After you have exported your knowledge base to the SAP CRM back end, you can localize the
characteristic for the United Kingdom by changing COLOR to COLOUR, and you can also add a new translation
COULEUR for French.
More Information
Definition
Classes are used to represent the different configurable parts within a solution model. Classes can be defined
in a hierarchy, with subclasses inheriting characteristics from their parent class. For example, you can define a
class called computer with two subclasses: laptop and desktop.
Structure
More Information
For information about defining classes, see Defining Classes [page 16].
Use
You use this procedure to define new classes in the Eclipse-based solution modeling environment.
Procedure
As you start to type class, the contents of the explorer are filtered, such that only the matching entries
are displayed.
Note
Example
class SME_EXAMPLE_MEMORY {
name "Memory"
characteristics
SME_INSTANCE_NF invisible,
SME_MEMORY_SPEED_S required,
SME_PART_NUMBER_S required
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
urls { "url" label "30 bytes descriptive text", "url" label "30 bytes descriptive text" ... }
Note
The urls keyword can be used at group, cstic, cstic value, class, and material level. As a general rule of
thumb, all elements that could be UI relevant have this attribute. It is also possible to define more than one
URL by using curly brackets.
characteristics characteristic-id
*--remaining keywords are specified for each characteristic on this class definition--*
required
noinput
urls { "url" label "30 bytes descriptive text", "url" label "30 bytes descriptive text" ... }
defaultValues( value1,value2,... )
assignedValues( value1,value2,... )
Multi-inheritance is sup
ported.
Example
Definition
In the Eclipse-based solution modeling environment, modelers define one or more materials, which can then be
referenced in constraints and rules.
Along with products and classes, materials are associated with a knowledge base by means of a profile in the
knowledge base definition.
Structure
More Information
For information about defining materials, see Defining Materials [page 21].
Context
You use this procedure to define new materials in the Eclipse-based solution modeling environment.
Procedure
The system displays a dialog prompting you to choose a folder and enter a file name for the new material.
2. Enter the required data.
3. Choose Finish.
Example
material SME_LAPTOP {
name 'Laptop'
classes
SME_LAPTOP
boms
SME_LAPTOP
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
, FR "descriptive
French text"
urls { "url" label "30 bytes descriptive text" , "url" label "30 bytes descriptive text... }
classes class-id
boms bom-id
class-id One or more class IDs as Required if classes keyword Optional
signed to this material. Sepa is used
rate multiple classes by a
comma.
Example
material CABLE_SET {
name "Cable set"
classes
CABLE_SET
}
3.1.4 Characteristic
Definition
Characteristics are the lowest level of detail in a solution model. They are used to define the distinguishing
properties or attributes of a class. For example, a computer monitor can have a characteristic called size.
Structure
A characteristic has an identifier, a name, and a type. Depending on the type selected, you may need to specify
additional information, as shown in the following table:
Characteristic Types
Text Length
Numeric Length
Decimal Places
Date
ADT Class
Reference Characteristics
Characteristics of type Text, Numeric, and Date can be made reference characteristics by using the reference
keyword. Reference characteristics can be used to do the following:
An abstract data type (ADT) is a special type of characteristic that is used to define the relationship between
two classes. For example, a computer monitor can have ADTs called has part and is part of.
● SALES HARD
● SALES SOFT
These ADTs are used to define parent-child relationships as either a hard tie or a soft tie. If two classes have a
hard tie, they cannot be split into separate sales documents. Only classes with soft ties can be split into
different sales documents.
You maintain the names of the hard and soft tie sales ADTs in Customizing for Customer Relationship
Management under Basic Functions Solution Sales Configuration Maintain Item Relationship Types .
More Information
For information about defining characteristics, see Defining Characteristics [page 25].
Use
You use this procedure to define new characteristics in the Eclipse-based solution modeling environment.
Note
An Identifier must consist of uppercase alphanumeric characters and underscores; it cannot start with
a numeric character. The Name defaults to the same as identifier; it can be changed, if required.
3. Choose Finish.
The new characteristic is opened in the text editor.
Note
As you start to type characteristic, the contents of the explorer are filtered, such that only the matching
entries are displayed.
4. Choose Next.
5. Enter the required data.
6. Choose Finish.
The new characteristic is opened in the text editor.
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
characteristic identifier {
textLength 1-132
restrictable (x-additionalValues)
caseSensitive
multiValue
additionalValues (x-restrictable)
longName or longNames Unlimited length text availa If the name keyword is not Optional
ble from the “more informa used, the longName is not
tion” link on the configura- used as the name.
tion UI. It is possible to em
bed hyperlinks in this text.
Maximum textLength is
132.
restrictable Indicates that the domain of This clause and the Optional
values can be restricted. If additionalValues clause
the values clause is used, are mutually exclusive.
the domain is restricted to
those values, and can be fur
ther restricted in constraints.
If no values clause is used,
the initial static domain is the
“unrestricted domain”. Any
value is valid, but can still be
restricted by constraints.
additionalValues Allows user entry of values. This clause and the Optional
Can be used with the values restrictable clause are
clause. The values specified mutually exclusive.
in the values clause are pre
sented for selection, but the
user can also enter a differ-
ent value if the
additionalValues clause
is specified.
Example
characteristic CABINET_TYPE {
name "Cabinet Type"
textLength 1
caseSensitive
restrictable
values
'a' name 'little aye',
'A' name 'Aye',
'B' name 'Bee',
'C' name 'See',
'D' name 'Dee',
'd' name 'little dee'
}
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
characteristic identifier {
numericLength 1-15
decimalPlaces 0-(numericLength-1)
restrictable (x-additionalValues)
multiValue
negativeValues
additionalValues (x-restrictable)
specialFunction aggregating
intervals < n1 || <= n1 || > n2 || >= n2 || n1 - n2 || (where n1, n2 are numeric values)
values n1, n2
Example
characteristic BLOCKING {
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
characteristic identifier {
date
restrictable (x-additionalValues)
multiValue
additionalValues (x-restrictable)
values yyyy-mm-dd
Note
The date must be specified in
“YYYY-MM-DD”format only.
Example
characteristic BIRTHDAY {
name "Date of Birth"
date
values
1992-12-25
}
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
To define an abstract data type (ADT) characteristic, use the following syntax:
characteristic identifier {
classType class-identifier
multiValue
Example
characteristic CONTAINS_THESE_ITEMS {
name "Contains these items"
classType ITEM
multiValue
}
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
A reference characteristic refers to the value of a field in the sales document. To define a reference
characteristic, use the following syntax:
characteristic identifier {
field field-name
Maximum decimalPlaces
is one less than the
numericLength.
Example
characteristic ITEM_QUANTITY {
names
EN 'Component quantity',
DE 'Komponentenmenge'
numericLength 13 decimalPlaces 3
negativeValues
reference table 'STPO' field 'MENGE'
}
Definition
Variant tables are used to store combinations of values for characteristics. They can be used to infer values as
part of constraints.
Structure
You define a variant table for one or more characteristics, whereby each characteristic has a column in the
variant table. You enter a row in the variant table for each possible combination of characteristic values.
Entering one of the characteristics then restricts the other characteristics that can be selected.
You define a variant table in the Solution Modeling environment by using the row, file, or externalTable
keywords.
Note
The externalTable keyword references a table from the ABAP back-end system. If this table exists, its
content is loaded at runtime instead of the content that is part of the knowledge base runtime version.
If you choose to enter a table from the ABAP back-end system, you must ensure that the ABAP table
contains not only columns for the characteristics of your variant table definition, but also valid to and from
Example
In the following example, memory description can be used to infer the memory size and memory speed:
1_1333 1 1333
2_1333 2 1333
2_1600 2 1600
2_2000 2 2000
4_1600 4 1600
4_2000 4 2000
In this case, if a memory size of 2 is specified, the system automatically restricts the possible entries for the
memory speed to 1333, 1600, and 2000.
More Information
For information about defining variant tables, see Defining Variant Tables [page 44].
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
variantTable identifier {
characteristics characteristic-id
*--indented keywords are specified for each characteristic in this class definition--*
Primary
externalTable 'db_tablename'
'textvalue', numericvalue
||
file "[Link]"
type 'CSV'
options
rows (x-file) Used to provide table content One of the keywords rows, Optional
in the table definition. file, or externalTable is
required. externalTable
Values are separated by a
can also be used in conjunc
comma. Rows are delimited
tion with rows or file.
by a semicolon.
file (x-rows) Used to provide table content One of the keywords rows, Optional
from a file. The file must be in file, or externalTable is
the same project folder as required. externalTable
the file containing this variant can also be used in conjunc
table definition. Using tion with rows or file.
the .vtable suffix is recom
mended.
type Indicates the type of file be Used with file only Optional
ing referenced. Possible val
ues are:
options Used to provide options re Used with file only Optional
lated to data present in the
file.
● charset=ISO-8859
-1
The character set of the
file, such as
“ISO-8859-1” or
“UTF-8”. Default is
Eclipse/OS-dependent.
● delimiter=,
The value delimiter. De
fault is ','. For tabulator
or space characters, use
TAB or SPACE .
● quoteChar="
The character to quote a
value. Default is '"'.
● commentChars=#
The character(s) to rec
ognize a comment line.
Default is disabled.
● surroundingSpace
sNeedQuotes=fals
e
Flag indicating whether
spaces at the beginning
or end of a cell are to be
ignored if they're not
surrounded by quotes.
The default is false be
cause spaces are con
sidered part of a field
and are not to be ig
nored according to RFC
4180. Use true to ena
ble. Similarly for Vtable
variantTable VT_ERLANG {
name "VT_ERLANG"
characteristics
ERLANG_LO primary,
ERLANG_HI primary,
BLOCKING primary,
NUM_LINES
externalTable 'MY_SAP_ERLANG'
file "VT_ERLANG.vtable"
}
Context
You use this procedure to create variant tables in the Eclipse-based solution modeling environment.
Procedure
Note
You must enter the rows for the new variant table using the text editor. The data can be entered in-line,
as shown in the example below, or in a separate table file.
Example
variantTable SME_VIDEO_CARD_EXAMPLE {
name 'SME_VIDEO_CARD_EXAMPLE'
characteristics
SME_VIDEO_CARD_S primary,
rows
Large variant tables, especially if they are designed as external variant tables, can lead to performance
degradation of the configuration, due to slower queries. To improve the performance of these large variant
tables, it is possible to reduce the scope of the table data by defining views on the table. The view defined on
the variant table is applicable within a configuration session.
You can define a view on a variant table using available APIs in the configuration engine. You can invoke these
APIs using pFunctions. For more information about this, refer to SAP Note 2509009 (Implement Variant
table views).
Note
Defining the variant table views improves performance in both, external and internal, variant tables.
3.1.6 Dependency
Definition
Dependency is the generic term used for constraints and rules. Dependencies are defined within a solution
model and specify the relationships between the characteristics and characteristic values of several classes.
Constraints
Constraints are interdependencies between objects and their characteristics. They are a primary form of
declarative dependency. All declarative dependencies can be modeled using constraints. You can use them to
set characteristic values or to check the consistency of assigned values. Constraints are grouped into
constraint nets, which are then assigned to tasks. Constraints are used by the configurator engine to derive or
infer any of the following:
● Contradiction
● Value assignment (for characteristics with an ADT, this means linking instances)
● Domain restriction
● Creation and placement of an instance in the PART_OF hierarchy (declarative selection)
● Specialization of an instance
● Relation link between instances for declared relations, when and if this feature becomes available
Rules
Rules are the primary procedural form of dependency. They act as a point of reference for the classes,
characteristics, materials, and variant tables created by the modeler. Rules are the procedural counterpart of
constraints used when procedural logic is required, for example, counting or invoking procedural functions
(pfunctions).A rule states that some action should be performed when the pattern of the rule is matched in the
DDB. It can either be one of the specially provided built-in ones or an existing function (such as built-in APIs or
user provided functions).Rules are grouped into rule nets, which are assigned to tasks. The tasks are then
assigned to the knowledge [Link] particular, a rule can:
● Perform aggregations
● Access and modify the DDB
● Access the KB
● Trigger front-end functions
● Access and modify external data
● Make logical inferences.
More Information
For information about defining dependencies, see Defining Solution Dependencies [page 46].
Use
You use this procedure to create solution dependencies by defining constraints and constraint nets as well as
rules and rule nets.
Procedure
Defining Constraints
You can choose a constraint template if a suitable one is available. Templates are indicated with a green
dot in the auto-completion dialog box.
Defining Rules
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
rule identifier {
where ?b = adt-cstic-on-a
condition:
or || and
part_of (?m,?a)
or || and
Note
A table statement in the “condition” section evaluates “True” if at least one row is found and “False” if no
row is found.
or || and
||
||
then do: Keyword used if the rule in Either then do: or then Optional
vokes a pfunction or sets a increment: is required.
“sticky” default value
then increment: Keyword used if the rule in Either then do: or then Optional
crements an aggregating increment: is required.
characteristic
by Keyword denoting the range Required with then Required with then
by which the increment is increment: increment:
made
pfunction Keyword used to indicate Allowed only with then do: Optional
that a pfunction is to be in
voked
pfunction-name Name of pfunction to be in Required with pfunction Required with pfunction
voked
?= Indicates setting a “sticky de Required with pfunction Required with pfunction
fault”. Whenever the charac
teristic has no value as
signed, this value will be as
signed as its default.
parameters List of parameters; must Required with pfunction Required with pfunction
match the parameters in the
pfunction definition
Note
Non-sticky defaults (assigned in the class definition using the defaultValues keyword) are retained until
changed by a user input or constraint. If subsequently reset to no value ( “space”), the assigned default is
not recovered. The cstic has no value assigned.
Example
rule SET_PROD_COLOR {
objects:
?p is_a (300)PRODUCT
condition:
?p.USAGE_TYPE = 'STEALTH'
body:
then do:
pfunction SET_PROD_COLOR_PF (
PRODUCT = ?p
)
}
rule COUNT_COMPONENTS {
objects:
?bundle is_a (300)HARDWARE_BUNDLE
where ?comp = COMPONENTS
body:
then increment:
?bundle.COMP_COUNT by 1
)
}
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
Optional keyword
User-specified value
constraint identifier {
where ?b = adt-cstic-on-a
condition:
or || and
part_of (?m,?a)
or || and
or || and
restrictions:
asserted facts
Note
For an explanation of the statements that can be used to assert facts, see the “Commands Used in the
Restrictions Section of a Constraint” table below. The list, along with detailed syntax, is also available via
the inline help for editing a constraint within the solution modeling environment.
inferences:
?[Link]-on-a
,?[Link]-on-a
,?[Link] cstic-on-a
Command Use
● rounded
● sin
● cos
● tan
● floor
● log10
For a full list of the available functions, see the inline help.
Example
constraint PLACE_FUNIT_A_1 {
objects:
?CA is_a (300)CABINET_A
,?FA is_a (300)FUNIT_A
condition:
?FA.INST_NUM = 1
restrictions:
?CA.FU_A = ?FA
inferences:
?CA.FU_A
explanations:
"first FUNIT_A goes in CAB_A"
}
Definition
A dependency net is a group of constraints or rules (also referred to as dependencies), which are defined within
a solution model and specify the relationships between the characteristics and characteristic values of several
classes.
Use
Constraints
Constraints are interdependencies between objects and their characteristics. They are used as a dependency
in variant configuration. You can use them to set characteristic values or to check the consistency of assigned
Rules
Rules act as a point of reference for the classes, characteristics, materials, and variant tables created by the
modeler. They are used when procedural logic is required, for example, counting or invoking procedural
functions (pfunctions). Rules are grouped into rule nets, which are assigned to tasks. The tasks are then
assigned to the knowledge bases.
Structure
The dependency net is displayed in the form of a hierarchy in the model graph.
More Information
For information about defining dependency nets, see Defining Solution Dependencies [page 46].
Definition
User-defined functions enable you to perform (complex) tasks using external program code. They can be used
to check values and infer characteristic values. You may want to create functions for the following purposes, for
example:
User-defined functions can be used in constraints and rules. In constraints, you can use functions to check the
consistency of the values entered, perform arbitrary complex calculations on inputs to determine output
values, and look up values in external systems. In rules, you can use functions to trigger arbitrary processing.
When you invoke a user-defined function in a constraint or rule, you are referring to a Java method.
Use
There are two forms of user-defined functions: declarative functions and procedural functions ( “pfunctions”).
Both declarative functions and pfunctions have the same interface.
Declarative functions and pfunctions are defined using the following framework:
function <identifier> {
characteristics
<parameter list>
}
Note
No values are returned from a
pfunction.
primary Required for at least one parameter. It Required for at least one parameter
indicates that the parameter is “input
only” to the invoked function. It does
not indicate that the parameter is re
quired.
Definition
Declarative functions are invoked from constraints. In their arguments, they receive data structures
representing input and output characteristics. Using these characteristics, they can read the values of the input
characteristics in the configuration and they can return values for the output characteristics.
A declarative function is insulated from the actual configuration and can neither influence the value of any
characteristic other than one that is passed to it as an output characteristic, nor create any other side effects.
More Information
The following example shows how to define, implement, and invoke a declarative function.
function DETERMINE_LABEL_ID {
characteristics
CPU primary,
HD primary,
LABEL_ID
}
The function is implemented in a java class. The java class has to be defined as follows:
The interface defines the following method that needs to be implemented: boolean execute(fn_args
args, Object obj);
● args contains the sequence of arguments - import arguments with an existing binding and export
arguments where the binding is to be set in the method implementation. All characteristics that have been
specified as primary in the function definition become import parameters. Other characteristics become
output parameters.
● The type of the second parameter obj depends on the context in which the function is executed. If this
parameter is executed as a declarative function, the parameter refers to the knowledge base object, which
provides access to static information such as the knowledge base name, version, and profile.
A declarative function returns a boolean value indicating success or failure. A declarative function invoked in
the condition part of a constraint, or in the if part of a restriction must return a meaningful boolean value
because the constraint is testing the return value.
return true;
}
}
This implementation retrieves the characteristics CPU and HD from the configuration as input parameters.
These two strings are concatenated and stored in the output parameter LABEL_ID.
Note
The implementation has only limited access to the current state of the configuration. Only the explicitly
defined input and output parameters can be accessed.
function DETERMINE_LABEL_ID {
CPU = ?[Link],
HD = ?[Link],
The characteristics on the left-hand side are characteristics of the function. The characteristics on the right-
hand side are characteristics of the instance (referred to with ?PC) of the configuration.
[Link] Pfunction
Definition
A “pfunction” (procedural function) provides read and write access to the configuration and dynamic database
(in contrast to a declarative function, which simply reads the knowledge base to derive export parameters).
Pfunctions can be used only in rules but address all configuration objects.
Pfunctions make all changes as side-effects and are not declarative. No actions are tracked by the TMS (unless
tracking is implemented manually). Unlike declarative functions, pfunctions can change the configuration
directly. A pfunction can explicitly invoke the execution of dependencies using the “Check” API.
More Information
Prerequisites
Context
When you open a knowledge base to test it, pfunctions may not be executed as expected. In this case, you can
use this procedure to test and debug the pfunctions.
The test UI appears in a new window. You can then set breakpoints in the Java program from the Debug
perspective in the solution modeling environment session.
The following example shows how to define, implement, and invoke a pfunction.
function NUMBER_OF_ITEMS {
characteristics
PC_REF primary,
HOLDS_HDS primary,
}
The function is implemented in a Java class. The Java class has to be defined as follows:
The interface defines the following method that needs to be implemented: boolean execute(fn_args
args, Object obj);
● args contains the sequence of arguments - import arguments with an existing binding and export
arguments where the binding is to be set in the method implementation. All characteristics that have been
specified as primary in the function definition become import parameters. Other characteristics become
output parameters.
● The type of the second parameter obj depends on the context in which the function is executed. If this
parameter is executed as a pfunction, the parameter refers to the configuration itself, which can be used to
perform changes in the configuration directly.
The boolean typed return parameter is of no use in the context of pfunctions. Whereas the return value of a
declarative function carries meaning, the return value of a pfunction should always be true. If the return value is
false, this can lead to errors in the engine and an inconsistent configuration.
A function implementation (that is, the Java class) can be invoked as a test or for setting cstic values, and
may even be used as the implementation of a pfunction. Such multiple use requires very careful
implementation. It is permitted but not necessarily recommended.
try {
// retrieve the values of characteristic HOLDS_HDS
kb_type instType = instance.ddb_get_inst_type();
kb_cstic csticToCnt = instType.kb_has_cstic_p("HOLDS_HDS");
read_only_sequence rs = instance.ddb_get_values(csticToCnt);
} catch (Exception e) {
final sce_user_fn_logging log = new sce_user_fn_logging();
[Link](this, [Link]());
}
return true;
}
}
This implementation counts the number of assigned values to characteristic HOLDS_HDS. The retrieved
number is assigned to characteristic NUMBER_OF_HDS.
The implementation has access to the complete state of the configuration. Argument configObj is an
instance of class cfg_imp that can be used to modify the state of the configuration in a non-declarative,
procedural way. In the example, the characteristic NUMBER_OF_HDS is modified that is not part of the argument
list of the pfunction.
The class [Link] provides utility methods that can be used by pfunctions to read and
write from/to the current configuration. Among others, this class provides the following functionality:
Method Purpose
scelib.vt_select_buffered(kBase, match, Selects lines of variant table <VTabName> that obey the
VTabName, condition, order) <condition> , ordered by <order>
Pfunctions are invoked in the same way as declarative functions, for example:
function NUMBER_OF_ITEMS {
PC_REF = ?PC.PC_REF
}
An interface design is an object that defines characteristic groups and assigns characteristics to those groups.
The configuration UI uses this information to present characteristics on the screen. Interface design objects
can be associated with classes or materials allowing different presentations of the characteristics to be
displayed based on the class or material.
Interface designs are inherited by subclasses and can be overridden by superclasses. If a subclass or material
extends (inherits from) more than one superclass with an interface design, the subclass must define its own
interface design.
Note
This description uses the following conventions to illustrate the syntax requirements:
Required keyword
User-specified value
interfaceDesign identifier-1 {
group identifier-A {
characteristics
characteristic-id, characteristic-id,
urls { "url" label "30 bytes descriptive text" , "url" label "30 bytes descriptive text"... }
group identifier-B {
characteristics
characteristic-id, characteristic-id,
urls { "url" label "30 bytes descriptive text" , "url" label "30 bytes descriptive text"... }
Definition
A bill of material (BOM) is a list of materials, assemblies, components, and parts required to manufacture a
product. These can be used to define simple relationships where one component comprises several
subcomponents. If required, you can define a maximum and a minimum quantity for each material and class in
the BOM.
More Information
For information about defining bills of material, see Defining Dynamic Bills of Material [page 65].
Context
You use this procedure to create new bills of material (BOMs) in the Eclipse-based solution modeling
environment.
The system displays a dialog prompting you to choose a folder and enter a file name for the new BOM.
2. Enter the required data.
3. Choose Finish.
Note
Note
Optionally you can specify a minimum and a maximum value for each material or class.
Example
The bill of material shown below comprises one class and two materials:
bom SME_WORKPLACE {
10 class SME_COMPUTER min 0 max 9999,
20 material SME_DESKTOP min 0 max 9999,
30 material SME_DESKTOP min 0 max 9999
}
SME not only performs language syntax validation but extends it further to also do logical validations. These
logical validations are performed at compile time which helps in providing feedback during the model
development phase itself, thus avoiding the expensive test cycle process. These logical validations include:
The Solution Modeling Environment is shipped with a few sample solution models that serve as points of
reference when you are building live solution models.
For more information about creating live projects based on these samples, refer to the link below.
Related Information
SAP Solution Sales Configuration supports the application of predetermined rules to orchestrate between
knowledge bases with multi-configuration instances (MCI). This sample model provides insight into how multi
configuration instances can be created and managed across multiple configurations through the knowledge
base orchestration process.
For more information about this, refer to SAP Note 2550572 (SAP SSC Knowledge Base Orchestration
(KBO) and Multi Configuration Instances (MCI)).
[Link] FBS_SSC_CA
A model to demonstrate how the hardware, software, and services can be packaged together and how guided
selling can be enabled.
The FBS_SSC_CA model is intended to configure a data center and its supply servers, supporting an
application with various user types. Based on the number of each user type specified, the model will generate
the number of servers required, with the appropriate memory, CPU speed, and number of CPU’s.
Keywords Description
The model was defined to automatically link all software and services to all server instances. This behavior of
the model can be overridden by changing the Auto Assign characteristic in any of the following instances:
● Server
● Software
● Service
Related Information
Related Information
The root instance of the configuration contains a set of prompts/questions through which you can specify your
business needs. In this case, a single question about user volume (number of users per user type) gathers all
the required information for the model, based on which the model determines the types of appropriate servers.
The user input for this question is supplied to the following fields:
● STD_SELFSERV_USERS
● SCM_SALES_USERS
Since both the fields work in a similar fashion, you can refer to the properties of STD_SELFSERV_USERS for
further information.
Right click on the field and select Find References to find the constraints in which it is used:
● DEMAND_STD_SELF
Here, the field STD_SELFSERV_USERS is used to compute the Demand, that is, the number of CPUs, CPU
speed, and RAM required to support the type and number of users specified.
● USER_MASTER_DATA
Here, the field STD_SELFSERV_USERS is used to create an instance in the configuration to hold data
specific to a user type. In this constraint, you can see the find_or_create command and right click on
the class name USER_MASTER_DATA to find references to it. The GET_USER_MASTER_DATA constraint
pulls data from a variant table and stores it in the USER_MASTER_DATA instance.
The field containing the list of servers becomes visible after the number of users is entered in either or both the
Number of Users fields. These lists of values are stored in form of variant tables and can be accessed through
rules. This is discussed in more detail below:
STD_SELF_SERVER_NAME is the selection field for the server name and is restricted by the following
constraints:
● VISIBLE_INST
This constraint is discussed in the chapter Guided Selling Questionnaire.
● SERVER_MASTER_DATA
This constraint uses the same techniques as is used for USER_DATA.
● DMN_SERVER_AND_CPU_SPD
This constraint restricts the domain of both Cpu_Speed and Server_Name values by using a field computed
in constraint DEMAND_STD_SELF based on User_type. Only those CPU speeds whose values are greater
than or equal to the speed required for the user type:
The constraint further uses the restricted domain to restrict the allowed server name values using a variant
table:
table T_SERVER_DATA
(SERVER_NAME = ?[Link] STD_SELF_SERVER_NAME
,PROCESSOR_SPD = ?[Link] ACTL_STD_SELF_CPU_SPD
)
● COMPUTE_REQ_SERVERS
This constraint computes the number of servers required to meet the memory demand and the required
number of CPUs. It then compares these values and retrieves the number of servers as the greater of these
two values.
● STD_SELF_INST_1 and STD_SELF_INST_N
These constraints work together to create the required number of servers, as discussed above.
The following conditions are considered by the constraints for the calculations:
○ STD_SELF_INST_1: If it is true that there is at least 1 (more than 0) server required, then it is also true
that there is a server with instance number = 1.
○ STD_SELF_INST_N: If it is true that many servers are required and a server exists with an instance
number < the number required, then it is also true that there is a server with instance number 1 greater
than the existing one.
To illustrate the above, assume 3 servers are required.
Related Information
Software is added by selecting values in field SOFTWARE_SELECT and services are added by selecting values
either in INST_SERVICE_SELECT (installation services) or MAINT_SERVICE_SELECT (maintenance services).
The constraint CREATE_SERVICE_INST adds service instances and will run once for each value in the
multivalued field. Using the values in the field to set a characteristic value on the service instance ensures that
each instance is unique.
constraint CREATE_SERVICE_INST {
objects:
?S is_a (300) FBS_SSC_CA
condition:
?S.SERVICE_SELECT specified
restrictions:
find_or_create
((300) SERVICE,
with SERVICE_PROFILE = ?S.SERVICE_SELECT;
IS_PART_OF_SD_SOFT = ?S;
SERVICE_IN_SOL_ADT = ?S)
explanations:
"CREATE service instance. multiValue will find_create for each value."
}
Note
If the SERVICE_PROFILE is not set on the service instance in the find_or_create statement. In this
case, only one service instance would be created and it would be justified in the engine's truth maintenance
system, once for each value in the SERVICE_SELECT field.
While each item added to the solution is a component of the solution, there are other relationships between the
components. These relationships are expressed by using ADT’s that function as pointers to other instances and
are restricted by the following constraints:
● LINK_SW_HW, LINK_HW_SW
● LINK_HW_SV, LINK_SV_HW
● LINK_SV_SW LINK_SW_SV
Each of the “LINK_...” constraints ensure that if item A points to item B, then item B also points back to
item A. For example, LINK_SW_HW ensures that if a software is run on a server, then it is also true that the
server runs that software.
● AUTO_ASSIGN_SW and AUTO_ASSIGN_SV
These constraints use a switch (AUTO_ASSIGN_TXT) to determine whether the system should
automatically establish these relationships, that is, assume that all software runs on all hardware, all
software and hardware are ‘serviced by’ all services in the configuration, or whether no such relationships
are assumed. If no relationships are assumed, then the user may assign the relationships manually by
making selections in the ADT characteristic fields.
The model includes a reference characteristic that allows the model to reference information that exists on the
sales document, such as customer number, country, sales organization, etc. and for the model to set values of
fields on the sales document, such as line item quantity. The reference characteristic in this model,
STOP_MENGE, is used to set the line item quantity.
characteristic STPO_MENGE {
names
EN 'Component quantity',
DE 'Komponentenmenge'
numericLength 13 decimalPlaces 3
negativeValues
reference table 'STPO' field 'MENGE'
}
To illustrate this, assume that a software’s quantity depends on the number of things it runs on.
So, if 1 server runs the software, item quantity is 1; but if it runs on 10 servers, then the quantity is 10. A similar
logic applies to service items.
For more information about how the number of software licenses is counted, see rule AGGR_SW_LIC and
constraint SET_SOFTWARE_STPO_MENGE to understand how that value is assigned to the reference
characteristic.
Use
You use this process to define a solution model in the Eclipse-based solution modeling environment, test it, and
transport it to a target system for use in the sales ordering process.
You perform these steps in Eclipse, using the SAP Modeling perspective. To change to a different perspective,
choose Window Open Perspective Other...
Note
● During SME installation, the system on which Eclipse is running must have internet connectivity.
Eclipse uses the default internet connectivity configured by proxy settings on OS level (for example, in
Windows Internet Options Connections LAN Settings or any other OS connectivity settings).
If no internet connectivity is configured, you must configure the proxy settings in Eclipse under
Windows Preferences General Network Connection , as part of the standard Eclipse set up
procedure.
● If you are working as part of a team and are using a source code management system, you must first
check out a file for editing, and then check it in after completing editing.
For more information, see chapter Collaboration Between Modelers.
Prerequisites
Process
1. You create or open the project for the solution model (see Creating Model Projects [page 76]).
2. You define the model master data, including characteristics and classes (see Defining Characteristics
[page 25] and Defining Classes [page 16]).
3. You define materials (see Defining Materials [page 21]).
4. You define variant tables (see Defining Variant Tables [page 44]).
5. You define dynamic bills of material (BOMs) (see Defining Dynamic Bills of Material [page 65]).
6. You define dependencies and dependency nets (see Defining Solution Dependencies [page 46]).
7. You define a knowledge base (see Defining Knowledge Bases [page 11]).
8. You test the model locally (see Testing Models Locally [page 92]).
9. You export the model to the target system (See Exporting a Knowledge Base Runtime Version [page 84]).
Your solution model is available for solution configuration in the target system.
Related Information
The SAP Modeling perspective features a number of views that allow you to represent your solution model in
different ways:
Component Description
Project Explorer The Project Explorer view allows you to explore the project
as it exists in the file system, that is, as a set of folders and
files. New files can be added, changed, or deleted just as
they are in Windows Explorer. Updates here are also made in
the local workspace. Adding a folder here, for example, adds
a folder on the local disk in your workplace and deleting files
removes them from the local disk.
Model Explorer The Model Explorer view allows you to explore the project as
it is seen by SAP Solution Sales Configuration, that is, as a
set of objects - characteristics, classes, constraints, and so
on.
Note
Objects can be opened and edited from this view, and
also created in existing files. New *.ssc files can be cre
ated in the Project Explorer view only.
Model Graph The Model Graph view shows the relationship between
classes or dependencies in a graphical view. It is useful for
understanding the relationships among classes and materi
als, or between dependencies. To view the class hierarchy,
use the donut icon; to view the materials, click the hierarchy
icon; to view the dependency structure, click the cube icon.
When you set Link to Editor, the editor repositions to the def
inition of the object selected in the graph and the graph high
lights the object based on the object definition being edited.
Note
Objects can be opened and edited from this view, but
not added or deleted. If you open the file in which an ob
ject is defined and set Link to Editor, the view will reposi
tion to the definition of the object selected in the graph,
and the graph will reposition (highlight) to the object
based on the object definition being edited.
Search The Search view shows the results of a search. You can also
initiate a search from the Search view or the Search menu.
Outline The Outline view works in tandem with the editor. It shows all
the objects defined within the active file in the editor. You can
also sort the object definitions in this view.
Use
You use this procedure to create a new SAP Solution Sales Configuration model project in the Eclipse-based
solution modeling environment.
Procedure
Note
Creating an empty model file is a quick way to start a new object definition. You can then use the context
help to complete the definition.
You use this procedure to create a solution configuration model from an example in the Eclipse-based solution
modeling environment
Result
You can see the new project in the Project Explorer.
Result
You can see the sample project in the Project Explorer.
Note
It is recommended to organize the project files in an object-oriented way. For example, you can have one file
with the classes of one (or several related) objects and their cstics. Similarly, you can have another file
which stores the constraints and constraint nets (of the completed model, or separated into several object-
oriented files). Similarly, a different file for materials, BOMS, and more.
Use
As a modeler, you can work with several workspaces, each with its own logically distinct set of projects. In some
cases, you might need to copy a project from one workspace to another, or you might want to work on a model
created by another colleague. You can do this by adding the project to your workspace.
Procedure
Note
Projects that are grayed out cannot be selected because they already exist in your workspace.
4. To make a copy of this project and copy it to your workspace, choose Copy Projects into Workspace. If you
want to work on the files in the current location, do not choose this option.
5. Choose Finish.
The project then appears in the Project Explorer.
1. Choose the Select Archive File: radio button and use the Browse... pushbutton to select the archive file
containing the project.
2. Select the project to be imported. The Copy Projects into Workspace option is selected by default and is
required.
Note
Projects that are grayed out cannot be selected because they already exist in your workspace.
3. Choose Finish.
The project then appears in the Project Explorer.
Use
It's common practice (and even a best practice) to create one or more projects containing frequently used
routines that can be reused in other model projects. To reuse content from another project, you designate the
project as a “reference project”. The solution modeling environment then treats the content as if it were
included in a single project.
Note
● Class
● Material
● Characteristic
● Constraint
● Rule
● Variant table
● Constraint net
● Rule net
● Pfunction
Procedure
1. In the Import window, open the General folder and choose File System.
Click on Next.
2. Specify the folder(s) and file(s) to be imported, using the Browse button.
Click on Finish.
Context
You use this procedure to export a solution model project so that you can share it with your colleagues.
Procedure
Context
You use this procedure to create a launch configuration from either the Java or Debug perspective.
Procedure
Results
Use
You use this procedure to create user-defined functions in the Eclipse-based solution modeling environment.
Procedure
The compiled Java class must be added to the class path of the EJB-IPC bundles
( [Link]-ipc). This can be done using a fragment or the
functionality Eclipse-RegisterBuddy: [Link]-ipc.
The new fragment or plug-in with the function can be handed over to the Eclipse environment itself
(MyEclipse\plugins or MyEclipse\dropins), or you can start the test UI in Eclipse in a runtime configuration,
which contains all the necessary bundles.
For more information about this, see SAP Note 1701098 (Documentation Update for Implementation of
Variant Functions).
Example
function FUNCTION {
name "Name"
characteristics
CSTIC1 primary,
CSTIC2,
}
Related Information
The Solution Modeling Environment allows you to export knowledge bases to different databases as well as a
file to the system.
To make this work, you would need to setup different database connections and the required drivers for the
database to which you are exporting the project, to allow successful exports.
● MsSQL
● MySQL
● HANA
● Oracle
● MaxDB
Apart from the local databases, knowledge bases can also be exported to the CRM and ECC systems.
Context
● MsSQL
● MySQL
● HANA
● Oracle
● SAP MaxDB
You can setup a connection to the local database using the procedure below:
Procedure
Click on OK.
Example
You can further refer to the example below for more information:
Context
Procedure
Note
Context
Procedure
Note
Use
You use this procedure to export a knowledge base and create a runtime version from it.
You can export a knowledge base from the File menu, from the Project Explorer view, or from the Model Explorer
view.
1. Choose File Export SAP Solution Sales Configuration Export Knowledge Base
2. Select the knowledge base you want to export
3. Choose Next
4. Select the connection for the target database
5. Optionally, you can also do the following:
○ Deactivate the validation option in the Export Knowledge Bases (multiple KB export) dialog
Caution
If you decide to deactivate the validation, the status of the data in the back end cannot be
guaranteed after the export.
○ Activate the Include local variant table content during export option
6. Enter the password and choose Finish.
1. Right-click anywhere in the Project Explorer and choose Export SAP Solution Sales Configuration
Export Knowledge Base .
2. Select the knowledge base you want to export.
3. Optional in the Export Knowledge Bases dialog (multiple kb export dialog): Deactivate the validation option.
Caution
If you decide to deactivate the validation, the status of the data in the back end cannot be guaranteed
after the export.
4. Choose Next.
5. Select the connection for the target database.
6. Enter the password.
7. Optional: Activate the Include local variant table content during export option.
8. Choose Finish.
1. Right-click the knowledge base definition and choose Export Knowledge Base.
2. Select the connection for the target database.
3. Enter the password and choose Finish.
Note
Every time you export a knowledge base, the system asks you whether you want to start a test session in
the testing perspective.
Caution
If a validation error is detected in any of the dependent .ssc files when you export a knowledge base (for
example, due to unrelated class, cstic, material, or variant tables present in that file, an error will be
thrown that prevents you from exporting the knowledge base.
Follow this process to export a knowledge base from the workspace to a local folder.
Context
This procedure exports all the .xml files to the local folder of the knowledge base. You can export a knowledge
base from the File menu either from the Project Explorer or the Model Explorer view.
Procedure
You use this procedure to upload a knowledge base into the local database. On the modeling user interface
(UI), you can upload the knowledge base using the Upload Knowledge Base menu. You can upload the
knowledge base as either flat files or xml files.
Procedure
Option Description
Flat file Choose Flat File Upload and browse for the knowledge
base flat-file directory.
XML file Choose Xml File Upload and browse for the knowledge
base XML-file directory.
3. Choose Next.
4. Choose the connection and enter the required details.
5. Choose Finish.
More Information
While downloading a runtime version via CU36 utility, some text formatting may be lost and replaced by hashes.
For more information about handling this issue, refer to SAP Note 2339258 (Japanese and Chinese texts are
lost in runtime version.).
You can use the Delete Knowledge Base option in the Solution Modeling Environment to delete knowledge
bases from supported databases.
Procedure
Results
The selected knowledge bases are deleted from the database and a confirmation message is displayed.
Context
You use this procedure to upload external variant tables to local databases that can be downloaded from the
ECC and CRM systems.
Note
Procedure
The SAP Testing perspective opens automatically when you open a knowledge base. This perspective has its
own set of associated views and editors. These include the Configuration Editor, Characteristics view, Non-Part
Instances view, Properties view, and a number of debug/analysis views.
Component Description
Note
Due to knowledge base orchestration (KBO), multiple
configurations driven by their own knowledge bases can
be active at the same time. These are 'orchestrated' to
work together as one configuration.
Below the configuration node are the class and material in
stances, under which are the characteristics with their as
signed values. A green square indicates that all the required
values have been assigned to the instance, that is, the in
stance is complete. A yellow triangle indicates that the in
stance is incomplete, that is, a required characteristic has
not been assigned a value. A red circle indicates a conflict or
inconsistent configuration. For help with debugging a con
flict, open the Conflicts view and click any item in the config-
uration flagged with a red circle. Information about the con
flict will be presented in the conflicts view.
Non-Part Instances View The Non-Part Instances view is used to manually add instan
ces of either classes or materials to the configuration. When
you double-click any item in the Non-Part Instances view, it
is added as an instance of that type in the form of a 'free-
standing' independent instance. It does not have a 'part of'
relation to the root instance, unless a constraint has been
added to the model to establish a relationship. It is called a
'non-part instance' because it is not part of anything else.
Note
You can add components to a material at a given BOM
position by right-clicking the material in the Configura-
tion Editor. If a BOM has been defined for the material,
the Add Component option is available for selection. If
selected, a 'part instance' is added as a component of
that material. Non-part instances cannot be added in
this way. In this case, they must be added using the
Non-Part Instances view.
Properties View The Properties view shows information about all the proper
ties of the current item (that is, the selected item in the ac
tive view). This can be an instance in the Configuration Edi
tor or Characteristics view, or a constraint in the Justifica-
tions view. Any item you select in a view has properties,
which are displayed in this view.
These views are presented as a set across the bottom of the SAP Testing Perspective.
Test Runner Tracks all actions and records them in a script file that can
be saved and re-executed. The run pushbutton runs an im
ported script in its entirety. To run only to a particular step,
select the last line to be executed, right-click, and choose
Run to Line.
Conflicts View When two contradictory facts are detected, the engine raises
a conflict. The Conflicts view lists the conflicts associated
with the instance currently selected in the Configuration Edi
tor. It also provides guidance for resolving the conflict in the
form of "conflict assumptions".
Trace View The Trace view provides a detailed account of all engine ac
tivities. For more information, see Tracing [page 97].
Context
You use this procedure to test your model prior to exporting it to the target system for use in the sales ordering
process. In the test user interface (UI) and the test configuration engine, you can configure the solution to
ensure that the model is performing as expected. You can either configure the solution manually or use a
recorded test script. You can also measure the performance of constraints and dependencies.
Procedure
Results
The system opens the test UI. As you configure the solution in the test UI, the system displays the information
on the following tab pages:
● Test Runner
The system records all of the actions you perform in the test UI and displays the resulting script on the
Recorded Script tab page. The script can be saved to a file. You can open a saved script on the Executable
Script tab page and then run it. You can run the whole script, or you can run the script up to a particular
line.
If you run a saved script and then continue to configure the solution, the system adds your actions to the
script.
● Conflicts
The system displays the model conflicts that occur while testing the solution model.
● Profiling
Note
After testing your model locally, you can test the knowledge base in the sales transactions within your back-
end SAP CRM or SAP ECC system. To do so, you must export the knowledge base to a CRM or ECC
database in the same way as you export it to the local database. In this case, however, you choose the CRM
or ECC connection instead of the local database connection. For more information, see Exporting a
Knowledge Base Runtime Version [page 84].
The “Test Runner” view allows you to run the test scripts partially or completely. Furthermore, it provides
actions for storing and loading test scripts. When a test script is run, the configuration tree is changed based
on the actions in the test script. For expectations, the configuration tree is inspected. If the expectation does
not match the actual state of the configuration tree, the deviation is reported in the “Test Runner” view. The
Loaded Files tab displays the loaded performer scripts.
The test (performer) script is used to record all user commands as test steps with the purpose of storing and
executing them at a later time. In the Solution Modeling Environment, you can record “expectations”. This
allows you to inspect a model after executing user commands and verify that the expectations still hold, for
example, after a model has been changed. Therefore, the test scripts and test-runner UI now serve as a simple
tool for automated model tests.
You use this procedure to save an SAP Solution Sales Configuration test script in the Eclipse-based Solution
Modeling Environment.
Procedure
The test script is saved in the specified location on the file system in the .performer format.
It contains the action performed by the user on a configuration and also records the expectation when
Expect All on Save is selected while saving the performer file. These performer scripts are also enhanced to
contain the configuration xml in a zipped format. It contains various flags for restoration and performance
checks which can we used when running the performer in the headless mode.
Next Steps
After you have saved the test script, you can load, run, and reset the script.
You use this procedure to load an SAP Solution Sales Configuration test script (performer files) in the Eclipse-
based Solution Modeling Environment.
Context
You can use this script to test the configuration for the model and can load a single or multiple test scripts to
set the configuration.
Procedure
Note
If multiple performer scripts are loaded, they must be of the same KB RTV.
The performer test scripts are displayed on the Loaded Files tab. The loaded performer script would only be
available in the performer run session, and not in the other configuration view launched for restore when
performer is run with flags enabled for restore.
You use this procedure to run an SAP Solution Sales Configuration test script in the Eclipse-based Solution
Modeling Environment.
Procedure
The Executable Script tab opens with the test script details.
Results
The performer test scripts run with the status SUCCESS or FAILURE.
You use this procedure to reset an SAP Solution Sales Configuration test script in the Eclipse-based Solution
Modeling Environment.
Context
The target configuration is set when a test script for a model is executed. You can choose to reset either one or
multiple configuration scripts, as they are loaded in the test runner.
Results
You use this procedure to delete SAP Solution Sales Configuration test scripts in the Eclipse-based Solution
Modeling Environment.
Procedure
Results
The performer test script is deleted from the Loaded Files tab.
You use this procedure to filter actions in the Eclipse-based solution modeling environment. You can filter the
actions based on the problem explanation to easily find out the failure actions encountered during the test
script run.
Procedure
Note
Use
Prerequisites
● You have activated the trace by choosing the View Menu pushbutton in the Trace view and then choosing
Configure. In the trace configuration window, choose Enable Tracing.
Note
For performance improvements in SME, traces would be updated only when the user clicks on the
Refresh button.
DDB (Dynamic database) The DDB is the engine-internal storage Tracks all assertion and retraction of
for facts maintained by the inference facts in the dynamic database
engine. Trace output of this type refers
to changes in the DDB.
PMS (Pattern matching system) The PMS is responsible for matching Tracks all patterns in the configuration
patterns in a dependency against facts that are detected by the pattern match
in the DDB. Dependencies are evalu ing system
ated against the provided matches. In
other words, the PMS is responsible for
identifying the dependencies to be exe
cuted and for providing them with the
objects (such as instances and charac
teristics) that are required for the de
pendency evaluation. Trace output of
this type refers to activities inside the
PMS.
CSTR (Constraint) Trace output of this type refers to con Records the execution of any constraint
straint evaluations.
RULE Trace output of this type refers to rule Records the execution of any rule
evaluations.
SCND (Selection condition) Trace output of this type refers to the Traces the execution of any selection
evaluation of selection conditions. condition
PCND (Precondition) Trace output of this type refers to the Traces the execution of any precondi
evaluation of preconditions. tions
PROC (Procedure) Trace output of this type refers to the Traces the execution of any procedures
evaluation of procedures.
FUNC (User-defined functions) Trace output of this type refers to the Records the execution of user-defined
evaluation of user-defined functions. functions
TABL (Variant tables) Trace output of this type refers to the Tracks interaction with a variant table
access of variant tables.
The trace result can be displayed in the configuration dialog. Each row is structured as follows:
Note
The message number of the text displayed for the engine activity performed corresponds to the numbers in
ABAP message class 34.
Example
Many expressions relating to the engine activity performed are self-explanatory. However, expressions about
facts need further explanation.
sf($1, COLOR, VAL, BLUE) This is a simple fact (sf). For the instance $1, this fact sets
the value of the characteristic COLOR to BLUE.
to($1, product: SAP_SYS) This is a type-of (to) fact which is used for classification. The
instance $1 is of the product type SAP_SYS
rd($1, COLOR, BLUE, RED) This fact is about a restrictable domain (rd).
For the instance $1, this fact sets the domain of values for
the characteristic COLOR to the values BLUE and RED.
Facets of Characteristics
The tracing output of a simple fact (sf) always describes a certain facet of a characteristic. A facet is a property
of a characteristic. The following facets exist:
You can test your configuration on the test UI of the Solution Modeling Environment. In this way, you can mimic
the restore scenario that is available on the user interface of SAP Solution Sales Configuration.
This feature in the Solution Modeling Environment enables you to perform the following tasks:
Export Configuration
On the SAP Testing user interface, you can export knowledge base configuration as a *.cfg file.
Restore Configuration
In the Solution Modeling Environment, you can restore the configuration XML as follows:
Note
You must create a connection to the local database if a connection doesn't already exist.
2. Enter the database password and click Next to open the wizard.
3. Click Browse to select a configuration file. You can export files that have the formats *.cfg or *.xml.
4. Select the KB reference date and click Finish to see the restored configuration on the SAP Testing UI.
Note
After the restore, you can edit the configuration on the SAP Testing UI. However, you cannot save a
performer script for this updated configuration. (The Save Script button has been disabled in Test Runner).
The Solution Modeling Environment provides dumps to support the user in analyzing modeling problems.
The following dumps are provided by the SME to help users analyze modeling problems:
You use this procedure to export a DDB dump from the Eclipse-based Solution Modeling Environment.
Procedure
1. Right-click the knowledge base in the Model view and select Configuration DDB Dump .
2. Choose the location in which you want to save the file and enter a file name.
DDB Dump
You use this procedure to export a PMS dump from the Eclipse-based Solution Modeling Environment.
Procedure
1. Right-click the knowledge base in the Model view and choose Configuration PMS Dump .
2. Choose a location in which to save the file and enter a file name.
You use this procedure to export a TMS dump from the Eclipse-based Solution Modeling Environment.
Procedure
1. Right-click the knowledge base in the Model view and choose Configuration TMS Dump .
2. Choose a location in which to save the file and enter a file name.
Use this process to import a knowledge base from an SAP ECC or SAP CRM system using the data loader.
Use
You use this procedure to import the interface characteristics from compatible-mode knowledge bases in the
source SAP ERP Core Component (SAP ECC) or Customer Relationship Management (CRM) system to the
solution modeling environment database. You perform these steps in the Eclipse-based solution modeling
environment.
Prerequisites
You have setup the data loader connection in the Solution Model Environment.
Note
Compatible mode knowledge bases imported from the SAP ECC system can be tested using the test user
interface; however they cannot be changed in the solution modeling environment.
For more information, see Data Loader in the Solution Modeling Environment.
More Information
Related Information
Prerequisites
A java project needs to be created, under which the relevant .ssc file is created.
Context
This procedure is used to import a knowledge base present in a backend database (CRM,ECC, local database)
into a file, in an existing java project. The imported file contains the following details:
● Material definition
Procedure
1. In the solution modeling environment, choose File Import SAP Solution Sales Configuration Import
Model to File .
Choose Next.
2. Choose one of the existing connection types: CRM, SAP ECC, or the local database.
3. Enter the Client, User, and Password.
Choose Next.
4. Select the knowledge base runtime version for the product .
You can sort the results by clicking on any one of the column headers.
5. Select the master data definitions you want to import.
Choose Include Dependent Bill of Materials if you want to import the material definitions with the boms
parameter. If you do not choose this option, the material definition will not contain a reference to a BOM.
If you choose Include Dependent Material Classifications, the imported material definitions will include the
classes parameter. If you do not choose this option, the material definition will not contain a reference to
classes.
Note
These options affect only the material definition and not the import of bill of material or class
definitions
Choose Next.
6. Specify the folder and file names to be created, to store the definitions of the imported items.
Note
Choose Finish.
Context
This procedure is used to import a knowledge base present in a backend database (CRM,ECC, local database)
into a Java project. The project then created will have individual folders of bills-of-materials, classes,
characteristic and materials. Each folder shall have the relevant material definition, class definition,
characteristic definition and bill of material definition in an .ssc file as per the elements selected during
creation
Procedure
1. In the solution modeling environment, choose File Import SAP Solution Sales Configuration Import
Model to New Project .
ChooseNext.
2. Choose one of the available connections: ECC, CRM, or the local database.
3. Enter the Client, User, and Password.
Choose Next.
4. Select the knowledge base runtime version for the product.
You can sort the results by clicking on any one of the column headers.
5. Select the master definitions you want to import.
6. Choose Include Bill of Material if you want to import the material definitions with the boms parameter. If you
do not choose this option, the material definition will not contain a reference to a BOM.
If you choose to Include Dependant Material Classifications, the imported material definitions will include
the classes parameter. If you do not choose this option, the material definition will not contain a reference
to classes.
Note
These options affect only the material definition and not the import of bill of materials definitions or
class definitions.
Choose Next.
7. Enter a project name under which the project folders will be created. The .ssc files with the selected
parameter definitions will be saved here.
Choose Finish.
Use
At runtime in the SAP Solution Sales Configuration engine, the solution knowledge bases created in the
solution modeling environment interact with the product knowledge bases created in SAP CRM/ECC.
Most of the master data for the referenced products is already defined in the SAP CRM/ECC system and can
be reused in the solution modeling environment. These master data definitions are included in the knowledge
base run time versions imported into the local SQL server database.
You use this procedure to import this master data to either a file or a new project.
Prerequisites
● You have configured a connection to your SAP ECC system in the Eclipse-based solution modeling
environment.
Procedure
1. In the solution modeling environment, choose File Import SAP Solution Sales Configuration Import
Model to File .
2. Choose Next.
3. Choose from an ECC or a CRM connection.
4. Enter the client, user, and password.
5. Choose Next.
6. Select the knowledge base runtime version for the product (you can sort the results by clicking any column
header).
7. Select the master data definitions you want to import.
Choose Include Dependent Bill of Materials if you want to import the material definitions with the “boms”
parameter. If you do not choose this option, the material definition will not contain a reference to a BOM.
If you choose Include Dependent Material Classifications, the imported material definitions will include the
“classes” parameter. If you do not choose this option, the material definition will not contain a reference to
classes.
Note
These options affect only the material definition and not the import of bill of material definitions or
class definitions.
8. Choose Next.
9. Specify the folder and file name to be created to store the definitions of the imported items.
1. In the solution modeling environment, choose File Import SAP Solution Sales Configuration Import
Model to new Project .
2. Choose Next.
3. Choose from an ECC or a CRM connection.
4. Enter the client, user, and password.
5. Choose Next.
6. Select the knowledge base runtime version for the product (you can sort the results by clicking any column
header).
7. Select the master data definitions you want to import.
Choose Include Dependent Bill of Materials if you want to import the material definitions with the “boms”
parameter. If you do not choose this option, the material definition will not contain a reference to a BOM.
If you choose Include Dependent Material Classifications, the imported material definitions will include the
“classes” parameter. If you do not choose this option, the material definition will not contain a reference to
classes.
Note
These options affect only the material definition and not the import of bill of material definitions or
class definitions.
8. Choose Next.
9. Enter a project name.
10. Choose Finish.
Use
The data loader is a tool that allows you to download the configuration master data either from an SAP ERP
Central Component (ECC) system or from a Customer Relationship Management (CRM) system. The data
loader registers with the SAP ECC or CRM gateway, initiates download requests, and processes the call-backs
from the SAP ECC or CRM system. The download itself is a “push” mechanism for which two RFC connections
are required:
1. Outbound connection from the data loader to the SAP ECC or CRM system to read the SAP gateway
parameters and initiate download requests.
2. Inbound connection from the SAP ECC or CRM system in order to process the “pushed” data.
The data loader is used in the solution modeling environment to download configuration master data, for your
solutions from the SAP ECC or CRM system to the solution modeling environment database. It is installed as an
Eclipse plug-in. Before you can download data, you must configure a connection to the source SAP ECC or CRM
system and then add the connection to the data loader configuration settings.
Related Information
To facilitate faster creation of automated setup for KB exports, a new SSC DevOps Project Wizard has been
added in SME. You can create a new DevOps project from the file menu and select the knowledge bases and
destinations for export. The wizard will generate a script for individual connections, and a master script for
exporting to all the connections. The wizard uses the KB project and its dependent project information from
the eclipse workspace to generate the scripts. These scripts can also be updated later to include more
knowledge bases and connections.
1. Go to File New SSC DevOps Project and specify the Project Name and Location.
2. In the next window, select the knowledge bases to be exported, and in the subsequent window, select the
connections to which the KBs need to be exported.
3. Upon finishing, one script for each individual connection, and a master script that can execute all the
individual scripts will be generated.
4. This DevOps project can be executed using SSC DevOps run configurations. Results of the execution are
displayed in the eclipse console.
5. To update the project, right click and select the Update Devops Project menu option. New SSC projects
added in the workspace will be listed which can be then selected for script creation.
This DevOps project can be managed in Git and can be then used to setup headless KB export on a continuous
integration server like Jenkins. For more infomartion, refer to the SSC Solution Modeling Environment Overview
presentation on the [Link] Search for SAP Solution Sales Configuration Relevant Version
Additional Information SSC Solution Modeling Environment Overview .
It is now possible to turn on pricing traces while testing the configuration. The pricing context parameters can
be set in preferences, and the pricing context can be set during the opening of a knowledge base in SME.
When the pricing context is enabled, pricing parameters set in preferences will be passed onto the
configuration session, and pricing will be enabled to turn on the pricing traces. It needs to be ensured that the
material and pricing data is already downloaded in the database using which the tests are being performed.
For more infomartion, refer to the SSC Solution Modeling Environment Overview presentation on the http://
[Link]. Search for SAP Solution Sales Configuration Relevant Version Additional Information
SSC Solution Modeling Environment Overview .
Use
Master data must be exchanged between the solution modeling environment and the target sales system, for
example, SAP Customer Relationship Management (SAP CRM) or SAP ERP Core Component (SAP ECC). The
main data exchanges are as follows:
● Material master data and compatible mode (classical IPC) knowledge bases are replicated from the SAP
ECC system to the SAP CRM system.
● Modelers import data such as characteristics and classes from the SAP CRM system to the solution
modeling environment.
● Modelers transfer the completed solution model (knowledge base runtime version) from the solution
modeling environment to the SAP CRM system or to the SAP ECC system.
Note
If you want to configure and export SME into a local database (for example, for use with SAP Solution Sales
Configuration in Hybris), you must download and register the relevant database driver.
Caution
The Data Loader does not import product data into the solution modeling environment. Therefore, you
must ensure that the products defined in the solution models also exist in the target sales system(s) where
the knowledge base is deployed.
You have configured the connection between the solution modeling environment and the target sales system.
More Information
For more information about importing data, see Data Loader in the Solution Modeling Environment [page 107].
Context
You use this procedure to maintain templates for model elements. When you open an empty text file in the
solution modeling environment, and then use the auto-completion feature ( CTRL + SPACEBAR ), the system
lists all of the available templates. Templates are stored as XML files.
Procedure
Results
The system lists all of the existing templates. A template is defined with the following information:
● Name
● Context (for example, Bill of Material, Class, Constraint, and so on)
● Description
● Pattern
If you select a template, the content of the template is displayed in the Preview area.
Function Description
Import You use this function to import a template from an XML file.
Export You use this function to export the selected template to an XML file.
To facilitate quick development of user exits, a new wizard has been added in SME. This wizard will create a
skeleton for a pFunction project in which custom classes can be added. This pFunction can be then exported
from SME to the local database or backend system for testing.
While executing a configuration in SME test perspective, pFunctions would be loaded from the database along
with the KB. The existing pFunction jar files can also be exported using this project by placing the jar files in the
target directory of the pFunction project.
In case a custom unit version has been used during project creation, the same needs to be specified in the
engine settings preference page before start of the configuration in the testing perspective.
For more infomartion, refer to the SSC Solution Modeling Environment Overview presentation on the http://
[Link]. Search for SAP Solution Sales Configuration Relevant Version Additional Information
SSC Solution Modeling Environment Overview .
Use
Complex solution models that combine different products are often maintained by more than one modeler. In
addition to this, master data can be reused in different products. This means that different modelers may have
When changes are made to a solution model, the system does not directly store the model in the SAP
Customer Relationship Management (SAP CRM) or the SAP Enterprise Resource Planning (SAP ERP) system.
It first merges the changes in a model repository that defines the rules and workflows for collaboration. A
consistent model version is then transferred from the model repository to the relevant system.
Note
The solution modeling environment does not contain its own repository technology; instead it is designed
to be used with existing file-based Source Code Management Systems (SCMS).
Integration
The solution modeling environment is based on the Eclipse platform, and connector plug-ins are freely
available for the most commonly used SCMS systems, such as Subversion, CVS, and Git. Most SCMS systems
also come with the Eclipse Connector plug-in.
The SCMS system can be integrated with the solution modeling environment in the following ways:
● By downloading the required SCMS connector plug-in to the solution modeling environment using the
integrated update manager.
● By downloading the solution modeling environment as a plug-in in an existing Eclipse-integrated
development environment (IDE) with an existing SCMS connector.
The configuration engine uses reference characteristics to obtain the context of the environment in which it is
working. An example of this context could be a sales organization, a distribution channel, etc. In SAP CRM/SAP
ECC/Hybris, this context is passed on to the configuration engine through RFCs and APIs.
In SME, this context can be passed using a properties file. The format of the context properties file should be:
ref_cstic1=value1
ref_cstic2=value2
You can use this procedure to set context properties while opening a runtime knowledge base version or while
restoring configuration.
The solution modeling environment interface allows a user to use different features of the product.
Most of the features on the SME UI require human intervention for execution, for example, exporting a model
project to a target system, restoring a configuration, execution of performer on a model project, etc.
The headless automated process not only allows automation of these features, but also allows the user to run
regular automated jobs to ensure stability of models. The features mentioned below are currently supported in
headless automation:
Use
You can use this process to export solution models to a target system, for example, a standalone database,
SAP ERP, or SAP CRM.
Prerequisites
● You have installed the solution modeling environment on the system from which you want to export the
solution models
● You have set up an Eclipse workspace for the solution modeling environment
● You have defined the required back-end connections under Window Preferences SAP Solution Sales
Configuration Connections
● If solution models are to be exported to any of the supported database systems (see the Product
Availability Matrix at [Link] ), such as Microsoft SQL Server, you have already
registered the relevant database driver under Window Preferences SAP Solution Sales Configuration
Drivers
● You have configured all relevant settings in your solution modeling environment, such as source formatting
and validation settings, under Window Preferences SAP Solution Sales Configuration Source
Formatter / Validation
Preparatory Steps
This information can be provided in multiple ways based on the mode of operation of the exporter:
● Workspace mode
An Eclipse workspace is used to determine the settings and relevant modeling projects.
● Directory mode
To start the headless knowledge base exporter, you must execute the [Link] or [Link] file in
your eclipse installation directory.
Recommendation
Write a batch ( .bat) or command ( .cmd) file that calls the executable.
Eclipse-Specific Arguments
Export-Application-Specific Arguments
Note
Always specify this parameter to
prevent inconsistent knowledge
bases from being exported.
Note
You can add logsys parameter with
value to the [Link] file
when LOGSYS needs to be over
written in the headless mode.
If the headless export code is put into a command file called [Link], it can be used as follows:
Remember
If the default eclipse workspace is not used, then -data argument should be used to specify the
workspace path in headless export mode.
● Directory mode
The application returns an exit code that can be accessed through variable ERRORLEVEL.
For more information about this, a sample batch script is available in SAP Note 2174488 (Headless
Knowledge Base Export - Sample Script).
Headless performer execution allows a user to run performer scripts on the exported models in the target
system, using an automated process.
You can use either the workspace scenario or the directory scenario to provide data for headless performer
execution.
Workspace Scenario
This is an Eclipse workspace with a project and defined connections and a performer script directory.
The headless performer script execution requires the following data for the workspace scenario:
The workspace should contain the projects. You can set up an export connection by choosing Window
Preferences SAP Solution Configuration Connections .
Note
When you close the workspace, the connections are stored under:
<workspace_dir.metadata>\.plugins\[Link]
\[Link]
Caution
Add a connection password to the XML at your own risk. The password is stored as unsecure plain text. To
do so, add the password attribute to the clientSettings element.
Directory Scenario
This is a simple directory containing sub-directories with the .performer script files and the required
pfunctions (if any) in the respective directories and paths given by parameters to a valid [Link].
The application needs a path to a (parent) directory (-psData “dir/parent”) and it will scan all
subdirectories for the available performer scripts. The scenario also requires a path to the connections via an
XML file (-conFile “path/[Link]”).
In both the workspace and directory scenarios, the performer run requires the [Link] to be present
in the same directory as the respective script.
To execute the “headless performer script”, call the [Link] or [Link] (without additional
console) in the Eclipse installation directory with the required arguments.
Recommendation
Argument Description
-XX:PermSize=128M -XX:MaxPermSize=256M
For a full list of the supported arguments, see the Eclipse documentation .
Note
Use quotation marks ("") for values that contain spaces such as -psdata “D: \Performer Data”.
-projectWorkspace ssc_office_example
-psData The path to the directory with the sub The path to the directory with the sub
directories containing all re directories containing all re
quired .performer files. quired .performer files.
-conFile “C:\path\[Link]”
-conDriver “D:\jars\[Link]”
-consoleLog -consoleLog
-conName “localCon”
-pContextPropertyFile Path for the context properties to be Path for the context properties to be
set. set.
Note
This is an optional field and can be used This is an optional field and can be used
Since 3.0 Patch 6, the context as required by user. For example, C: as required by user. For example, C:
properties are saved in a performer \Users\Admin\ContextProperty \Users\Admin\ContextProperty
file which can also be used in the \sme_office_prop.properties. \sme_office_prop.properties.
headless execution mode.
-pFunction Specify the required pfunctions(if any). Specify the required pfunctions(if any).
For example, -pFunction "C:/users/ For example, -pFunction "C:/users/
dir1/[Link];C:/users/dir2/ dir1/[Link];C:/users/dir2/
[Link]". [Link]".
Recommendation
The application will return an exit code (see echo %ERRORLEVEL% in example cmd).
Workspace Mode
Sample Code
@echo off
eclipse\eclipsec -vm “%JRE_HOME%\bin” --[Link] -application
[Link]
n -noSplash -console -psConsoleLog -projectWorkspace “ssc_office_example” -
psData “C:\Users\Public\PROJECTWORK\Enhancements\TestRunner in Headless Mode
\PerformerData” -conName “localCon” -conPassword “mypassword”
Sample Code
@echo off
eclipse\eclipsec -vm "%JRE_HOME%\bin" --[Link] -application
[Link]
n -noSplash -console -psConsoleLog -conDriver "C:\Users\Public\SOFTWARES
\[Link]" –conFile "C:\Users\Public\PROJECTWORK\Enhancements\TestRunner
in Headless Mode\PerformerData\config\[Link]" –psData "C:\Users
\Public\PROJECTWORK\Enhancements\TestRunner in Headless Mode
\PerformerData"REM -Xdebug -Xnoagent -[Link]=NONE -
Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005@echo EXIT CODE:
%ERRORLEVEL%
The headless restore configuration feature is part of the solution modeling environment that allows
configuration restore using the .cfg/xml files through the headless automated process for the exported models
on the target system.
● Workspace scenario
An Eclipse workspace with project and its defined connections. The headless restore configuration needs
the following data for workspace scenario:
○ Project workspace with projects
○ Valid defined connections
○ Configuration files directory (containing .cfg/.xml files)
The workspace should contain all the relevant projects. You can setup an export connection from here:
Window Preferences SAP Solution Configuration Connections .
Note
When you close the workspace, the connections are stored under:
<workspace_dir.metadata>\.plugins\[Link]
\[Link]
Caution
Add a connection password to the XML at your own risk. The password is stored as unsecure plain text.
To do so, add the password attribute to the clientSettings element.
● Directory scenario
A simple directory with sub-directories with the .cfg/.xml files and paths given by parameters to a valid
[Link]. The headless restore configuration script execution needs the following data for
directory scenario:
○ Configuration files directory (containing .cfg/.xml files)
○ An XML file ([Link]) for the connection (DB)
○ A path to the connection driver jar file, for example, D:\jars\[Link]
The application needs a path to a parent directory (-rsData “dir/parent”) and it will scan all sub-
directories for the available configuration files (.cfg/.xml). The scenario requires also a path to the
connections via XML file (-conFile “path/[Link]”).
To execute the headless restore configuration script, call the [Link] or [Link] (without
additional console) in the Eclipse installation directory with the required arguments.
Recommendation
Write a batch ( .bat) or command ( .cmd) file that calls the executable.
Eclipse-Specific Arguments
-application For the application to start. The Value (application ID) is sep
[Link] arated from the argument by a single space.
[Link]
Posting Instructions
For a complete list of the supported arguments, see the Eclipse documentation .
-projectWorkspace
ssc_office_example
-rsData The path to the directory with the sub- The path to the directory with the sub-
directories containing all required con directories containing all the required
figuration files configuration files
-conFile “C:\path
\[Link]”
-conDriver “D:\jars
\[Link]”
- rsConsoleLog - rsConsoleLog
-conName “localCon”
Note
“” are used for values containing spaces, for example, -rsdata “D: \Configuration Data”.
It is recommended to use a batch file, [Link] for the restore process and the application
returns an exit code once the restore is complete.
For more information about this, see echo %ERRORLEVEL% in example cmd.
Workspace mode
@echo off
eclipse\eclipsec -vm "%JRE_HOME%\bin" --[Link] -application
[Link] -
noSplash -console -rsConsoleLog -conDriver "C:\Users\Demo\SOFTWARES
\[Link]" –conFile "C:\Users\Demo\PROJECTWORK\Enhancements\RestoreConfigData
\config\[Link]" –rsData "C:\Users\Demo\PROJECTWORK\Enhancements\
RestoreConfigData" REM -Xdebug -Xnoagent -[Link]=NONE -
Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005 @echo EXIT CODE:
%ERRORLEVEL%
The headless upload external variant table feature is the part of solution modeling environment that allows
upload of external variant table to a target system through headless automated process.
There are two possible scenarios to provide the data for headless upload of external variant table:
● Workspace scenario
An Eclipse workspace with a project and its defined connections. The headless upload external variant
table needs the following data for workspace scenario:
○ Project workspace with projects
○ Valid defined connections
○ Data directory for external variant table downloaded from ECC/CRM system.
Note
When you close the workspace, the connections are stored under:
<workspace_dir.metadata>\.plugins\[Link]
\[Link]
Caution
Add a connection password to the XML at your own risk. The password is stored as unsecure plain text.
To do so, add the password attribute to the clientSettings element.
● Directory scenario
A simple directory containing the external variant table data files and their paths, given by parameters to a
valid [Link]. The headless external variant table script execution needs the following data for
directory scenario:
○ Data directory for external variant table downloaded from ECC/CRM system
○ An XML ([Link]) file for the connection (DB)
○ A path to the connection driver jar file, for example, D:\jars\[Link]
The application needs a path to a parent directory (-vtData “dir/parent”), the data downloaded from
ECC/CRM external variant table download utility. The scenario requires also a path to the connections via XML
file (-conFile “path/[Link]”).
To execute the headless upload external variant table script call [Link] or [Link] (without
additional console) in the Eclipse installation directory with the required arguments.
Recommendation
Write a batch ( .bat) or command ( .cmd) file that calls the executable.
Eclipse-Specific Arguments
Posting Instructions
For a full list of the supported arguments, see the Eclipse documentation .
-projectWorkspace ssc_office_example
-vtData The path to the directory with the sub- The path to the directory with the sub-
directories containing all required con directories containing all required exter
figuration files. nal variant table files.
-conFile “C:\path\[Link]”
-conDriver “D:\jars\[Link]”
-vtConsoleLog -vtConsoleLog
-conName “localCon”
Note
“” are used for values containing spaces, for example, -vtdata “D: \External Variant Data”.
It is recommended to use a batch file, restore [Link] for the restore process and the application
returns an exit code once the restore is complete.
For more information about this, see echo %ERRORLEVEL% in example cmd.
Workspace mode
Directory mode
@echo off
eclipse\eclipsec -vm "%JRE_HOME%\bin" --[Link] -application
[Link]
ableapplication -noSplash -console -vtConsoleLog -conDriver "C:\Users\Demo
\SOFTWARES\[Link]" –conFile "C:\Users\Demo\PROJECTWORK\Enhancements
\ExtVarTabData\config\[Link]" –vtData "C:\Users\Demo\PROJECTWORK
\Enhancements\ ExtVarTabData" REM -Xdebug -Xnoagent -[Link]=NONE -
Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005 @echo EXIT CODE:
%ERRORLEVEL%
The process of headless upload of knowledge bases allows upload of .xml/.txt files pertaining to a certain
knowledge base into a target system through headless automated process.
There are two possible scenarios to provide the data for headless upload of knowledge bases:
● Workspace scenario
An Eclipse workspace with a project and its defined connections. The headless upload external variant
table needs the following data for workspace scenario:
○ Project workspace with projects
○ Valid defined connections
○ .xml/.txt files data directory for external variant table downloaded from ECC/CRM system.
The workspace should contain all the relevant projects. You can setup an export connection from
Window Preferences SAP Solution Configuration Connections .
When you close the workspace, the connections are stored under:
<workspace_dir.metadata>\.plugins\[Link]
\[Link]
Caution
Add a connection password to the XML at your own risk. The password is stored as unsecure plain text.
To do so, add the password attribute to the clientSettings element.
● Directory scenario
A simple directory containing .xml/.txt files and their paths, given by parameters to a valid
[Link]. The headless upload of knowledge base script execution needs the following data for
directory scenario:
○ .xml/.txt files directory downloaded from ECC/CRM system
○ An XML ([Link]) file for the connection (DB)
○ A path to the connection driver jar file, for example, D:\jars\[Link]
The application needs a path to a parent directory (-kbData absolute path to the .xml/.txt files), the data
downloaded from ECC/CRM by download utility. The scenario also requires a path to the connections via XML
file (-conFile “path/[Link]”).
To execute the script for headless upload of knowledge bases, you must call the [Link] or
[Link] (without additional console) in your eclipse installation directory, with the required arguments.
Recommendation
Write a batch ( .bat) or command ( .cmd) file that calls the executable.
Eclipse-Specific Arguments
Posting Instructions
For a full list of the supported arguments, see the Eclipse documentation .
Note
Use quotation marks ("") for values that contain spaces such as -kbData “D: \KnowledgeBaseData”.
-projectWorkspace ssc_office_example
-uploadConsoleLog
-conName “localCon”
-kbData Path to the directory contain The argument mentions the path to the
ing .xml/.txt files directory containing .xml/.txt files of
the knowledge base
Recommendation
The application will return an exit code (see echo %ERRORLEVEL% in example cmd).
Workspace Mode
Sample Code
echo
Sample Code
@echo off
"C:\Users\Demo\PROJECTWORK\Enhancements\[Link]" –kbData
"C:\Users\Administrator\xmlModels\TestModel "
To execute the script for headless dataloader, you must call the [Link] or [Link] (without
additional console) in your eclipse installation directory, with the required arguments.
Recommendation
Write a batch ( .bat) or command ( .cmd) file that calls the executable.
Posting Instructions
For a full list of the supported arguments, see the Eclipse documentation .
Note
Use quotation marks ("") for values that contain spaces such as -conDriver "D:\Database Drivers
\mssql\[Link].
-psConsoleLog -psConsoleLog
Print logs on console.
-backendPassword -backendPassword
Password for the user specified for
"backendpassword"
source backend system in the data
loader connection settings.
-createTables -createTables
Specify this argument if create table
needs to be run while running the data
loader. There is no value required for
this argument.
-initialDownload -initialDownload
Specify this argument if initial down
load needs to be run while running the
dataloader. No value required for this
argument.
Recommendation
The application will return an exit code (refer to echo %ERRORLEVEL% in example command.
@echo off
eclipse\eclipsec -vm "%JRE_HOME%\bin" --[Link] -application
[Link] -
noSplash
-console
-psConsoleLog -conDriver "D:\DBdrivers\Database_Drivers\mssql\[Link]"
-conName "con" -conPassword "password" -backendPassword "bkpassword"
-conFile "D:\DBdrivers\[Link]"-createTables -initialDownloadREM -Xdebug -
Xnoagent -[Link]=NONE-
Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005@echo EXIT CODE:
%ERRORLEVEL%
The exit codes for headless dataloader execution are given in the table below:
Use
The solution configuration environment is part of the SAP Solution Sales Configuration application. It is used to
define the configuration of a solution in a business document, such as a sales quotation or a sales order, and is
integrated with sales order processing transactions in the following systems:
Runtime Component
At run time, SAP Solution Sales Configuration comprises of the following components:
● A configuration UI: Launched from a sales application within the context of a sales document. It interacts
with the engine via a command layer with well-documented APIs.
● A command layer: Exposes the functionality of the engine and content of a configuration session to the
outside world.
● KBO - knowledge base orchestration layer: Enables multiple discrete knowledge bases to be accessed
dynamically as required during a configuration session.
● SPE - Sales Pricing Engine: Accesses the pricing master data to calculate pricing.
● SCE - Sales Configuration Engine: Accesses knowledge base run time versions in the back-end database (if
not already cached in memory). These can be solution knowledge bases generated from the solution
modeling environment as well as product knowledge bases from CRM and ECC.
Component Description
PMS - pattern matching Responsible for identifying the objects in the configuration
that are "in scope", as defined by the objects/condition sec
tions of constraints and rules. This process is called pattern
matching.
TMS - truth maintenance Tracks the facts asserted into the configuration session,
along with their justifications.
Note
An event is logged for each action taken by these three components. The tracing and profiling capabilities
of the engine support recording of these events, which are used in the solution modeling environment and,
if enabled, in the production run time engine.
Integration
The solution configuration environment is built and packaged as an Enterprise Java Beans (EJB) component
based on Java 2 Enterprise Edition (J2EE) standards. It is primarily intended to be deployed on an SAP J2EE
NetWeaver Server.
The solution configuration environment for SAP Commerce is built and packaged as a Java Archive (.jar), which
is added to the SAP Commerce class path. The Hybris service layer directly communicates with the Solution
Configuration Engine (ConfigSession) "in-process", giving the best performance using Java native "call-by-
reference".
The solution configuration environment integrates with the following business processes:
When you choose to edit a configurable product in a sales document, the system opens the JSP UI. When you
accept your configuration and close the JSP UI, you are returned to the SAP CRM or SAP ERP system, and the
configuration result is reflected in the sales document, with any sales-relevant components listed as sub-line
items. A saved configuration can be reopened, changed, and saved in the sales document, as necessary.
As a system administrator, you can also customize the behavior of the Solution Configuration Engine, by
modifying the engine parameters. For more information about working with engine parameters, please refer to
SAP Note 2291607 (Engine Parameters for Hybris SSC, SAP Solution Sales Configuration, and Solution
Modeling Environment).
Constraints
The following features are available in SAP CRM, but not in SAP ERP or the Hybris Commerce Suite:
Recommendation
If you want to use configuration mode B (Copy Configuration from Source Item) in Customizing for
Copy Control, do not set the Reexplode Structure/Free Goods flag. If this flag is set, all the solution
configuration data may not be copied.
With the Reexplode Structure/Free Goods flag not set, if you copy a line item within the same sales
document, you must reopen the copied item's configuration and accept it to obtain the sub-items.
Related Information
Use
You use this process to add a solution, or a component of a solution to a sales document, and then configure it
in the standard SAP Customer Relationship Management (SAP CRM) WebClient user interface.
Note
If you have installed SAP Solution Sales Configuration, the system displays the SAP Solution Sales
Configuration JavaServer Pages user interface (JSP UI) for the configuration of both compatible mode and
advanced mode products.
Prerequisites
● You have entered product master data and configuration master data.
● You have maintained the solution object to be used for starting the configuration of a component in
Customizing for Customer Relationship Management under Basic Functions Solution Sales
Configuration Maintain Solution Objects for Products .
Process
1. You create a sales document such as a package quotation, in the standard SAP CRM WebClient UI.
2. You add a solution, or a component of a solution, to the sales document.
The system displays the solution or component, as a line item in the sales document.
3. You choose the Edit icon next to the line item for the solution or component.
The system displays the configuration user interface for the solution and all of its component parts.
Note
If you have added a component of a solution to the sales document, the system initializes the
configuration using the knowledge base for the solution. The configuration user interface displays the
solution at the top level and the entered component (along with other components, if any) underneath.
Note that the knowledge base for the solution must be modeled with the component (material) as one
of the non-part instances.
You can also copy a solution configuration to a new sales document using the standard SAP CRM Online
copy function.
You cannot copy a solution from one line item to another line item in a sales document.
More Information
● For information about the relationships between components, see One-to-Many Relationships Between
Components [page 145] and Hard and Soft Ties Between Components [page 146].
● For information about splitting line items when creating follow-up documents, see Splitting Line Items in
Follow-Up Document Creation [page 147].
● For information about the functions in the configuration user interface, see Creating Solution
Configurations [page 178].
Use
Solutions can include a mixture of interrelated components such as hardware components, software
components, and services. There can be different kinds of relationships between these components, for
example, has part, is part of, is served by, and so on. The system uses a special type of characteristic called an
abstract data type (ADT) to model such relationships between components. ADT characteristics are defined in
the solution modeling environment.
ADTs can be used to model one-to-many relationships. For example, a single service product can be associated
with multiple hardware and software components.
Prerequisites
● You have modeled ADT characteristics for the solution in the solution modeling environment.
● You have maintained the names of the ADT characteristics to be used for different relationship types in
Customizing for Customer Relationship Management under Basic Functions Solution Sales
Configuration Maintain Item Relationship Types .
Although you can model your own custom relationship types and the associated ADT characteristics, SAP
Solution Sales Configuration provides the following two predefined relationship types:
For more information about these predefined relationship types, see Hard and Soft Ties Between Components
[page 146].
Use
SAP Solution Sales Configuration provides the following predefined sales abstract data types (ADTs) to
represent parent-child relationships between sales-relevant components:
● SALES_HARD
Denotes a hard tie between two components
● SALES_SOFT
Denotes a soft tie between two components
When you create follow-up documents for a solution quotation, you may want to split the components of the
solution into separate follow-up documents. For example, you could have a package quotation for a solution
that consists of a few hardware items and a few service items. You could create a sales order for the hardware
items and a service contract for the service items.
However, certain components of the solution may be so closely related that they must be processed together.
You control which components must be processed together by using the correct tie type to establish a
relationship between those components. Components that are related by a hard tie must be processed as a
group. They must remain together in the initial sales document and cannot be split into separate follow-up
documents. Components with soft ties can be split into separate follow-up documents.
Prerequisites
● You have modeled sales ADT characteristics for the solution in the solution modeling environment.
● You have maintained the names of the hard and soft tie sales ADTs in Customizing for Customer
Relationship Management under Basic Functions Solution Sales Configuration Maintain Item
Relationship Types .
More Information
For more information, see Splitting Line Items in Follow-Up Document Creation [page 147].
Use
You use this procedure to split line items in a package quotation into separate follow-up documents.
Prerequisites
● You have modeled sales abstract data type (ADT) characteristics for the solution in the solution modeling
environment.
● You have maintained the names of the hard and soft-tying sales ADTs in Customizing for Customer
Relationship Management under Basic Functions Solution Sales Configuration Maintain Item
Relationship Types .
● You have maintained the copying control settings in Customizing for Customer Relationship Management
under Transactions Basic Settings Copying Control for Business Transactions .
● You have created a package quotation for a solution.
Procedure
Note
A special modeling technique is required to enable trimmed solutions. For more information, see SAP
Note 2086153 (SSC Modeling for Trimmed Solutions).
You can subsequently reconfigure the follow-up documents on an individual basis as you require.
More Information
● For more information, see Hard and Soft Ties Between Components
● Note
While creating a follow-up document with configurable sub items, some characteristics' values may not
copied be to the configuration of these items. If you observe this issue, please refer to SAP Note
2314099 (CRM: Utility to switch characteristics author during split).
● With SAP Solution Sales Configuration 3.0, splitting is now available for provider orders and provider
contracts, in addition to sales and service transactions.
Related Information
Use
You can configure a solution on the CRM user interface and replicate the data to the SAP ERP central
component, where you can process it further. Replicating the data to SAP ERP means that you can take
advantage of the functions and features offered by SAP ERP, such as creating a production order.
Prerequisites
● You have established an RFC connection between SAP CRM and SAP ERP.
● You have exported the solution models (knowledge bases) manually or via "headless export", from the
solution modeling environment to SAP CRM and SAP ERP.
You can find more information about this on the SAP Help Portal and navigate to the SAP Solution Sales
Configuration Version 3.0 Installation Guide .
● You have set up the necessary data structures and bills of material in SAP Solution Sales Configuration and
SAP ERP.
SAP Solution Sales Configuration enables you to create different types of documents in SAP CRM, such as
sales quotations, service quotations, and contracts. The follow-up documents that are created in SAP CRM and
then replicated to SAP ERP differ depending on the type of document originally created. For example, you can
create a package quotation and then generate a service order that is replicated to SAP ERP. Alternatively, you
can choose to create a sales order that is replicated to SAP ERP. In the steps below, we use the example of a
sales order that is used to generate a production order in SAP ERP.
Create Quotation
1. In the SAP CRM Web client UI, create a package quotation (document type SRVP) and enter the business
partners and accounts.
2. In the Items assignment block, enter the name of the product that you want to configure.
3. Choose the edit icon in the Actions column.
The item details screen appears.
4. In the Configuration assignment block, specify the configuration elements that you require.
Mandatory fields are indicated by a yellow triangle.
5. Choose the Back pushbutton to return to the quotation screen and then save.
The system generates a document number for the quotation.
1. On the Package Quotation screen, choose the Create Follow-Up button and select the “sales process”
document type.
2. In the pop up that appears, select the product that you configured in “Create Quotation” above.
3. Enter any missing information and save the sales order.
The system generates a document number for the sales order and automatically replicates the sales order
to SAP ERP.
You can display the sales order in SAP ERP to check that the data has been replicated correctly. To do so,
proceed as follows:
Note
If any of the replicated data is incorrect, you can change it by calling transaction VA02 ( Change Sales
Order).
Use
You use this process to add a solution to a sales document and configure it in the SAP Enterprise Resource
Planning (SAP ERP) system.
Note
SAP ERP has an integrated configuration engine called the Variant Configurator, which supports only
compatible-mode configurations, however. If you install SAP Solution Sales Configuration, the SAP ERP
system opens the SAP Solution Sales Configuration JavaServer Pages (JSP) user interface (UI) instead of
the standard Variant Configurator user interface when you choose to configure a product (a solution)
during the sales ordering process.
An alternative to the Variant Configurator for compatible-mode configurations is the use of the IPC.
A Customizing is available to select the VC or SSC configurator, based on transactions. You may customize
entries in the table /SLCE/DEL_TRAN, to change the configurator if required. For more information about
this, refer to SAP notes 2701187 (Configuration is not displayed for planned order and 2705646
(Configuration is not displayed for planned order - 2).
Prerequisites
● You have entered product master data and configuration master data
● You have marked the solution product as 'to-be-configured' with the IPC in the PME-VC (Product Modeling
Environment-VC)
Process
More Information
For more information about the functions in the configuration user interface, see Creating Solution
Configurations [page 178].
Note
In SAP ERP, it is not possible to copy a solution configuration from one sales document to another or to
split the line items for a solution into separate follow-up documents. It is also not possible to copy a
solution from one line item to another line item in the same sales document.
The business scenario for enhancement of ERP IDOC inbound interface for sales order creation has the
following steps:
1. You send IDOCs from a source to a target system where the source system may be an SAP- or third-party
system with SSC add-on installed and the target system is an SAP ERP system with the SSC add-on
installed.
2. You use ORDERS IDOC inbound interface in the target ERP system to create sales documents with the
configured items.
3. You use basic IDOC type ORDERS05 and the function module for IDOC_INPUT_ORDERS standard inbound
for IDOC processing.
IDOC Processing
An ERP solution configuration created by SSC operates in the following two modes at the same time:
Basic IDOC type ORDERS05 provides a set of segments to transfer configuration results, such as, E1CUCFG,
E1CUINS, etc. These segments must be used to transfer the PRS. As of today, the rich-config XML cannot be
transferred by a standard IDOC type or BAPI.
If you create sales orders by IDOCs that contain only the PRS configuration results but not the rich-config XML,
then the users cannot see the full advanced mode configuration when they try to open the configuration
manually in that sales order.
To solve this problem, SAP Notes 1996874 (Orders IDOC Inbound for SSC - config XML extension) and
2003665 (Orders IDOC Inbound for SSC - config XML extension (II)) enhance IDOC inbound processing in
the following way:
After implementation of solution (Read: SAP Note 1996874 (Orders IDOC Inbound for SSC - config XML
extension)).
You can use this process to create a sales document with items configured by IDOC. You will be able to view the
advanced mode model by opening the configuration in SSC UI.
For more information about creating a sales order, refer to Enhancement of ERP IDOC Inbound Interface for
Sales Order Creation.
Related Information
Enhancement of ERP IDOC Inbound Interface for Sales Order Creation [page 154]
Note
You need to use the enhancements provided in SAP Notes 1996874 (Orders IDOC Inbound for SSC -
config XML extension) and 2003665 (Orders IDOC Inbound for SSC - config XML extension (II)).
● FBS Solution Sales Configurator (SSC) add-on for SAP ERP (SLCE) has been installed with the correct
version and latest support package.
● SAP Note 2003665 (Orders IDOC Inbound for SSC - config XML extension (II)) has been implemented,
including pre- and post-installation steps.
● The following notes need to be implemented as well:
○ SAP Note 1991156 (IDoc order creation: Sub-item without configuration tie)
○ SAP Note 1996874 (Order IDOC Inbound for SSC - config XML extension)
○ SAP Note 2006212 (Additional enhancement point in function group V45CU)
○ SAP Note 1923474 (Items on the Sales Document are deleted and recreated.)
○ SAP Note 1880466 (ECC:Create With Reference results in Exception on Config UI)
● If you have implemented and activated BAdI /SLCE/CONFIGURE_BACKGROUND, apply SAP Note 2455331
(ECC:Segregate menthod IS_ITEM_PROMOTION_ACTIVE from BAdi /SLCE/
CONFIGURE_BACKGROUND) as well.
Assumptions
● You have already customized ORDERS IDOC inbound interface in the target ERP system and are able to
create sales documents by basic IDOC type ORDERS05.
● The sales documents are already created with the correct PRS configuration and only the rich-config XML
is missing
Out of Scope
The out of scope processes and functions are especially but not limited to the following:
Related Information
Use
Light engineer-to-order ( “light ETO”) enables you to split a complex configuration between the sales level and
the engineering level, making the configuration process clearer. The processor of the production order BOM
can also change the configuration on an individual basis in cases where a required change is too specific to be
included in the configuration rules.
Process
1. The sales representative creates a sales order that contains a configurable material, either directly in SAP
ERP (transaction VA01) or by replicating it from SAP CRM (see Replicating Data from SAP CRM to SAP
ERP [page 148]).
2. The sales representative starts the sales configurator by choosing the Item details: Configuration
pushbutton.
3. The sales configurator explodes the sales order BOM components.
4. The sales representative configures the components in the sales order BOM. The component may already
be partly configured as the result of rules that have been defined in the system (see Defining Solution
Dependencies [page 46]).
Note
The component configured here is also the header of the production order BOM and is, therefore,
visible in both the solution sales configurator and the variant configurator.
5. The sales representative accepts the configuration to transfer the result to the production order. The sales
order is then saved and the sales order number communicated to the production engineer.
6. The production engineer opens the order BOM, for example, in transaction CU51 by entering the order
number and the item number that he or she wants to configure.
Note
All standard engineering-to-order processes can be used (for example, transactions CSKB, CS6x, and
CU51).
The variant configurator opens and displays the header level of the engineering structure.
7. The production engineer navigates to the subitems and configures the relevant data.
8. The production engineer clicks the configuration tree structure to explode the BOM again. If there are any
dependencies between the data (for example, the engineer has specified a component but not the
component type), the system requests the missing data.
9. The production engineer saves the data.
You have a material ( MY_SYSTEM) that has been configured with the components RACK, SUBRACK, and
DEVICE. The device slots into the subrack, which in turn slots into the rack.
The sales representative creates a sales order for the material MY_SYSTEM and starts the sales configurator.
After the sales representative has specified the general data, the system displays three more dropdown areas -
one for RACK, one for SUBRACK, and one for DEVICE (whereby SUBRACK and DEVICE are classes only). The
sales representative configures the data for RACK and saves the order.
The production engineer opens the order BOM with the item number that is to be configured (in this example,
item 20). The engineer navigates to SUBRACK in the configuration tree structure and enters the required data.
He or she then explodes the BOM again and repeats the process to configure the required data for DEVICE.
Use
In certain cases, a production engineer may want to change the data in a bill of material for a specific
production order. The required change is too specific to be included in the configuration rules, and so the
engineer must change the data manually.
Procedure
1. Display the order BOM in transaction CU51 and open the configuration result by choosing the Result
pushbutton ( CTRL + F9 ).
2. Select the checkbox for the component that you want to change and choose the Item in Full pushbutton
( SHIFT + F4 ).
3. Change the required data, return to the configuration result, and save.
Note
You can also add further items to the BOM by choosing the Insert pushbutton ( SHIFT + F1 ). Examples of
items that you can add include documents, texts, and compatible units.
Use
You use this process to configure a solution in Hybris and then add it to your shopping cart.
● You have created product master data and configuration master data.
● You have created the solution product in your Hybris catalog.
● You have downloaded the master data from the SAP back-end system to the Hybris database using the
Data Loader.
For more information on using the Data Loader in Hybris, see the Hybris help portal and Integrations and
Data Management SAP Integrations SAP Product Configuration (On-Premise Edition) Installing
Product Configuration Post Installation Steps Configuring and Running the Data Loader Loading
Configuration Master Data through Data Loader .
Process
1. You search for the solution product you require in the catalog.
2. You choose to configure the solution.
The system displays the configuration user interface.
3. You configure the solution.
4. You add the solution to your shopping cart.
The system closes the configuration user interface and displays your shopping cart.
5. You start the checkout process.
More Information
For more information about the functions in the configuration user interface, see Creating Solution
Configurations [page 178].
Context
SAP Solution Sales Configuration enables you to manually add related products to your solution.
The system displays a list of related products. The default implementation of the search filter for “related
products” uses the potential “non-part instances”of the solution model. You can enhance this with your
own logic.
2. Select the product that you want to add to the solution.
Results
The system shows the added product in the section Selected Products Related to This Solution.
Use
Component promotion (or “order stripping”) enables you to use the sales configurator to select any number of
components, which you can then save to a sales order without the organizational structure (that is, the top
node in the product or solution hierarchy).
For example, your company produces assembly lines and you want to configure the entire assembly line.
However, you do not manufacture the entire assembly line in your factory. Instead, you manufacture the
machines that are sent to your customer, and the assembly line is then put together by the customer on site. In
this case, you want to include the components of the assembly line in your sales order but not the assembly
line itself.
Activities
The configuration modeler activates component promotion in the model by adding the reserved Promote
Subitems? characteristic ( SSC_PROMOTE_SUBITEMS) to the Configuration Root class and setting it to invisible
with an assigned value of Yes.
If a user selects the value of this cstic as 'Y' during configuration, the root materials will be stripped and all
dependent sub-items will be promoted as root items.
Component promotion is inactive by default from SAP Solution Sales Configuration Version 2.0 Support
Package 6 onwards. To enable it, follow this procedure:
If the item promotion is required, a new implementation can be created for the BAdI /SLCE/
ITEM_PROMOTION_SWITCH and the logic provided with template implementation /SLCE/
EHI_SWITCH_ITEM_PROM can be used to switch on the item promotion.
Use
SAP systems provide two modes of configuration: compatible mode and advanced mode. Compatible mode is
suitable for simple product configurations and uses a super bill of material (super BOM). Advanced mode
provides the additional flexibility required to configure complex solutions. It uses a dynamic BOM and abstract
data types (ADTs).
Features
Advanced mode uses ADTs to define relationships outside those defined in the BOM. This means that more
complex relationships can be defined, including one-to-one and one-to-many relationships. For example, a
solution configuration could have a service item that relates to multiple hardware items.
You can display the ADTs by choosing Show ADT Nodes from the context menu and determine how each ADT is
used.
Advanced mode uses a dynamic BOM, instead of the traditional super BOM used in compatible mode
configurations. A dynamic BOM allows the instantiation of multiple subcomponents at the same BOM position.
Use
During the solution configuration process, the system calculates and displays the price of the solution after
each change in the configuration, for example, when the value of a characteristic is changed, when an instance
is deleted, and when an instance is added. This is known as interactive pricing.
Integration
The solution configuration process uses configuration and pricing data from the source system (SAP CRM or
SAP ERP). To access the data, therefore, the system must be connected to the relevant database. This
connection is implemented as a static destination setting between the J2EE environment, where the
configuration engine is deployed, and the source system (SAP CRM or SAP ECC).
To optimize performance, pricing and configuration data is cached at Java stack level.
Prerequisites
● You have maintained prices (list prices) for the required products.
● You have maintained one-to-one variant conditions in the solution configuration model to reflect the
surcharge or the price reduction for each characteristic value.
Recommendation
To optimize system performance, SAP recommends that you maintain a pricing procedure that is
dedicated to interactive pricing purposes. This pricing procedure should hold only the necessary condition
types and condition tables relevant for interactive pricing.
Activities
Interactive Pricing
To calculate and display interactive prices, the system performs the following steps:
1. The order mapper interprets the solution configuration and converts it into a sales product structure that
can be used by the sales pricing engine (SPE).
The sales product structure is represented in the configuration result by the following types of instance
relationship:
○ Sales abstract data type (ADT) characteristics (see Characteristic [page 24])
○ Compatible mode sales bill of material (BOM) explosions of the super BOM
2. The system passes the sales product structure to the SPE.
3. The system triggers the pricing determination process.
The SPE calculates the total price of the solution, which is a summation of all the instance (product) list
prices and all the variant conditions attached to the selected characteristic values.
4. The system passes the result of the pricing determination process to the configuration user interface and
updates the display.
The pricing procedure used for interactive pricing should not propagate the prices of subitems to the root
item price.
Delta Pricing
To calculate and display delta prices, the system performs the following steps:
1. The surcharge or reduction price for each pricing-relevant characteristic value is retrieved and displayed
next to each characteristic value in the user interface.
2. After each change to the configuration, the surcharge or reduction price is recalculated based on the user's
last selection.
It is assumed that a one-to-one characteristic value/variant condition assignment is used. Therefore, the
new delta prices only need to be calculated for the values of the characteristic that was changed last.
The following formula is used to calculate the delta price:
characteristic value price = variant condition value price - selected characteristic value price
If the value is positive, the delta price is a surcharge. If the value is negative, the delta price is a reduction.
More Information
Note
You can enable and disable interactive pricing and delta pricing using a checkbox in the configuration user
interface.
For more information about using the configuration user interface, see Creating Solution Configurations [page
178].
Pricing is a highly customizable and configurable engine. However, in some cases, the regular features and
functionalities provided by the pricing engine are not sufficient. In such cases, it is possible to meet the special
business requirements by using Pricing Formulas and User Exits. These are custom functions that allow
customization of the default behavior of existing pricing conditions.
For more information about this, refer to the SAP Help Portal and navigate to Basic Functions and Master
Data in SD Processing (SD-BF) Basic Functions in SD Pricing and Conditions .
Here, you can find all the relevant information related to the available pricing-related user-exit types. First, the
standard features are explained and then the different types of user exits. The parameters that form the
interface between pricing and user exits are also described briefly.
For customer pricing user exits, there is an easy way to include fast logging. The
[Link] class implements two methods for logging debug
messages or error messages. Logging is fast and done only if the appropriate log level is reached, which you
can define at runtime.
ZSpecialRoundingValueFormula (shorten)
package [Link];
import [Link];
[..]
public class ZSpecialRoundingValueFormula extends ValueFormulaAdapter {
13 Use writeLogDebug(String s) or
writeLogError(String s) to log the string s in the log.
The condition base formula can be used to overturn the automatically calculated base value of a condition. This
type of user exit must be assigned in Customizing to the user exits type BAS (condition base formula).
This user exit is called after the condition base value has been calculated for each pricing condition. The user
exit class must be inherited from BaseFormulaAdapter and implement method
overwriteConditionBase. The overwriteConditionBase method has the parameters pricingItem
and pricingCondition, which represents the item and the actual condition.
If this method returns a null object reference, pricing will keep the base value that is called automatically.
ZSpecialBaseFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
BigDecimal result;
return result;
}
}
This seldom-used user exit is available to change the document and item if necessary before item pricing takes
place. This type of user exit must be assigned in Customizing to user exit type CAB (Item Calculation Begin
Formula).
ZSpecialCalculationBeginFormula
package [Link];
import [Link];
import [Link];
import
[Link]
ter;
stepNumber = 10;
counter = 1;
[Link](true);
}
}
This seldom-used user exit is available to change the document and item if necessary after item pricing has
taken place. This type of user exit must be assigned in Customizing to user exit type CAE (Item Calculation End
Formula).
ZSpecialCalculationEndFormula
package [Link];
import [Link];
import [Link];
import
[Link]
r;
stepNumber = 10;
counter = 1;
[Link](stepNumber, counter).setConditionControl('A');
}
}
This seldom-used user exit is called when the product configuration process creates subitems. This type of
user exit must be assigned in Customizing to user exit type CFG (Configuration Formula), which is called for
subitems created by SCE.
ZSpecialConfigurationFormula
package [Link];
import [Link];
import [Link];
import
[Link];
return [Link]();
}
}
After a pricing condition has been initialized, it can be changed with this user exit, which is called whenever an
internal condition (a transactional object or business entity) is created. This type of user exit must be assigned
in Customizing to user exit type CNI (Condition Init Formula).
The user exit class must be inherited from PricingConditionInitFormulaAdapter and must overwrite
the method init. It allows the new condition to be changed (parameter prCondition).
ZSpecialConditionInitFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import
[Link];
if ([Link]() != "0PR0"
&& [Link]())
[Link](new BigDecimal("2"));
}
}
While a document is being copied, the pricing condition can be fixed or other changes can take place if
required. This type of user exit must be assigned in Customizing to user exit type CPY (Copy Formula).
This user exit is called during the copying process. The user exit class must be inherited from class
PricingCopyFormulaAdapter and implement method pricingCopy. Parameters pricingDocument,
ZSpecialCopyFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
After a pricing document has been initialized, it can be changed with this user exit, which is called when a new
pricing document is created. This type of user exit must be assigned in Customizing to user exits type DOI
(Document Init Formula).
The user exit class must be inherited from class PricingDocumentInitFormulaAdapter and implement
method init. A reference to the new document is passed.
package [Link];
import [Link];
import
[Link];
This user exit can be used to replace the automatically determined condition value. This type of user exit must
be assigned in Customizing to user exit type VAL (Condition Value Formula).
This user exit is called after the condition value has been calculated for each pricing condition. The user exit
class must be inherited from class ValueFormulaAdapter and implement at least
overwriteConditionValue. If group condition processing is enabled for the condition type, the
implementation of method overwriteGroupConditionValue is possible. Both methods can return null to
indicate that the original value is to be taken.
ZSpecialRoundingValueFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
return [Link](qnt);
}
After the pricing item has been initialized, it can be changed with this user exit, which is called when a new
pricing item is created. This type of user exit must be assigned in Customizing to user exit type ITI (Item Init
Formula).
The user exit class must be inherited from class PricingItemInitFormulaAdapter and implement method
init. A reference to the document and to the new item is passed.
package [Link];
import [Link];
import [Link];
import
[Link];
In previous releases, this user exit was called CRMDocumentStandardExit where it was used mainly to pass
header attributes to be used in method initializeDocument. As of Release 2.0 SP5, these attributes can be
customized. Pricing Init user exits can now be used only to set the unit of rounding to the smallest unit of a
currency. This type of user exit must be assigned in Customizing to the user exit type PRI (Pricing Init).
This user exit is called when a new pricing document is created. The user exit class must be inherited from
class PricingInitFormulaAdapter and must implement method initializeDocument. This method has
parameter documentUserExitAccess, which represents the pricing document.
ZPricingInit
package [Link];
import [Link];
import [Link];
In previous releases, this user exit was called CRMItemStandardExit. Pricing Prepare user exits can be used
to add header and/or item attributes to be used during the pricing process. These attributes can now be
customized. This type of user exit must be assigned in Customizing to the user exit type PRP (Pricing Prepare).
The Pricing Prepare user exit is called when creating a new pricing item and when new pricing takes place. The
user exit class must be inherited from class PricingPrepareFormulaAdapter and must implement method
addAttributeBindings. This method has parameter itemUserExitAccess, which represents the pricing
item.
ZPricingPrepare
package [Link];
import [Link];
import [Link];
[Link]("ZLAND", "DE");
}
}
[Link].13 Requirement
This user exit is used during condition determination at pricing procedure step/counter level and at condition
access step level. This type of user exit must be assigned in Customizing to the user exit type REQ
(Requirement).
The user exit class must be inherited from RequirementAdapter and implement method
checkRequirement. If this method returns false, the actual access is not made.
ZSpecialRequirement
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
This user exit can be used to replace the automatically determined scale base. This type of user exit must be
assigned in Customizing to the user exit type SCL (Scale Base Formula).
This user exit is called after the condition-scale base value has been calculated for a pricing condition. The user
exit class must be inherited from class ScaleBaseFormulaAdapter and implement at least
overwriteScaleBase. If group condition processing is enabled for the condition type, method
overwriteGroupScaleBase can also be implemented. Both methods can return null to indicate that the
original value is to be taken.
ZSpecialScaleBaseFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
if ([Link]() != null) {
return [Link]().getValue().setScale(0,
BigDecimal.ROUND_FLOOR);
}
else
{
return null;
}
}
if ([Link]() != null) {
return [Link]().getValue().setScale(0,
BigDecimal.ROUND_FLOOR);
}
else
{
return null;
}
}
}
This user exit can be used to replace the automatically determined condition value. This type of user exit must
be assigned in Customizing to user exit type VAL (Condition Value Formula).
This user exit is called after the condition value has been calculated for each pricing condition. The user exit
class must be inherited from class ValueFormulaAdapter and implement at least
overwriteConditionValue. If group condition processing is enabled for the condition type, the
implementation of method overwriteGroupConditionValue is possible. Both methods can return null to
indicate that the original value is to be taken.
ZSpecialRoundingValueFormula
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
return [Link](qnt);
}
If you want to change the pricing context for the header or item of a document, you can implement the /SLCC/
MODIFY_PRICING_CONTEXT BadI. SAP delivers a default implementation of this BadI and customers can have
their own implementation as this is a multiple use BadI.
Use
This procedure explains how to use the main functions in the advanced-mode configuration user interface. The
user interface is presented as an accordion with collapsible layers. Within the Configuration layer, there is a
layer for each component in the solution.
Prerequisites
You have created a sales document, added an advanced mode product, and chosen to edit it.
Procedure
To access individual functions shown in the table, use the Configuration layer of the user interface:
Add a non-part instance Choose Add Non Part Instance The system displays a list of all the non-
part instances for the solution.
Enable or Disable Interactive Pricing Select or deselect the Interactive The system enables or disables both in
Pricing checkbox teractive pricing (display of the total
price) and delta pricing (display of sur
charges and price reductions).
Display the sales structure for the solu Select the Sales Structure checkbox The system displays the solution con
tion figuration in one of the following ways:
● Flat Structure
This view displays the non-part in
stances in a list and the bill of ma
terial (BOM) explosion as a hier
archical structure. The relation
ships between the non-part instan
ces are not displayed.
● Sales Structure
This view displays the hierarchical
relationships between the instan
ces, which are interpreted from the
sales abstract data types (ADTs)
and the BOM explosion.
View or specify the configuration set Choose Settings The system displays the following infor
tings mation:
Manually add a component to the con Choose Add Component The system displays the list of compo
figuration nents that can be added to the configu-
ration manually, with the following infor
mation:
Delete a component Choose Delete Component You cannot delete a component that is
related to another component by a con
straint.
Specialize a component Choose Specialize The system displays a list of the possi
ble products. The list is maintained as
part of the knowledge base for the solu
tion.
Unspecialize a component Choose Unspecialize You use this function to reverse a spe
cialization.
The steps below show how you can customize properties in the XCM Settings:
3. Click Edit
6. Click Next
The Configuration Engine processes data used during configuration of products. It also supports configuration
processes and the final configuration can be save and restored later, for editing.
The restore process creates/modifies facts, fires dependencies, and then deletes the facts used while
configuring the products. For more information about this process, refer to SAP Note 2365244
(Configuration restore based on the user inputs).
While performing configuration in SSC, the configuration result information is captured in an XML document,
which is then submitted to the integrated backend system for further processing
In some custom integration scenarios, it might be required to use this configuration xml for some custom
process flows. Refer to the attachment SSC_ConfigResult_1.[Link] in SAP Note 2948568 for the XML
schema definition of the SSC configuration result.
User exits are user-defined functions (declarative functions and pfunctions in the configuration engine and
pricing formulas in the pricing engine) which consist of customer-specific code that allows specific custom
tasks to be performed. User-defined functions are invoked from a model during a configuration session. They
can be used, for example, for checking values and inferring characteristic values.
There are two types of user-defined function, namely declarative functions and procedural functions
( pfunctions). From a technical perspective, both are implemented in the same way. They are Java classes that
implement a specific interface. During a configuration session, these Java classes must be made available to
the configuration runtime engine, which happens through an automated process.
Storage
Depending upon the deployment scenario, user exits are stored in a central database of AS ABAP (ECC/CRM)
or AS Java, and can be uploaded without having to interrupt and restart the application.
Management
User exits are managed in a central location. This involves uploading new exits, deleting existing ones, and
retrieving information about the exits currently deployed. Management takes place via the REST API interface.
This REST API can be called from different locations, for example, from a third-party application. The solution
modeling environment uses this REST API interface in its pFunction wizard.
All java classes of a user exit are confined within a unit and can be identified with a Unit Name during the upload
process. Like in a java project, java classes are expected to be unique in a unit. As solutions evolve, it might be
required to test the behavior of a new version of a user exit. This can be achieved by specifying the Version field
during upload of the user exit, for example, dev , test , prod. The configuration runtime engine can use only
one version at a time. This is specified in the configuration parameters of the engine settings and can be
configured in the server.
5.2 Invocation
User exits are invoked based upon the version setting of the configuration runtime engine parameter. One
version can be active at any given point in time in SME.
Only users having the SME and EJB IPC roles will be able to upload pFunctions in the backend system.
Size Limitations
The upload file size has been defaulted to a maximum of 20MB, and a file size exceeded exception will be
thrown when this limit is exceeded. This can be controlled via the customizing settings in backend or by
changing the engine settings, in case of export to local database or NW Java for Ready-to-Integrate scenario.
Virus Scanning
For protection against any malicious software, virus scanning can be enabled in NW ABAP or NW Java. For
more information, see Enabling Virus Scanner for User Exits in the SSC Security Guide on the SAP Help Portal.
Use
SAP Solution Sales Configuration can be integrated with other sales systems. This scenario is relevant for SAP
customers who use their own or a third-party Customer Relationship Management (CRM) system or an e-
commerce application, and wish to use the configuration and pricing features of SAP Solution Sales
Configuration outside the standard SAP scenarios.
Integration
The following figure illustrates the architecture for integrating SAP Solution Sales Configuration with Hybrisand
non-SAP sales systems.
Architecture for Integrating SAP Solution Sales Configuration and Non-SAP Sales Systems
SAP Solution Sales Configuration consists of a sales configuration engine (SCE), a sales pricing engine (SPE),
and a configuration user interface (UI) based on JavaServer Pages (JSP). A component called the Data Loader
is used to fill a standalone database with configuration data from a source ERP Central Component (ECC)
system. The system provides application programming interfaces (APIs) that enable third-party CRM and Web
Shop applications to interact with the configuration engine, pricing engine, and JSP UI.
● Configuration APIs
APIs are provided for implementing the following configuration functions:
○ Creation of a configuration session.
○ Interaction with the configuration session for compatible mode, advanced mode, and knowledge base
orchestration.
○ Retrieval of the configuration result (in BLOB or XML format).
○ Retrieval of the sales structure (order mapper).
● Pricing APIs
APIs are provided for implementing the following pricing functions:
○ Creation of a pricing session.
○ Interaction with a pricing session.
○ Retrieval of the pricing result (in BLOB or XML format).
● Deployment as a J2EE Application
The configuration engine is built and packaged as an Enterprise JavaBeans (EJB) component based on
Java 2 Enterprise Edition (J2EE) standards. It is primarily intended to be deployed on an SAP J2EE engine
(SAP NetWeaver 7.30) but can be adapted to run on any J2EE-certified runtime environment (Java 6) with
minimum implementation effort.
● Deployment as a Desktop Application
The configuration engine can be deployed as libraries that can be embedded in a desktop application. The
EJB layer can be by-passed to allow direct access to the configuration session or to the engine abstraction
layer of the application.
● Enhanced JSP UI
The JSP UI can be called with an HTTP request.
● Standalone or Local Database
The configuration engine can be connected directly to a database management system such as Microsoft
SQL Server. The system provides scripts to create the database and an application to run the scripts.
● Data Loader
The Data Loader is used to fill the local standalone database with configuration data from an ECC system.
For more information, see Data Loader in the Solution Modeling Environment [page 107].
Constraints
In the solution modeling environment, the Data Loader does not download pricing data or customizing data.
The interactive pricing and delta pricing features do not, therefore, work if the configuration environment is
used with a standalone database.
If the configuration environment is connected to the ECC database, the interactive pricing and delta pricing
features work, and the standalone database and the Data Loader are not required.
This section provides information about the various business functions that are available in SAP Solution Sales
Configuration.
Use
Technical Data
/SLCE/BF_XML_COMPRSSION
You can use this business function to store XML configuration results in the database in compressed form. If
the business function is deactivated, the configuration results are stored in uncompressed form.
Integration
The business function can be activated separately in SAP ERP and SAP CRM. You can activate the business
function in one system but leave it deactivated in the other system.
● If sales documents with configurable products already exist before you activate the business function, you
must migrate the data manually from table /SLCC/CFG_XML to /SLCC/XML_BLOB (for SAP CRM) or
from /SLCE/CFG_XML to /SLCE/XML_BLOB (for SAP ERP). Unless you do so, the system cannot restore
the configurations for existing sales document items.
The data migration is necessary because XML configuration results for sales document items are no longer
stored in table /SLCC/CFG_XML or /SLCE/CFG_XML after you have activated the business function.
Instead, they are stored in tables /SLCC/XML_BLOB and /SLCE/XML_BLOB. Configuration results are read
either from table *CFG_XML or *XML_BLOB (for example, when the configuration screen of an existing item
is opened).
Features
Configuration results for sales document items are stored as XML in the back-end system. In releases of SAP
Solution Sales Configuration earlier than Support Package 3, the configuration results are stored in an
uncompressed form. This is also the case in Support Package 3 if this business function is deactivated. If you
activate this business function, the configuration results are stored in a compressed form.
If you do not activate the business function, configuration results are stored in table /SLCC/CFG_XML for SAP
CRM and /SLCE/CFG_XML for SAP ERP. If you activate the business function, the configuration results are
stored in table /SLCC/XML_BLOB for SAP CRM and /SLCE/XML_BLOB for SAP ERP.
The business function is reversible and can be deactivated again if it has been activated. Note that some
manual migration activities are required for existing configuration results.
Use
SAP Solution Sales Configuration allows you to create a variety of complex solution configurations in a
hierarchical manner. This flexibility makes the implementation of a standard analytical reporting solution
challenging.
For analytical reporting, the system must assemble a large number of objects such as sales order items or
quotation items. Furthermore, these must be assembled in accordance with a common set of properties
(characteristics) and a common set of measures (key figures). However, if the actual configurations of the
solution differ significantly between different sales documents, it becomes difficult for the system to identify
the common properties and measures. Therefore, the analytical reporting solution for SAP Solution Sales
Configuration is designed to be flexible, so that you can adapt it to suit your own specific analytical
requirements.
To analyze the solution selling process, solution configuration data from the sales system must be combined
with data from other systems, such as data from the fulfillment process and financial data. Therefore, SAP
Solution Sales Configuration requires the use of a separate data warehouse to consolidate the data from the
various processes. Data extractors are provided to transfer the data from the source systems to the data
warehouse. You can then design your own persistence layer and user interfaces based on your own specific
reporting requirements.
Integration
Note
You can use an alternative data warehouse solution to SAP BW. In this case, you must implement
BusinessObjects Data Services to use the data extraction layers.
Features
The system provides a comprehensive set of data extractors in the SAP CRM system. The data extractors allow
you to extract all of the relevant solution configuration data to the SAP BW system. The data includes business
document item information for the solution configuration, in addition to master data and description data. You
can choose the data you consider relevant for analytical reporting.
Note
SAP Solution Sales Configuration does not provide any SAP BW business content objects. You must create
these objects based on your own specific analytical requirements.
Constraints
● SAP CRM provides standard DataSources for most CRM Business Documents such as Quotation Items
and Sales Order Items. Business Intelligence (BI) content for SAP CRM is also available; this provides
InfoProviders and the corresponding staging processes in SAP BW for most SAP CRM objects. The
DataSources for SAP Solution Sales Configuration only refer to properties that are specific to solution
configuration; properties that are already available in the standard SAP CRM DataSources are not
included.
● It is assumed that the meaning of characteristics and symbol values remains unchanged when they are
inherited from the previous version of the knowledge base and used in a new solution model. This is
required to ensure consistency in knowledge base independent analytics.
● It is recommended that properties are not deleted; instead they are marked as obsolete. This is because a
deleted property can be referenced in historical transactional data. Unless configuration master data has
previously been extracted to SAP BW, the analytics layer cannot interpret such properties, and such data is
flagged as corrupted in the data extraction layer.
Use
You use this process to create an SAP BW system for the analysis of solution configuration data.
Process
1. You create an extraction layer (data sources) in the SAP Customer Relationship Management (SAP CRM)
system.
SAP Solution Sales Configuration provides a set of data sources for transactional data and master data.
These data sources are used to transfer solution configuration data from the SAP CRM system to the SAP
BW system. For more information, see DataSources [page 194].
2. You create a persistence layer (data staging) in the SAP BW system.
In the SAP BW system, you define InfoObjects (for master data) and Data Store Objects or InfoCubes (for
transactional data) to store the solution configuration data. You then define Transformations and Data
Transfer Processes to transfer the SAP CRM data into the SAP BW persistence layer.
Caution
When defining the persistence layer, you must ensure to take account of delta processing. In particular,
the deletion of objects such as order items or characteristics in the SAP CRM system must be properly
reflected in the SAP BW system.
Note
SAP Solution Sales Configuration does not provide business intelligence (BI) content for the persistence
layer and the user interface layer. You must create these based on your own reporting requirements.
8.2 DataSources
The data model for solution configuration data has the following elements:
● Characteristics
The system provides one text DataSource and one attribute DataSource for each of the model elements
(knowledge bases, characteristics, and symbol values). There are two versions of each of these DataSources:
one for knowledge base dependent analytics and one for knowledge base independent analytics.
Use
You use this DataSource to extract configuration information on a sub item level from SAP Customer
Relationship Management (SAP CRM) business documents. The selection parameters are OBJECT_TYPE and
PROCESS_TYPE. For convenience, OBJECT_ID is also included as a selection parameter, so that the result of
an extraction can be tested in transaction RSA3 (Extractor Checker) for individual SAP CRM Business
Documents.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable Yes
Delta Update
The delta management is based on the time stamp field HEAD_CHANGED_AT in CRMD_ORDERADM_H. Since
items with configurations have an entry in table CRMD_STRUCT_I, all such items can be retrieved with an inner
join between CRMD_ORDERADM_H and CRMD_STRUCT_I. To efficiently control the package size the following
strategy is applied:
1. All items with configuration data from CRMD_ORDERADM_H and CRMD_STRUCT_I are stored in a static
table in the first package. The table is sorted by the header GUID.
2. From the internal item table a minimum number of items are processed (currently 100). To ensure that all
the items in a business document are processed in one package, items are added from the internal item
table until a new header GUID is encountered.
3. For all these items the configuration data is retrieved from the cBase using the function module
COM_CUXI_GET_MULTI_CFG and then the extract table is populated. The current size of the package is
computed and if it is less than the minimum package size, then the process is repeated.
Subsequently, the additional fields in the extract structure for knowledge base independent analytics are
populated using the function modules /SLCC/READ_KBID_I and /SLCC/READ_CHARAC_I.
Configuration instances can have references to objects that have been deleted from the knowledge base. In this
event, the indicator field CORRUPTED in the extract structure is set to X (otherwise the value is a space).
Caution
This DataSource reads directly from the database tables CRMD_ORDERADM_H and CRMD_STRUCT_I.
These tables provide information about the currently existing Business Document data. They do not
contain any information about deleted items or deleted documents. If previously uploaded data is deleted,
then such data is not automatically deleted in the SAP Business Information Warehouse (SAP BW). This
can only be achieved in the SAP BW staging process using the standard SAP Business Intelligence (SAP BI)
content DataSources such as 0CRM_SALES_ORDER_I. In delta uploads, only the One Order DataSources
contain the necessary information about deleted objects. The design of a proper staging process is
described in the How-To Guide for SAP Solution Sales Configuration analytics.
OBJECT_ID Transaction ID
FACTOR Factor
/SLCC/CFG_KBID_ATTR
Use
You use this DataSource to extract data from COMM_CFGKB, based on a delta time stamp in /SLCC/
CFGKB_CHGD.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
/SLCC/CFG_KBID_TEXT
Use
You use this DataSource to extract data from COMM_CFGKBTX, based on a delta time stamp in /SLCC/
CFGKB_CHGD.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_CHARAC_ATTR
Use
You use this DataSource to extract knowledge base characteristic attributes from COMM_CFGCHARAC and
COMM_CFGCHAREF, based on a delta time stamp in /SLCC/CFGKB_CHGD. The extraction takes place by way
of the structure /SLCC/S_CFG_CHARAC_ATTR, using the extractor /SLCC/CFG_CHARAC_ATTR.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_CHARAC_TEXT
Use
You use this DataSource to extract description data from COMM_CFGCHATX, based on a delta time stamp in /
SLCC/CFGKB_CHGD.
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_SYMVAL_ATTR
Use
You use this DataSource to extract data from COMM_CFGSYMVAL. The usage is then determined from the
following tables:
● COMM_CFGSTRDOM
● COMM_CFGNUMDOM
Numerical values are used to define ranges in the application, and indicators are used to define whether each
numerical value is the start, or the end of the range, or both. VALUECODE is populated with the usage type. For
example, the value type 01 means that the symbol value is used in the application with meaning equal.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_SYMVAL_TEXT
Use
You use this DataSource to extract description data from COMM_CFGVALTX for string-like symbols, based on a
delta time stamp in /SLCC/CFGKB_CHGD.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_KBID_I_ATTR
Use
You use this DataSource to extract knowledge base independent attributes from COMM_CFGKB. The
properties are retrieved from the knowledge base with the most recent validity date (the current version of the
knowledge base).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_KBID_I_TEXT
Use
You use this DataSource to extract knowledge base independent descriptions from COMM_CFGKBTX. The
properties are retrieved from the knowledge base with the most recent validity date (the current version of the
knowledge base).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_CHARAC_I_ATTR
Use
You use this DataSource to extract knowledge base independent characteristic attributes. The properties are
retrieved from the knowledge base with the most recent validity date (the current version of the knowledge
base). The extraction takes place by way of the structure /SLCC/S_CFG_CHARAC_I_ATTR, using the
extractor /SLCC/CFG_CHARAC_I_ATTR.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_CHARAC_I_TEXT
Use
You use this DataSource to extract knowledge base independent characteristic descriptions. The properties are
retrieved from the knowledge base with the most recent validity date (the current version of the knowledge
base). The extraction takes place by way of the structure /SLCC/S_CFG_CHARAC_I_TEXT using the
extractor /SLCC/CFG_CHARAC_I_TEXT.
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
/SLCC/CFG_SYMVAL_I_ATTR
Use
You use this DataSource to extract knowledge base independent symbol value attributes from
COMM_CFGSYMVAL. The properties are retrieved from the knowledge base with the most recent validity date
(the current version of the knowledge base).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
/SLCC/CFG_SYMVAL_I_TEXT
Use
You use this DataSource to extract knowledge base independent symbol value descriptions from
COMM_CFGVALTX. The properties are retrieved from the knowledge base with the most recent validity date
(the current version of the knowledge base).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable Yes
Verifiable No
Data Modeling
/SLCC/CFG_VALUECODE_TEXT
Use
You use this DataSource to extract configuration value code descriptions from the /SLCC/CFG_VALUECODE
domain. The extraction takes place by way of the structure Interface: Generic transfer of text (ROTEXTSTR1).
Technical Data
Shipment
Delta-Capable No
Verifiable No
Data Modeling
LANGU Language
/SLCC/CFG_DATATYPE_TEXT
Use
You use this DataSource to extract configuration data type descriptions from the /SLCC/CFG_DATATYPE
domain. The extraction takes place by way of the structure Interface: Generic transfer of text (ROTEXTSTR1).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable No
Data Modeling
LANGU Language
/SLCC/CFG_AUTHOR_TEXT
Use
You use this DataSource to extract configuration author descriptions from the /SLCC/CFG_AUTHOR domain.
The extraction takes place by way of the structure Interface: Generic transfer of text (ROTEXTSTR1).
Technical Data
Shipment
RemoteCube-Capable No
Delta-Capable No
Verifiable No
LANGU Language
Certain administrative activities are required to use SAP Solution Sales Configuration. For more information
about the use and administration of the application, see the following sections:
Related Information
Use
Wily Introscope is a third-party administrative tool from Computer Associates. It is used for application
performance monitoring and diagnostics, and can be integrated with SAP Solution Sales Configuration.
More Information
For information about the installation, setup, and configuration of Wily Introscope, see SAP Notes 797147
(Introscope Installation for SAP Customers) and 1237887 (Introscope 7.2.3 Release Notes).
You can implement logging and tracing in SAP Solution Sales Configuration using the standard logging
capabilities provided in the Java Development Kit (JDK). The package [Link] provides logging
capabilities via the class Logger.
After installing the solution modeling environment plug-in in Eclipse, you can enable logging in the
[Link] file.
SLG1 Logging
You can check SSC log details in transaction SLG1, for the following components:
● /SLCC/ (CRM)
● /SLCE/ (ECC)
The application (session) log is important for the understanding and initial analysis of the issue as well as the
technical flow of the process.
You can create an application log using the instructions in SAP Note 1090753 (Creation of logs for
WebChannel/E-Commerce applications).
You can create a session-specific log using the instructions in SAP Note 921409 (Enable session tracing in
mySAP CRM 5.0 java components).
You can configure the maximum size limit for the uploaded user exit (.jar) files. To do this, perform the following
steps:
1. In the ABAP backend system, a new transaction code /SLCE/FILE_SIZE has been delivered by SSC.
Execute this transaction code to maintain the maximum permissible size limit for the uploaded file.
2. When you enter the transaction, you need to maintain a single integer entry in the view. This value will
correspond to the size limit of the uploaded file in MBs (megabytes).
3. Save your entries.
Considering an entry has been maintained in the above view, when we upload a file using the Solution
Modelling Environment (SME), the ABAP back end enforces this size limit and if the size of the file exceeds this
value, INSERT_EXCEPTION, a kind of exception is returned to the SME, and a message is logged in the ABAP
SLG1 application logs as follows:
Sub-object: DATALODER
Message: User exit upload failed. Size for the filename & exceeds the limit & MB.
You can clear the SAP Solution Sales Configurationruntime engine cache on the NetWeaver Java server using
the procedure below:
Logging on to NW
2. Once you click on Start & Stop, go to the Java Applications tab
3. Search for keyword slc and select the component cdev~fbs_slc_java
You can monitor SAP Solution Sales Configuration runtime engine cache on SAP management console using
the procedure below:
Monitoring SAP Solution Sales ConfigurationRuntime Engine Cache on SAP Management Console
Use the solution configuration support to access (transaction /n/SLCE/CFG_SUPPORT in ECC and /n/SLCC/
CFG_SUPPORT in CRM) SSC related utilities.
Here, you can download the sales data in an XML, simply by entering the relevant document and item numbers.
IPC does not store data in an XML but SSC does.
Here, you can preload some standard data and inputs for the configuration page, to enhance performance of
the tool. The knowledge bases are synced with a cache that is called when the pre-defined set of inputs are
entered to generate the configuration page.
You can do this simply by entering the product name, type, its validity date, and the name of the production
system.
Initialize Configuration DB
This utility is used to initialize the replication of classical knowledge bases generated in SAP ERP, from the
SCE* tables to the COMM_CFG* tables.
A similar standard utility report CFG_ERP_INITIALISE_DB also exists for this purpose, but it is advisable to
not use this standard report in SAP Solution Sales Configuration. This standard report deletes all the advanced
mode knowledge-base runtime versions from the COMM_CFG* tables.
Here, you can update the data that is stored in the cache, post updation of the data in the external text and
variant tables.
You can identify the specific table for updation and use this utility to process the change in data.
Here, you can clean up your system and remove the configuration XMLs that are now obsolete.
This utility calculates size information for a given set of knowledge base runtime versions.
For models created with version lower than SME 4.0, this utility is required to update the KnowledgeBase table
for storage indicator. Models created with SME should have storage = 30 in table COMM_CFGKB.
● Upload of pFunction user exits in the ERP database by uploading user exits in the form .JAR files.
● Deletion of pFunction user exits already existing in the database table /SLCE/USER_EXIT.
For more information to use SAP Solution Sales Configuration, refer to the following SAP Notes:
Hyperlinks
Some links are classified by an icon and/or a mouseover text. These links provide additional information.
About the icons:
● Links with the icon : You are entering a Web site that is not hosted by SAP. By using such links, you agree (unless expressly stated otherwise in your
agreements with SAP) to this:
● The content of the linked-to site is not SAP documentation. You may not infer any product claims against SAP based on this information.
● SAP does not agree or disagree with the content on the linked-to site, nor does SAP warrant the availability and correctness. SAP shall not be liable for any
damages caused by the use of such content unless damages have been caused by SAP's gross negligence or willful misconduct.
● Links with the icon : You are leaving the documentation for that particular SAP product or service and are entering a SAP-hosted Web site. By using such
links, you agree that (unless expressly stated otherwise in your agreements with SAP) you may not infer any product claims against SAP based on this
information.
Example Code
Any software coding and/or code snippets are examples. They are not for productive use. The example code is only intended to better explain and visualize the syntax
and phrasing rules. SAP does not warrant the correctness and completeness of the example code. SAP shall not be liable for errors or damages caused by the use of
example code unless damages have been caused by SAP's gross negligence or willful misconduct.
Gender-Related Language
We try not to use gender-specific word forms and formulations. As appropriate for context and readability, SAP may use masculine word forms to refer to all genders.
SAP and other SAP products and services mentioned herein as well as
their respective logos are trademarks or registered trademarks of SAP
SE (or an SAP affiliate company) in Germany and other countries. All
other product and service names mentioned are the trademarks of their
respective companies.