/// <summary>
/// Create an Address with optional verifications.
/// </summary>
/// <param name="address">Address to create</param>
/// <param name="verify">Verification flags to to control verification. You can verify the delivery address or the
/// extended zip4 value. If you use the strict versions an HttpException to be raised if unsucessful.
/// </param>
/// <returns>Address instance.</returns>
public Task <Address> CreateAddress(
Address address,
VerificationFlags verify = VerificationFlags.None)
{
var request = new EasyPostRequest("addresses", Method.POST);
request.AddBody(address.AsDictionary(), "address");
if ((verify & VerificationFlags.Delivery) != 0)
{
request.AddParameter("verify[]", "delivery", ParameterType.QueryString);
}
if ((verify & VerificationFlags.Zip4) != 0)
{
request.AddParameter("verify[]", "zip4", ParameterType.QueryString);
}
if ((verify & VerificationFlags.DeliveryStrict) != 0)
{
request.AddParameter("verify_strict[]", "delivery", ParameterType.QueryString);
}
if ((verify & VerificationFlags.Zip4Strict) != 0)
{
request.AddParameter("verify_strict[]", "zip4", ParameterType.QueryString);
}
return(Execute <Address>(request));
}
/// <summary>
/// Create a Parcel.
/// </summary>
/// <param name="parcel">Parcel to create</param>
/// <returns>Parcel instance.</returns>
public async Task <Parcel> CreateParcel(
Parcel parcel)
{
var request = new EasyPostRequest("parcels", Method.POST);
request.AddBody(parcel.AsDictionary(), "parcel");
return(await Execute <Parcel>(request));
}
/// <summary>
/// Create an Item.
/// </summary>
/// <param name="item">Item to create</param>
/// <returns>EasyPost.Item instance.</returns>
public async Task <Item> CreateItem(
Item item)
{
var request = new EasyPostRequest("items", Method.POST);
request.AddBody(item.AsDictionary(), "item");
return(await Execute <Item>(request));
}
/// <summary>
/// Create a CustomsInfo.
/// </summary>
/// <param name="customsInfo">Customs info to create</param>
/// <returns>EasyPost.CustomsInfo instance.</returns>
public async Task <CustomsInfo> CreateCustomsInfo(
CustomsInfo customsInfo)
{
var request = new EasyPostRequest("customs_infos", Method.POST);
request.AddBody(customsInfo.AsDictionary(), "customs_info");
return(await Execute <CustomsInfo>(request));
}
/// <summary>
/// Create a Shipment.
/// </summary>
/// <param name="shipment">Shipment details</param>
/// <returns>Shipment instance.</returns>
public async Task <Shipment> CreateShipment(
Shipment shipment)
{
var request = new EasyPostRequest("shipments", Method.POST);
request.AddBody(shipment.AsDictionary(), "shipment");
return(await Execute <Shipment>(request));
}
/// <summary>
/// Create a CarrierAccount.
/// </summary>
/// <param name="carrierAccount">Carriern account details to create</param>
/// <returns>CarrierAccount instance.</returns>
public async Task <CarrierAccount> CreateCarrierAccount(
CarrierAccount carrierAccount)
{
var request = new EasyPostRequest("carrier_accounts", Method.POST);
request.AddBody(carrierAccount.AsDictionary(), "carrier_account");
return(await Execute <CarrierAccount>(request));
}
/// <summary>
/// Create a Order.
/// </summary>
/// <param name="order">Order details</param>
/// <returns>Order instance.</returns>
public async Task <Order> CreateOrder(
Order order)
{
var request = new EasyPostRequest("orders", Method.POST);
request.AddBody(order.AsDictionary(), "order");
return(await Execute <Order>(request));
}
/// <summary>
/// Create a Container.
/// </summary>
/// <param name="container">Container parameters</param>
/// <returns>EasyPost.Container instance.</returns>
public async Task <Container> CreateContainer(
Container container)
{
var request = new EasyPostRequest("containers", Method.POST);
request.AddBody(container.AsDictionary(), "container");
return(await Execute <Container>(request));
}
/// <summary>
/// Create a CustomsItem.
/// </summary>
/// <param name="customsItem">Customs item parameters</param>
/// <returns>EasyPost.CustomsItem instance.</returns>
public async Task <CustomsItem> CreateCustomsItem(
CustomsItem customsItem)
{
var request = new EasyPostRequest("customs_items", Method.POST);
request.AddBody(customsItem.AsDictionary(), "customs_item");
return(await Execute <CustomsItem>(request));
}
/// <summary>
/// Update the User associated with the api_key specified.
/// </summary>
/// <param name="user">User parameters to update</param>
public async Task <User> UpdateUser(
User user)
{
var request = new EasyPostRequest("users/{id}", Method.PUT);
request.AddUrlSegment("id", user.Id);
request.AddBody(user.AsDictionary(), "user");
return(await Execute <User>(request));
}
/// <summary>
/// Update this CarrierAccount.
/// </summary>
/// <param name="carrierAccount">Carrier account details</param>
/// <returns>CarrierAccount instance.</returns>
public async Task <CarrierAccount> UpdateCarrierAccount(
CarrierAccount carrierAccount)
{
var request = new EasyPostRequest("carrier_accounts/{id}", Method.PUT);
request.AddUrlSegment("id", carrierAccount.Id);
request.AddBody(carrierAccount.AsDictionary(), "carrier_account");
return(await Execute <CarrierAccount>(request));
}
/// <summary>
/// Create a child user for the account associated with the api_key specified.
/// </summary>
/// <param name="userName">Name of the user</param>
/// <returns>EasyPost.User instance.</returns>
public async Task <User> CreateUser(
string userName)
{
var request = new EasyPostRequest("users", Method.POST);
request.AddBody(new Dictionary <string, object> {
{ "name", userName }
}, "user");
return(await Execute <User>(request));
}
/// <summary>
/// Create a Pickup.
/// </summary>
/// <param name="pickup">Pickup to create</param>
/// <returns>Pickup instance.</returns>
public async Task <Pickup> CreatePickup(
Pickup pickup = null)
{
var request = new EasyPostRequest("pickups", Method.POST);
if (pickup != null)
{
request.AddBody(pickup.AsDictionary(), "pickup");
}
return(await Execute <Pickup>(request));
}
/// <summary>
/// Buy insurance for a shipment for the given amount.
/// </summary>
/// <param name="id">The id of the shipment to buy insurance for</param>
/// <param name="amount">The amount to insure the shipment for. Currency is provided when creating a shipment.</param>
/// <returns>Shipment instance.</returns>
public async Task <Shipment> BuyInsuranceForShipment(
string id,
double amount)
{
var request = new EasyPostRequest("shipments/{id}/insure", Method.POST);
request.AddUrlSegment("id", id);
request.AddBody(new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("amount", amount.ToString())
});
return(await Execute <Shipment>(request));
}
/// <summary>
/// Buy a label for this shipment with the given rate.
/// </summary>
/// <param name="id">The id of the shipment to buy the label for</param>
/// <param name="rateId">The id of the rate to purchase the shipment with.</param>
/// <returns>Shipment instance.</returns>
public async Task <Shipment> BuyShipment(
string id,
string rateId)
{
var request = new EasyPostRequest("shipments/{id}/buy", Method.POST);
request.AddUrlSegment("id", id);
request.AddBody(new Dictionary <string, object> {
{ "id", rateId }
}, "rate");
return(await Execute <Shipment>(request));
}
/// <summary>
/// Creates a tracker for a carrier and tracking code
/// </summary>
/// <param name="carrier">Carrier</param>
/// <param name="trackingCode">Tracking code</param>
/// <returns>Tracker instance.</returns>
public async Task <Tracker> CreateTracker(
string carrier,
string trackingCode)
{
var request = new EasyPostRequest("trackers", RestSharp.Method.POST);
var parameters = new Dictionary <string, object>()
{
{ "tracking_code", trackingCode },
{ "carrier", carrier }
};
request.AddBody(parameters, "tracker");
return(await Execute <Tracker>(request));
}
/// <summary>
/// Remove shipments from the batch.
/// </summary>
/// <param name="id">Batch id to add the shipments to</param>
/// <param name="shipmentIds">List of shipment ids to be removed.</param>
/// <returns>Batch instance.</returns>
public async Task <Batch> RemoveShipmentsFromBatch(
string id,
IEnumerable <string> shipmentIds)
{
var request = new EasyPostRequest("batches/{id}/remove_shipments", Method.POST);
request.AddUrlSegment("id", id);
var body = shipmentIds.Select(shipmentId => new Dictionary <string, object> {
{ "id", shipmentId }
}).ToList();
request.AddBody(body, "shipments");
return(await Execute <Batch>(request));
}
/// <summary>
/// Purchase this pickup.
/// </summary>
/// <param name="id">Pickup id to purchase</param>
/// <param name="carrier">The name of the carrier to purchase with.</param>
/// <param name="service">The name of the service to purchase.</param>
/// <returns>Pickup instance.</returns>
public async Task <Pickup> BuyPickup(
string id,
string carrier,
string service)
{
var request = new EasyPostRequest("pickups/{id}/buy", Method.POST);
request.AddUrlSegment("id", id);
request.AddBody(new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("carrier", carrier),
new KeyValuePair <string, string>("service", service)
});
return(await Execute <Pickup>(request));
}
/// <summary>
/// Create a Batch.
/// </summary>
/// <param name="shipments">Optional list of shipments</param>
/// <param name="reference">Optional reference</param>
/// <returns>EasyPost.Batch instance.</returns>
public async Task <Batch> CreateBatch(
IEnumerable <Shipment> shipments = null,
string reference = null)
{
var request = new EasyPostRequest("batches", Method.POST);
var parameters = new Dictionary <string, object>();
if (reference != null)
{
parameters.Add("reference", reference);
}
if (shipments != null)
{
parameters.Add("shipments", shipments.Select(shipment => shipment.AsDictionary()).ToList());
}
request.AddBody(parameters, "batch");
return(await Execute <Batch>(request));
}
/// <summary>
/// Asynchronously generate a label containing all of the Shipment labels belonging to the batch.
/// </summary>
/// <param name="id">Batch id to generate the label for</param>
/// <param name="fileFormat">Format to generate the label in. Valid formats: "pdf", "zpl" and "epl2".</param>
/// <param name="orderBy">Optional parameter to order the generated label. Ex: "reference DESC"</param>
/// <returns>Batch instance.</returns>
public async Task <Batch> GenerateLabelForBatch(
string id,
string fileFormat,
string orderBy = null)
{
var request = new EasyPostRequest("batches/{id}/label", Method.POST);
request.AddUrlSegment("id", id);
var body = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("file_format", fileFormat)
};
if (orderBy != null)
{
body.Add(new KeyValuePair <string, string>("order_by", orderBy));
}
request.AddBody(body);
return(await Execute <Batch>(request));
}
/// <summary>
/// Buy a label for this shipment with the given rate.
/// Optionally include insurance
/// </summary>
/// <param name="id">The id of the shipment to buy the label for</param>
/// <param name="rateId">The id of the rate to purchase the shipment with.</param>
/// <param name="insuranceValue">The value to insure the shipment for.</param>
/// <returns>Shipment instance.</returns>
public Task <Shipment> BuyShipment(
string id,
string rateId,
double?insuranceValue = null)
{
var request = new EasyPostRequest("shipments/{id}/buy", Method.POST);
request.AddUrlSegment("id", id);
var parameters = new Dictionary <string, object> {
{ "rate", new Dictionary <string, object> {
{ "id", rateId }
} }
};
if (insuranceValue > 0)
{
parameters["insurance"] = insuranceValue.Value;
}
request.AddBody(parameters, "");
return(Execute <Shipment>(request));
}
