/// <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)); }