protected string RunQuerywithParam(int IssueID, APIResource apiresource, string method = "GET")
{
string url;
HttpWebRequest request = null;
HttpWebResponse response = null;
string result = null;
if (apiresource == APIResource.Devstatus_Detail)
{
url = m_BaseUrlDev_Status + IssueID + "&applicationType=stash&dataType=repository";
request = WebRequest.Create(url) as HttpWebRequest;
request.ContentType = "application/json";
request.Method = method;
}
if (request != null)
{
string base64Credentials = GetEncodedCredentials();
request.Headers.Add("Authorization", "Basic " + base64Credentials);
response = request.GetResponse() as HttpWebResponse;
result = string.Empty;
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
result = reader.ReadToEnd();
}
}
return(result);
}
private static void RunBatchExample(APIResource resource)
{
ShippoCollection <CarrierAccount> carrierAccounts = resource.AllCarrierAccount();
string defaultCarrierAccount = "";
foreach (CarrierAccount account in carrierAccounts)
{
if (account.Carrier.ToString() == "usps")
{
defaultCarrierAccount = account.ObjectId;
}
}
Address addressFrom = Address.createForPurchase("Mr. Hippo", "965 Mission St.", "Ste 201", "SF",
"CA", "94103", "US", "4151234567", "*****@*****.**");
Address addressTo = Address.createForPurchase("Mrs. Hippo", "965 Missions St.", "Ste 202", "SF",
"CA", "94103", "US", "4151234568", "*****@*****.**");
Parcel[] parcels = { Parcel.createForShipment(5, 5, 5, "in", 2, "oz") };
Shipment shipment = Shipment.createForBatch(addressFrom, addressTo, parcels);
BatchShipment batchShipment = BatchShipment.createForBatchShipments(defaultCarrierAccount, "usps_priority", shipment);
List <BatchShipment> batchShipments = new List <BatchShipment> ();
batchShipments.Add(batchShipment);
Batch batch = resource.CreateBatch(defaultCarrierAccount, "usps_priority", ShippoEnums.LabelFiletypes.PDF_4x6,
"BATCH #170", batchShipments);
Console.WriteLine("Batch Status = " + batch.Status);
Console.WriteLine("Metadata = " + batch.Metadata);
}
/// <summary>
/// Gets results from the GW2 API and saves those results to the SQL database.
/// </summary>
/// <typeparam name="R">The result type that query results from the GW2 API are to be filtered into.</typeparam>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="targetDataSet">The dataset containing entities to be populated from results from the GW2 API.</param>
/// <param name="ids">The unique identifiers in the GW2 API for the items for which data is to be retrieved.</param>
private void UploadToDatabase <R, E>(APIResource resource, DbSet <E> targetDataSet, IEnumerable <int> ids)
where R : APIDataResult <E>
where E : Entity
{
if (ids == null)
{
return;
}
//this.OnDataLoadStarted(new DataLoadEventArgs(resource, ids.Count()));
var count = 0;
E result = null;
foreach (var id in ids)
{
count += 1;
result = this.GetSingleResult <R, E>(resource, id) as E;
if (result != null)
{
targetDataSet.Add(result);
}
if (count % _updateInterval == 0)
{
this.SaveChanges(resource, () => targetDataSet.Remove(result));
//this.OnDataLoadStatusUpdate(new DataLoadEventArgs(resource, count));
}
}
this.SaveChanges(resource, () => targetDataSet.Remove(result));
//this.OnDataLoadFinished(new DataLoadEventArgs(resource, null));
}
/// <summary>
/// Returns a result for a single ID from the GW2 API for the specified resource.
/// </summary>
/// <typeparam name="R">The result type that query results from the GW2 API are to be filtered into.</typeparam>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="client">The HTTP client used to interact with the GW2 API.</param>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="id">The ID of the result to be retrieved.</param>
/// <returns>A result for a single ID from the GW2 API for the specified resource.</returns>
private Entity GetSingleResult <R, E>(APIResource resource, int id)
where R : APIDataResult <E>
where E : Entity
{
var baseURL = Settings.Default.APIBaseURL;
var listURL = $"{baseURL}/{resource.GetPath()}";
var singleResultURL = $"{listURL}/{id}";
var retryCount = 0;
while (retryCount < this._maxRetryCount)
{
var singleResultResponse = this._httpClient.GetAsync(singleResultURL).Result;
if (singleResultResponse.IsSuccessStatusCode)
{
Debug.WriteLine($"Resource : {resource} | ID : {id} | Retry Count : {retryCount}");
return(singleResultResponse.Content.ReadAsAsync <R>().Result.ToEntity());
}
if (singleResultResponse.ReasonPhrase == "Not Found")
{
return(null);
}
retryCount += 1;
}
return(null);
}
/// <summary>
/// Saves a set of entity changes to the SQL database.
/// </summary>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="targetDataSet">The dataset containing entities to be populated from results from the GW2 API.</param>
/// <param name="result">The GW2 API query result containing data to be saved to the database.</param>
private void SaveChanges(APIResource resource, Action onFailure)
{
try
{
this._entities.SaveChanges();
}
catch (DbUpdateException e)
{
var message = $"Error saving changes for resource \"{resource}\". Exception message: {e.Message}";
if (e.InnerException != null)
{
message += $" First sub-exception message: {e.InnerException.Message}";
}
if (e.InnerException.InnerException != null)
{
message += $" Second sub-exception message: {e.InnerException.InnerException.Message}";
}
message += $" : {e.StackTrace}";
//this.OnDataLoadStatusUpdate(new DataLoadEventArgs(resource, null, message));
onFailure?.Invoke();
if (!this._continueOnError)
{
throw;
}
}
}
public async Task <bool> CreateResource(APIResource req)
{
if (req.ResName == string.Empty)
{
return(false);
}
var apires = new ApiResourceApiDto()
{
Description = req.Description,
DisplayName = req.ResName,
Enabled = true,
Name = req.ResName
};
var res = await apiLao.CreateApiResource(apires);
if (res)
{
req.ResID = apires.Id;
var result = await couchContext.InsertAsync <APIResource>(couchDbHelper, req);
return(result.IsSuccess);
}
return(false);
}
/// <summary>
/// Downloads data from the GW2 API for the specified resource with the option
/// to append to or replace existing data for that resource.
/// </summary>
/// <param name="resource">The API resource for which to download data.</param>
/// <param name="replace">True if existing data is to be replace; false otherwise.</param>
public void Load(APIResource resource, bool replace)
{
if (replace)
{
_entities.Delete(resource);
}
switch (resource)
{
case APIResource.Items:
_isModelBuilt = false;
_api.UploadToDatabase <ItemResult, ItemEntity>(resource, _entities.Items);
break;
case APIResource.Recipes:
_isModelBuilt = false;
_api.UploadToDatabase <RecipeResult, RecipeEntity>(resource, _entities.Recipes);
break;
case APIResource.CommerceListings:
var sellableItems = ApplyListingsToSellableItems();
_api.UploadToDatabase <ListingResult, ListingEntity>(resource, _entities.Listings, sellableItems);
break;
default:
throw new ArgumentException($"Unable to load data for API resource \"{nameof(resource)}\".", nameof(resource));
}
}
private static void RunInternationalAddressValidationExample(APIResource resource)
{
Hashtable parameters = new Hashtable();
parameters.Add("name", "Shippo Hippo");
parameters.Add("company", "Shippo");
parameters.Add("street_no", null);
parameters.Add("street1", "40 Bay St");
parameters.Add("street2", null);
parameters.Add("city", "Toronto");
parameters.Add("state", "ON");
parameters.Add("zip", "M5J 2X2");
parameters.Add("country", "CA");
parameters.Add("phone", "+1 555 341 9393");
parameters.Add("email", "*****@*****.**");
parameters.Add("metadata", "Customer ID 123456");
parameters.Add("validate", "true");
Address address = resource.CreateAddress(parameters);
Console.Out.WriteLine("Address IsValid: " + address.ValidationResults.IsValid);
if (address.ValidationResults.Messages != null)
{
foreach (ValidationMessage message in address.ValidationResults.Messages)
{
Console.Out.WriteLine("Address Message Code: " + message.Code);
Console.Out.WriteLine("Address Message Text: " + message.Text);
Console.Out.WriteLine();
}
}
Console.Out.WriteLine("Address Latitude: " + address.Latitude);
Console.Out.WriteLine("Address Longitude: " + address.Longitude);
}
private static void RunTrackingExample(APIResource resource)
{
Track track = resource.RetrieveTracking("usps", TRACKING_NO);
Console.WriteLine("Carrier = " + track.Carrier.ToUpper());
Console.WriteLine("Tracking number = " + track.TrackingNumber);
}
/// <summary>
/// Gets results from the GW2 API and saves those results to the SQL database.
/// </summary>
/// <typeparam name="R">The result type that query results from the GW2 API are to be filtered into.</typeparam>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="client">The HTTP client used to interact with the GW2 API.</param>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="targetDataSet">The dataset containing entities to be populated from results from the GW2 API.</param>
public void UploadToDatabase <R, E>(APIResource resource, DbSet <E> targetDataSet)
where R : APIDataResult <E>
where E : Entity
{
var ids = this.GetIds(resource, targetDataSet);
this.UploadToDatabase <R, E>(resource, targetDataSet, ids);
}
[SetUp] public void Init()
{
String token = Environment.GetEnvironmentVariable("Wrapper_Token");
apiResource = new APIResource(token);
liveAPI = new APIResource(Environment.GetEnvironmentVariable("Live_Token"));
now = DateTime.Now.ToString("yyyy-MM-dd HH':'mm':'ss");
live = false;
}
public ActionResult <object> ShipAsync(ShippoShipping model)
{
APIResource resource = new APIResource("shippo_test_4b21ff87309dbb951077d18f554f1ffc1d1f9988");
Hashtable parameters = new Hashtable();
parameters.Add("address_to", model.address_to);
parameters.Add("address_from", model.address_from);
parameters.Add("parcels", model.parcels);
parameters.Add("async", false);
var shipmentInfo = resource.CreateShipment(parameters);
return(shipmentInfo);
}
public async Task Request_withdraw()
{
// Arrange
AccountRequestWithdrawResponse response;
// Act && Assert
using (IApiResources apiClient = new APIResource())
using (var client = new Account(apiClient))
{
var value = 5.00m;
response = await client.RequestWithdrawAsync("74c265aedbfaea379bc0148fae9b5526", value, "74c265aedbfaea379bc0148fae9b5526").ConfigureAwait(false);
Assert.That(response.WithdrawValue, Is.EqualTo(value));
}
}
public async Task Update_account_information_configurations_with_success()
{
// Arrange
SimpleResponseMessage response;
var request = new BankVerificationRequestMessage(AvailableBanks.Santander, "1111", "99999999-9", BankAccountTypeAbbreviation.CC, true);
// Act && Assert
using (IApiResources apiClient = new APIResource())
using (var client = new Account(apiClient))
{
response = await client.UpdateBankAccoutDataAsync(request, "74c265aedbfaea379bc0148fae9b5526").ConfigureAwait(false);
}
Assert.That(response.Success, Is.True);
}
public async Task CreateNewResource(string apiname, string display, string description,
string userid, string created)
{
APIResource req = new APIResource()
{
ResName = apiname,
Created = created,
Description = description,
UserID = userid,
DisplayName = display
};
var result = await myAPIResouce.CreateResource(req);
Assert.True(result);
}
public ActionResult <object> ShippingLabelAsync(ShippoShippingLabel model)
{
APIResource resource = new APIResource("shippo_test_4b21ff87309dbb951077d18f554f1ffc1d1f9988");
Hashtable parameters = new Hashtable();
parameters.Add("shipment", model.shipment);
parameters.Add("carrier_account", model.carrier_account);
parameters.Add("servicelevel_token", model.servicelevel_token);
var shippingLabel = resource.CreateTransaction(parameters);
return(shippingLabel);
}
public async Task Update_account_configurations_with_success()
{
// Arrange
GetAccountResponseMessage response;
var request = new AccountConfigurationRequestMessage
{
PerDayInterest = true,
Fines = true,
LatePaymentFine = 2,
};
// Act && Assert
using (IApiResources apiClient = new APIResource())
using (var client = new Account(apiClient))
{
Assert.DoesNotThrow(async() => { await client.ConfigureAccountAsync(request, "74c265aedbfaea379bc0148fae9b5526").ConfigureAwait(false); });
}
}
/// <summary>
/// Deletes existing data from the SQL database. Respects foreign key relationships in that data.
/// </summary>
/// <param name="resource">The resource for which data is to be deleted.</param>
public void Delete(APIResource resource)
{
if (resource == APIResource.Recipes || resource == APIResource.Items)
{
this.Disciplines.RemoveRange(this.Disciplines);
this.RecipeFlags.RemoveRange(this.RecipeFlags);
this.Ingredients.RemoveRange(this.Ingredients);
this.GuildIngredients.RemoveRange(this.GuildIngredients);
this.Recipes.RemoveRange(this.Recipes);
}
if (resource == APIResource.Items)
{
this.ItemFlags.RemoveRange(this.ItemFlags);
this.Items.RemoveRange(this.Items);
}
this.SaveChanges();
}
public async Task Verify_if_account_is_valid()
{
// Arrange
var requestAccountVerify = new VerifyAccountRequestMessage(expectedResponse.Data, true);
VerifyAccountResponseMessage verifyAccountResponse;
var responseContent = JsonConvert.SerializeObject(expectedResponse);
// Act
using (IHttpClientWrapper stubHttpClient = new StubHttpClient(new StringContent(responseContent, Encoding.UTF8, "application/json")))
using (IApiResources apiClient = new APIResource(stubHttpClient))
using (var client = new Account(apiClient))
{
verifyAccountResponse = await client.VerifyUnderAccountAsync(requestAccountVerify, response.AccountId, response.UserToken).ConfigureAwait(false);
}
// Assert
Assert.That(expectedResponse.Data.Name, Is.EqualTo(verifyAccountResponse.Data.Name));
Assert.That(expectedResponse.Data.Address, Is.EqualTo(verifyAccountResponse.Data.Address));
Assert.That(expectedResponse.AccountId, Is.EqualTo(verifyAccountResponse.AccountId));
}
public async Task Get_a_created_account()
{
// Arrange
var requestAccountVerify = new VerifyAccountRequestMessage(expectedResponse.Data, true);
var request = new Fixture().Build <GetAccountResponseMessage>().Create();
var responseContent = JsonConvert.SerializeObject(request);
GetAccountResponseMessage response;
// Act
using (IHttpClientWrapper stubHttpClient = new StubHttpClient(new StringContent(responseContent, Encoding.UTF8, "application/json")))
using (IApiResources apiClient = new APIResource(stubHttpClient))
using (var client = new Account(apiClient))
{
response = await client.GetAsync(request.AccountId, "any-user-token").ConfigureAwait(false);
}
// Assert
response.ShouldBeEquivalentTo(request);
}
/// <summary>
/// Returns a complete list of all possible IDs for the specified resource.
/// </summary>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="client">The HTTP client used to interact with the GW2 API.</param>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="targetDataSet">The dataset containing entities to be populated from results from the GW2 API.</param>
/// <returns>A complete list of all possible IDs for the specified resource.</returns>
private IEnumerable <int> GetIds <E>(APIResource resource, DbSet <E> targetDataSet)
where E : Entity
{
var baseURL = Settings.Default.APIBaseURL;
var listURL = $"{baseURL}/{resource.GetPath()}";
var response = this._httpClient.GetAsync(listURL).Result;
if (!response.IsSuccessStatusCode)
{
return(null);
}
var queryableDbSet = (IQueryable <Entity>)targetDataSet;
var existingIds = queryableDbSet.Select(row => row.APIID)
.OrderBy(id => id)
.ToList();
var newIds = response.Content.ReadAsAsync <List <int> >().Result;
return(newIds.Except(existingIds));
}
public async Task PrepareTests()
{
var request = new AccountRequestMessage {
Name = "*****@*****.**", CommissionPercent = 10
};
var responseContent = JsonConvert.SerializeObject(new Fixture().Build <AccountModel>()
.With(a => a.Name, request.Name)
.Create());
using (IHttpClientWrapper stubHttpClient = new StubHttpClient(new StringContent(responseContent, Encoding.UTF8, "application/json")))
using (IApiResources apiClient = new APIResource(stubHttpClient))
using (var client = new MarketPlace(apiClient))
{
response = await client.CreateUnderAccountAsync(request).ConfigureAwait(false);
}
var address = new Fixture().Build <AddressModel>().Create();
var fullAddress = $"{address.Street}, {address.Number} - {address.City} - {address.State}/{address.Country}";
expectedResponse = new VerifyAccountResponseMessage
{
AccountId = response.AccountId,
Data = new AccountModel(fullAddress)
{
PriceRange = "Entre R$ 100,00 e R$ 500,00",
PhysicalProducts = false,
BusinessDescription = "Negócios online",
PersonType = Constants.PersonType.INDIVIDUAL_PERSON,
AcceptAutomaticTransfer = true,
CPF = "42753418306",
Name = "Meu Cliente",
Phone = "2199999999",
Bank = Constants.SupportedBanks.CAIXA_ECONOMICA,
AccountType = Constants.BankAccountType.CHECKING_ACCOUNT,
BankAgency = "1520",
BankAccountNumber = "00100021066-6"
},
};
}
/// <summary>
/// Runs a query towards the JIRA REST api
/// </summary>
/// <param name="resource">The kind of resource to ask for</param>
/// <param name="argument">Any argument that needs to be passed, such as a project key</param>
/// <param name="data">More advanced data sent in POST requests</param>
/// <param name="method">Either GET or POST</param>
/// <param name="APIBase">Base or DevStatus</param>
/// <returns></returns>
protected string RunQuery(JiraResource resource, APIResource apiresource, string argument = null, string data = null, string method = "GET")
{
string url = string.Format("{0}{1}/", m_BaseUrl, resource.ToString());
if (argument != null)
{
url = string.Format("{0}{1}/", url, argument);
}
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
request.CachePolicy = noCachePolicy;
request.ContentType = "application/json";
request.Method = method;
if (data != null)
{
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write(data);
}
}
string base64Credentials = GetEncodedCredentials();
request.Headers.Add("Authorization", "Basic " + base64Credentials);
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
string result = string.Empty;
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
result = reader.ReadToEnd();
}
return(result);
}
public async Task Create_a_under_acoount_with_success()
{
// Arrange
var request = new AccountRequestMessage {
Name = "*****@*****.**", CommissionPercent = 10
};
AccountResponseMessage response;
var responseContent = JsonConvert.SerializeObject(new Fixture().Build <AccountModel>()
.With(a => a.Name, request.Name)
.Create());
// Act
using (IHttpClientWrapper stubHttpClient = new StubHttpClient(new StringContent(responseContent, Encoding.UTF8, "application/json")))
using (IApiResources apiClient = new APIResource(stubHttpClient))
using (var client = new MarketPlace(apiClient))
{
response = await client.CreateUnderAccountAsync(request).ConfigureAwait(false);
}
// Assert
Assert.That(response.Name, Is.EqualTo(request.Name));
}
[SetUp] public void Init()
{
apiResource = new APIResource("<Shippo Token>");
}
[SetUp] public void Init()
{
apiResource = new APIResource("<Shippo Token>");
now = DateTime.Now.ToString("yyyy-MM-dd HH':'mm':'ss");
}
static void Main(string[] args)
{
// replace with your Shippo Token
// don't have one? get more info here
// (https://goshippo.com/docs/#overview)
APIResource resource = new APIResource("<Shippo Token>");
// to address
Hashtable toAddressTable = new Hashtable();
toAddressTable.Add("object_purpose", "PURCHASE");
toAddressTable.Add("name", "Shippo Itle");
toAddressTable.Add("company", "Shippo");
toAddressTable.Add("street1", "215 Clayton St.");
toAddressTable.Add("city", "San Francisco");
toAddressTable.Add("state", "CA");
toAddressTable.Add("zip", "94117");
toAddressTable.Add("country", "US");
toAddressTable.Add("phone", "+1 555 341 9393");
toAddressTable.Add("email", "*****@*****.**");
// from address
Hashtable fromAddressTable = new Hashtable();
fromAddressTable.Add("object_purpose", "PURCHASE");
fromAddressTable.Add("name", "Mr Hippo");
fromAddressTable.Add("company", "San Diego Zoo");
fromAddressTable.Add("street1", "2920 Zoo Drive");
fromAddressTable.Add("city", "San Diego");
fromAddressTable.Add("state", "CA");
fromAddressTable.Add("zip", "92101");
fromAddressTable.Add("country", "US");
fromAddressTable.Add("email", "*****@*****.**");
fromAddressTable.Add("phone", "+1 619 231 1515");
fromAddressTable.Add("metadata", "Customer ID 123456");
// parcel
Hashtable parcelTable = new Hashtable();
parcelTable.Add("length", "5");
parcelTable.Add("width", "5");
parcelTable.Add("height", "5");
parcelTable.Add("distance_unit", "in");
parcelTable.Add("weight", "2");
parcelTable.Add("mass_unit", "lb");
// shipment
Hashtable shipmentTable = new Hashtable();
shipmentTable.Add("address_to", toAddressTable);
shipmentTable.Add("address_from", fromAddressTable);
shipmentTable.Add("parcel", parcelTable);
shipmentTable.Add("object_purpose", "PURCHASE");
// create Shipment object
Console.WriteLine("Creating Shipment object..");
Shipment shipment = resource.CreateShipment(shipmentTable);
// get shipping rates
Console.WriteLine("Generating rates for shipment " + shipment.ObjectId);
ShippoCollection <Rate> rates = resource.GetShippingRatesSync((String)shipment.ObjectId);
Console.WriteLine(String.Format("Obtained " + rates.Data.Count + " rates for shipment " + shipment.ObjectId));
Rate rate = rates.Data [0];
Console.WriteLine("Getting shipping label..");
Hashtable transactionParameters = new Hashtable();
transactionParameters.Add("rate", rate.ObjectId);
Transaction transaction = resource.CreateTransactionSync(transactionParameters);
if (((String)transaction.ObjectStatus).Equals("SUCCESS", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("Label url : " + transaction.LabelURL);
Console.WriteLine("Tracking number : " + transaction.TrackingNumber);
}
else
{
Console.WriteLine("An Error has occured while generating your label. Messages : " + transaction.Messages);
}
}
static void Main(string[] args)
{
// replace with your Shippo Token
// don't have one? get more info here
// (https://goshippo.com/docs/#overview)
APIResource resource = new APIResource ("<Shippo Token>");
// to address
Hashtable toAddressTable = new Hashtable ();
toAddressTable.Add ("object_purpose", "PURCHASE");
toAddressTable.Add ("name", "Mr. Hippo");
toAddressTable.Add ("company", "Shippo");
toAddressTable.Add ("street1", "215 Clayton St.");
toAddressTable.Add ("city", "San Francisco");
toAddressTable.Add ("state", "CA");
toAddressTable.Add ("zip", "94117");
toAddressTable.Add ("country", "US");
toAddressTable.Add ("phone", "+1 555 341 9393");
toAddressTable.Add ("email", "*****@*****.**");
// from address
Hashtable fromAddressTable = new Hashtable ();
fromAddressTable.Add ("object_purpose", "PURCHASE");
fromAddressTable.Add ("name", "Ms Hippo");
fromAddressTable.Add ("company", "San Diego Zoo");
fromAddressTable.Add ("street1", "2920 Zoo Drive");
fromAddressTable.Add ("city", "San Diego");
fromAddressTable.Add ("state", "CA");
fromAddressTable.Add ("zip", "92101");
fromAddressTable.Add ("country", "US");
fromAddressTable.Add ("email", "*****@*****.**");
fromAddressTable.Add ("phone", "+1 619 231 1515");
fromAddressTable.Add ("metadata", "Customer ID 123456");
// parcel
Hashtable parcelTable = new Hashtable ();
parcelTable.Add ("length", "5");
parcelTable.Add ("width", "5");
parcelTable.Add ("height", "5");
parcelTable.Add ("distance_unit", "in");
parcelTable.Add ("weight", "2");
parcelTable.Add ("mass_unit", "lb");
// shipment
Hashtable shipmentTable = new Hashtable ();
shipmentTable.Add ("address_to", toAddressTable);
shipmentTable.Add ("address_from", fromAddressTable);
shipmentTable.Add ("parcel", parcelTable);
shipmentTable.Add ("object_purpose", "PURCHASE");
shipmentTable.Add ("async", false);
// create Shipment object
Console.WriteLine ("Creating Shipment object..");
Shipment shipment = resource.CreateShipment (shipmentTable);
// select desired shipping rate according to your business logic
// we simply select the first rate in this example
Rate rate = shipment.RatesList[0];
Console.WriteLine ("Getting shipping label..");
Hashtable transactionParameters = new Hashtable ();
transactionParameters.Add ("rate", rate.ObjectId);
transactionParameters.Add ("async", false);
Transaction transaction = resource.CreateTransaction (transactionParameters);
if (((String) transaction.ObjectStatus).Equals ("SUCCESS", StringComparison.OrdinalIgnoreCase)) {
Console.WriteLine ("Label url : " + transaction.LabelURL);
Console.WriteLine ("Tracking number : " + transaction.TrackingNumber);
} else {
Console.WriteLine ("An Error has occured while generating your label. Messages : " + transaction.Messages);
}
}
public void Init()
{
apiResource = new APIResource ("<Shippo Token>");
}
public void Test()
{
var resource = new APIResource("shippo_live_c436088fca4e8ddee7df15da1c46458777e9d687");
// Create address (from)
var fromAdr = new Hashtable();
fromAdr.Add("name", "Mr. Thierry Habart");
fromAdr.Add("street1", "223 avenue des croix du feu");
fromAdr.Add("city", "BRUXELLES");
fromAdr.Add("zip", "1020");
fromAdr.Add("country", "BE");
fromAdr.Add("phone", "0485350536");
fromAdr.Add("email", "*****@*****.**");
var fromAddress = resource.CreateAddress(fromAdr);
// Create address (to)
var toAdr = new Hashtable();
toAdr.Add("name", "Mr. Donabedian David");
toAdr.Add("street1", "rue solleveld 20");
toAdr.Add("city", "BRUXELLES");
toAdr.Add("zip", "1200");
toAdr.Add("country", "BE");
toAdr.Add("phone", "0485350536");
toAdr.Add("email", "*****@*****.**");
var toAddress = resource.CreateAddress(toAdr);
// Create a parcel (colis)
var parcel = new Hashtable();
parcel.Add("length", 5);
parcel.Add("width", 5);
parcel.Add("height", 5);
parcel.Add("distance_unit", "cm");
parcel.Add("weight", 2);
parcel.Add("mass_unit", "kg");
var p = resource.CreateParcel(parcel);
// Create shippment.
var shippment = new Hashtable();
var lstParcels = new List <string> {
p.ObjectId
};
shippment.Add("address_to", toAddress.ObjectId);
shippment.Add("address_from", fromAddress.ObjectId);
shippment.Add("object_purpose", "PURCHASE");
shippment.Add("parcels", lstParcels);
shippment.Add("insurance_currency", "EUR");
shippment.Add("insurance_amount", 0);
shippment.Add("submission_type", "DROPOFF");
shippment.Add("submission_date", "2017-09-04T23:59:50+00:00");
var ship = resource.CreateShipment(shippment);
// Get rates
var rates = resource.GetShippingRatesSync(ship.ObjectId);
string s = "";
}
static void Main(string[] args)
{
// replace with your Shippo Token
// don't have one? get more info here
// (https://goshippo.com/docs/#overview)
APIResource resource = new APIResource("<Shippo Token>");
// to address
Hashtable toAddressTable = new Hashtable();
toAddressTable.Add("name", "Mr. Hippo");
toAddressTable.Add("company", "Shippo");
toAddressTable.Add("street1", "215 Clayton St.");
toAddressTable.Add("city", "San Francisco");
toAddressTable.Add("state", "CA");
toAddressTable.Add("zip", "94117");
toAddressTable.Add("country", "US");
toAddressTable.Add("phone", "+1 555 341 9393");
toAddressTable.Add("email", "*****@*****.**");
// from address
Hashtable fromAddressTable = new Hashtable();
fromAddressTable.Add("name", "Ms Hippo");
fromAddressTable.Add("company", "San Diego Zoo");
fromAddressTable.Add("street1", "2920 Zoo Drive");
fromAddressTable.Add("city", "San Diego");
fromAddressTable.Add("state", "CA");
fromAddressTable.Add("zip", "92101");
fromAddressTable.Add("country", "US");
fromAddressTable.Add("email", "*****@*****.**");
fromAddressTable.Add("phone", "+1 619 231 1515");
fromAddressTable.Add("metadata", "Customer ID 123456");
// parcel
Hashtable parcelTable = new Hashtable();
parcelTable.Add("length", "5");
parcelTable.Add("width", "5");
parcelTable.Add("height", "5");
parcelTable.Add("distance_unit", "in");
parcelTable.Add("weight", "2");
parcelTable.Add("mass_unit", "lb");
// shipment
Hashtable shipmentTable = new Hashtable();
shipmentTable.Add("address_to", toAddressTable);
shipmentTable.Add("address_from", fromAddressTable);
shipmentTable.Add("parcel", parcelTable);
shipmentTable.Add("object_purpose", "PURCHASE");
shipmentTable.Add("async", false);
// create Shipment object
Console.WriteLine("Creating Shipment object..");
Shipment shipment = resource.CreateShipment(shipmentTable);
// select desired shipping rate according to your business logic
// we simply select the first rate in this example
Rate rate = shipment.Rates[0];
Console.WriteLine("Getting shipping label..");
Hashtable transactionParameters = new Hashtable();
transactionParameters.Add("rate", rate.ObjectId);
transactionParameters.Add("async", false);
Transaction transaction = resource.CreateTransaction(transactionParameters);
if (((String)transaction.Status).Equals("SUCCESS", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("Label url : " + transaction.LabelURL);
Console.WriteLine("Tracking number : " + transaction.TrackingNumber);
}
else
{
Console.WriteLine("An Error has occured while generating your label. Messages : " + transaction.Messages);
}
Console.WriteLine("\nBatch\n");
RunBatchExample(resource);
Console.WriteLine("\nTrack\n");
RunTrackingExample(resource);
}
/// <summary>
/// Gets results from the GW2 API and saves those results to the SQL database.
/// </summary>
/// <typeparam name="R">The result type that query results from the GW2 API are to be filtered into.</typeparam>
/// <typeparam name="E">The entity type that is to be used to save the result data to the SQL database.</typeparam>
/// <param name="resource">The type of resource to get data for.</param>
/// <param name="targetDataSet">The dataset containing entities to be populated from results from the GW2 API.</param>
/// <param name="ids">The items in the GW2 API for which data is to be retrieved.</param>
public void UploadToDatabase <R, E>(APIResource resource, DbSet <E> targetDataSet, IEnumerable <Item> items)
where R : APIDataResult <E>
where E : Entity
{
this.UploadToDatabase <R, E>(resource, targetDataSet, items.Select(i => i.ID));
}
