All URIs are relative to https://api.api2cart.local.com/v1.1
| Method | HTTP request | Description |
|---|---|---|
| orderAbandonedList | GET /order.abandoned.list.json | order.abandoned.list |
| orderAbandonedListWithHttpInfo | GET /order.abandoned.list.json | order.abandoned.list |
| orderAdd | POST /order.add.json | order.add |
| orderAddWithHttpInfo | POST /order.add.json | order.add |
| orderCalculate | POST /order.calculate.json | order.calculate |
| orderCalculateWithHttpInfo | POST /order.calculate.json | order.calculate |
| orderCount | GET /order.count.json | order.count |
| orderCountWithHttpInfo | GET /order.count.json | order.count |
| orderFinancialStatusList | GET /order.financial_status.list.json | order.financial_status.list |
| orderFinancialStatusListWithHttpInfo | GET /order.financial_status.list.json | order.financial_status.list |
| orderFulfillmentStatusList | GET /order.fulfillment_status.list.json | order.fulfillment_status.list |
| orderFulfillmentStatusListWithHttpInfo | GET /order.fulfillment_status.list.json | order.fulfillment_status.list |
| orderInfo | GET /order.info.json | order.info |
| orderInfoWithHttpInfo | GET /order.info.json | order.info |
| orderList | GET /order.list.json | order.list |
| orderListWithHttpInfo | GET /order.list.json | order.list |
| orderPreestimateShippingList | POST /order.preestimate_shipping.list.json | order.preestimate_shipping.list |
| orderPreestimateShippingListWithHttpInfo | POST /order.preestimate_shipping.list.json | order.preestimate_shipping.list |
| orderRefundAdd | POST /order.refund.add.json | order.refund.add |
| orderRefundAddWithHttpInfo | POST /order.refund.add.json | order.refund.add |
| orderReturnAdd | POST /order.return.add.json | order.return.add |
| orderReturnAddWithHttpInfo | POST /order.return.add.json | order.return.add |
| orderReturnDelete | DELETE /order.return.delete.json | order.return.delete |
| orderReturnDeleteWithHttpInfo | DELETE /order.return.delete.json | order.return.delete |
| orderReturnUpdate | PUT /order.return.update.json | order.return.update |
| orderReturnUpdateWithHttpInfo | PUT /order.return.update.json | order.return.update |
| orderShipmentAdd | POST /order.shipment.add.json | order.shipment.add |
| orderShipmentAddWithHttpInfo | POST /order.shipment.add.json | order.shipment.add |
| orderShipmentAddBatch | POST /order.shipment.add.batch.json | order.shipment.add.batch |
| orderShipmentAddBatchWithHttpInfo | POST /order.shipment.add.batch.json | order.shipment.add.batch |
| orderShipmentDelete | DELETE /order.shipment.delete.json | order.shipment.delete |
| orderShipmentDeleteWithHttpInfo | DELETE /order.shipment.delete.json | order.shipment.delete |
| orderShipmentEventAdd | POST /order.shipment.event.add.json | order.shipment.event.add |
| orderShipmentEventAddWithHttpInfo | POST /order.shipment.event.add.json | order.shipment.event.add |
| orderShipmentEventList | GET /order.shipment.event.list.json | order.shipment.event.list |
| orderShipmentEventListWithHttpInfo | GET /order.shipment.event.list.json | order.shipment.event.list |
| orderShipmentInfo | GET /order.shipment.info.json | order.shipment.info |
| orderShipmentInfoWithHttpInfo | GET /order.shipment.info.json | order.shipment.info |
| orderShipmentList | GET /order.shipment.list.json | order.shipment.list |
| orderShipmentListWithHttpInfo | GET /order.shipment.list.json | order.shipment.list |
| orderShipmentTrackingAdd | POST /order.shipment.tracking.add.json | order.shipment.tracking.add |
| orderShipmentTrackingAddWithHttpInfo | POST /order.shipment.tracking.add.json | order.shipment.tracking.add |
| orderShipmentUpdate | PUT /order.shipment.update.json | order.shipment.update |
| orderShipmentUpdateWithHttpInfo | PUT /order.shipment.update.json | order.shipment.update |
| orderStatusList | GET /order.status.list.json | order.status.list |
| orderStatusListWithHttpInfo | GET /order.status.list.json | order.status.list |
| orderTransactionList | GET /order.transaction.list.json | order.transaction.list |
| orderTransactionListWithHttpInfo | GET /order.transaction.list.json | order.transaction.list |
| orderUpdate | PUT /order.update.json | order.update |
| orderUpdateWithHttpInfo | PUT /order.update.json | order.update |
orderAbandonedList(orderAbandonedListRequest): ApiRequest[ModelResponseOrderAbandonedList]
order.abandoned.list
Get list of orders that were left by customers before completing the order.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val start: Int = 0 // Int | This parameter sets the number from which you want to get entities
val count: Int = 20 // Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250
val pageCursor: String = // String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter)
val customerId: String = 5 // String | Retrieves orders specified by customer id
val customerEmail: String = jubari@hannsgroup.com // String | Retrieves orders specified by customer email
val storeId: String = 1 // String | Store Id
val createdFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their creation date
val createdTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their creation date
val modifiedFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their modification date
val modifiedTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their modification date
val skipEmptyEmail: Boolean = true // Boolean | Filter empty emails
val roundingPrecision: Int = 3 // Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p>
val responseFields: String = {return_code,pagination,result{order{id,customer{email},created_at,totals{total},order_products}}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val params: String = force_all // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = customer // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val request = apiInstance.orderAbandonedList(start, count, pageCursor, customerId, customerEmail, storeId, createdFrom, createdTo, modifiedFrom, modifiedTo, skipEmptyEmail, roundingPrecision, responseFields, params, exclude)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderAbandonedList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderAbandonedList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| start | Int | This parameter sets the number from which you want to get entities | [optional] |
| count | Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250 | [optional] |
| pageCursor | String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter) | [optional] |
| customerId | String | Retrieves orders specified by customer id | [optional] |
| customerEmail | String | Retrieves orders specified by customer email | [optional] |
| storeId | String | Store Id | [optional] |
| createdFrom | String | Retrieve entities from their creation date | [optional] |
| createdTo | String | Retrieve entities to their creation date | [optional] |
| modifiedFrom | String | Retrieve entities from their modification date | [optional] |
| modifiedTo | String | Retrieve entities to their modification date | [optional] |
| skipEmptyEmail | Boolean | Filter empty emails | [optional] |
| roundingPrecision | Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p> | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
ApiRequest[ModelResponseOrderAbandonedList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderAdd(orderAddRequest): ApiRequest[OrderAdd200Response]
order.add
Add a new order to the cart.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderAdd: OrderAdd = // OrderAdd |
val request = apiInstance.orderAdd(orderAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderAdd | OrderAdd |
ApiRequest[OrderAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderCalculate(orderCalculateRequest): ApiRequest[OrderCalculate200Response]
order.calculate
<p>Calculates the total cost of an order for a given customer and a set of products, as well as the available shipping methods based on the specified address. The calculation takes into account store product prices, discounts, taxes, shipping costs, and other store settings. The result includes a detailed breakdown of the final order cost by its components.</p> <p>Note that the final totals, taxes, and other amounts must include the corresponding values for the selected shipping method.</p><p>The result of this method can be used when creating an order using the <strong>order.add</strong> method.</p>
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderCalculate: OrderCalculate = // OrderCalculate |
val request = apiInstance.orderCalculate(orderCalculate)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderCalculate")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderCalculate")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderCalculate | OrderCalculate |
ApiRequest[OrderCalculate200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderCount(orderCountRequest): ApiRequest[OrderCount200Response]
order.count
Count orders in store
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderIds: String = 24,25 // String | Counts orders specified by order ids
val ids: String = 24,25 // String | Counts orders specified by ids
val customerId: String = 5 // String | Counts orders quantity specified by customer id
val storeId: String = 1 // String | Counts orders quantity specified by store id
val customerEmail: String = jubari@hannsgroup.com // String | Counts orders quantity specified by customer email
val orderStatus: String = Completed // String | Counts orders quantity specified by order status
val orderStatusIds: Seq[String] = // Seq[String] | Retrieves orders specified by order statuses
val ebayOrderStatus: String = Active // String | Counts orders quantity specified by order status
val financialStatus: String = paid // String | Counts orders quantity specified by financial status
val financialStatusIds: Seq[String] = // Seq[String] | Retrieves orders count specified by financial status ids
val fulfillmentChannel: String = local // String | Retrieves order with a fulfillment channel
val fulfillmentStatus: String = fulfilled // String | Create order with fulfillment status
val shippingMethod: String = flatrate_flatrate // String | Retrieve entities according to shipping method
val deliveryMethod: String = local // String | Retrieves order with delivery method
val tags: String = tag1,tag2 // String | Order tags
val shipNodeType: String = SellerFulfilled // String | Retrieves order with ship node type
val createdFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their creation date
val createdTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their creation date
val modifiedFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their modification date
val modifiedTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their modification date
val useLatestApiVersion: Boolean = true // Boolean | Use the latest platform API version
val vendorId: String = 1 // String | Counts orders specified by vendor id
val request = apiInstance.orderCount(orderIds, ids, customerId, storeId, customerEmail, orderStatus, orderStatusIds, ebayOrderStatus, financialStatus, financialStatusIds, fulfillmentChannel, fulfillmentStatus, shippingMethod, deliveryMethod, tags, shipNodeType, createdFrom, createdTo, modifiedFrom, modifiedTo, useLatestApiVersion, vendorId)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderCount")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderCount")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderIds | String | Counts orders specified by order ids | [optional] |
| ids | String | Counts orders specified by ids | [optional] |
| customerId | String | Counts orders quantity specified by customer id | [optional] |
| storeId | String | Counts orders quantity specified by store id | [optional] |
| customerEmail | String | Counts orders quantity specified by customer email | [optional] |
| orderStatus | String | Counts orders quantity specified by order status | [optional] |
| orderStatusIds | Seq[String] | Retrieves orders specified by order statuses | [optional] |
| ebayOrderStatus | String | Counts orders quantity specified by order status | [optional] |
| financialStatus | String | Counts orders quantity specified by financial status | [optional] |
| financialStatusIds | Seq[String] | Retrieves orders count specified by financial status ids | [optional] |
| fulfillmentChannel | String | Retrieves order with a fulfillment channel | [optional] |
| fulfillmentStatus | String | Create order with fulfillment status | [optional] |
| shippingMethod | String | Retrieve entities according to shipping method | [optional] |
| deliveryMethod | String | Retrieves order with delivery method | [optional] |
| tags | String | Order tags | [optional] |
| shipNodeType | String | Retrieves order with ship node type | [optional] |
| createdFrom | String | Retrieve entities from their creation date | [optional] |
| createdTo | String | Retrieve entities to their creation date | [optional] |
| modifiedFrom | String | Retrieve entities from their modification date | [optional] |
| modifiedTo | String | Retrieve entities to their modification date | [optional] |
| useLatestApiVersion | Boolean | Use the latest platform API version | [optional] |
| vendorId | String | Counts orders specified by vendor id | [optional] |
ApiRequest[OrderCount200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderFinancialStatusList(): ApiRequest[OrderFinancialStatusList200Response]
order.financial_status.list
Retrieve list of financial statuses
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val request = apiInstance.orderFinancialStatusList()
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderFinancialStatusList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderFinancialStatusList")
exception.printStackTrace();
}
}This endpoint does not need any parameter.
ApiRequest[OrderFinancialStatusList200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderFulfillmentStatusList(orderFulfillmentStatusListRequest): ApiRequest[OrderFulfillmentStatusList200Response]
order.fulfillment_status.list
Retrieve list of fulfillment statuses
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val action: String = add // String | Available statuses for the specified action.
val request = apiInstance.orderFulfillmentStatusList(action)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderFulfillmentStatusList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderFulfillmentStatusList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| action | String | Available statuses for the specified action. | [optional] |
ApiRequest[OrderFulfillmentStatusList200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderInfo(orderInfoRequest): ApiRequest[OrderInfo200Response]
order.info
Info about a specific order by ID
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val id: String = 10 // String | Retrieves order info specified by id
val orderId: String = 25 // String | Retrieves order’s info specified by order id
val storeId: String = 1 // String | Defines store id where the order should be found
val params: String = order_id,totals,status // String | Set this parameter in order to choose which entity fields you want to retrieve
val responseFields: String = {result{order_id,customer,totals,address,items,bundles,status}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = order_id,totals,status // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val enableCache: Boolean = true // Boolean | If the value is 'true' and order exist in our cache, we will return order.info response from cache
val useLatestApiVersion: Boolean = true // Boolean | Use the latest platform API version
val roundingPrecision: Int = 3 // Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p>
val allowUserDefinedOrderStatuses: Boolean = true // Boolean | Indicates whether custom (user-defined) order statuses should be included in the response.
val request = apiInstance.orderInfo(id, orderId, storeId, params, responseFields, exclude, enableCache, useLatestApiVersion, roundingPrecision, allowUserDefinedOrderStatuses)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderInfo")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderInfo")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| id | String | Retrieves order info specified by id | [optional] |
| orderId | String | Retrieves order’s info specified by order id | [optional] |
| storeId | String | Defines store id where the order should be found | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
| enableCache | Boolean | If the value is 'true' and order exist in our cache, we will return order.info response from cache | [optional] |
| useLatestApiVersion | Boolean | Use the latest platform API version | [optional] |
| roundingPrecision | Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p> | [optional] |
| allowUserDefinedOrderStatuses | Boolean | Indicates whether custom (user-defined) order statuses should be included in the response. | [optional] |
ApiRequest[OrderInfo200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderList(orderListRequest): ApiRequest[ModelResponseOrderList]
order.list
Get list of orders from store.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val start: Int = 0 // Int | This parameter sets the number from which you want to get entities
val count: Int = 20 // Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250
val pageCursor: String = // String | Used to retrieve orders via cursor-based pagination (it can't be used with any other filtering parameter)
val ids: String = 24,25 // String | Retrieves orders specified by ids
val orderIds: String = 24,25 // String | Retrieves orders specified by order ids
val sinceId: String = 56 // String | Retrieve entities starting from the specified id.
val storeId: String = 1 // String | Store Id
val vendorId: String = 1 // String | Retrieves orders specified by vendor id
val customerId: String = 5 // String | Retrieves orders specified by customer id
val customerEmail: String = jubari@hannsgroup.com // String | Retrieves orders specified by customer email
val basketId: String = 1 // String | Retrieves order’s info specified by basket id.
val currencyId: String = usd // String | Currency Id
val phone: String = 56686868654 // String | Filter orders by customer's phone number
val orderStatus: String = Completed // String | Retrieves orders specified by order status
val orderStatusIds: Seq[String] = // Seq[String] | Retrieves orders specified by order statuses
val ebayOrderStatus: String = Active // String | Retrieves orders specified by order status
val financialStatus: String = paid // String | Retrieves orders specified by financial status
val financialStatusIds: Seq[String] = // Seq[String] | Retrieves orders specified by financial status ids
val fulfillmentStatus: String = fulfilled // String | Create order with fulfillment status
val returnStatus: String = RETURNED // String | Retrieves orders specified by return status
val fulfillmentChannel: String = local // String | Retrieves order with a fulfillment channel
val shippingMethod: String = flatrate_flatrate // String | Retrieve entities according to shipping method
val skipOrderIds: String = 24,25 // String | Skipped orders by ids
val isDeleted: Boolean = true // Boolean | Filter deleted orders
val shippingCountryIso3: String = DEU // String | Retrieve entities according to shipping country
val deliveryMethod: String = local // String | Retrieves order with delivery method
val shipNodeType: String = SellerFulfilled // String | Retrieves order with ship node type
val createdTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their creation date
val createdFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their creation date
val modifiedTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their modification date
val modifiedFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their modification date
val tags: String = tag1,tag2 // String | Order tags
val sortBy: String = modified_at // String | Set field to sort by
val sortDirection: String = asc // String | Set sorting direction
val params: String = order_id,totals,status // String | Set this parameter in order to choose which entity fields you want to retrieve
val responseFields: String = {return_code,pagination,result{order{order_id,customer,totals,address,items,bundles,status}}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = order_id,totals,status // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val enableCache: Boolean = true // Boolean | If the value is 'true', we will cache orders for a 15 minutes in order to increase speed and reduce requests throttling for some methods and shoping platforms (for example order.shipment.add)
val useLatestApiVersion: Boolean = true // Boolean | Use the latest platform API version
val roundingPrecision: Int = 3 // Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p>
val allowUserDefinedOrderStatuses: Boolean = true // Boolean | Indicates whether custom (user-defined) order statuses should be included in the response.
val request = apiInstance.orderList(start, count, pageCursor, ids, orderIds, sinceId, storeId, vendorId, customerId, customerEmail, basketId, currencyId, phone, orderStatus, orderStatusIds, ebayOrderStatus, financialStatus, financialStatusIds, fulfillmentStatus, returnStatus, fulfillmentChannel, shippingMethod, skipOrderIds, isDeleted, shippingCountryIso3, deliveryMethod, shipNodeType, createdTo, createdFrom, modifiedTo, modifiedFrom, tags, sortBy, sortDirection, params, responseFields, exclude, enableCache, useLatestApiVersion, roundingPrecision, allowUserDefinedOrderStatuses)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| start | Int | This parameter sets the number from which you want to get entities | [optional] |
| count | Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250 | [optional] |
| pageCursor | String | Used to retrieve orders via cursor-based pagination (it can't be used with any other filtering parameter) | [optional] |
| ids | String | Retrieves orders specified by ids | [optional] |
| orderIds | String | Retrieves orders specified by order ids | [optional] |
| sinceId | String | Retrieve entities starting from the specified id. | [optional] |
| storeId | String | Store Id | [optional] |
| vendorId | String | Retrieves orders specified by vendor id | [optional] |
| customerId | String | Retrieves orders specified by customer id | [optional] |
| customerEmail | String | Retrieves orders specified by customer email | [optional] |
| basketId | String | Retrieves order’s info specified by basket id. | [optional] |
| currencyId | String | Currency Id | [optional] |
| phone | String | Filter orders by customer's phone number | [optional] |
| orderStatus | String | Retrieves orders specified by order status | [optional] |
| orderStatusIds | Seq[String] | Retrieves orders specified by order statuses | [optional] |
| ebayOrderStatus | String | Retrieves orders specified by order status | [optional] |
| financialStatus | String | Retrieves orders specified by financial status | [optional] |
| financialStatusIds | Seq[String] | Retrieves orders specified by financial status ids | [optional] |
| fulfillmentStatus | String | Create order with fulfillment status | [optional] |
| returnStatus | String | Retrieves orders specified by return status | [optional] |
| fulfillmentChannel | String | Retrieves order with a fulfillment channel | [optional] |
| shippingMethod | String | Retrieve entities according to shipping method | [optional] |
| skipOrderIds | String | Skipped orders by ids | [optional] |
| isDeleted | Boolean | Filter deleted orders | [optional] |
| shippingCountryIso3 | String | Retrieve entities according to shipping country | [optional] |
| deliveryMethod | String | Retrieves order with delivery method | [optional] |
| shipNodeType | String | Retrieves order with ship node type | [optional] |
| createdTo | String | Retrieve entities to their creation date | [optional] |
| createdFrom | String | Retrieve entities from their creation date | [optional] |
| modifiedTo | String | Retrieve entities to their modification date | [optional] |
| modifiedFrom | String | Retrieve entities from their modification date | [optional] |
| tags | String | Order tags | [optional] |
| sortBy | String | Set field to sort by | [optional] |
| sortDirection | String | Set sorting direction | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
| enableCache | Boolean | If the value is 'true', we will cache orders for a 15 minutes in order to increase speed and reduce requests throttling for some methods and shoping platforms (for example order.shipment.add) | [optional] |
| useLatestApiVersion | Boolean | Use the latest platform API version | [optional] |
| roundingPrecision | Int | <p>Specifies the rounding precision for fractional numeric values (such as prices, taxes, and weights).</p> <p>Supported values range from <b>1</b> to <b>6</b>.</p> <p>The default rounding precision may vary depending on the platform. You can retrieve the default value using the <strong>cart.info</strong> method in the <code>default_rounding_precision</code> field. </p><p>Values are rounded to the nearest number at the specified precision. Fractions of .5 or higher are rounded up, while fractions lower than .5 are rounded down.</p> | [optional] |
| allowUserDefinedOrderStatuses | Boolean | Indicates whether custom (user-defined) order statuses should be included in the response. | [optional] |
ApiRequest[ModelResponseOrderList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderPreestimateShippingList(orderPreestimateShippingListRequest): ApiRequest[ModelResponseOrderPreestimateShippingList]
order.preestimate_shipping.list
Retrieve list of order preestimated shipping methods
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderPreestimateShippingList: OrderPreestimateShippingList = // OrderPreestimateShippingList |
val request = apiInstance.orderPreestimateShippingList(orderPreestimateShippingList)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderPreestimateShippingList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderPreestimateShippingList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderPreestimateShippingList | OrderPreestimateShippingList |
ApiRequest[ModelResponseOrderPreestimateShippingList]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderRefundAdd(orderRefundAddRequest): ApiRequest[OrderRefundAdd200Response]
order.refund.add
Add a refund to the order.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderRefundAdd: OrderRefundAdd = // OrderRefundAdd |
val request = apiInstance.orderRefundAdd(orderRefundAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderRefundAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderRefundAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderRefundAdd | OrderRefundAdd |
ApiRequest[OrderRefundAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderReturnAdd(orderReturnAddRequest): ApiRequest[OrderReturnAdd200Response]
order.return.add
Create new return request.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderReturnAdd: OrderReturnAdd = // OrderReturnAdd |
val request = apiInstance.orderReturnAdd(orderReturnAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderReturnAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderReturnAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderReturnAdd | OrderReturnAdd |
ApiRequest[OrderReturnAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderReturnDelete(orderReturnDeleteRequest): ApiRequest[AttributeValueDelete200Response]
order.return.delete
Delete return.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val returnId: String = 200000002 // String | Return ID
val orderId: String = 25 // String | Defines the order id
val storeId: String = 1 // String | Store Id
val request = apiInstance.orderReturnDelete(returnId, orderId, storeId)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderReturnDelete")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderReturnDelete")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| returnId | String | Return ID | |
| orderId | String | Defines the order id | |
| storeId | String | Store Id | [optional] |
ApiRequest[AttributeValueDelete200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderReturnUpdate(orderReturnUpdateRequest): ApiRequest[AccountConfigUpdate200Response]
order.return.update
Update order's shipment information.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderReturnUpdate: OrderReturnUpdate = // OrderReturnUpdate |
val request = apiInstance.orderReturnUpdate(orderReturnUpdate)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderReturnUpdate")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderReturnUpdate")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderReturnUpdate | OrderReturnUpdate |
ApiRequest[AccountConfigUpdate200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentAdd(orderShipmentAddRequest): ApiRequest[OrderShipmentAdd200Response]
order.shipment.add
Add a shipment to the order.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderShipmentAdd: OrderShipmentAdd = // OrderShipmentAdd |
val request = apiInstance.orderShipmentAdd(orderShipmentAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderShipmentAdd | OrderShipmentAdd |
ApiRequest[OrderShipmentAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentAddBatch(orderShipmentAddBatchRequest): ApiRequest[CategoryAddBatch200Response]
order.shipment.add.batch
Add a shipments to the orders.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderShipmentAddBatch: OrderShipmentAddBatch = // OrderShipmentAddBatch |
val request = apiInstance.orderShipmentAddBatch(orderShipmentAddBatch)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentAddBatch")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentAddBatch")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderShipmentAddBatch | OrderShipmentAddBatch |
ApiRequest[CategoryAddBatch200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentDelete(orderShipmentDeleteRequest): ApiRequest[OrderShipmentDelete200Response]
order.shipment.delete
Delete order's shipment.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val shipmentId: String = 200000002 // String | Shipment id indicates the number of delivery
val orderId: String = 25 // String | Defines the order for which the shipment will be deleted
val storeId: String = 1 // String | Store Id
val request = apiInstance.orderShipmentDelete(shipmentId, orderId, storeId)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentDelete")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentDelete")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| shipmentId | String | Shipment id indicates the number of delivery | |
| orderId | String | Defines the order for which the shipment will be deleted | |
| storeId | String | Store Id | [optional] |
ApiRequest[OrderShipmentDelete200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentEventAdd(orderShipmentEventAddRequest): ApiRequest[AttributeAdd200Response]
order.shipment.event.add
Add a tracking event to the shipment.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderShipmentEventAdd: OrderShipmentEventAdd = // OrderShipmentEventAdd |
val request = apiInstance.orderShipmentEventAdd(orderShipmentEventAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentEventAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentEventAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderShipmentEventAdd | OrderShipmentEventAdd |
ApiRequest[AttributeAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentEventList(orderShipmentEventListRequest): ApiRequest[ModelResponseOrderShipmentEventList]
order.shipment.event.list
Get list of shipment tracking events.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val shipmentId: String = 200000002 // String | Defines the shipment for which tracking events will be retrieved
val orderId: String = 25 // String | Defines the order to which the shipment belongs
val storeId: String = 1 // String | Store Id
val start: Int = 0 // Int | This parameter sets the number from which you want to get entities
val count: Int = 20 // Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250
val pageCursor: String = // String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter)
val responseFields: String = {result} // String | Set this parameter in order to choose which entity fields you want to retrieve
val request = apiInstance.orderShipmentEventList(shipmentId, orderId, storeId, start, count, pageCursor, responseFields)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentEventList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentEventList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| shipmentId | String | Defines the shipment for which tracking events will be retrieved | |
| orderId | String | Defines the order to which the shipment belongs | [optional] |
| storeId | String | Store Id | [optional] |
| start | Int | This parameter sets the number from which you want to get entities | [optional] |
| count | Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250 | [optional] |
| pageCursor | String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter) | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
ApiRequest[ModelResponseOrderShipmentEventList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentInfo(orderShipmentInfoRequest): ApiRequest[OrderShipmentInfo200Response]
order.shipment.info
Get information of shipment.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val id: String = 10 // String | Entity id
val orderId: String = 25 // String | Defines the order id
val start: Int = 0 // Int | This parameter sets the number from which you want to get entities
val storeId: String = 1 // String | Store Id
val responseFields: String = {result{id,order_id,shipment_provider,tracking_numbers{tracking_number},items{product_id,quantity}}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val params: String = id,model,price,images // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = false // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val request = apiInstance.orderShipmentInfo(id, orderId, start, storeId, responseFields, params, exclude)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentInfo")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentInfo")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| id | String | Entity id | |
| orderId | String | Defines the order id | |
| start | Int | This parameter sets the number from which you want to get entities | [optional] |
| storeId | String | Store Id | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
ApiRequest[OrderShipmentInfo200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentList(orderShipmentListRequest): ApiRequest[ModelResponseOrderShipmentList]
order.shipment.list
Get list of shipments per order.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderId: String = 25 // String | Retrieves shipments specified by order id
val start: Int = 0 // Int | This parameter sets the number from which you want to get entities
val count: Int = 20 // Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250
val pageCursor: String = // String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter)
val storeId: String = 1 // String | Store Id
val createdFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their creation date
val createdTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their creation date
val modifiedFrom: String = 2010-07-29 13:45:52 // String | Retrieve entities from their modification date
val modifiedTo: String = 2100-08-29 13:45:52 // String | Retrieve entities to their modification date
val responseFields: String = {status_code,pagination,result{shipment{id,order_id,shipment_provider,tracking_numbers{tracking_number},items{product_id,quantity}}}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val params: String = id,model,price,images // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = false // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val request = apiInstance.orderShipmentList(orderId, start, count, pageCursor, storeId, createdFrom, createdTo, modifiedFrom, modifiedTo, responseFields, params, exclude)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderId | String | Retrieves shipments specified by order id | |
| start | Int | This parameter sets the number from which you want to get entities | [optional] |
| count | Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250 | [optional] |
| pageCursor | String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter) | [optional] |
| storeId | String | Store Id | [optional] |
| createdFrom | String | Retrieve entities from their creation date | [optional] |
| createdTo | String | Retrieve entities to their creation date | [optional] |
| modifiedFrom | String | Retrieve entities from their modification date | [optional] |
| modifiedTo | String | Retrieve entities to their modification date | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
ApiRequest[ModelResponseOrderShipmentList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentTrackingAdd(orderShipmentTrackingAddRequest): ApiRequest[OrderShipmentTrackingAdd200Response]
order.shipment.tracking.add
Add order shipment's tracking info.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderShipmentTrackingAdd: OrderShipmentTrackingAdd = // OrderShipmentTrackingAdd |
val request = apiInstance.orderShipmentTrackingAdd(orderShipmentTrackingAdd)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentTrackingAdd")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentTrackingAdd")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderShipmentTrackingAdd | OrderShipmentTrackingAdd |
ApiRequest[OrderShipmentTrackingAdd200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderShipmentUpdate(orderShipmentUpdateRequest): ApiRequest[AccountConfigUpdate200Response]
order.shipment.update
Update order's shipment information.
// Import classes:
import
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderShipmentUpdate: OrderShipmentUpdate = // OrderShipmentUpdate |
val request = apiInstance.orderShipmentUpdate(orderShipmentUpdate)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderShipmentUpdate")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderShipmentUpdate")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderShipmentUpdate | OrderShipmentUpdate |
ApiRequest[AccountConfigUpdate200Response]
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderStatusList(orderStatusListRequest): ApiRequest[ModelResponseOrderStatusList]
order.status.list
Retrieve list of statuses
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val storeId: String = 1 // String | Store Id
val action: String = add // String | Available statuses for the specified action.
val allowUserDefinedOrderStatuses: Boolean = true // Boolean | Indicates whether custom (user-defined) order statuses should be included in the response.
val responseFields: String = {return_code,return_message,result} // String | Set this parameter in order to choose which entity fields you want to retrieve
val request = apiInstance.orderStatusList(storeId, action, allowUserDefinedOrderStatuses, responseFields)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderStatusList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderStatusList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| storeId | String | Store Id | [optional] |
| action | String | Available statuses for the specified action. | [optional] |
| allowUserDefinedOrderStatuses | Boolean | Indicates whether custom (user-defined) order statuses should be included in the response. | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
ApiRequest[ModelResponseOrderStatusList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderTransactionList(orderTransactionListRequest): ApiRequest[ModelResponseOrderTransactionList]
order.transaction.list
Retrieve list of order transaction
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderIds: String = 24,25 // String | Retrieves order transactions specified by order ids
val count: Int = 20 // Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250
val pageCursor: String = // String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter)
val storeId: String = 1 // String | Store Id
val params: String = id,model,price,images // String | Set this parameter in order to choose which entity fields you want to retrieve
val responseFields: String = {return_code,pagination,result{transactions_count,transactions{id,transaction_id,status,description,settlement_amount,gateway,card_brand,card_last_four}}} // String | Set this parameter in order to choose which entity fields you want to retrieve
val exclude: String = false // String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all
val request = apiInstance.orderTransactionList(orderIds, count, pageCursor, storeId, params, responseFields, exclude)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderTransactionList")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderTransactionList")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderIds | String | Retrieves order transactions specified by order ids | |
| count | Int | This parameter sets the entity amount that has to be retrieved. Max allowed count=250 | [optional] |
| pageCursor | String | Used to retrieve entities via cursor-based pagination (it can't be used with any other filtering parameter) | [optional] |
| storeId | String | Store Id | [optional] |
| params | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| responseFields | String | Set this parameter in order to choose which entity fields you want to retrieve | [optional] |
| exclude | String | Set this parameter in order to choose which entity fields you want to ignore. Works only if parameter `params` equal force_all | [optional] |
ApiRequest[ModelResponseOrderTransactionList]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
orderUpdate(orderUpdateRequest): ApiRequest[AccountConfigUpdate200Response]
order.update
Update existing order.
// Import classes:
import
import org.openapitools.client.core._
import org.openapitools.client.core.CollectionFormats._
import org.openapitools.client.core.ApiKeyLocations._
import akka.actor.ActorSystem
import scala.concurrent.Future
import scala.util.{Failure, Success}
object Example extends App {
implicit val system: ActorSystem = ActorSystem()
import system.dispatcher
// Configure API key authorization: StoreKeyAuth
implicit val StoreKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
// Configure API key authorization: ApiKeyAuth
implicit val ApiKeyAuth: ApiKeyValue = ApiKeyValue("YOUR API KEY")
val apiInvoker = ApiInvoker()
val apiInstance = OrderApi("https://api.api2cart.local.com/v1.1")
val orderId: String = 25 // String | Defines the orders specified by order id
val storeId: String = 1 // String | Defines store id where the order should be found
val orderStatus: String = Completed // String | Defines new order's status
val financialStatus: String = paid // String | Update order financial status to specified
val fulfillmentStatus: String = fulfilled // String | Create order with fulfillment status
val cancellationReason: String = ORDER_UNPAID // String | Defines the cancellation reason when the order will be canceled
val orderPaymentMethod: String = PayPal // String | Defines order payment method.<br/>Setting order_payment_method on Shopify will also change financial_status field value to 'paid'
val comment: String = This coole order // String | Specifies order comment
val adminComment: String = Test admin comment // String | Specifies admin's order comment
val adminPrivateComment: String = Test admin private comment // String | Specifies private admin's order comment
val invoiceAdminComment: String = Test admin comment // String | Specifies admin's order invoice comment
val dateModified: String = 2014-05-05 05:05:00 // String | Specifies order's modification date
val dateFinished: String = 2014-06-05 05:05:00 // String | Specifies order's finished date
val sendNotifications: Boolean = true // Boolean | Send notifications to customer after order was created
val createInvoice: Boolean = true // Boolean | Determines whether an invoice should be created if it has not already been created
val origin: String = newsletter // String | The source of the order
val tags: String = tag1,tag2 // String | Order tags
val idempotencyKey: String = 098f6bcd4621d373cade4e832627b4f6 // String | A unique identifier associated with a specific request. Repeated requests with the same <strong>idempotency_key</strong> return a cached response without re-executing the business logic. <strong>Please note that the cache lifetime is 15 minutes.</strong>
val request = apiInstance.orderUpdate(orderId, storeId, orderStatus, financialStatus, fulfillmentStatus, cancellationReason, orderPaymentMethod, comment, adminComment, adminPrivateComment, invoiceAdminComment, dateModified, dateFinished, sendNotifications, createInvoice, origin, tags, idempotencyKey)
val response = apiInvoker.execute(request)
response.onComplete {
case Success(ApiResponse(code, content, headers)) =>
System.out.println(s"Status code: $code}")
System.out.println(s"Response headers: ${headers.mkString(", ")}")
System.out.println(s"Response body: $content")
case Failure(error @ ApiError(code, message, responseContent, cause, headers)) =>
System.err.println("Exception when calling OrderApi#orderUpdate")
System.err.println(s"Status code: $code}")
System.err.println(s"Reason: $responseContent")
System.err.println(s"Response headers: ${headers.mkString(", ")}")
error.printStackTrace();
case Failure(exception) =>
System.err.println("Exception when calling OrderApi#orderUpdate")
exception.printStackTrace();
}
}| Name | Type | Description | Notes |
|---|---|---|---|
| orderId | String | Defines the orders specified by order id | |
| storeId | String | Defines store id where the order should be found | [optional] |
| orderStatus | String | Defines new order's status | [optional] |
| financialStatus | String | Update order financial status to specified | [optional] |
| fulfillmentStatus | String | Create order with fulfillment status | [optional] |
| cancellationReason | String | Defines the cancellation reason when the order will be canceled | [optional] |
| orderPaymentMethod | String | Defines order payment method.<br/>Setting order_payment_method on Shopify will also change financial_status field value to 'paid' | [optional] |
| comment | String | Specifies order comment | [optional] |
| adminComment | String | Specifies admin's order comment | [optional] |
| adminPrivateComment | String | Specifies private admin's order comment | [optional] |
| invoiceAdminComment | String | Specifies admin's order invoice comment | [optional] |
| dateModified | String | Specifies order's modification date | [optional] |
| dateFinished | String | Specifies order's finished date | [optional] |
| sendNotifications | Boolean | Send notifications to customer after order was created | [optional] |
| createInvoice | Boolean | Determines whether an invoice should be created if it has not already been created | [optional] |
| origin | String | The source of the order | [optional] |
| tags | String | Order tags | [optional] |
| idempotencyKey | String | A unique identifier associated with a specific request. Repeated requests with the same <strong>idempotency_key</strong> return a cached response without re-executing the business logic. <strong>Please note that the cache lifetime is 15 minutes.</strong> | [optional] |
ApiRequest[AccountConfigUpdate200Response]
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |