SAP s Processing Rule

Описание: What Are Processing Rules?
Processing rules are a critical part of Billable Item Class configuration within SAP Convergent Invoicing (CI). They govern how a billable item is treated as it moves through the invoicing pipeline — from the moment it is received into CI until it appears on a billing document (invoice/credit memo).
In essence, the processing rule answers the question: "What should the system do with this billable item during billing?"

Where Do Processing Rules Sit in Configuration?
Processing rules are assigned at the Billable Item Class level. The Billable Item Class is the central configuration object in CI that defines the characteristics and behavior of billable items. Each billable item that enters CI is associated with a class, and the processing rule attached to that class dictates how it will be handled.
The configuration path is typically:
Billable Item Class → Processing Rule → Aggregation / Rating / Posting behavior

Purpose and Functions of Processing Rules
Processing rules control three major dimensions of billable item handling:
1. Aggregation Control
The processing rule determines whether and how billable items are aggregated (summarized) before they appear as line items on an invoice. For example, if a telecom customer makes 500 voice calls in a month, rather than showing 500 individual line items, the processing rule can dictate that all voice-call billable items be aggregated into a single line item on the invoice showing a total amount.
Example from the material: A mobile telecom provider receives thousands of CDRs (Call Detail Records) rated by Convergent Charging. Each CDR becomes a billable item in CI with a class like VOICE_CALL. The processing rule on this class specifies that all items with the same billing account, billing period, and service type should be aggregated into one invoice line item. The customer's invoice then shows:
Voice Calls – Total: 500 calls – ₹1,200.00
…instead of 500 separate lines.
2. Consumption Behavior (Item Processing)
The processing rule controls whether the billable item is:
• Consumed individually — each item is processed on its own and produces its own invoice line.
• Consumed in bulk (mass processing) — items are collected and processed together in a billing run.
• Not consumed / Deferred — items are held and not yet included in a billing document (useful for interim or future-dated charges).
This is especially important for distinguishing between one-time charges (e.g., an activation fee that should appear as a single line) vs. usage charges (e.g., data consumption that should be aggregated).
3. Integration with Rating (Pricing)
Some billable items arrive in CI already pre-rated (i.e., they already carry a price from Convergent Charging or an external system). Others arrive un-rated and need pricing to be applied within CI itself using pricing conditions or BRF+ rules.
The processing rule indicates whether the billable item requires rating within CI or if it should pass through as-is. For instance:
• A rated CDR from Convergent Charging enters CI with amount = ₹2.50. The processing rule says: "Do not re-rate; use the incoming amount."
• A subscription fee billable item enters CI without an amount. The processing rule says: "Apply pricing from the contract/pricing master data."
4. Posting and Transfer to FI-CA
The processing rule also influences how the resulting invoice line items are posted to Financial Contract Accounting (FI-CA). It can determine the posting logic, revenue recognition triggers, and whether the item contributes to the receivable immediately or is deferred.

Practical End-to-End Example
Consider a utility company billing electricity consumption:
Billable Item Class Processing Rule Behavior
Monthly meter reading (usage) ELEC_USAGE Aggregate all daily readings into one line; already rated by external metering system (no re-rating); post to FI-CA as receivable
Late payment penalty LATE_FEE Process individually (no aggregation); apply pricing via CI pricing conditions; post immediately
One-time connection fee CONN_FEE Process individually; pre-rated (fixed amount from contract); post as one-time receivable
Government tax surcharge TAX_SURCHG Aggregate with related usage items; calculate via BRF+ tax rule; post to separate G/L account
Each of these billable item classes has a different processing rule because the business requires different treatment for each type of charge.

Key Takeaways
• Processing rules are the "behavioral blueprint" for billable items — they tell the CI engine what to do with each item during the billing run.
• They control aggregation (summarize or keep individual), rating (re-price or accept incoming price), and posting (how and when to create accounting entries).
• They are configured at the Billable Item Class level, which means every billable item inherits its processing behavior from its class.