/*follow the logic in Java code from here...https://developer.walmart.com/#/apicenter/marketPlace/v2#getReport */
private async Task <string> parseResponse(Base.Http.IResponse response, string folderName)
{
System.Net.Http.Headers.HttpContentHeaders headers = response.RawResponse.Content.Headers;
string fileDir = null;
using (Stream inputStream = await response.RawResponse.Content.ReadAsStreamAsync())
{
if ((response.StatusCode == System.Net.HttpStatusCode.OK) && (headers.ContentLength > 0))
{
try
{
var header = headers.GetValues("Content-Disposition").First();
if ((header != null) && (!header.Equals("")))
{
var length = header.Length;
var start = header.IndexOf("filename=");
var fileName = header.Substring(start, length - start);
var str = fileName.Split('=');
var dir = folderName + str[1];
using (Stream fileStream = new FileStream(dir, FileMode.Create, FileAccess.Write))
{
inputStream.CopyTo(fileStream);
}
fileDir = dir;
}
}
catch (System.Exception ex)
{
throw new Base.Exception.InvalidValueException("Error " + ex.Message);
}
}
}
return(fileDir);
}
public async Task <PartnerFeedResponse> GetFeedStatus(string feedId, bool includeDetails = false, int offset = 0, int limit = 0)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v3/feeds/{0}", feedId);
// by default it's false and we don't need to send it
if (includeDetails)
{
request.QueryParams.Add("includeDetails", "true");
}
if (offset > 0)
{
request.QueryParams.Add("offset", offset.ToString());
}
if (limit > 0)
{
request.QueryParams.Add("limit", limit.ToString());
}
Base.Http.IResponse response = await client.GetAsync(request);
PartnerFeedResponse result = await ProcessResponse <PartnerFeedResponse>(response);
return(result);
}
public async Task <PartnerFeedResponse> GetFeedStatus(string feedId, bool includeDetails = false, int offset = 0, int limit = 0)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v2/feeds/{0}", feedId);
request.QueryParams.Add("feedId", feedId);
if (includeDetails)
{
request.QueryParams.Add("includeDetails", "true");
if (offset > 0)
{
request.QueryParams.Add("offset", offset.ToString());
}
if (limit > 0)
{
if (limit > 1000)
{
throw new System.Exception("Parameter 'limit' can't be more than 1000!");
}
request.QueryParams.Add("limit", limit.ToString());
}
}
Base.Http.IResponse response = await client.GetAsync(request);
PartnerFeedResponse result = await ProcessResponse <PartnerFeedResponse>(response);
return(result);
}
public async Task <string> GetCPAReport(string folderName)
{
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v2/getReport?type=cpa";
Base.Http.IResponse response = await client.GetAsync(request);
return(await parseResponse(response, folderName));
}
public async Task <LagTime> GetLagTime(string merchantSku)
{
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v2/lagtime?sku={0}", merchantSku);
Base.Http.IResponse response = await client.GetAsync(request);
LagTime result = await ProcessResponse <LagTime>(response);
return(result);
}
public static ApiException Factory(IErrorsPayload errorDetails, Base.Http.IResponse errorResponse)
{
var httpResponse = errorResponse.RawResponse;
var exceptionMessage = string.Format("API Error Occured [{0} {1}]", ((int)httpResponse.StatusCode).ToString(), httpResponse.ReasonPhrase);
exceptionMessage += errorDetails.RenderErrors();
var exception = new ApiException(exceptionMessage);
exception.Details = errorDetails;
exception.Response = errorResponse;
return(exception);
}
public async Task <Inventory> UpdateInventory(string merchantSku, string bodyContent)
{
// avoiding deadlock if client execute this method synchronously
await new ContextRemover();
Base.Http.Request request = PrepareUpdateInventoryRequest(merchantSku, bodyContent);
Base.Http.IResponse response = await client.PutAsync(request);
Inventory result = await ProcessResponse <Inventory>(response);
return(result);
}
public async Task <ServiceResponse> GetPromotionPrice(string merchantSku)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v3/promo/sku/{0}", merchantSku);
Base.Http.IResponse response = await client.GetAsync(request);
ServiceResponse result = await ProcessResponse <ServiceResponse>(response);
return(result);
}
public async Task <ItemRetireResponse> RetireItem(string merchantSku)
{
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v3/items/{0}", merchantSku);
Base.Http.IResponse response = await client.DeleteAsync(request);
ItemRetireResponse result = await ProcessResponse <ItemRetireResponse>(response);
return(result);
}
public async Task <ItemResponse> GetItem(string merchantSku)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v3/items/{0}", merchantSku);
Base.Http.IResponse response = await client.GetAsync(request);
ItemResponses result = await ProcessResponse <ItemResponses>(response);
return(result.ItemResponse[0]);
}
public async Task FixedCountReturnResultForSuccessWithoutRetries()
{
var fetcher = new Mock <Base.Http.Fetcher.IFetcher>();
var request = new Mock <Base.Http.IRequest>();
var response = new Mock <Base.Http.IResponse>();
fetcher.Setup(t => t.ExecuteAsync(It.IsAny <Base.Http.IRequest>())).ReturnsAsync(response.Object);
var policy = new Base.Http.Retry.FixedCountPolicy(1);
Base.Http.IResponse result = await policy.GetResponse(fetcher.Object, request.Object);
Assert.Equal(result, response.Object);
}
public async Task <ItemRetireResponse> RetireItem(string merchantSku)
{
// avoiding deadlock if client execute this method synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v2/items/{0}", merchantSku);
Base.Http.IResponse response = await client.DeleteAsync(request);
ItemRetireResponse result = await ProcessResponse <ItemRetireResponse>(response);
return(result);
}
public async Task LuckyMeFetchResult()
{
var fetcher = new Mock <Base.Http.Fetcher.IFetcher>();
var request = new Mock <Base.Http.IRequest>();
var response = new Mock <Base.Http.IResponse>();
fetcher.Setup(t => t.ExecuteAsync(It.IsAny <Base.Http.IRequest>()))
.Returns(Task.FromResult(response.Object));
var policy = new Base.Http.Retry.LuckyMePolicy();
Base.Http.IResponse result = await policy.GetResponse(fetcher.Object, request.Object);
Assert.Equal(result, response.Object);
}
public async Task <Inventory> UpdateInventory(string merchantSku, System.IO.Stream stream)
{
// avoiding deadlock if client execute this method synchronously
await new ContextRemover();
var content = new StreamReader(stream).ReadToEnd();
Base.Http.Request request = PrepareUpdateInventoryRequest(merchantSku, content);
Base.Http.IResponse response = await client.PutAsync(request);
Inventory result = await ProcessResponse <Inventory>(response);
return(result);
}
public async Task <Inventory> GetInventory(string merchantSku)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v2/inventory";
request.QueryParams.Add("sku", merchantSku);
Base.Http.IResponse response = await client.GetAsync(request);
Inventory result = await ProcessResponse <Inventory>(response);
return(result);
}
public async Task <Inventory> UpdateInventory(Inventory inventory)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
// enforce XML serializer here, API doesn't support JSON in requests
var content = payloadFactory.GetSerializer(ApiFormat.XML).Serialize <Inventory>(inventory);
Base.Http.Request request = PrepareUpdateInventoryRequest(inventory.Sku, content);
Base.Http.IResponse response = await client.PutAsync(request);
Inventory result = await ProcessResponse <Inventory>(response);
return(result);
}
public async Task <FeedAcknowledgement> UploadFeed(System.IO.Stream file, V3.Payload.FeedType feedType)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/feeds";
request.QueryParams.Add("feedType", feedType.ToString());
request.AddMultipartContent(file);
Base.Http.IResponse response = await client.PostAsync(request);
FeedAcknowledgement result = await ProcessResponse <FeedAcknowledgement>(response);
return(result);
}
public async Task FixedCountMultipleAttemptsGiveResult()
{
var fetcher = new Mock <Base.Http.Fetcher.IFetcher>();
var request = new Mock <Base.Http.IRequest>();
var response = new Mock <Base.Http.IResponse>();
fetcher.SetupSequence(t => t.ExecuteAsync(It.IsAny <Base.Http.IRequest>()))
.ThrowsAsync(new Base.Http.Exception.HttpException("test"))
.ThrowsAsync(new Base.Http.Exception.HttpException("test"))
.Returns(Task.FromResult(response.Object));
var policy = new Base.Http.Retry.FixedCountPolicy(3);
Base.Http.IResponse result = await policy.GetResponse(fetcher.Object, request.Object);
Assert.Equal(result, response.Object);
}
public async Task <TokenFeedResponse> GetToken()
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/token";
request.HttpRequest.Content = new StringContent("grant_type=client_credentials");
request.HttpRequest.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-www-form-urlencoded");
Base.Http.IResponse response = await client.PostAsync(request);
TokenFeedResponse result = await ProcessResponse <TokenFeedResponse>(response);
return(result);
}
public async Task <ItemPriceResponse> UpdatePromotionPrice(Stream stream)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/price?promo=true";
var payload = new StreamReader(stream).ReadToEnd();
request.HttpRequest.Content = new StringContent(payload);
//set the headers to avoid broken responses because of encodding=utf-8
request.HttpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(request.GetContentType());
Base.Http.IResponse response = await client.PutAsync(request);
ItemPriceResponse result = await ProcessResponse <ItemPriceResponse>(response);
return(result);
}
public async Task <ItemPriceResponse> UpdatePrice(string sku, string currency, double price)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v2/prices";
request.QueryParams.Add("sku", sku);
request.QueryParams.Add("currency", currency);
request.QueryParams.Add("price", price.ToString());
request.HttpRequest.Content = new StringContent("");
request.HttpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(request.GetContentType());
Base.Http.IResponse response = await client.PutAsync(request);
ItemPriceResponse result = await ProcessResponse <ItemPriceResponse>(response);
return(result);
}
public async Task <ItemPriceResponse> UpdatePrice(Stream stream)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/price";
var payload = new StreamReader(stream).ReadToEnd();
request.HttpRequest.Content = new StringContent(payload);
// have to explicitly set this header for content, otherwise it also has encodding=utf-8
// and it breaks response from API
request.HttpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(request.GetContentType());
Base.Http.IResponse response = await client.PutAsync(request);
ItemPriceResponse result = await ProcessResponse <ItemPriceResponse>(response);
return(result);
}
public async Task PutRequestGoThroughRetryPolicy()
{
var response = new Mock <Base.Http.IResponse>();
var request = new Mock <Base.Http.IRequest>();
var policy = new Mock <Base.Http.Retry.IRetryPolicy>();
policy.Setup(t => t.GetResponse(It.IsAny <IFetcher>(), It.IsAny <Base.Http.IRequest>()))
.ReturnsAsync(response.Object);
var config = new Mock <Base.Primitive.Config.IHttpConfig>();
config.Setup(t => t.RequestTimeoutMs).Returns(1000);
config.Setup(t => t.BaseUrl).Returns("http://www.test.com");
var handler = new Base.Http.Handler(config.Object)
{
RetryPolicy = policy.Object
};
Base.Http.IResponse result = await handler.PutAsync(request.Object);
Assert.Equal(response.Object, result);
}
public async Task <EnrollmentResponse> SetupAllCpaSku(bool enroll)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/cppreference";
var content = JsonConvert.SerializeObject(new Payload.Cpa.Enrollment()
{
Enroll = enroll
});
request.HttpRequest.Content = new StringContent(content, Encoding.UTF8, "application/json");
request.HttpRequest.Headers.Add("Accept", "application/json");
Base.Http.IResponse response = await client.PostAsync(request);
var responseContent = await response.GetPayloadAsString();
EnrollmentResponse result = JsonConvert.DeserializeObject <EnrollmentResponse>(responseContent);
return(result);
}
public async Task <ItemResponses> GetAllItems(int limit = 10, int offset = 0)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = "/v3/items";
if (limit > 0)
{
request.QueryParams.Add("limit", limit.ToString());
}
if (offset > 0)
{
request.QueryParams.Add("offset", offset.ToString());
}
Base.Http.IResponse response = await client.GetAsync(request);
ItemResponses result = await ProcessResponse <ItemResponses>(response);
return(result);
}
public abstract System.Exception CreateApiException(ApiFormat format, string content,
Base.Http.IResponse response);
