com.ibm.commerce.order.facade.client

Class CommonOrderFacadeClient

  • Direct Known Subclasses:
    OrderFacadeClient

    public class CommonOrderFacadeClient
extends AbstractOrderFacadeClient
    This class provides common methods that the order facade can use. This class also provides a set of convenient Java APIs to represent particular order operations. This set of Java APIs also includes APIs for Web-based requests to transform the name-value pair request into the appropriate request documents.

    • Field Detail

      • COPYRIGHT

        public static final java.lang.String COPYRIGHT
        the IBM Copyright notice field.
        See Also:
        Constant Field Values

      • COMPONENT_NAME

        public static final java.lang.String COMPONENT_NAME
        The component name for the order component.
        See Also:
        Constant Field Values

    • Constructor Detail

      • CommonOrderFacadeClient

        public CommonOrderFacadeClient()
        The default constructor of the class.

      • CommonOrderFacadeClient

        public CommonOrderFacadeClient(BusinessContextType businessContext,
                               javax.security.auth.callback.CallbackHandler callbackHandler)
        This method constructs an object by business context and call back handler.
        Parameters:
        businessContext - The business context.
        callbackHandler - The call back handler.

    • Method Detail

      • createGetOrder

        public GetOrderType createGetOrder()
        This method returns a new instance of the GetOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the GetOrder object that is associated with a container.

      • createShowOrder

        public ShowOrderType createShowOrder()
        This method returns a new instance of the ShowOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the ShowOrder object that is associated with a container.

      • createProcessOrder

        public ProcessOrderType createProcessOrder()
        This method returns a new instance of the ProcessOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the ProcessOrder object that is associated with a container.

      • createChangeOrder

        public ChangeOrderType createChangeOrder()
        This method creates an instance of ChangeOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the ChangeOrder object that is associated with a container.

      • createSyncOrder

        public SyncOrderType createSyncOrder()
        This method creates an instance of SyncOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the SyncOrder object that is associated with a container.

      • createAcknowledgeOrder

        public AcknowledgeOrderType createAcknowledgeOrder()
        This method returns a new instance of the AcknowledgeOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the AcknowledgeOrder object that is associated with a container.

      • createRespondOrder

        public RespondOrderType createRespondOrder()
        This method returns a new instance of the RespondOrder object. This object is associated with a container object to convert the object into an XML document.
        Returns:
        A new instance of the RespondOrder object that is associated with a container.

      • addOrderItem

        public java.util.Map addOrderItem(java.util.Map parameters)
                           throws OrderException
        This method adds an order item.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("quantity", new String[] { "3", "4" });
      parameters.put("catEntryId", new String[] { "10002", "10003" });
      parameters.put("contractId", new String[] { "10001", "10001" });
      parameters.put("UOM", new String[] { "C62", "C62" });
      parameters.put("calculationUsage", new String[] { "-1,-7" });
      parameters.put("externalId",new String[] {"10001", "10002"});
      parameters.put("giftMessage",new String[]{"a message to giver","another message to giver"};
      parameters.put("shipToRegistrant", new String[]{"1","1"};
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.addOrderItem(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outOrderItemId = (String[]) response.get("orderItemId");
        The behavior is:
        1. Calls the buildOrderItem(Map, String) method to build order item request information according to the given parameters.
        2. Calls the buildOrderIdentifier(Map, String) method to build the order identifier object.
        3. Calls the addOrderItem(OrderIdentifierType, OrderItemType[]) method to send the request to add the order items to the order.
        Parameters:
        parameters - The map that contains the following keys: orderId , quantity, catEntryId, contractId, UOM, externalId, giftMessage and shipToRegistrant. The last three parameters, externalId, giftMessage and shipToRegistrant are related with gift list. They should be put into the map when the order item is a gift which is purchased by the gift giver. 
                  orderId: The order ID of the order to which the order item will be added; 
              if no order ID is proviede, the current pending order is used. 
          quantity: The quantity of the added product. 
          catEntryId: The catalog entry ID of the added product. 
          contractId: The contract ID of the contract on which the order item addition is based.
          UOM: The unit of measure of the order item.
          externalId: The external gift list id.
          giftMessage: The gift message along with the gift. 
          shipToRegistrant: A parameter indicating to ship the gift to register or shopper.
        Returns:
        The map that contains the orderId and orderItemId.
        orderId: The order ID of the order to which the order item will be added.
        orderItemId: The new order item ID.
        Throws:
        OrderException

      • deleteOrderItem

        public java.util.Map deleteOrderItem(java.util.Map parameters)
                              throws OrderException
        This method deletes order items.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderItemId", new String[] { "10002", "10003" });
      parameters.put("calculationUsage", new String[] { "-1,-7" });
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.deleteOrderItem(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        The behavior is:
        1. Calls the buildOrderItem(Map, String) method to build order item request information according to the given parameters.
        2. Calls the buildOrderIdentifier(Map, String) method to build the order identifier object.
        3. Calls the updateOrderItem(OrderIdentifierType, OrderItemType[]) method to send the request to delete the order items from the order.
        Parameters:
        parameters - The map that contains the orderId, and the orderItemId. 
                  <code>orderId</code>: An optional parameter that contains the order ID of the 
               order from which the order item will be deleted.
          <code>orderItemId</code>: The order item ID to delete.
        Returns:
        The Map that contains the orderId. orderId: The order ID from which the order item will be deleted.
        Throws:
        OrderException

      • updateOrderItem

        public java.util.Map updateOrderItem(java.util.Map parameters)
                              throws OrderException
        This method updates multiple order items of an order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("quantity",new String[]{"30","40"});
      parameters.put("orderItemId",new String[]{orderItemId1,orderItemId2});
      parameters.put("contractId",new String[]{"10001","10001"});
      parameters.put("UOM",new String[]{"C62","C62"});
      parameters.put("calculationUsage", new String[] { "-1,-7" });
      parameters.put("externalId",new String[] {"10001", "10002"});
      parameters.put("giftMessage",new String[]{"a message along with the gift","another message along with the gift"};
      parameters.put("shipToRegistrant", new String[]{"1","1"};
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.updateOrderItem(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outOrderItemId = (String[]) response.get("orderItemId");
        The behavior is:
        1. Calls the buildOrderItem(Map, String) method to build order item request information according to the given parameters.
        2. Calls the buildOrderIdentifier(Map, String) method to build the order identifier object.
        3. Calls the updateOrderItem(OrderIdentifierType, OrderItemType[]) method to send the request to update the order items to the order.
        Parameters:
        parameters - The map that contains the quantity, orderId, orderItemId, contractId, and UOM, externalId, giftMessage and shipToRegistrant. The last three parameters, externalId, giftMessage and shipToRegistrant are related with gift list. They should be put into the map when the order item is a gift which is purchased by the gift giver. 
                  <code>orderId</code>: An optional parameter that contains the order ID of the order that contains the order items to update.
          <code>quantity</code>: The quantity of the updated product. 
          <code>orderItemId</code>: The order item ID to be updated. 
          <code>contractId</code>: The contract ID of the contract on which the order item update is based.
          <code>UOM</code>: The unit of measure of the order item.
          <code>externalId</code>: The external gift list id.
          <code>giftMessage</code>: The gift message along with the gift. 
          <code>shipToRegistrant</code>: A parameter indicating to ship the gift to register or shopper.
        Returns:
        The map that contains the orderId and the orderItemId.
        orderId: The order ID of the order that contains the updated order items.
        orderItemId: The updated order item ID.
        Throws:
        OrderException

      • updateOrderShippingInfo

        public java.util.Map updateOrderShippingInfo(java.util.Map parameters)
                                      throws OrderException
        This method updates the shipping information of the order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("ShipAsComplete",new String[]{"N"});
      parameters.put("orderId",new String[]{"10001"});
      parameters.put("requestedShipDate",new String[]{"2006-12-24T03:32:34.953Z"});
      parameters.put("shipModeId",new String[]{"10001"});
      parameters.put("addressId",new String[]{"11301"});
      parameters.put("shipInstructions",new String[]{"hello"});
      parameters.put("orderItemId",new String[]{"120001"});
      parameters.put("calculationUsage", new String[] { "-1,-7" });
      parameters.put("allocate", new String[]{"*aig,*ubg"});
      parameters.put("backorder", new String[]{"***"});
      parameters.put("externalId",new String[] {"10001", "10002"});
      parameters.put("giftMessage",new String[]{"a message along with the gift","another message along with the gift"};
      parameters.put("shipToRegistrant", new String[]{"1","1"};
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.updateOrderShippingInfo(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outOrderItemId = (String[]) response.get("orderItemId");
        The behavior is:
        1. Calls the buildOrderItem(Map, String) method to build order item request information according to the given parameters.
        2. Calls the buildOrderIdentifier(Map, String) method to build the order identifier object.
        3. Calls the updateOrderShippingInfo(OrderIdentifierType, Boolean, OrderItemType[]) method to send the request to update the order shipping information.
        Parameters:
        parameters - The map that contains the following keys: ShipAsComplete, orderId, orderItemId, requestedShipDate, shipModeId, isExpedited, addressId, shipInstructions, and tieShipCode, externalId, giftMessage and shipToRegistrant. The last three parameters, externalId, giftMessage and shipToRegistrant are related with gift list. They should be put into the map when the order item is a gift which is purchased by the gift giver. 
                  <code>orderId</code>: The order ID to be updated. 
          <code>orderItemId</code>: The order item ID to be updated. 
          <code>ShipAsComplete</code>: The flag which specifies whether the order is shipped as complete. 
          <code>requestedShipDate</code>: The requested ship date of the order item.
          <code>shipModeId</code>: The ship mode ID.
          <code>isExpedited</code>: The value to specify whether the ship information is expedited. 
          <code>addressId</code>: The address ID.
          <code>shipInstructions</code>: The ship instructions of the order.
          <code>tieShipCode</code>: The tie ship code.
          <code>externalId</code>: The external gift list id.
          <code>giftMessage</code>: The gift message along with the gift. 
          <code>shipToRegistrant</code>: A parameter indicating to ship the gift to register or shopper.
        Returns:
        The map that contains the orderId, and the orderItemId.
        orderId: The order ID of the order on which the ship information update is based.
        orderItemId: The updated order item ID.
        Throws:
        OrderException

      • updateOrderGiftInfo

        public java.util.Map updateOrderGiftInfo(java.util.Map parameters)
                                  throws OrderException
        This method updates the gift information of the order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();    
      parameters.put("orderId",new String[]{"10001"});
      parameters.put("giftMessage",new String[]{"Happy Birthday"};
      parameters.put("shipToRegistrant", new String[]{"1"};
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.updateOrderGiftInfo(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outOrderItemId = (String[]) response.get("orderItemId");
        The behavior is:
        1. Calls the buildOrder(Map, String) method to build the order identifier object.
        2. Calls the updateOrderGiftInfo(OrderIdentifierType, Map) method to send the request to update the order gift information.
        Parameters:
        parameters - The map that contains the following keys: orderId, giftMessage and shipToRegistrant. The two parameters, giftMessage and shipToRegistrant are specific for Gift Registry. They apply to all the gift items inside the order which is purchased by the gift giver. 
                  <code>orderId</code>: The order ID to be updated. 
          <code>giftMessage</code>: The gift message along with the gift. 
          <code>shipToRegistrant</code>: A parameter indicating to ship the gift to register or shopper.
        Returns:
        The map that contains the orderId, and the orderItemId.
        orderId: The order ID of the order on which the gift information update is based.
        orderItemId: The updated order item ID.
        Throws:
        OrderException

      • cancelShoppingCart

        public java.util.Map cancelShoppingCart(java.util.Map parameters)
                                 throws OrderException
        This method deletes the order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderId", new String[] { "10001" });
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.cancelShoppingCart(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        Parameters:
        parameters - The map that contains: orderId. 
                  <code>orderId</code>: The order ID of the order to delete.
        Returns:
        The map that contains the deleted orderId. orderId: The order ID of the order to be canceled.
        Throws:
        OrderException

      • updateRewardOption

        public java.util.Map updateRewardOption(java.util.Map parameters)
                                 throws OrderException
        This method updates the reward option.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderId",new String[]{"10001"});
      parameters.put("rewardOptionId",new String[]{"801"});
      parameters.put("catEntryId",new String[]{"10254", "10252"});
      parameters.put("quantity",new String[]{"1", "1"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.updateRewardOption(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        The behavior is:
        1. Calls the buildOrder(Map, String) method to build the order object.
        2. Calls the buildRewardOption(Map, String) method to build reward option request information according to the given parameters.
        3. Calls the updateRewardOption(OrderIdentifierType, RewardOptionType) method to send the request to update the reward option information.
        Parameters:
        parameters - The map that contains the following keys: orderId , rewardOptionId, catEntryId, quantity and optionally the UOM of the quantity. 
                      <code>orderId</code>: The order ID to which the reward option will be updated. 
              <code>rewardOptionId</code>: The reward option ID to update. 
              <code>catEntryId</code>: The ID of the catalog entry chosen. 
              <code>quantity</code>: The quantity of the catalog entry chosen. 
              <code>UOM</code>: The unit of measure of the quantity of the catalog entry chosen. If
              nothing is specified, then the default value of "C62" is used.
        Returns:
        The Map that contains the orderId.
        orderId: The order ID of the order to which the reward option is updated.
        Throws:
        OrderException

      • addPaymentInstruction

        public java.util.Map addPaymentInstruction(java.util.Map parameters)
                                    throws OrderException
        This method adds the payment instruction list.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderId",new String[]{"10001"});
      parameters.put("payMethodId",new String[]{"VISA"});
      parameters.put("piAmount",new String[]{"200"});
      parameters.put("billing_address_id",new String[]{"11301"});
      parameters.put("account",new String[]{"4111111111111111"});
      parameters.put("cc_brand",new String[]{"VISA"});
      parameters.put("expire_month",new String[]{"12"});
      parameters.put("expire_year",new String[]{"2009"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.addPaymentInstruction(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outpiId = (String[]) response.get("piId");
        Parameters:
        parameters - The map that contains the following keys: orderId , payMethodId, piAmount, paymentTCId, billing_address_id and protocol data (such as account, and expire_year). 
                      <code>orderId</code>: The order ID to which the payment instruction will be added; 
              <code>payMethodId</code>: The payment method. 
              <code>piAmount</code>: The amount of the payment instruction. 
              <code>paymentTCId</code>: The <code>paymentTC</code> ID. 
              <code>billing_address_id</code>: The billing address of the payment instruction.
        Returns:
        The Map that contains the orderId and the piId list.
        orderId: The order ID of the order to which the payment instruction is added.
        piId: The payment instruction identifier to be added.
        Throws:
        OrderException

      • updatePaymentInstruction

        public java.util.Map updatePaymentInstruction(java.util.Map parameters)
                                       throws OrderException
        This method updates the payment instruction list.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("piId",new String[]{"10002"});
      parameters.put("orderId",new String[]{"10001"});
      parameters.put("payMethodId",new String[]{"VISA"});
      parameters.put("piAmount",new String[]{"300"});
      parameters.put("billing_address_id",new String[]{"11301"});
      parameters.put("account",new String[]{"4111111111111111"});
      parameters.put("cc_brand",new String[]{"VISA"});
      parameters.put("expire_month",new String[]{"12"});
      parameters.put("expire_year",new String[]{"2009"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.updatePaymentInstruction(parameters);
      String[] outorderId = (String[]) response.get("orderId");
      String[] outpiId = (String[]) response.get("piId");
        Parameters:
        parameters - The map that contains the following keys: orderId, piId, payMethodId, piAmount, paymentTCId, billing_address_id and protocol data (such as account, and expire_year). 
                      orderId: The order ID of the order for which the payment instruction will be updated. 
              piId: The payment instruction to be updated.
              payMethodId: The payment method. 
              piAmount: The amount of the payment instruction. 
              paymentTCId : The <code>paymentTC</code> ID. 
              <code>billing_address_id</code>: The billing address of the payment instruction.
        Returns:
        The Map that contains orderId and the piId list.
        orderId: The order ID of the order for which the payment instruction is updated.
        piId: The payment instruction identifier to be updated.
        Throws:
        OrderException

      • removePaymentInstruction

        public java.util.Map removePaymentInstruction(java.util.Map parameters)
                                       throws OrderException,
                                              java.lang.NumberFormatException
        This method removes the list of payment instructions.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("piId",new String[]{"10002"});
      parameters.put("orderId",new String[]{"10001"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.removePaymentInstruction(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        Parameters:
        parameters - The map that contains the orderId, and the piId. 
                  <code>orderId</code>: The order ID of the order from which the payment instruction will be deleted.
          <code>piId</code>: The payment instruction to be deleted.
        Returns:
        The map that contains the orderId.
        orderId: The order ID.
        Throws:
        OrderException
        java.lang.NumberFormatException

      • prepareOrder

        public java.util.Map prepareOrder(java.util.Map parameters)
                           throws OrderException
        This method prepares the order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderId", new String[] { "10001"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.prepareOrder(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        Parameters:
        parameters - The map that contains the orderId.
        orderId: The order ID of the order to prepare.
        Returns:
        The map that contains the orderId.
        orderId: The order ID that has been prepared.
        Throws:
        OrderException

      • submitOrder

        public java.util.Map submitOrder(java.util.Map parameters)
                          throws OrderException
        This method submits the order.
        The following sample code demonstrates how to use the API: 
              Map parameters = new HashMap();
      parameters.put("orderId", new String[] { "10001"});
      OrderFacadeClient client = new OrderFacadeClient(businessContext,null);
      Map response = client.submitOrder(parameters);
      String[] outorderId = (String[]) response.get("orderId");
        Parameters:
        parameters - The map that contains the following keys: purchaseorder_id, orderId, payMethodId, piAmount, paymentTCId, billing_address_id, order notification parameters, and protocol data. 
                      purchaseorder_id: The purchase order ID.
              orderId: The order ID to be submitted.
              orderId: The order ID to be submitted.
              payMethodId: The ID of the payment method.
              piAmount: The amount of the payment instruction of the order.
              paymentTCId: The <code>paymentTC</code> ID.
              billing_address_id: The billing address of the payment instruction.
              updateChannelId: Whether to update business channel id for order
                      "Y" indicates that business channel id need to be updated
                      "N" indicates that business channel id does not need to be updated
        Returns:
        The map that contains the orderId.
        orderId: The order ID which is submitted.
        Throws:
        OrderException

      • addOrderItem

        public RespondOrderDataAreaType addOrderItem(java.lang.String actionCode,
                                             OrderType order,
                                             OrderItemType[] orderItems)
                                      throws OrderException
        This method adds an order item.
        Parameters:
        actionCode - The action code to use for the service
        order - The order to which the order items are added.
        orderItems - An array of order items to be added.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and order item IDs.
        Throws:
        OrderException

      • updateOrderItem

        public RespondOrderDataAreaType updateOrderItem(OrderType order,
                                                OrderItemType[] orderItems)
                                         throws OrderException
        This method updates order items.
        Parameters:
        order - The order to be updated.
        orderItems - An array of order items to be updated.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and order item IDs.
        Throws:
        OrderException

      • updateOrderShippingInfo

        public RespondOrderDataAreaType updateOrderShippingInfo(OrderType order,
                                                        OrderItemType[] orderItems)
                                                 throws OrderException
        This method updates the shipping information of the order.
        Parameters:
        order - The order for which to update the shipping information.
        orderItems - The order items to be updated.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and order item IDs.
        Throws:
        OrderException

      • addPaymentInstruction

        public RespondOrderDataAreaType addPaymentInstruction(OrderIdentifierType orderId,
                                                      PaymentInstructionType[] paymentInstructions)
                                               throws OrderException
        This method adds payment instructions for an order.
        Parameters:
        orderId - The order ID of the order to which the payment instructions are added.
        paymentInstructions - The payment instructions list to be added.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and payment instructions.
        Throws:
        OrderException

      • updatePaymentInstruction

        public RespondOrderDataAreaType updatePaymentInstruction(OrderIdentifierType orderId,
                                                         PaymentInstructionType[] paymentInstructions)
                                                  throws OrderException
        This method updates the payment instructions.
        Parameters:
        orderId - The order for which the payment instructions are updated.
        paymentInstructions - The payment instructions list to be added.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and payment instructions.
        Throws:
        OrderException

      • removePaymentInstruction

        public RespondOrderDataAreaType removePaymentInstruction(OrderIdentifierType orderId,
                                                         PaymentInstructionType[] paymentInstruction)
                                                  throws OrderException
        This method removes the payment instructions.
        Parameters:
        orderId - The ID of the order from which the payment instructions are removed.
        paymentInstruction - The payment instructions to be removed.
        Returns:
        The RespondOrderDataAreaType that contains the orderId and payment instructions.
        Throws:
        OrderException

      • processOrder

        public AcknowledgeOrderDataAreaType processOrder(java.lang.String action,
                                                 OrderType order)
                                          throws OrderException
        This method processes the order.
        Parameters:
        action - The action for processing the order.
        order - The order to be processed.
        Returns:
        The AcknowledgeOrderDataAreaType that contains the order ID.
        Throws:
        OrderException

      • processOrder

        public AcknowledgeOrderDataAreaType processOrder(java.lang.String action,
                                                 OrderType order,
                                                 java.lang.String expression)
        This method processes the order.
        Parameters:
        action - The action for processing the order.
        order - The order to be processed.
        expression - the expression.
        Returns:
        The AcknowledgeOrderDataAreaType that contains the order ID.

      • syncOrder

        public ConfirmBODType syncOrder(java.lang.String actionCode,
                                OrderType order)
                         throws OrderException
        This method synchronizes the order.
        Parameters:
        actionCode - The action code for synchronizing the order.
        order - The order to be synchronized.
        Returns:
        ConfirmBODType which indicates success or failure.
        Throws:
        OrderException - if an error occurs.

      • syncOrder

        public ConfirmBODType syncOrder(java.lang.String actionCode,
                                OrderType order,
                                java.lang.String expression)
                         throws OrderException
        This method synchronizes the order.
        Parameters:
        actionCode - The action code for synchronizing the order.
        order - The order to be synchronized.
        expression - The expression.
        Returns:
        ConfirmBODType which indicates success or failure.
        Throws:
        OrderException - if an error occurs.

      • changeOrder

        public RespondOrderDataAreaType changeOrder(java.lang.String action,
                                            OrderType order,
                                            java.lang.String expression)
                                     throws OrderException
        This method changes the order.
        Parameters:
        action - The action for changing order.
        order - The order to be changed.
        expression - The expression.
        Returns:
        The AcknowledgeOrderDataAreaType that contains the order ID.
        Throws:
        OrderException

      • findShoppingCartItemsWithValue

        public ShowOrderDataAreaType findShoppingCartItemsWithValue(java.lang.String storeId,
                                                            java.lang.String memberId,
                                                            java.lang.String dispayCurrency,
                                                            java.lang.String startCreateDate,
                                                            java.lang.String endCreateDate,
                                                            java.math.BigInteger recordSetStartNumber,
                                                            java.math.BigInteger maxItems)
                                                     throws OrderException
        This method retrieves the items in a customer's shopping cart.
        Parameters:
        storeId - The store ID.
        memberId - The member ID.
        dispayCurrency - The currency to display the order item amount.
        startCreateDate - The beginning of create date.
        endCreateDate - The end of create date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum number of the shopping cart items to be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findShoppingCartItemsWithProductID

        public ShowOrderDataAreaType findShoppingCartItemsWithProductID(java.lang.String storeId,
                                                                java.lang.String memberId,
                                                                java.lang.String startCreateDate,
                                                                java.lang.String endCreateDate,
                                                                java.math.BigInteger recordSetStartNumber,
                                                                java.math.BigInteger maxItems)
                                                         throws OrderException
        This method retrieves items and their values, and quantities from a customer's shopping cart.
        Parameters:
        storeId - The store ID.
        memberId - The member IDs.
        startCreateDate - The beginning of create date.
        endCreateDate - The end of create date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum number of the shopping cart items to be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findPurchaseHistoryItemsWithValue

        public ShowOrderDataAreaType findPurchaseHistoryItemsWithValue(java.lang.String storeId,
                                                               java.lang.String[] memberIds,
                                                               java.lang.String dispayCurrency,
                                                               java.lang.String startCreateDate,
                                                               java.lang.String endCreateDate,
                                                               java.math.BigInteger recordSetStartNumber,
                                                               java.math.BigInteger maxItems)
                                                        throws OrderException
        This method retrieves a customer's purchased order items and their values, and quantities.
        Parameters:
        storeId - The store ID.
        memberIds - The member IDs.
        dispayCurrency - The currency to display the order item amount.
        startCreateDate - The beginning of create date.
        endCreateDate - The end of create date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum number of the shopping cart items to be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findPurchaseHistoryItemsWithProductID

        public ShowOrderDataAreaType findPurchaseHistoryItemsWithProductID(java.lang.String storeId,
                                                                   java.lang.String[] memberIds,
                                                                   java.lang.String startCreateDate,
                                                                   java.lang.String endCreateDate,
                                                                   java.math.BigInteger recordSetStartNumber,
                                                                   java.math.BigInteger maxItems)
                                                            throws OrderException
        This method retrieves the order items that customers have purchased.
        Parameters:
        storeId - The store ID.
        memberIds - The member IDs.
        startCreateDate - The beginning of create date.
        endCreateDate - The end of create date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum number of order items to be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findPurchaseHistory

        public ShowOrderDataAreaType findPurchaseHistory(java.lang.String storeId,
                                                 java.lang.String[] memberIds,
                                                 java.lang.String dispayCurrency,
                                                 java.lang.String startPlacedDate,
                                                 java.lang.String endPlacedDate,
                                                 java.math.BigInteger recordSetStartNumber,
                                                 java.math.BigInteger maxItems)
                                          throws OrderException
        This method retrieves the customers' purchase history.
        Parameters:
        storeId - The store ID.
        memberIds - The member IDs.
        dispayCurrency - The currency in which the application displays the order amount.
        startPlacedDate - The beginning of placed date.
        endPlacedDate - The end of placed date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum of items returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findOrderItemByStoreMemberAndCreateDate

        public ShowOrderDataAreaType findOrderItemByStoreMemberAndCreateDate(java.lang.String strAccessProfile,
                                                                     java.lang.String[] orderItemStatuses,
                                                                     java.lang.String storeId,
                                                                     java.lang.String[] memberIds,
                                                                     java.lang.String dispayCurrency,
                                                                     java.lang.String startCreateDate,
                                                                     java.lang.String endCreateDate,
                                                                     java.math.BigInteger recordSetStartNumber,
                                                                     java.math.BigInteger maxItems)
                                                              throws OrderException
        This method retrieves order items according to the given store ID, member IDs, and create date.
        Parameters:
        strAccessProfile - The access profile.
        orderItemStatuses - The order item statuses.
        storeId - The store ID.
        memberIds - The member IDs.
        dispayCurrency - The currency in which the application displays the order item amount.
        startCreateDate - The beginning of create date.
        endCreateDate - The end of create date.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null, no pagination will be performed. If not null, should be >= 0. If < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, no pagination will be performed. If not null, should be > 0. If <= 0, no items will be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findOrderByStoreMemberAndPlacedDate

        public ShowOrderDataAreaType findOrderByStoreMemberAndPlacedDate(java.lang.String strAccessProfile,
                                                                 java.lang.String[] orderStatuses,
                                                                 java.lang.String storeId,
                                                                 java.lang.String[] memberIds,
                                                                 java.lang.String dispayCurrency,
                                                                 java.lang.String startPlacedDate,
                                                                 java.lang.String endPlacedDate,
                                                                 java.math.BigInteger recordSetStartNumber,
                                                                 java.math.BigInteger maxItems)
                                                          throws OrderException
        This method retrieves orders according to the give store ID, member IDs, and placed date.
        Parameters:
        strAccessProfile - The access profile.
        orderStatuses - The order statuses.
        storeId - The store ID.
        memberIds - The member IDs.
        dispayCurrency - The currency to display the order amount.
        startPlacedDate - The beginning of placed date.
        endPlacedDate - The end of placed date.
        recordSetStartNumber - The record set start number.
        maxItems - The maximum of items returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findByOrderStatus

        public ShowOrderDataAreaType findByOrderStatus(java.lang.String[] orderStatusTypes,
                                               boolean isSummary)
                                        throws OrderException
        This method retrieves orders according to the given status.
        Parameters:
        orderStatusTypes - The array of order status.
        isSummary - The boolean value to specify whether it is a summary.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findByOrderStatus

        public ShowOrderDataAreaType findByOrderStatus(java.lang.String[] orderStatusTypes,
                                               boolean isSummary,
                                               java.math.BigInteger recordSetStartNumber,
                                               java.math.BigInteger maxItems)
                                        throws OrderException
        This method retrieves orders according to the given status.
        Parameters:
        orderStatusTypes - The array of order status.
        isSummary - The boolean value to specify whether it is a summary.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • findByOrderId

        public ShowOrderDataAreaType findByOrderId(java.lang.String[] orderIdTypes,
                                           boolean isSummary)
                                    throws OrderException
        Retrieves orders based on their order IDs, and specifies the level of detail of the returned data. If isSummary is false, the number of order items returned will be bounded by a default value.
        Parameters:
        orderIdTypes - An array which contains the order ID of all the orders to find. Cannot be null.
        isSummary - A value of true indicates that only summary data for the orders should be returned, false indicates that details should be returned for the orders.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findByOrderId

        public ShowOrderDataAreaType findByOrderId(java.lang.String[] orderIDs,
                                           java.lang.String accessProfile)
                                    throws OrderException
        Retrieves orders based on their order IDs, and specifies the level of detail of the returned data.
        Parameters:
        orderIDs - An array which contains the order ID of all the orders to find. Cannot be null.
        accessProfile - The access profile, like "IBM_Summary", "IBM_Details". Cannot be null or empty.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findByOrderId

        public ShowOrderDataAreaType findByOrderId(java.lang.String orderID,
                                           java.math.BigInteger recordSetStartNumber,
                                           java.math.BigInteger maxItems)
                                    throws OrderException
        Retrieves a single order based on its order ID, and whether noun-parts should be paginated.
        Parameters:
        orderID - The ID of the order to return.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findCurrentShoppingCart

        public ShowOrderDataAreaType findCurrentShoppingCart(boolean isSummary)
                                              throws OrderException
        Retrieves the order that represents the current shopping cart, and specifies the level of detail of the returned data. There will be no sorting or pagination of noun-parts.
        Parameters:
        isSummary - A value of true indicates that only summary data for the order should be returned, false indicates that details should be returned for the order.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findCurrentShoppingCart

        public ShowOrderDataAreaType findCurrentShoppingCart(boolean isSummary,
                                                     java.lang.String sortOrderItemBy)
                                              throws OrderException
        Retrieves the order that represents the current shopping cart, and specifies the level of detail of the returned data. The sorting behaviour can also be specified.
        Parameters:
        isSummary - A value of true indicates that only summary data for the order should be returned, false indicates that details should be returned for the order.
        sortOrderItemBy - The name of the element to sort the orders by. If null, no sorting will be performed. If not null, must be a valid element name for a noun or noun-part.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findCurrentShoppingCart

        public ShowOrderDataAreaType findCurrentShoppingCart(java.lang.String sortOrderItemBy,
                                                     java.math.BigInteger recordSetStartNumber,
                                                     java.math.BigInteger maxItems)
                                              throws OrderException
        Retrieves the order that represents the current shopping cart, and how sorting and pagination are to be performed.
        Parameters:
        sortOrderItemBy - The name of the element to sort the orders by. If null, no sorting will be performed. If not null, must be a valid element name for a noun or noun-part.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • findUsablePaymentOrShipInformation

        public ShowOrderDataAreaType findUsablePaymentOrShipInformation(java.lang.String[] orderIdTypes,
                                                                boolean isPaymentInfo)
                                                         throws OrderException
        This method finds usable payment or shipping information for the specified order.
        Parameters:
        orderIdTypes - The array of order IDs.
        isPaymentInfo - The boolean value used to specify whether to find payment information.
        Returns:
        The usable payment or shipping information.
        Throws:
        OrderException

      • createGetVerb

        public static GetType createGetVerb(ExpressionType selectionCriteriaExpression,
                                    java.lang.String recordSetReferenceId,
                                    int recordSetStartNumber,
                                    int maxItems)
        This is a utility method to create the Get verb. This method returns a new instance of the get verb and a single expression type that contains the expression specified.
        Parameters:
        selectionCriteriaExpression - A list of ExpressionType for the request.
        recordSetReferenceId - The internal identifier for the result set, so that it can be resolved on a subsequent request.
        recordSetStartNumber - The start index of the noun-part to be paginated. Should be >= 0. If < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. Should be > 0. If <= 0, then no items will be returned.
        Returns:
        A new instance of the get verb object. This get verb will contain the specified expressions.

      • findUsableShippingInfoByOrderID

        public ShowOrderDataAreaType findUsableShippingInfoByOrderID(java.lang.String orderID,
                                                             java.math.BigInteger recordSetStartNumber,
                                                             java.math.BigInteger maxItems)
                                                      throws OrderException
        Retrieves the usable shipping information of a particular order. Usable shipping information includes the shipping addresses and shipping modes that are applicable for the current shopper.
        Parameters:
        orderID - The ID of the order.
        recordSetStartNumber - The start index of the order item to be paginated. If null, no pagination will be performed. If not null, should be >= 0. If < 0, 0 will be used instead.
        maxItems - The number of order items per page. If null, no pagination will be performed. If not null, should be > 0. If <= 0, no items will be returned.
        Returns:
        The returned data from the "Order" Show action. Will not be null.
        Throws:
        OrderException - If there was an error in the Get action data.

      • scheduleOrder

        public java.util.Map scheduleOrder(java.util.Map parameters)
                            throws OrderException
        This method creates a schedule order which related to a schedule job.

        The following sample code demonstrates how to use the API: 
                        Map parameters = new HashMap();
                parameters.put("orderId",new String[]{"10001"});
                parameters.put("strStartDate",new String[]{"2006-12-24T03:32:34.953Z"});
      parameters.put("interval",new String[]{"10"});
      parameters.put("PONumber", new String[]{"PONumber101"});
                Map response = client.scheduleOrder(parameters);
                String[] outorderId = (String[]) response.get("orderId");
        The behavior is:
        1. Invokes the com.ibm.commerce.order.commands.OrderScheduleCmd command to create a schedule order.
        2. After scheduled success, it will return the schedule orderId.
        3. When input start time or interval format is wrong, this method will throw out an exception.
        Parameters:
        parameters - The map that contains: orderId,strStartDate, interval. 
                  <code>orderId</code>: The order ID of the order to be schedule.
          <code>strStartDate</code>: The start date of the scheduled order.
          <code>interval</code>: The time interval of the repeated schedule task.
        Returns:
        The map that contains the scheduled orderId. orderId: The order ID of the order to be scheduled.
        Throws:
        OrderException

      • findScheduledOrder

        public ShowOrderDataAreaType findScheduledOrder(boolean isSummary,
                                                java.lang.String memberId,
                                                java.lang.String storeId,
                                                java.lang.String startTime,
                                                java.math.BigInteger recordSetStartNumber,
                                                java.math.BigInteger maxItems)
                                         throws OrderException
        This method retrieves scheduled orders according to the start time, member and store. Pagination is supported.
        Parameters:
        isSummary - A value of true indicates that only summary data for the order should be returned, false indicates that details should be returned for the order.
        memberId - The member ID.
        storeId - The store ID.
        startTime - The start time line of scheduled job.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null, no pagination will be performed. If not null, should be >= 0. If < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, no pagination will be performed. If not null, should be > 0. If <= 0, no items will be returned.
        Returns:
        The value of "Order" containment reference list.
        Throws:
        OrderException

      • cancelScheduledOrder

        public java.util.Map cancelScheduledOrder(java.util.Map parameters)
                                   throws OrderException
        This method cancels a scheduled order and deactivates the related schedule job.

        The following sample code demonstrates how to use the API: 

                        Map parameters = new HashMap();
                parameters.put("orderId",new String[]{"10001"});
                Map response = client.cancelScheduledOrder(parameters);
                String[] outorderId = (String[]) response.get("orderId");
        The behavior is:
        1. Invokes the com.ibm.commerce.order.commands.ScheduledOrderCancelCmd command to cancel a scheduled order.
        2. After canceled success, it will return the canceled scheduled orderId.
        3. When input orderId is wrong, this method will throw out an exception.
        Parameters:
        parameters - The map that contains: orderId. 
                      orderId: The order ID of the order to be schedule.
        Returns:
        The map that contains the canceled scheduled orderId. orderId: The order ID of the order to be canceled.
        Throws:
        OrderException

      • findOrderByExternalOrderID

        public ShowOrderDataAreaType findOrderByExternalOrderID(java.lang.String[] astrOrderId,
                                                        boolean isSummary,
                                                        java.math.BigInteger recordSetStartNumber,
                                                        java.math.BigInteger maxItems)
                                                 throws OrderException
        This method retrieves orders from external system according to the given external order id.
        Parameters:
        astrOrderId - the array of external order identifier.
        isSummary - A value of true indicates that only summary data for the order should be returned, false indicates that details should be returned for the order.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The value of "order" containment reference list.
        Throws:
        OrderException - if there was an error in the Get action data.

      • findQuoteByExternalQuoteID

        public ShowQuoteDataAreaType findQuoteByExternalQuoteID(java.lang.String[] astrQuoteId,
                                                        boolean isSummary,
                                                        java.math.BigInteger recordSetStartNumber,
                                                        java.math.BigInteger maxItems)
                                                 throws QuoteException
        This method retrieves quotes according to the given quote id.
        Parameters:
        astrQuoteId - the array of external quote identifier.
        isSummary - A value of true indicates that only summary data for the order should be returned, false indicates that details should be returned for the order.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The value of "Quote" containment reference list.
        Throws:
        QuoteException

      • findQuotesByStatus

        public ShowQuoteDataAreaType findQuotesByStatus(java.lang.String[] orderStatusTypes,
                                                boolean isSummary,
                                                java.math.BigInteger recordSetStartNumber,
                                                java.math.BigInteger maxItems)
                                         throws QuoteException
        This method retrieves quotes according to the given status.
        Parameters:
        orderStatusTypes - The array of order status.
        isSummary - The boolean value to specify whether it is a summary.
        recordSetStartNumber - The start index of the noun-part to be paginated. If null or < 0, 0 will be used instead.
        maxItems - The number of noun-parts per page. If null, a default value will be used. If not null, should be > 0, but will be bounded by a maximum value. If <= 0, no items will be returned.
        Returns:
        The value of "Quote" containment reference list.
        Throws:
        QuoteException

      • repay

        public java.util.Map repay(java.util.Map parameters)
                    throws OrderException
        It will send a BOD with process verb and action code 'Repay' to order server. It will construct a SDO and invoke repay(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • findConfigurationByOrderItemId

        public ShowOrderDataAreaType findConfigurationByOrderItemId(java.lang.String orderItemId)
                                                     throws OrderException
        This method retrieves order item configuration according to the given order item id.
        Parameters:
        orderItemId - The order item id. CatEntry type of this order item should be DynamicKitBean
        Returns:
        The returned data from the "Order" Show action. It contains order item id and order item configuration.
        Throws:
        OrderException

      • applyCoupon

        public java.util.Map applyCoupon(java.util.Map parameters)
                          throws OrderException
        It will send a BOD with process verb and action code 'ApplyCoupon' to order server. It will construct a SDO and invoke applyCoupon(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • applyCoupon

        public AcknowledgeOrderDataAreaType applyCoupon(OrderType order)
                                         throws OrderException
        It will send a BOD with process verb and action code 'ApplyCoupon' to order server.
        Parameters:
        order - SDO sent to server to do the applyCoupon action.
        Returns:
        response from server
        Throws:
        OrderException - if any errors occur.

      • removeCoupon

        public java.util.Map removeCoupon(java.util.Map parameters)
                           throws OrderException
        It will send a BOD with process verb and action code 'RemoveCoupon' to order server. It will construct a SDO and invoke removeCoupon(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • removeCoupon

        public AcknowledgeOrderDataAreaType removeCoupon(OrderType order)
                                          throws OrderException
        It will send a BOD with process verb and action code 'RemoveCoupon' to order server.
        Parameters:
        order - SDO sent to server to do the removeCoupon action.
        Returns:
        response from server
        Throws:
        OrderException - if any errors occur.

      • applyPromotionCode

        public java.util.Map applyPromotionCode(java.util.Map parameters)
                                 throws OrderException
        It will send a BOD with process verb and action code 'ApplyPromotionCode' to order server. It will construct a SDO and invoke applyPromotionCode(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • applyPromotionCode

        public AcknowledgeOrderDataAreaType applyPromotionCode(OrderType order)
                                                throws OrderException
        It will send a BOD with process verb and action code 'ApplyPromotionCode' to order server.
        Parameters:
        order - SDO sent to server to do the applyPromotionCode action.
        Returns:
        response from server
        Throws:
        OrderException - if any errors occur.

      • removePromotionCode

        public java.util.Map removePromotionCode(java.util.Map parameters)
                                  throws OrderException
        It will send a BOD with process verb and action code 'RemovePromotionCode' to order server. It will construct a SDO and invoke removePromotionCode(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • removePromotionCode

        public AcknowledgeOrderDataAreaType removePromotionCode(OrderType order)
                                                 throws OrderException
        It will send a BOD with process verb and action code 'RemovePromotionCode' to order server.
        Parameters:
        order - SDO sent to server to do the removePromotionCode action.
        Returns:
        response from server
        Throws:
        OrderException - if any errors occur.

      • lockOrder

        public java.util.Map lockOrder(java.util.Map parameters)
                        throws OrderException
        It will send a BOD with process verb and action code 'lock' to order server. It will construct a SDO and invoke lockOrder(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • unlockOrder

        public java.util.Map unlockOrder(java.util.Map parameters)
                          throws OrderException
        It will send a BOD with process verb and action code 'Unlock' to order server. It will construct a SDO and invoke unlockOrder(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.

      • calculateOrder

        public java.util.Map calculateOrder(java.util.Map parameters)
                             throws OrderException
        It will send a BOD with process verb and action code 'CalculateInternally' to order server. It will construct a SDO and invoke calculateOrder(OrderType) to get the server response, as AcknowledgeOrderDataAreaType.
        Parameters:
        parameters - request parameters to construct a SDO.
        Returns:
        response populated from AcknowledgeOrderDataAreaType
        Throws:
        OrderException - if any errors occur.
Skip navigation links