StatefulServiceClient (SAP CC 4.1 Java APIs (Core Library))

java.lang.Object
- com.highdeal.cnd.message.AsyncRatingServiceClient
- - com.highdeal.cnd.message.AsyncStatefulServiceClient
  - - com.highdeal.cnd.message.StatefulServiceClient

All Implemented Interfaces:: com.highdeal.barbus.ISSLContextProvider

Direct Known Subclasses:: ChargeableItemCollectorClient

public class StatefulServiceClient
extends AsyncStatefulServiceClient

This main Java class provides the operations necessary to implement real-time charging services (event-based or session-based) in your system landscape by using the Message TCP technical interface with very high throughput performances.

Your client application converts the information data about the customer service usage (service consumption) to a chargeable item and sends this data event to the connected SAP CC system, the online charging system (OCS) for being rated (dynamic pricing) and charged to an account or allowance.

This class provides the necessary methods to implement online charging services in your system landscape with or without credit control before the customer service delivery.

Recommendation

You can implement the AsyncStatefulServiceClient class to speed up the processing.

Example

The SAP CC Message Client user interface is a good example of implementation. This user interface implements this com.highdeal.cnd.message.StatefulServiceClient class to allow the SAP CC user to send some charging operations to the SAP CC system for test, demo, or training purposes. For more information, see the primary help.

Consider the following information in this topic:

Synchronous Services and Operations
Features
Implementation in Your Client Application
Notes on SAP CC Implementation

Synchronous Services and Operations

With this Java class, you can implement online event-based charging services or online session-based charging services via the Message TCP high-speed technical interface.

Business Services: Online Stateful Charging	Operations	Technical Names (Consider the methods in this Java class)
Event-based charging without credit control	Immediate charging operation (for direct debiting)	`charge(..)`
Event-based charging with credit control	Best-effort charging operation	`checkLimit(..)`
Event-based advice of charge	Blank charging operation	`blankCharge(..)`
Event-based advice of charge	Inverse rating operation	`checkLimit(..) in estimation mode`
Multiservice session-based charging (multiple charging sessions of reservations/confirmations)	Quota reservations and consumption confirmations (partial or complete) related to the usage of several customer services or several options of a global service: A multiservice session includes several charging sessions Optional reservation renewal mechanism associated to a `specialized listener`	You manage a multiservice session relating to several customer services with: `createSessionStartOperation(..)` `createSessionUpdateOperation(..)` `createSessionStopOperation(..)` Within this multiservice session, you manage the charging sessions (of quota reservations and consumption confirmations related to the usage of one customer service) with: Reservations through calls to `prepareReserve(..)` Confirmations through calls to `prepareConfirm(..)` Cancellations through calls to `prepareCancel(..)` Reservation extensions through calls to `prepareConfirmAndReserve(..)` You handle the new reservation notifications on partially granted reservations with a `specialized listener`. This listener must register to the connected SAP CC system.
Business monitoring	Spending status monitoring (advanced implementation and customizing)	You manage the spending status monitoring by `register` the specialized `listener` manage (start/update/stop) the monitoring using the method `monitorSpendingStatus` (see the Advanced Implementation section)
Billing process synchronization	Activation of periodic and one-off fees	`activate(..)`

Special:

cleanup(java.lang.String , java.lang.String , java.util.Date , int )
translate(..)

Notes

Consult all the online charging services that you can implement in your Java-based client application.
Refer to the AsyncStatefulServiceClient class for asynchronous communications and very-high throughput performances.

Deprecated Services and Operations

The following business operations or services are now deprecated and replaced. SAP SE recommends that you do not implement these operations anymore. They will be revoked in newer versions of SAP Convergent Charging.

Business Services	Deprecated Operations	Technical Names (Consider the methods in this Java class)	Replaced by
Non authenticated server connection	All class builders (except the empty one) that connect the client to the server without user credentials.	`StatefulServiceClient(String, int)` `StatefulServiceClient(String, int, int)` `StatefulServiceClient(String, int, com.highdeal.cnd.message.FoundLostRatingListener)` `StatefulServiceClient(String, int, String, int, com.highdeal.cnd.message.FoundLostRatingListener)`	Replaced by the `StatefulServiceClient()` + a call to `AsyncRatingServiceClient.setUserCredentials(String, String)` then a call to one of the following methods to connect the client: `AsyncRatingServiceClient.connect(InstanceMap, String, int, FoundLostRatingListener, ServiceClientTuning)` `AsyncRatingServiceClient.connect(String, java.net.InetSocketAddress...)` `AsyncRatingServiceClient.connect(String, com.highdeal.barbus.InstanceAddress... )` `AsyncRatingServiceClient.connect(String, int )` `AsyncRatingServiceClient.connect(String, int, boolean, String, int, FoundLostRatingListener, ServiceClientTuning)` `AsyncRatingServiceClient.connect(String, int, FoundLostRatingListener)` `AsyncRatingServiceClient.connect(String, int, java.net.InetSocketAddress, String, int, FoundLostRatingListener, ServiceClientTuning, java.net.InetSocketAddress...)` `AsyncRatingServiceClient.connect(String, int, java.net.InetSocketAddress, String, int, FoundLostRatingListener, ServiceClientTuning, com.highdeal.barbus.InstanceAddress... )` `AsyncRatingServiceClient.connect(String, int, int)` `AsyncRatingServiceClient.connect(String, int, String, int, FoundLostRatingListener)` `AsyncRatingServiceClient.connect(String, int, String, int, FoundLostRatingListener, ServiceClientTuning)`
Event-based advice of charge	Price estimating operation	`getEstimatedPrice(..)`	Replaced by the `Blank charging operation`
Event-based charging with credit control	Prerating operation	`preRate(..)` `postRate(..)`	Replaced by the multiservice session-based charging service
Session-based charging (single charging session) Replaced by: Multiservice session-based charging	Quota reservation and consumption confirmation related to the usage of one customer service: Start a charging session by reserving credit Update the session by confirming or canceling the previous reservation (effective charging) and operating a new reservation Stop the session	`startRate(..)` `updateRate(..)` `stopRate(..)`	Replaced by the multiservice session-based charging service

Features

This charging client benefits from the functions provided by the Message TCP technical interface. Refer to its features about:

High Availability Management
High Volume Management
High Performance Management

Operation Results

The connected SAP CC system replies to operation requests with the following data:

Charging Contract Operational Status

Most of services and operations take into account the operational status of a charging contract (excepting the preRate and the postRate deprecated operations). This means that an operation exception can be thrown if the operational status of a charging contract is locked or closed.

Communication Timeout

When a timeout is associated to a given message client, it must be performed during this limited time. If this limited time is exceeded, the operation is rolled back but the client timeout does not guarantee that related operations successfully ended (see the SAP CC Application Help for more information).

High Performances

By default, this charging client provides high throughput performances. For very high throughput performances, consider the AsyncStatefulServiceClient or the fine-tuning activity.

High Availability (HA)

By default, this charging client provides high availability services with an SAP CC system with distributed instances in HA setup.

You can implement several charging clients in your Java-based client application and you can implement several client applications to manage failover mechanism in your client applications.

Notification

You can implement the handling of the notifications sent by the SAP CC Core Server system:

Asynchronous service for batch management: The notifications are regularly sent by the SAP CC system. Refer to the Java package information.
Synchronous service for real-time management: The notifications are embedded by the SAP CC system in the result messages of the charging requests. The renew reservation notifications are managed via a specialized listener (see advanced implementation). You can implement in your client application the immediate processing of these notifications.

Security

To implement a ciphered connection between the client and SAP CC, use AsyncRatingServiceClient.setSslContext(javax.net.ssl.SSLContext )

Since SAP CC 4.1 SP2, SAP CC is able to require an authenticated connection from a client application (see the MESSAGE_API_AUTHENTICATION_REQUIRED parameter in the parameter reference guide). The client must setup some valid user credentials by calling the setUserCredentials() method. Then, the client application will be authenticated and authorized to connect to the SAP CC server by calling one of the following connect() methods:

AsyncRatingServiceClient.connect(InstanceMap, String, int, FoundLostRatingListener, ServiceClientTuning)

AsyncRatingServiceClient.connect(String, java.net.InetSocketAddress...)

AsyncRatingServiceClient.connect(String, com.highdeal.barbus.InstanceAddress... )

AsyncRatingServiceClient.connect(String, int )

AsyncRatingServiceClient.connect(String, int, boolean, String, int, FoundLostRatingListener, ServiceClientTuning)

AsyncRatingServiceClient.connect(String, int, FoundLostRatingListener)

AsyncRatingServiceClient.connect(String, int, java.net.InetSocketAddress, String, int, FoundLostRatingListener, ServiceClientTuning, java.net.InetSocketAddress...)

AsyncRatingServiceClient.connect(String, int, java.net.InetSocketAddress, String, int, FoundLostRatingListener, ServiceClientTuning, com.highdeal.barbus.InstanceAddress... )

AsyncRatingServiceClient.connect(String, int, int)

AsyncRatingServiceClient.connect(String, int, String, int, FoundLostRatingListener)

AsyncRatingServiceClient.connect(String, int, String, int, FoundLostRatingListener, ServiceClientTuning)

Code Snippet

The following code snippet provides an example of how to authenticate a client application to the SAP CC server :

    private static final String DISPATCHER_HOST = "localhost";
    private static final int DISPATCHER_EXT_PORT = 2000;

    // Initialize the stateful service client by (always) calling the empty builder (other builders are deprecated)
    StatefulServiceClient client = new StatefulServiceClient();

    // Set the user credentials for the new created client
    // These credentials must refer to an existing service user in SAP CC that has the "messageChargingClient" role.
    client.setUserCredentials("clientX", "foopasswd");

    //Call one of the connect() methods that are provided in Service Client classes according to the
    //  expected behavior.
    ConnectionStatus status = client.connect(DISPATCHER_HOST, DISPATCHER_EXT_PORT);

    // Check the result of the  connect() method.
    if (!status.isServiceAvailable()) { // No dispatcher can be reached
    } // else at least one CC dispatcher has been reached and charging is available

Implementation in Your Client Application

Initializing and Connecting

Your charging client (based on this StatefulServiceClient class) must be initialized via establishing a connection to one or more dispatcher instances available in the distant SAP CC system. Once at least one dispatcher of the SAP CC system is connected from the client application, the client application retrieves automatically the list of all available dispatcher instances on the server system side. It establishes a connection with every one of them automatically.

Implementing Session-Based Charging Services

You implement the following operations in your Java-based client application to manage a multiservice session:

Note

Refer to the implementation note section if you want to provide the optional reservation renewal function in your system landscape.

System Configuration

Consult the SAP CC Configuration and Implementation Guide to know the necessary configuration settings of the SAP CC system.

Master Data Configuration

Particular constraints apply to the configuration of the pricing logic. Pay attention when designing and configuring price plans dedicated to session-based charging services. Consult the SAP CC Application Help and the primary help of the SAP CC Core Tool user interface for more information.

Implementing Event-Based Charging Services

Depending on your business requirements, you implement one of the following operations in your Java-based client application:

Implementing Policy Control Services

You implement this function to provide policy control mechanisms in your system landscape.

Prerequisites

The SAP CC system is configured to support the reservation renewal function.

Customizing Sequence

Dedicated Listener

System Configuration

Consult the SAP CC Configuration and Implementation Guide to know the necessary configuration settings of the SAP CC system. Before implementing SAP Convergent Charging in your system landscape, you must configure the systems and the data.

Terminating

Your client application must release the connections when it ends. Implement the method.

Advanced Implementation

The following advanced implementation activities are possible. Refer to the implementation note section for more information.

Reservation renewal function (in the session-based charging services)
Spending status monitoring function
Fine-tuning

Notes on SAP CC Implementation

Fine-Tuning

By default, this charging client provides high throughput performances.

You can fine tune the behavior of your client application by implementing the StatefulServiceClientTuning class.

Implementing the Spending Status Monitoring Function

This function is available in the online charging services. In this Customizing activity you develop a client application and a monitoring client that manages spending status monitoring and report handling.

Prerequisites

The SAP CC system is configured to support the spending status monitoring function.

Customizing Sequence

Depending on your business requirements, design your listener of spending status reports accordingly to the spending status changes sent by the SAP CC system
Implement the integration code of a spending status report listener based on the ISpendingStatusReportListener interface. Develop your own onSpendingStatusReport(...) method
Depending on your business requirements, design your client application accordingly to your own spending status monitoring sequences
In your client application, implement a monitoring client based on this StatefulServiceClient class:
- Register your own spending status report listener implementation with the registerSpendingStatusReportListener(...) method
- Manage the relevant spending status monitoring sequences with the monitorSpendingStatus(...) method. This method enables you to create, change or cancel a spending status monitoring.
- Finally, unregister your spending status report listener with the unregisterSpendingStatusReportListener(...) method

System Configuration

Implementing the `ISpendingStatusReportListener` `interface`

A client application must implement the ISpendingStatusReportListener interface to be able to handle monitoring reports.

Implementing the Reservation Renewal Function

This function is available in the session-based charging services.

Prerequisites

The SAP CC system is configured to support the reservation renewal function.

Customizing Sequence

Depending on your business requirements, design the functions of the listeners of renew reservation notifications
Implement the integration code of a reservation renewal listener based on the IReservationRenewalListener interface. You develop your own onRenewReservation(..) method.
Extend the initialization of the charging client: Implement the registration of a listener with the registerReservationRenewalListener(..) method .
Otherwise, you can implement another client based on the StatefulServiceClient class in the client application or in another client application. This new notification client is responsible for handling all the renew reservation notifications for all the charging client instances in the client application.
Change the implementation of the multiservice session-based charging services
- In the Multiservice session start:
  - Enable the reservation renewal function when starting a multiservice session by using the setReservationRenewalListenerId(..) inherited method. Specify that the multiservice sessions are eligible for renew reservation notifications by the reservation renewal listener identified by the specified identifier.
  - When relevant for your business requirements, set up external data that the reservation renewal listener(s) may need when processing the renew reservation notifications. Use the setExternalData(..) inherited method. This data is never changed by the SAP CC Core Server system.
- In the Multiservice session update: When relevant for your business requirements, change external data that is copied to the renew reservation notifications by the connected SAP CC system.
Change the termination of the charging client: Implement the unregistration of a listener

System Configuration

Consult the SAP CC Configuration and Implementation Guide to know the necessary configuration settings of the SAP CC system that relates to the reservation renewal function available in the session-based charging services.

Implementing the `IReservationRenewalListener` `interface`

A client application must implement the IReservationRenewalListener interface to be able to handle Renew Reservation notifications.

The implementation of this interface allows the SAP CC system to inform the client application that additional credit has been made available during a multiservice charging session. When such a notification occurs, the client application may not have to stop the session and may continue to update the session by making new reservations on charging sessions. The client application can handle this use case by implementing an IReservationRenewalListener and attaching it to the charging client.

The IReservationRenewalListener interface defines a unique method to handle the notification: onRenewReservation(). This method provides the necessary parameters to handle the notification:

The session identifier, which is unique to the multiservice charging session
The reservation identifier, which is unique to the service charging session for the multiservice charging session
The external data that can optionally be passed to the SAP CC system during a start or update operation
An index indicating the number of attempts to transmit this notification
An IReservationRenewalAcknowledger object that must be used to acknowledge the receipt of this notification

The acknowledger is an optional feature allowing the client application to tell the SAP CC system the notification has been received and handled. This feature is useful when the RENEW_RESERVATION_RESEND_ATTEMPTS parameter of the SAP CC system is set with a positive and non-zero value. Once the SAP CC system is acknowledged by the client application, the resend procedure is canceled for this notification.

Code Snippet

The following code snippet provides an example of how to implement an IReservationRenewalListener interface to receive and handle a Renew Reservation notification:

    private class MyReservationRenewalListener implements IReservationRenewalListener {

        public void onRenewReservation(String sessionId, String reservationId, byte[] externalData, short resendAttempt, IReservationRenewalAcknowledger acknowledger) {

            // Simple implementation: print notification to console
            System.out.println("Renew Reservation notification received for session/reservation " + sessionId + " " + reservationId);

            // (Optional) Acknowledge the handling message
            acknowledger.ack(new IReservationRenewalAcknowledgerListener() {

                public void onException(ServerFailureException e) {
                    // Handle server failure exception
                    System.err.println("ServerFailureException in acknowledgment: " + e.getMessage());
                }

                public void onException(IllegalArgumentException e) {
                    // Handle illegal argument exception
                    System.err.println("IllegalArgumentException in acknowledgment: " + e.getMessage());
                }

                public void onException(CommunicationFailureException e) {
                    // Handle communication failure exception
                    System.err.println("CommunicationFailureException in acknowledgment: " + e.getMessage());
                }

                public void onResult() {
                    // Handle acknowledgment result
                    System.out.println("Server has received acknowledgment");
                }
            });
        }
    }

Implementing the `registerReservationRenewalListener(byte, IReservationRenewalListener)` `method`

To be able to receive and handle Renew Reservation notifications, the client application must use the registerReservationRenewalListener method of the charging client. The client application must provide a ReservationRenewalListener identifier (rrlId) and the ReservationRenewalListener that can handle the Renew Reservation notification. The rrlId value can be 1 to 127 included.

Code Snippet

The following code snippet provides an example of how to call the registerReservationRenewalListener() method of the charging client:

    private static final String DISPATCHER_HOST = "localhost";
    private static final int DISPATCHER_EXT_PORT = 2000;
    private static final byte RRLID = 1;

    // Initialize the listener
    MyReservationRenewalListener myListener = new MyReservationRenewalListener();

    // Initialize the stateful service client
    StatefulServiceClient client = new StatefulServiceClient(DISPATCHER_HOST, DISPATCHER_EXT_PORT);

    // Register a reservation renewal listener
    client.register(RRLID, myListener);

Implementing the `unregisterReservationRenewalListener(byte)` `method`

To stop receiving Renew Reservation notifications, the client application must use the unregisterReservationRenewalListener method of the charging client. The client application must provide a ReservationRenewalListener identifier (rrlId). The rrlId value can be 1 to 127 included.

Code Snippet

The following code snippet provides an example of how to call the unregisterReservationRenewalListener() method of the charging client:

    private static final String DISPATCHER_HOST = "localhost";
    private static final int DISPATCHER_EXT_PORT = 2000;
    private static final byte RRLID = 1;

    // Initialize the listener
    MyReservationRenewalListener myListener = new MyReservationRenewalListener();

    // Initialize the stateful service client
    StatefulServiceClient client = new StatefulServiceClient(DISPATCHER_HOST, DISPATCHER_EXT_PORT);

    // Unregister a reservation renewal listener
    client.register(RRLID);

Changing the Implementation of the Session-Based Charging APIs

In the implementation of the charging process of the service client, additional actions must be taken in the integration code when managing multiservice charging sessions.

On multiservice charging session start:

Specify that the session is monitored for renew reservation notifications by the reservation renewal listener identified by the given identifier. The method setReservationRenewalListenerId() of the operation should be used.
Optionally, add external data that the reservation renewal listener may need when processing the notification. The method setExternalData() of the operation should be used. This data is not read nor changed by SAP CC Server.

Code Snippet

    // Create a multiservice charging session start operation
    ISessionStartChargingOperation startOp = client.createSessionStartOperation(sessionID, userServiceID, serviceID, consumptionDate);

    // Add a charging session operation: reserve
    startOp.prepareReserve(reservationId, reservationItem, defaultResolution, ttl, propertyToInverse);

    // Indicate that this multiservice charging session is monitored for renew reservation notifications by the reservation renewal listener identified by the rrlId
    startOp.setReservationRenewalListenerId(rrlId);

    // (Optional) Add external data, that is sent back unchanged in the renew reservation notifications
    startOp.setExternalData(externalData);

    // Execute the start operation
    startOp.execute(sessionResultListener);

On multiservice charging session update:

Optionally, add external data that the reservation renewal listener may need when processing the notification. The method setExternalData() of the operation should be used. This data is not read nor changed by SAP CC Server.

Code Snippet

    // Create a multiservice charging session update operation
    ISessionUpdateChargingOperation updateOp = client.createSessionUpdateOperation(sessionID, userServiceID, serviceID, consumptionDate);

    // Add a charging session operation: confirm and reserve
    updateOp.prepareConfirmAndReserve(reservationId, confirmationItem, reservationItem);

    // (Optional) Add external data, that is sent back unchanged in the renew reservation notifications
    updateOp.setExternalData(externalData);

    // Execute the update operation
    updateOp.execute(sessionResultListener);

On multiservice charging session stop:

No additional action is necessary

Additional Information

Consult all the online and offline charging services that you can implement in your Java-based client application.

Consult the SAP CC Application Help for more information about the online charging services, the charging process and its execution modes.

Field Summary
- Fields inherited from class com.highdeal.cnd.message.AsyncRatingServiceClient
  ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING, CANCELLED, CONFIRMED, MASTER_TRANSACTION, NONE_TRANSACTION

Constructor Summary

Constructors
Constructor and Description
`StatefulServiceClient()` Creates a non-initialized `charging client`; Use one of the `connect(..) methods` to connect this client to the distant SAP CC Core Server system.
`StatefulServiceClient(String hostName, int port)` Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Creates a `charging client` and connects it to the distant SAP CC Core Server system
`StatefulServiceClient(String hostName, int port, FoundLostRatingListener ratingListener)` Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Initializes a `charging client` and connects it to the distant SAP CC Core Server system;
`StatefulServiceClient(String hostName, int port, int timeout)` Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Creates a `charging client` and connects it to the distant SAP CC Core Server system; A client timeout is specified for the communications.
`StatefulServiceClient(String hostName, int port, String bindAddress, int timeout, FoundLostRatingListener ratingListener)` Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Initializes a `charging client` and connects it to the distant SAP CC Core Server system; A binding network address and a client timeout are specified for the communications with the connected SAP CC system.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`PurchaseOrder`	`activate(String subscriberAccountCode, String serviceProvider, int resultType, boolean ft, Date toDate)` Consider the main `activate operation` for more information.
`PurchaseOrder`	`activate(String subscriberAccountCode, String serviceProvider, int resultType, Date toDate)` This main business operation triggers the activation of all the periodic and one-off fees (see recurring/one-shot rates in charges) configured in the provider contracts and `subscriptions` relating to the specified `subscriber account`; You use this operation to prepare the invoicing and billing operations in an external system.
`ChargingResult`	`blankCharge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, ChargeExecutionContext context)` This main business operation requests the SAP CC system to charge in blank mode the specified chargeable item for the specified user service ID and service ID at the specified date.
`PurchaseOrder`	`blankCharge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts)` This main business operation requests the SAP CC system to charge in blank mode the specified chargeable item for the specified user service ID and service ID at the specified date.
`PurchaseOrder`	`blankCharge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts, boolean ft)` Consider the `main blank charge operation` for more information; You can specify if the returned `transactions` must be filtered according to the `transactionTemplate`.
`PurchaseOrder`	`charge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate)` This main business operation requests the SAP CC system to charge the `specified chargeable item` for the specified user service ID and the specified service ID at the specified date without transaction selection.
`ChargingResult`	`charge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, ChargeExecutionContext context)` This main business operation requests the SAP CC system to charge the `specified chargeable item` for the specified user service ID and service ID at the specified date.
`PurchaseOrder`	`charge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts)` Consider the main `charge operation` `charge(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date)`
`PurchaseOrder`	`charge(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts, boolean ft)` Consider the main `charge operation` `charge(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date)`
`CheckLimitResult`	`checkLimit(ChargeableItem item, String serviceID, String userServiceID, Date consumptionDate, String propertyName, BigDecimal precision, Money limitAmount, boolean estimationMode)` This main business operation requests either an inverse rating operation or a best-effort charging operation.
`CheckLimitResult`	`checkLimit(ChargeableItem item, String serviceID, String userServiceID, Date consumptionDate, String propertyName, BigDecimal precision, Money limit, boolean estimationMode, int ts, boolean ft)` Consider the main `checkLimit(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date, java.lang.String, java.math.BigDecimal, com.highdeal.currency.Money, boolean)` check limit operation for more information.
`CleanupResult`	`cleanup(String subscriberAccountCode, String serviceProvider, Date toDate, int resultType)` This main business operation triggers the cleanup process in the connected SAP CC Core Server system; The SAP CC system goes through all the existing rating records of a given subscription and deletes the ones that are not relevant at all.
`CleanupResult`	`cleanup(String subscriberAccountCode, String serviceProvider, Date toDate, int resultType, boolean ft)` Consider the main `cleanup operation` for more information.
`ISessionStartChargingOperation`	`createSessionStartOperation(String sessionID, String userServiceID, String serviceID, Date consumptionDate)` This `method` allows you to create a `start operation` to manage the service consumption by an end customer.
`ISessionStopChargingOperation`	`createSessionStopOperation(String sessionID, String userServiceID, String serviceID, Date consumptionDate)` This `stop operation` confirms (partially or totally) previous reservations and is able to cancel some other reservations.
`ISessionUpdateChargingOperation`	`createSessionUpdateOperation(String sessionID, String userServiceID, String serviceID, Date consumptionDate)` This `method` allows you to create an `update operation` to process an update event of a multiservice session-based charging sequence.
`PurchaseOrder`	`getEstimatedPrice(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation This main business operation requests the SAP CC system to estimate the price of a usage consumption (white rating). Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
`PurchaseOrder`	`getEstimatedPrice(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation Consider the main `get estimated price operation` for more information. Estimates the price of a usage consumption (white rating). Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
`PurchaseOrder`	`getEstimatedPrice(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int ts, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation Consider the main `get estimated price operation` for more information. Estimates the price of a usage consumption (white rating). Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
`IMonitorSpendingStatusResultListener.ISpendingStatusMonitoringResult`	`monitorSpendingStatus(String monitoringId, byte ssrlId, String userServiceId, String[] spendingStatusIds, int ttl)` Manages the monitoring of spending statuses concerning the charging contract that relates to the specified `userServiceId`.
`PostRateResult`	`postRate(long reservationUID, String serviceID, String userServiceID, int resolution, int resultType, boolean ft, ChargeableItem newCi)` Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Asks the server to post-rate the specified reservation unique identifier using the given resolution. If more than one rating record for that reservation identifier are present into the database, the operation chooses one arbitrarily. In that case, the operation logs the reservation identifier. When resolution is CONFIRMED then a new `ChargeableItem` may be passed. Not like `PostRateOp`, there are `serviceID` and `userServiceID` parameters. They have no functional meaning and are not mandatory, but setting them with same value as for `preRate` may increase the performance in multi-server configuration.
`PostRateResult`	`postRate(long reservationUID, String serviceID, String userServiceID, int resolution, int resultType, ChargeableItem newCi)` Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Asks the server to post-rate the specified reservation unique identifier using the given resolution. If more than one rating record for that reservation identifier are present into the database, the operation chooses one arbitrarily. In that case, the operation logs the reservation identifier. When resolution is CONFIRMED then a new `ChargeableItem` may be passed. Not like `PostRateOp`, there are `serviceID` and `userServiceID` parameters. They have no functional meaning and are not mandatory, but setting them with same value as for `preRate` may increase the performance in multi-server configuration.
`PreRateResult`	`preRate(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int resultType, boolean ft, long reservationUID, int defaultResolution, long ttl)` Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services This main operation asks the SAP CC system to prerate the specified chargeable item for the specified user service ID and the specified service ID at the specified date, and using the passed reservation unique identifier, default resolution and time to live. The operation allows the use of the same reservation unique identifier for more than one prerating. This case is managed at post-rating time.
`PreRateResult`	`preRate(ChargeableItem ci, String serviceID, String userServiceID, Date consumptionDate, int resultType, long reservationUID, int defaultResolution, long ttl)` Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Consider the main `prerate operation` for more information. Asks the server to prerate the specified chargeable item for the specified user service ID and the specified service ID at the specified date, and using the passed reservation unique identifier, default resolution and time to live. The operation allows the use of the same reservation unique identifier for more than one prerating. This case is managed at postrating time.
`StartRateResult`	`startRate(ChargeableItem reservationItem, String sessionID, Date consumptionDate, String serviceID, String userServiceID, int defaultResolution, long ttl, int resultType, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the start of a session-based charging operation. It is in charge of rating the reservation chargeable item and doing the related counter reservations. It creates a rating session (keeping the reservation chargeable item) and returns a rating result used to reserve the balance. The parameters `ttl` and `defaultResolution` are used by the session cleaning process to confirm or cancel the last counter reservations after a given amount of time. The result of this method contains either the amount or all the transactions to reserve. These transactions are not provided to the TIF since they are not the final ones.
`StartRateResult`	`startRate(ChargeableItem reservationItem, String sessionID, Date consumptionDate, String serviceID, String userServiceID, int defaultResolution, long ttl, int resultType, int cleanupResultType, boolean ft, String propertyToInverse)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services Consider the main `start rate operation` for more information. This operation represents the beginning of a session-based charging sequence. It creates a charging session. It is in charge of rating the reservation chargeable item and doing the related counter reservations. It creates a rating session (keeping the reservation chargeable item) and returns a rating result used to reserve the balance. If the reservation fails due to a low-credit, an inverse rating may be attempted if the property name of the property to inverse is provided. This mechanism is known as best effort reservation. This property name is saved in the rating session to avoid providing it again or changing it at update time. The parameters `ttl` and `defaultResolution` are used by the session cleaning process to confirm or cancel the last counter reservations after a given amount of time. The result of this method contains either the amount or all the transactions to reserve. These transactions are not provided to the TIF since they are not the final ones.
`StopRateResult`	`stopRate(ChargeableItem confirmationItem, String sessionID, String serviceID, String userServiceID, int resolution, int resultType, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the termination of a session-based charging sequence. Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF. Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are committed into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF. This method manages also the session cancellation case by setting the `resolution` parameter to `CANCELLED`. It retrieves the rating session first and cancels the related counter reservations coming from either a previous session start or a session update. The rating result that is returned is empty in case of cancellation. Finally, the rating session is removed and the session identifier becomes available for next sessions.
`StopRateResult`	`stopRate(ChargeableItem confirmationItem, String sessionID, String serviceID, String userServiceID, int resolution, int resultType, int cleanupResultType, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services Consider the main `stop rate operation` for more information. This operation class represents the stop of a session-based charging. Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF. Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are committed into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF. This method manages also the session cancellation case by setting the `resolution` parameter to `CANCELLED`. It retrieves the rating session first and cancels the related counter reservations coming from either a previous session start or a session update. The rating result that is returned is empty in case of cancellation. Finally, the rating session is removed and the session identifier becomes available for next sessions.
`Object[]`	`translate(String tableCode, int operator, Date date, Date referenceDate, String[] inValues)` Translates some values by using a translation table
`Object[]`	`translate(String tableCode, int operator, Date date, String[] inValues)` Translates some values by using a translation table
`UpdateRateResult`	`updateRate(ChargeableItem confirmationItem, ChargeableItem reservationItem, String sessionID, Date consumptionDate, String serviceID, String userServiceID, int resultType, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the update of a charging session. Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF. Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are updated into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF. Thirdly, the engine consolidates a chargeable item for reservation using both the old reservation item (from the rating session) and the provided one (if not present, the old one is used instead). It rates this new reservation item considering the update date and does the related counter reservations. A third rating result is available for balance reservation. Finally, it updates the rating session with the new reservation chargeable item.
`UpdateRateResult`	`updateRate(ChargeableItem confirmationItem, ChargeableItem reservationItem, String sessionID, Date consumptionDate, String serviceID, String userServiceID, int resultType, int cleanupResultType, boolean ft)` Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services Consider the main `update rate operation` for more information. This operation represents the update of a session-based charging sequence. Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF. Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are updated into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF. Thirdly, the engine consolidates a chargeable item for reservation using both the old reservation item (from the rating session) and the provided one (if not present, the old one is used instead). It rates this new reservation item considering the update date and does the related counter reservations. A third rating result is available for balance reservation. Finally, it updates the rating session with the new reservation chargeable item.

Methods inherited from class com.highdeal.cnd.message.AsyncRatingServiceClient
addAuthenticationListener, close, connect, connect, connect, connect, connect, connect, connect, connect, connect, connect, connect, getBootMode, getClientOpEventListener, getConnectionStatus, getSslContext, getTimeout, isAtLeastOneConnectionIsRegistered, isConnected, isNoTimeout, setBootMode, setClientOpEventListener, setHAEventListener, setNoTimeout, setSslContext, setUserCredentials

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - StatefulServiceClient
```
public StatefulServiceClient()
```
    Creates a non-initialized charging client; Use one of the connect(..) methods to connect this client to the distant SAP CC Core Server system.
  - StatefulServiceClient
```
@Deprecated
public StatefulServiceClient(String hostName,
                                          int port)
                                   throws IOException
```
    Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Creates a charging client and connects it to the distant SAP CC Core Server system
    
    Parameters:
    
    hostName - The host name of the SAP CC Core Server system
    
    port - The communication port on which the SAP CC system waits for requests via the Message TCP technical interface
    
    Throws:
    
    IOException - if the client cannot connect to the SAP CC system.
  - StatefulServiceClient
```
@Deprecated
public StatefulServiceClient(String hostName,
                                          int port,
                                          int timeout)
                                   throws IOException
```
    Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Creates a charging client and connects it to the distant SAP CC Core Server system; A client timeout is specified for the communications.
    
    Parameters:
    
    hostName - The host name of the SAP CC Core Server system
    
    port - The communication port on which the SAP CC system waits for request via the Message TCP technical interface
    
    timeout - The timeout in milliseconds for each request (or -1 to wait indefinitely) If you use zero and acknowledgments are requested then a CommunicationFailureException will be thrown without sending request.
    
    Throws:
    
    IOException - if the client cannot connect to the SAP CC system (if the server system is not running, for instance)
  - StatefulServiceClient
```
@Deprecated
public StatefulServiceClient(String hostName,
                                          int port,
                                          FoundLostRatingListener ratingListener)
                                   throws IOException
```
    Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Initializes a charging client and connects it to the distant SAP CC Core Server system;
    
    Parameters:
    
    hostName - The host name of the SAP CC Core Server system
    
    port - The communication port on which the SAP CC system waits for requests
    
    ratingListener - The listener informed when rating is found or lost
    
    Throws:
    
    IOException - if the client cannot connect to the SAP CC system
  - StatefulServiceClient
```
@Deprecated
public StatefulServiceClient(String hostName,
                                          int port,
                                          String bindAddress,
                                          int timeout,
                                          FoundLostRatingListener ratingListener)
                                   throws IOException
```
    Deprecated. Deprecated since version 4.1 SP2 of SAP CC and replaced by the empty builder and an authenticated connection. Initializes a charging client and connects it to the distant SAP CC Core Server system; A binding network address and a client timeout are specified for the communications with the connected SAP CC system.
    
    Parameters:
    
    hostName - The host name of the SAP CC Core Server system
    
    port - The communication port on which the SAP CC system waits for requests
    
    bindAddress - The network address to bind to
    
    timeout - The timeout in milliseconds for each request (or -1 to wait indefinitely). If you use zero and acknowledgments are requested then a CommunicationFailureException will be thrown without sending request.
    
    ratingListener - The listener informed when rating is found or lost
    
    Throws:
    
    IOException - if the client cannot connect to the SAP CC system
- Method Detail
  - charge
```
public PurchaseOrder charge(ChargeableItem ci,
                            String serviceID,
                            String userServiceID,
                            Date consumptionDate,
                            int ts,
                            boolean ft)
                     throws InvalidItemException,
                            ForbiddenChargeException,
                            TransactionClearingException,
                            ServerFailureException,
                            CommunicationFailureException
```
    Consider the main charge operation charge(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date)
    Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date. This operation may conflict with the prerating feature. Do not use this operation if some preratings are not post-rated.
    
    Parameters:
    
    ci - The ChargeableItem to rate
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    ts - The transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    ft - Flag to specify if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    The transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - charge
```
public PurchaseOrder charge(ChargeableItem ci,
                            String serviceID,
                            String userServiceID,
                            Date consumptionDate,
                            int ts)
                     throws InvalidItemException,
                            ForbiddenChargeException,
                            TransactionClearingException,
                            ServerFailureException,
                            CommunicationFailureException
```
    Consider the main charge operation charge(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date)
    Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date with transaction filtered selection. This operation may conflict with the prerating feature. Do not use this operation if some preratings are not post-rated.
    
    Parameters:
    
    ci - the ChargeableItem to rate
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    ts - the transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    Returns:
    
    the transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - charge
```
public PurchaseOrder charge(ChargeableItem ci,
                            String serviceID,
                            String userServiceID,
                            Date consumptionDate)
                     throws InvalidItemException,
                            ForbiddenChargeException,
                            TransactionClearingException,
                            ServerFailureException,
                            CommunicationFailureException
```
    This main business operation requests the SAP CC system to charge the specified chargeable item for the specified user service ID and the specified service ID at the specified date without transaction selection.
    
    Note
    
    This operation may conflict with the prerating feature that is now deprecated. Do not use this operation if some prerating operations are not post-rated.
    
    Parameters:
    
    ci - the chargeable item to charge
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    Returns:
    
    The purchase order resulting from the charging process
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - charge
```
public ChargingResult charge(ChargeableItem ci,
                             String serviceID,
                             String userServiceID,
                             Date consumptionDate,
                             ChargeExecutionContext context)
                      throws InvalidItemException,
                             ForbiddenChargeException,
                             TransactionClearingException,
                             ServerFailureException,
                             CommunicationFailureException
```
    This main business operation requests the SAP CC system to charge the specified chargeable item for the specified user service ID and service ID at the specified date.
    
    The behavior of the operation as well as the content of the result of the operation can be configured using an execution context.
    
    Note
    
    This operation may conflict with the prerating feature that is now deprecated. Do not use this operation if some prerating operations are not post-rated.
    
    Parameters:
    
    ci - The chargeable item to charge
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer
    
    context - The context in which the operation is executed
    
    Returns:
    
    The result of the charging operation
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - blankCharge
```
public PurchaseOrder blankCharge(ChargeableItem ci,
                                 String serviceID,
                                 String userServiceID,
                                 Date consumptionDate,
                                 int ts)
                          throws InvalidItemException,
                                 ForbiddenChargeException,
                                 TransactionClearingException,
                                 ServerFailureException,
                                 CommunicationFailureException
```
    This main business operation requests the SAP CC system to charge in blank mode the specified chargeable item for the specified user service ID and service ID at the specified date.
    
    This operation is equivalent to charge operation but the blank mode means that no data is committed to the database.
    
    Caution
    
    If the transaction processor does not take care about the database transaction (transaction processor which stores the transactions into a file by example), the transaction processor action will not be rollbacked.
    
    Parameters:
    
    ci - the chargeable item to advise
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer
    
    ts - the transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    Returns:
    
    The transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - blankCharge
```
public PurchaseOrder blankCharge(ChargeableItem ci,
                                 String serviceID,
                                 String userServiceID,
                                 Date consumptionDate,
                                 int ts,
                                 boolean ft)
                          throws InvalidItemException,
                                 ForbiddenChargeException,
                                 TransactionClearingException,
                                 ServerFailureException,
                                 CommunicationFailureException
```
    Consider the main blank charge operation for more information; You can specify if the returned transactions must be filtered according to the transactionTemplate.
    
    Parameters:
    
    ci - the ChargeableItem to estimate the price
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    ts - The transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    ft - Flag to specify if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    The transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - blankCharge
```
public ChargingResult blankCharge(ChargeableItem ci,
                                  String serviceID,
                                  String userServiceID,
                                  Date consumptionDate,
                                  ChargeExecutionContext context)
                           throws InvalidItemException,
                                  ForbiddenChargeException,
                                  TransactionClearingException,
                                  ServerFailureException,
                                  CommunicationFailureException
```
    This main business operation requests the SAP CC system to charge in blank mode the specified chargeable item for the specified user service ID and service ID at the specified date.
    
    The behavior of the operation as well as the content of the result of the operation can be configured using an execution context.
    
    This operation is equivalent to the charge operation but the blank mode means that no data is committed to the database.
    
    Caution
    
    If the transaction processor does not take care about the database transaction (transaction processor which stores the transactions into a file by example), the transaction processor action will not be rollbacked.
    
    Parameters:
    
    ci - The chargeable item to advise
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer
    
    context - The context in which the operation is executed
    
    Returns:
    
    The result of the charging operation
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - getEstimatedPrice
```
@Deprecated
public PurchaseOrder getEstimatedPrice(ChargeableItem ci,
                                                    String serviceID,
                                                    String userServiceID,
                                                    Date consumptionDate)
                                             throws ForbiddenChargeException,
                                                    InvalidItemException,
                                                    ServerFailureException,
                                                    CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation
    This main business operation requests the SAP CC system to estimate the price of a usage consumption (white rating).
    Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
    
    Parameters:
    
    ci - The chargeable item to determine the price
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer
    
    Returns:
    
    The transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - getEstimatedPrice
```
@Deprecated
public PurchaseOrder getEstimatedPrice(ChargeableItem ci,
                                                    String serviceID,
                                                    String userServiceID,
                                                    Date consumptionDate,
                                                    int ts)
                                             throws ForbiddenChargeException,
                                                    InvalidItemException,
                                                    ServerFailureException,
                                                    CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation
    Consider the main get estimated price operation for more information.
    Estimates the price of a usage consumption (white rating).
    Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
    
    Parameters:
    
    ci - the ChargeableItem to rate
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    ts - the transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    Returns:
    
    the transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - getEstimatedPrice
```
@Deprecated
public PurchaseOrder getEstimatedPrice(ChargeableItem ci,
                                                    String serviceID,
                                                    String userServiceID,
                                                    Date consumptionDate,
                                                    int ts,
                                                    boolean ft)
                                             throws ForbiddenChargeException,
                                                    InvalidItemException,
                                                    ServerFailureException,
                                                    CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the blank charging operation
    Consider the main get estimated price operation for more information.
    Estimates the price of a usage consumption (white rating).
    Asks the server to rate the specified chargeable item for the specified user service ID and the specified service ID at the specified date without impacting the database.
    
    Parameters:
    
    ci - The ChargeableItem to rate
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer
    
    ts - The transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    ft - Sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    the transaction's PurchaseOrder
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - checkLimit
```
public CheckLimitResult checkLimit(ChargeableItem item,
                                   String serviceID,
                                   String userServiceID,
                                   Date consumptionDate,
                                   String propertyName,
                                   BigDecimal precision,
                                   Money limitAmount,
                                   boolean estimationMode)
                            throws InvalidItemException,
                                   ForbiddenChargeException,
                                   TransactionClearingException,
                                   CannotInverseException,
                                   ServerFailureException,
                                   CommunicationFailureException
```
    This main business operation requests either an inverse rating operation or a best-effort charging operation.
    - The inverse rating operation determines the maximum quantity of a customer service that an end customer can consume based on a limit amount specified in the operation request. The inverse charging operation only checks this limit. This is an estimate.
    - The best-effort charging operation checks first this limit and charges the end customer for that price even if the customer does not totally use the service.
    The chargeable item that is specified must contain a value for the property to inverse. This value represents the maximum value return for the property to inverse. The value must be valid regarding the precision specified. This business operation assumes that the value of the property to inverse is between 0 and the maximum value.
    
    Once answered, you can request a charging operation to reserve a credit on a prepaid account.
    
    Note
    
    To implement a credit reservation function in online event-based charging services, you can implement the inverse rating operation by specifying the estimation mode to false (see estimationMode). In that case, the SAP CC system automatically processes a charging operation after the inverse rating operation.
    
    Options: You can specify the precision. The precision of the result must be one of the following: 1, 0.1, 0.01, 0.001 ...
    
    Note
    
    When the limit amount of money is not provided (null value), the limit is retrieved from the account balances.
    
    Caution
    
    When the processed charging plan depends on the property to inverse, the inverse rating operation can return a value which does not correspond to the exact limit, and thus fails when really charged.
    
    The configuration of the pricing catalog of a service provider (master data) is very important. Check the pricing logic (price plan) and the charging logic (charging plan) of the charges customized in the charge plans (or the offers) that are activated in the provider contract (or subscription) of the end customer who uses the customer service.
    Parameters:
    
    item - The chargeable item to use for the inverse rating or best-effort charging
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    propertyName - the name of the property used by the inverse rating function
    
    precision - the precision for the computed property value
    
    limitAmount - the limit amount to inverse (must be positive or null)
    
    estimationMode - the estimation mode (false for a best-effort charging operation; true for an inverse rating operation)
    
    Returns:
    
    The maximum quantity of service an end customer can consume based on a limit amount
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    CannotInverseException - if the inverse rating cannot be performed
    
    ServerFailureException - if the SAP CC system is not available
    
    CommunicationFailureException - if a communication failure occurs
  - checkLimit
```
public CheckLimitResult checkLimit(ChargeableItem item,
                                   String serviceID,
                                   String userServiceID,
                                   Date consumptionDate,
                                   String propertyName,
                                   BigDecimal precision,
                                   Money limit,
                                   boolean estimationMode,
                                   int ts,
                                   boolean ft)
                            throws InvalidItemException,
                                   ForbiddenChargeException,
                                   TransactionClearingException,
                                   CannotInverseException,
                                   ServerFailureException,
                                   CommunicationFailureException
```
    Consider the main checkLimit(com.highdeal.pnr.hci.ChargeableItem, java.lang.String, java.lang.String, java.util.Date, java.lang.String, java.math.BigDecimal, com.highdeal.currency.Money, boolean) check limit operation for more information.
    This operation represents the property limit check operation also called Inverse Rating. The chargeable item that is sent during this operation must contain a value for the property to inverse. This value represents the maximum value return for the property to inverse. The value must be valid regarding the precision used. This operation assumes that the value of the property to inverse is between 0 and the maximum value. An inverse rating is performed followed by a final rating if the estimation mode is set to false. In addition, the client has the ability to specify the precision. The precision of the result must be one of the following: 1, 0.1, 0.01, 0.001 ...
    When the limit amount of money is not provided (null value), the limit is retrieved from the account balances. Note: - When the Charging Plan depends on the property to inverse, the Check Limit operation can return a value which does not correspond to the exact limit, and thus fails when really charged.
    
    Parameters:
    
    item - the ChargeableItem to rate
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    propertyName - the name of the property used by the inverse rating process
    
    precision - the precision for the computed property value
    
    limit - the limit to inverse (must be positive or null)
    
    estimationMode - the estimation mode
    
    ts - the transaction selection NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION, ALL_TRANSACTION_AND_RECURRING
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    the check limit result
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    CannotInverseException - if the check limit cannot be performed
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - preRate
```
@Deprecated
public PreRateResult preRate(ChargeableItem ci,
                                          String serviceID,
                                          String userServiceID,
                                          Date consumptionDate,
                                          int resultType,
                                          long reservationUID,
                                          int defaultResolution,
                                          long ttl)
                                   throws InvalidItemException,
                                          ForbiddenChargeException,
                                          TransactionClearingException,
                                          PreRateException,
                                          ServerFailureException,
                                          CommunicationFailureException
```
    Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Consider the main prerate operation for more information. Asks the server to prerate the specified chargeable item for the specified user service ID and the specified service ID at the specified date, and using the passed reservation unique identifier, default resolution and time to live. The operation allows the use of the same reservation unique identifier for more than one prerating. This case is managed at postrating time.
    
    Parameters:
    
    ci - the ChargeableItem to rate.
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    resultType - the result type (see PreRateOp for the constants)
    
    reservationUID - the reservationUID used later to post-rate
    
    defaultResolution - the default resolution to be used at expiration (see PreRateOp}for the constants)
    
    ttl - the time to live given in seconds
    
    Returns:
    
    The computed PreRateResult
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    PreRateException - if a prerating error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - preRate
```
@Deprecated
public PreRateResult preRate(ChargeableItem ci,
                                          String serviceID,
                                          String userServiceID,
                                          Date consumptionDate,
                                          int resultType,
                                          boolean ft,
                                          long reservationUID,
                                          int defaultResolution,
                                          long ttl)
                                   throws InvalidItemException,
                                          ForbiddenChargeException,
                                          TransactionClearingException,
                                          PreRateException,
                                          ServerFailureException,
                                          CommunicationFailureException
```
    Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services This main operation asks the SAP CC system to prerate the specified chargeable item for the specified user service ID and the specified service ID at the specified date, and using the passed reservation unique identifier, default resolution and time to live. The operation allows the use of the same reservation unique identifier for more than one prerating. This case is managed at post-rating time.
    
    Parameters:
    
    ci - the ChargeableItem to rate.
    
    serviceID - the service ID
    
    userServiceID - the user service ID. This parameter is used as key for determining the partition ID for guiding the request towards the related rater. So it cannot be set to null. If this parameter is set to null, ForbiddenChargeException is thrown with ILLEGAL_ARGUMENT as reason.
    
    consumptionDate - the consumption date
    
    resultType - the result type (see PreRateOp for the constants)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    reservationUID - the reservationUID used later to post-rate
    
    defaultResolution - the default resolution to be used at expiration (see PreRateOp}for the constants)
    
    ttl - the time to live given in seconds
    
    Returns:
    
    the computed PreRateResult
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    PreRateException - if a prerating error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - postRate
```
@Deprecated
public PostRateResult postRate(long reservationUID,
                                            String serviceID,
                                            String userServiceID,
                                            int resolution,
                                            int resultType,
                                            ChargeableItem newCi)
                                     throws InvalidItemException,
                                            ForbiddenChargeException,
                                            TransactionClearingException,
                                            PostRateException,
                                            ServerFailureException,
                                            CommunicationFailureException
```
    Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Asks the server to post-rate the specified reservation unique identifier using the given resolution. If more than one rating record for that reservation identifier are present into the database, the operation chooses one arbitrarily. In that case, the operation logs the reservation identifier. When resolution is CONFIRMED then a new ChargeableItem may be passed.
    Not like PostRateOp, there are serviceID and userServiceID parameters. They have no functional meaning and are not mandatory, but setting them with same value as for preRate may increase the performance in multi-server configuration.
    
    Parameters:
    
    reservationUID - the reservationUID to post-rate
    
    serviceID - the service ID (no functional meaning, used only as load balancing key on HA configuration)
    
    userServiceID - the user service ID (no functional meaning, used only as load balancing key on HA configuration)
    
    resolution - the resolution to be used (see PostRateOp for the constants)
    
    resultType - the result type (see PostRateOp for the constants)
    
    newCi - the new ChargeableItem to be used for this post-rating
    
    Returns:
    
    The computed PostRateResult
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    PostRateException - if a prerating error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - postRate
```
@Deprecated
public PostRateResult postRate(long reservationUID,
                                            String serviceID,
                                            String userServiceID,
                                            int resolution,
                                            int resultType,
                                            boolean ft,
                                            ChargeableItem newCi)
                                     throws InvalidItemException,
                                            ForbiddenChargeException,
                                            TransactionClearingException,
                                            PostRateException,
                                            ServerFailureException,
                                            CommunicationFailureException
```
    Deprecated. Deprecated since version 2.0 of SAP CC and replaced by the session-based charging services Asks the server to post-rate the specified reservation unique identifier using the given resolution. If more than one rating record for that reservation identifier are present into the database, the operation chooses one arbitrarily. In that case, the operation logs the reservation identifier. When resolution is CONFIRMED then a new ChargeableItem may be passed.
    Not like PostRateOp, there are serviceID and userServiceID parameters. They have no functional meaning and are not mandatory, but setting them with same value as for preRate may increase the performance in multi-server configuration.
    
    Parameters:
    
    reservationUID - the reservationUID to post-rate
    
    serviceID - the service ID (no functional meaning, used only as load balancing key on HA configuration)
    
    userServiceID - the user service ID (no functional meaning, used only as load balancing key on HA configuration)
    
    resolution - the resolution to be used (see PostRateOp for the constants)
    
    resultType - the result type (see PostRateOp for the constants)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    newCi - the new ChargeableItem to be used for this post-rating
    
    Returns:
    
    The computed PostRateResult
    
    Throws:
    
    InvalidItemException - if the chargeable item is not valid
    
    ForbiddenChargeException - if charging is forbidden
    
    TransactionClearingException - if a transaction clearing error occurs
    
    PostRateException - if a prerating error occurs
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - if a communication failure occurs
  - activate
```
public PurchaseOrder activate(String subscriberAccountCode,
                              String serviceProvider,
                              int resultType,
                              Date toDate)
                       throws ForbiddenChargeException,
                              ActivateException,
                              TransactionClearingException,
                              ServerFailureException,
                              CommunicationFailureException
```
    This main business operation triggers the activation of all the periodic and one-off fees (see recurring/one-shot rates in charges) configured in the provider contracts and subscriptions relating to the specified subscriber account; You use this operation to prepare the invoicing and billing operations in an external system. The operation returns the related purchase order.
    
    Parameters:
    
    subscriberAccountCode - The identification code of the subscriber account representing an end customer of a service provider
    
    serviceProvider - The identification code of the service provider, owner of both the pricing catalogs and the customer master data (subscriber accounts, provider contracts, subscriptions, ...)
    
    resultType - The result type to be returned (NO_TRANSACTION, MASTER_TRANSACTION or ALL_TRANSACTION).
    
    toDate - The reference date for triggering the periodic fees. Only fees for which the trigger date is before or equal to this reference date will be triggered and will generate a transaction (or not - not mandatory -)
    
    Returns:
    
    The related purchase order that includes the list of generated transactions (if required and if some transactions exist)- one-shot and recurring ones -. The purchase order contains the total of generated amounts and the state of the purchase.
    
    Throws:
    
    ForbiddenChargeException - if the SAP CC system cannot retrieve the contract (or subscription) or if a parameter is malformed
    
    ActivateException - if the contract (or subscription) cannot be activated for several reasons (see ActivateException for more information)
    
    TransactionClearingException - if the Transaction Processor plugged, is not able to clear at least one of the generated transactions
    
    ServerFailureException - if the targeted rater instance (of the SAP CC system) is not ready to treat the activation request
    
    CommunicationFailureException - if the targeted rater instance cannot be reached by the Packets over TCP communication layer
  - activate
```
public PurchaseOrder activate(String subscriberAccountCode,
                              String serviceProvider,
                              int resultType,
                              boolean ft,
                              Date toDate)
                       throws ForbiddenChargeException,
                              ActivateException,
                              TransactionClearingException,
                              ServerFailureException,
                              CommunicationFailureException
```
    Consider the main activate operation for more information. Activates all the periodic and one-off fees for a specified subscriber account and returns the related purchase order; Transaction filtering is available.
    
    Parameters:
    
    subscriberAccountCode - The identification code of the subscriber account
    
    serviceProvider - The code of the service provider
    
    resultType - The result type to be returned (NO_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or CHARGING_RESULT).
    
    ft - The flag to specify if the returned transactions must be filtered according to the transactionTemplate
    
    toDate - The reference date for triggering the recurring fees. Only fees for which the trigger date is before or equal to this reference date will be trigger and will generate a transaction (or not - not mandatory -)
    
    Returns:
    
    The related purchase order which will contain the list of generated transactions (if required and if some transactions exist)- one shot and recurring ones -. However, the purchase order will contain the total of generated amounts and the state of the purchase.
    
    Throws:
    
    ForbiddenChargeException - if the SAP CC system cannot retrieve the subscription or if a parameter is malformed.
    
    ActivateException - if the subscription cannot be activated for diverse reasons (ActivateException for more info about reasons).
    
    TransactionClearingException - if the Transaction Processor plugged, is not able to clear at least one of the generated transactions
    
    ServerFailureException - if the targeted rater instance is not ready to treat the activation request
    
    CommunicationFailureException - if the targeted rater instance cannot be reached by the Packets over TCP communication layer
  - cleanup
```
public CleanupResult cleanup(String subscriberAccountCode,
                             String serviceProvider,
                             Date toDate,
                             int resultType)
                      throws ForbiddenChargeException,
                             TransactionClearingException,
                             ServerFailureException,
                             CommunicationFailureException,
                             CleanupException
```
    This main business operation triggers the cleanup process in the connected SAP CC Core Server system; The SAP CC system goes through all the existing rating records of a given subscription and deletes the ones that are not relevant at all.
    More precisely, the SAP CC system executes the post-rating process for the expired records, using their default resolution (passed into the PreRateOp).
    As for the postRate, transactions may be computed. In such a case, these transactions are sent to the TIF connector and can be returned if asked.
    You must specify a reference date (see toDate) that is used by the SAP CC system to determine whether a rating record is expired or not.
    Note
    
    If you do not implement this operation in your client application, an SAP CC administrator can manually trigger the cleanup operation (see the Admin+ user interface) or configure the SAP CC system to regularly process the cleanup (see the CLEANUP_SCHEDULER_ENABLED system parameter).
    
    See also PreRateOp
    
    Parameters:
    
    subscriberAccountCode - The identification code of the subscriber account
    
    serviceProvider - The code of the service provider
    
    resultType - The result type to be returned (NO_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or CHARGING_RESULT)
    
    toDate - The reference date which is used to determine whether a rating record is expired or not. This parameter cannot be null otherwise the ForbiddenChargeException exception with ILLEGAL_ARGUMENT will be thrown.
    
    Returns:
    
    The related purchase order which will contain the list of generated transactions (if required and if some transactions exist). However, the purchase order will contain the total of generated amounts and the state of the purchase.
    
    Throws:
    
    ForbiddenChargeException - if the server cannot retrieve the subscription or if a parameter is malformed.
    
    TransactionClearingException - if the Transaction Processor plugged on the PnR output, is not able to clear at least one of the generated transactions.
    
    ServerFailureException - if the targeted rater instance is not ready to treat the activation request
    
    CommunicationFailureException - the targeted rater instance cannot be reached by the Packets over TCP communication layer (see the Message Tcp technical interface of SAP CC).
    
    CleanupException - if the date or the subscription or the currency is not valid.
  - cleanup
```
public CleanupResult cleanup(String subscriberAccountCode,
                             String serviceProvider,
                             Date toDate,
                             int resultType,
                             boolean ft)
                      throws ForbiddenChargeException,
                             TransactionClearingException,
                             ServerFailureException,
                             CommunicationFailureException,
                             CleanupException
```
    Consider the main cleanup operation for more information. This method implements the cleanup process. It goes through the rating records of a given subscription and deletes the ones that are not relevant at all. More precisely, it executes the post-rating process for the expired records, using their default resolution (passed into the PreRateOp).
    As for the postRate, transactions may be computed. In such a case, these transactions are sent to the TIF connector and can be returned if asked.
    This operation takes a date as input. This date is used to determine whether a rating record is expired or not. This operation may be scheduled periodically by the server or externally called. See also PreRateOp
    
    Parameters:
    
    subscriberAccountCode - The code of the subscriber account
    
    serviceProvider - The code of the service provider
    
    resultType - The result type to be returned (NO_TRANSACTION, MASTER_TRANSACTION or ALL_TRANSACTION, CHARGING_RESULT).
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    toDate - the reference date which is used to determine whether a rating record is expired or not. This parameter cannot be null otherwise the ForbiddenChargeException exception with ILLEGAL_ARGUMENT will be thrown.
    
    Returns:
    
    the related purchase order which will contain the list of generated transactions (if required and if some transactions exist). However, the purchase order will contain the total of generated amounts and the state of the purchase.
    
    Throws:
    
    ForbiddenChargeException - if the server cannot retrieve the subscription or if a parameter is malformed.
    
    TransactionClearingException - if the Transaction Processor plugged on the PnR output, is not able to clear at least one of the generated transactions.
    
    ServerFailureException - if the targeted rater instance is not ready to treat the activation request.
    
    CommunicationFailureException - the targeted rater instance cannot be reached by the Packets over TCP communication layer.
    
    CleanupException - if the date or the subscription or the currency is not valid.
  - translate
```
public Object[] translate(String tableCode,
                          int operator,
                          Date date,
                          String[] inValues)
                   throws DoesNotExistException,
                          CommunicationFailureException,
                          ServerFailureException
```
    Translates some values by using a translation table
    
    Parameters:
    
    tableCode - The identification code of the translation table which must be used
    
    operator - The comparison operator
    
    date - The version date of the translation table
    
    inValues - An array of String which represents the input values
    
    Returns:
    
    An array of the translated Object
    
    Throws:
    
    DoesNotExistException - thrown if the translation table does not exist
    
    CommunicationFailureException - if a communication failure occurs
    
    ServerFailureException
    
    See Also:
    
    TranslateValueOp
  - translate
```
public Object[] translate(String tableCode,
                          int operator,
                          Date date,
                          Date referenceDate,
                          String[] inValues)
                   throws DoesNotExistException,
                          CommunicationFailureException,
                          ServerFailureException
```
    Translates some values by using a translation table
    
    Parameters:
    
    tableCode - The identification code of the translation table which must be used
    
    operator - The comparison operator
    
    date - The version date of the translation table
    
    referenceDate - The reference date used to check the column "start date" and the column "end date"
    
    inValues - An array of String which represents the input values
    
    Returns:
    
    an array of the translated Object
    
    Throws:
    
    DoesNotExistException - thrown if the translation table does not exist
    
    CommunicationFailureException - if a communication failure occurs
    
    ServerFailureException
    
    See Also:
    
    TranslateValueOp
  - startRate
```
@Deprecated
public StartRateResult startRate(ChargeableItem reservationItem,
                                              String sessionID,
                                              Date consumptionDate,
                                              String serviceID,
                                              String userServiceID,
                                              int defaultResolution,
                                              long ttl,
                                              int resultType,
                                              boolean ft)
                                       throws InvalidItemException,
                                              ForbiddenChargeException,
                                              StartRateException,
                                              ServerFailureException,
                                              CommunicationFailureException,
                                              TransactionClearingException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the start of a session-based charging operation.
    It is in charge of rating the reservation chargeable item and doing the related counter reservations. It creates a rating session (keeping the reservation chargeable item) and returns a rating result used to reserve the balance.
    The parameters ttl and defaultResolution are used by the session cleaning process to confirm or cancel the last counter reservations after a given amount of time.
    The result of this method contains either the amount or all the transactions to reserve. These transactions are not provided to the TIF since they are not the final ones.
    
    Parameters:
    
    reservationItem - The reservation item (mandatory)
    
    sessionID - The session identifier which has to be unique
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    defaultResolution - The default resolution of the rating session at expiration time (CANCELLED or CONFIRMED)
    
    ttl - The time to live expressed in seconds
    
    resultType - The rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    ft - Sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    A rating result used to reserve the balance
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    StartRateException - when rating session cannot be created
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
    
    TransactionClearingException - when transactions cannot be cleared
    
    See Also:
    
    updateRate(ChargeableItem, ChargeableItem, String, Date, String, String, int, boolean), updateRate(ChargeableItem, ChargeableItem, String, Date, String, String, int, int, boolean), stopRate(ChargeableItem, String, String, String, int, int, boolean), stopRate(ChargeableItem, String, String, String, int, int, int, boolean)
  - startRate
```
@Deprecated
public StartRateResult startRate(ChargeableItem reservationItem,
                                              String sessionID,
                                              Date consumptionDate,
                                              String serviceID,
                                              String userServiceID,
                                              int defaultResolution,
                                              long ttl,
                                              int resultType,
                                              int cleanupResultType,
                                              boolean ft,
                                              String propertyToInverse)
                                       throws InvalidItemException,
                                              ForbiddenChargeException,
                                              StartRateException,
                                              ServerFailureException,
                                              CommunicationFailureException,
                                              TransactionClearingException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services
    Consider the main start rate operation for more information. This operation represents the beginning of a session-based charging sequence. It creates a charging session.
    It is in charge of rating the reservation chargeable item and doing the related counter reservations. It creates a rating session (keeping the reservation chargeable item) and returns a rating result used to reserve the balance.
    If the reservation fails due to a low-credit, an inverse rating may be attempted if the property name of the property to inverse is provided. This mechanism is known as best effort reservation. This property name is saved in the rating session to avoid providing it again or changing it at update time.
    The parameters ttl and defaultResolution are used by the session cleaning process to confirm or cancel the last counter reservations after a given amount of time.
    The result of this method contains either the amount or all the transactions to reserve. These transactions are not provided to the TIF since they are not the final ones.
    
    Parameters:
    
    reservationItem - the reservation item (mandatory)
    
    sessionID - the session identifier which has to be unique
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    defaultResolution - the default resolution of the rating session at expiration time (CANCELLED or CONFIRMED)
    
    ttl - the time to live expressed in seconds
    
    resultType - the rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    cleanupResultType - the session cleanup rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    propertyToInverse - the name of the property to inverse in case of best effort reservation
    
    Returns:
    
    A rating result used to reserve the balance
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    StartRateException - when rating session cannot be created
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
    
    TransactionClearingException - when transactions cannot be cleared
  - updateRate
```
@Deprecated
public UpdateRateResult updateRate(ChargeableItem confirmationItem,
                                                ChargeableItem reservationItem,
                                                String sessionID,
                                                Date consumptionDate,
                                                String serviceID,
                                                String userServiceID,
                                                int resultType,
                                                boolean ft)
                                         throws ForbiddenChargeException,
                                                InvalidItemException,
                                                UpdateRateException,
                                                TransactionClearingException,
                                                ServerFailureException,
                                                CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the update of a charging session.
    Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF.
    Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are updated into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF.
    Thirdly, the engine consolidates a chargeable item for reservation using both the old reservation item (from the rating session) and the provided one (if not present, the old one is used instead). It rates this new reservation item considering the update date and does the related counter reservations. A third rating result is available for balance reservation. Finally, it updates the rating session with the new reservation chargeable item.
    
    Parameters:
    
    confirmationItem - the confirmation item (optional, null value is accepted)
    
    reservationItem - the reservation item (optional, null value is accepted)
    
    sessionID - the session identifier previously used
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    resultType - the rating result type to be returned (NONE_TRANSACTION or MASTER_TRANSACTION, ALL_TRANSACTION)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    a rating result used to cancel, confirm, and reserve the balance UpdateRateResult
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    UpdateRateException - when rating session cannot be updated
    
    TransactionClearingException - when transactions cannot be cleared
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
    
    See Also:
    
    startRate(ChargeableItem, String, Date, String, String, int, long, int, int, boolean, String), startRate(ChargeableItem, String, Date, String, String, int, long, int, boolean), stopRate(ChargeableItem, String, String, String, int, int, boolean), stopRate(ChargeableItem, String, String, String, int, int, int, boolean)
  - updateRate
```
@Deprecated
public UpdateRateResult updateRate(ChargeableItem confirmationItem,
                                                ChargeableItem reservationItem,
                                                String sessionID,
                                                Date consumptionDate,
                                                String serviceID,
                                                String userServiceID,
                                                int resultType,
                                                int cleanupResultType,
                                                boolean ft)
                                         throws ForbiddenChargeException,
                                                InvalidItemException,
                                                UpdateRateException,
                                                TransactionClearingException,
                                                ServerFailureException,
                                                CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services
    Consider the main update rate operation for more information. This operation represents the update of a session-based charging sequence.
    Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF.
    Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are updated into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF.
    Thirdly, the engine consolidates a chargeable item for reservation using both the old reservation item (from the rating session) and the provided one (if not present, the old one is used instead). It rates this new reservation item considering the update date and does the related counter reservations. A third rating result is available for balance reservation. Finally, it updates the rating session with the new reservation chargeable item.
    
    Parameters:
    
    confirmationItem - the confirmation item (optional, null value is accepted)
    
    reservationItem - the reservation item (optional, null value is accepted)
    
    sessionID - the session identifier previously used
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - the date the service was consumed by the end customer
    
    resultType - the rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    cleanupResultType - the session cleanup rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    a rating result used to cancel, confirm, and reserve the balance UpdateRateResult
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    UpdateRateException - when rating session cannot be updated
    
    TransactionClearingException - when transactions cannot be cleared
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
  - stopRate
```
@Deprecated
public StopRateResult stopRate(ChargeableItem confirmationItem,
                                            String sessionID,
                                            String serviceID,
                                            String userServiceID,
                                            int resolution,
                                            int resultType,
                                            boolean ft)
                                     throws ForbiddenChargeException,
                                            InvalidItemException,
                                            StopRateException,
                                            TransactionClearingException,
                                            ServerFailureException,
                                            CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services This main business operation represents the termination of a session-based charging sequence.
    Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF.
    Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are committed into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF.
    This method manages also the session cancellation case by setting the resolution parameter to CANCELLED. It retrieves the rating session first and cancels the related counter reservations coming from either a previous session start or a session update. The rating result that is returned is empty in case of cancellation.
    Finally, the rating session is removed and the session identifier becomes available for next sessions.
    
    Parameters:
    
    confirmationItem - The confirmation item (optional, null value is accepted)
    
    sessionID - The session identifier previously used
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    resolution - The resolution of the rating session (CANCELLED or CONFIRMED)
    
    resultType - The rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    a rating result used to cancel and confirm the balance StopRateResult
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    StopRateException - when rating session cannot be stopped
    
    TransactionClearingException - when transactions cannot be cleared
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
    
    See Also:
    
    startRate(ChargeableItem, String, Date, String, String, int, long, int, int, boolean, String), startRate(ChargeableItem, String, Date, String, String, int, long, int, boolean), updateRate(ChargeableItem, ChargeableItem, String, Date, String, String, int, boolean), updateRate(ChargeableItem, ChargeableItem, String, Date, String, String, int, int, boolean)
  - stopRate
```
@Deprecated
public StopRateResult stopRate(ChargeableItem confirmationItem,
                                            String sessionID,
                                            String serviceID,
                                            String userServiceID,
                                            int resolution,
                                            int resultType,
                                            int cleanupResultType,
                                            boolean ft)
                                     throws ForbiddenChargeException,
                                            InvalidItemException,
                                            StopRateException,
                                            TransactionClearingException,
                                            ServerFailureException,
                                            CommunicationFailureException
```
    Deprecated. Deprecated since version 4.0 of SAP CC and replaced by the multiservice session-based charging services
    Consider the main stop rate operation for more information. This operation class represents the stop of a session-based charging.
    Firstly, it retrieves the rating session and re-rate the reservation item to compute a first rating result used by the client application to cancel the previous balance reservation. The transactions from this rating result are provided to the TIF.
    Secondly, it consolidates a chargeable item for confirmation using both the reservation one from the rating session and the confirmation one if present. This chargeable item is rated and previously reserved counters are committed into the database. A second rating result is then available for the client application to confirm the balance reservation. The transactions from this rating result are also provided to the TIF.
    This method manages also the session cancellation case by setting the resolution parameter to CANCELLED. It retrieves the rating session first and cancels the related counter reservations coming from either a previous session start or a session update. The rating result that is returned is empty in case of cancellation.
    Finally, the rating session is removed and the session identifier becomes available for next sessions.
    
    Parameters:
    
    confirmationItem - the confirmation item (optional, null value is accepted)
    
    sessionID - the session identifier previously used
    
    serviceID - the service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - the user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    resolution - the resolution of the rating session (CANCELLED or CONFIRMED)
    
    resultType - the rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    cleanupResultType - the session cleanup rating result type to be returned (NONE_TRANSACTION, MASTER_TRANSACTION, ALL_TRANSACTION or ALL_TRANSACTION_AND_RECURRING)
    
    ft - sets if the returned transactions must be filtered according to the transactionTemplate
    
    Returns:
    
    A rating result used to cancel and confirm the balance StopRateResult
    
    Throws:
    
    ForbiddenChargeException - when the rating is not allowed
    
    InvalidItemException - when the chargeable item is invalid
    
    StopRateException - when rating session cannot be stopped
    
    TransactionClearingException - when transactions cannot be cleared
    
    ServerFailureException - when the rater instance cannot handle the request
    
    CommunicationFailureException - when the rater instance cannot be reached
  - createSessionStartOperation
```
public ISessionStartChargingOperation createSessionStartOperation(String sessionID,
                                                                  String userServiceID,
                                                                  String serviceID,
                                                                  Date consumptionDate)
```
    This method allows you to create a start operation to manage the service consumption by an end customer. In a session-based charging scenario, a customer is charged for the consumptions of different service options (voice, text, data) defined in a service bundle. For each service option, you manage a charging session that is a sequence of reservations and reservation confirmations.
    You manage a customer session that relates to the activity of an end customer. This session includes several charging sessions, each charging session is identified by a unique reservation ID. Once a charging session is ended, you can reuse its ID.
    
    Customizing
    
    The interface returned by this method allows defining several reservations through multiple calls to prepareReserve(..). You define a reservation for each service option that is consumed by the end customer.
    When all the reservations are prepared, a call to execute() method sends the request to the connected SAP CC system.
    This operation charges each reservation (represented as a chargeable item) and creates the related reservations on counters and balances. For each of these reservations a persistent charging session is created and a rating result is returned. This return can be used to reserve the balance.
    
    Note
    
    This operation should be executed only once. It must not be reused for future calls.
    
    Parameters:
    
    sessionID - The session identifier that has to be unique
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the service was consumed by the end customer (this date is used as a consumption date for reservations)
    
    Returns:
    
    The operation responsible for collecting and executing the reservations
  - createSessionUpdateOperation
```
public ISessionUpdateChargingOperation createSessionUpdateOperation(String sessionID,
                                                                    String userServiceID,
                                                                    String serviceID,
                                                                    Date consumptionDate)
```
    This method allows you to create an update operation to process an update event of a multiservice session-based charging sequence.
    Customizing
    
    The interface returned by this method allows managing several pending reservations and associated reservation cycles and charging sessions:
    - Reservations through calls to prepareReserve(..)
    - Confirmations through calls to prepareConfirm(..)
    - Cancellations through calls to prepareCancel(..)
    - Reservation extensions through calls to prepareConfirmAndReserve(..)
    When all the reservations, confirmations, cancellations, and reservation extensions are prepared, a call to execute() method sends the request to the connected SAP CC system.
    This operation charges each reservation (represented as chargeable item) and creates the related reservations on counters and balances. It extends a reservation by charging a partial or total confirmation of a previous reservation and updates the related reservations on counters and balances for the new reservation. And finally it confirms (partially or totally) a previous reservation. Alternatively it is able to cancel the reservation. For each of the new reservations a persistent charging session is created and a rating result is returned. This return can be used to reserve the balance. If the charging session already exists, it is updated with the new reservation.
    
    Note
    
    This operation should be executed each time customer events or reservation extension cycles apply.
    Parameters:
    
    sessionID - The session identifier which has to be unique
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date the marketable service was consumed by the end customer (this date is used as a consumption date for new reservations)
    
    Returns:
    
    The operation responsible for collecting and executing the reservations and the confirmations
  - createSessionStopOperation
```
public ISessionStopChargingOperation createSessionStopOperation(String sessionID,
                                                                String userServiceID,
                                                                String serviceID,
                                                                Date consumptionDate)
```
    This stop operation confirms (partially or totally) previous reservations and is able to cancel some other reservations.
    This method creates a stop operation to process a termination event of a multiservice session-based charging sequence.
    Customizing
    
    The interface returned by this method allows finalizing pending reservations:
    - Confirmations through calls to prepareConfirm(..)
    - Cancellations through calls to prepareCancel(..)
    When all the reservation confirmations and reservation cancellations are prepared, a call to the execute() method sends the request to the connected SAP CC system.
    Notes
    
    In a multiservice session, this operation should be executed only once. It must not be reused for future calls.
    
    This stop operation is optional: do not execute this operation when all the reservations have been automatillcaly confirmed or when a previous update operation has already confirmed (or canceled) all the pending reservations.
    
    You cannot initiate a new charging session. The prepareReserve(..) and prepareConfirmAndReserve(..) methods are not available.
    Parameters:
    
    sessionID - The session identifier which has to be unique
    
    serviceID - The service identifier (SID), which represents a technical identifier of the service provided by the service provider
    
    userServiceID - The user service identifier (USID), which represents a technical identifier of the end customer consuming the service
    
    consumptionDate - The date when the session stops
    
    Returns:
    
    The operation responsible for collecting and executing the confirmations
  - monitorSpendingStatus
```
public IMonitorSpendingStatusResultListener.ISpendingStatusMonitoringResult monitorSpendingStatus(String monitoringId,
                                                                                                  byte ssrlId,
                                                                                                  String userServiceId,
                                                                                                  String[] spendingStatusIds,
                                                                                                  int ttl)
                                                                                           throws IllegalArgumentException,
                                                                                                  ForbiddenChargeException,
                                                                                                  ServerFailureException,
                                                                                                  CommunicationFailureException
```
    Manages the monitoring of spending statuses concerning the charging contract that relates to the specified userServiceId.
    The spending status monitoring is identified by the monitoringId.
    The spendingStatusIds contains the list of spending status identifiers to monitor. This list can be:
    - null: To cancel the monitoring
    - empty: To monitor all the available spending statuses for the retrieved charging contract
    - explicit: To monitor only the specified spending statuses
    The TTL "Time-To-Live" indicates a period of time (in seconds) after wich the SAP CC system automatically stops this spending status monitoring. The resend of pending spending status report(s) that relate to this monitoring is also canceled.
    
    Prerequisite
    
    Your monitoring client must implement a spending status report listener in charge of receiving and processing the spending status changes. Monitoring results are returned to the implementation of the IMonitorSpendingStatusResultListener.
    
    Note
    
    You can create, update, and cancel a spending status monitoring. You can monitor several times the same end customer.
    Parameters:
    
    monitoringId - The identifier of the spending status monitoring
    
    ssrlId - The identifier of the SpendingStausReportListener (accepted values: 1 to 127)
    
    userServiceId - The user service identifier (USID): A technical identifier of the end customer
    
    spendingStatusIds - Identifying the set of spending status to monitor
    
    ttl - The time to live given in seconds
    
    Returns:
    
    The operation result which contains the performed operation and the current label value for each monitored spending status
    
    Throws:
    IllegalArgumentException -
    
    when spendingStatusMonitoringId, userServiceId is null or empty
    
    when the ssrlId is not in the range [1, 127]
    
    when a name of the spendingStatusIds is null or empty
    
    when a name is duplicated in the spendingStatusIds
    ForbiddenChargeException - when the access is not found
    
    ServerFailureException - if the server is not available
    
    CommunicationFailureException - when a communication failure occurs

Class StatefulServiceClient

Synchronous Services and Operations

Deprecated Services and Operations

Features

Operation Results

Charging Contract Operational Status

Communication Timeout

High Performances

High Availability (HA)

Notification

Security

Implementation in Your Client Application

Initializing and Connecting

Implementing Session-Based Charging Services

System Configuration

Master Data Configuration

Implementing Event-Based Charging Services

Implementing Policy Control Services

Prerequisites

Customizing Sequence

System Configuration

Terminating

Advanced Implementation

Notes on SAP CC Implementation

Fine-Tuning

Implementing the Spending Status Monitoring Function

Prerequisites

Customizing Sequence

System Configuration

Implementing the ISpendingStatusReportListener interface

Implementing the Reservation Renewal Function

Prerequisites

Customizing Sequence

System Configuration

Implementing the IReservationRenewalListener interface

Implementing the registerReservationRenewalListener(byte, IReservationRenewalListener) method

Implementing the unregisterReservationRenewalListener(byte) method

Changing the Implementation of the Session-Based Charging APIs

Additional Information

Field Summary

Fields inherited from class com.highdeal.cnd.message.AsyncRatingServiceClient

Constructor Summary

Method Summary

Methods inherited from class com.highdeal.cnd.message.AsyncStatefulServiceClient

Methods inherited from class com.highdeal.cnd.message.AsyncRatingServiceClient

Methods inherited from class java.lang.Object

Constructor Detail

StatefulServiceClient

StatefulServiceClient

StatefulServiceClient

StatefulServiceClient

StatefulServiceClient

Method Detail

charge

charge

charge

charge

blankCharge

blankCharge

blankCharge

getEstimatedPrice

getEstimatedPrice

getEstimatedPrice

checkLimit

checkLimit

preRate

preRate

postRate

postRate

activate

activate

cleanup

cleanup

translate

translate

startRate

startRate

updateRate

updateRate

stopRate

Implementing the `ISpendingStatusReportListener` `interface`

Implementing the `IReservationRenewalListener` `interface`

Implementing the `registerReservationRenewalListener(byte, IReservationRenewalListener)` `method`

Implementing the `unregisterReservationRenewalListener(byte)` `method`