/// <inheritdoc />
public List <CountryTerritorialUnit> GetCanadaProvinces()
{
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/countries/canada/provinces",
Method = RequestMethod.Get,
Deserializer = new JsonResponseToTerritorialUnitsDeserializer(),
};
var result = Executor.ExecuteApiWithWrappedResponse <List <CountryTerritorialUnit> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Models.Payment CreateNewPayment(CreatePaymentRequest paymentRequest)
{
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/payments",
Method = RequestMethod.Post,
Body = paymentRequest,
};
var result = Executor.ExecuteApiWithWrappedResponse <Models.Payment>(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Models.Basket UpsertBasket(UpsertBasketParameters basketParameters)
{
ThrowArgumentExceptionIfBasketDetailsNotSet(basketParameters);
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/baskets",
Method = RequestMethod.Patch,
Body = basketParameters,
};
var response = Executor.ExecuteApiWithWrappedResponse <Models.Basket>(parameters);
return(response.DataOrException);
}
/// <inheritdoc />
public IList <MonthlyPriceRange> GetMonthlyPriceRanges(string productId, int quantity, DateTime fromDate, DateTime toDate)
{
ThrowArgumentExceptionIfProductIdNotSet(productId);
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/pricing/months/products/{productId}/quantity/{quantity}" +
$"/from/{fromDate.ToEncoreDate()}/to/{toDate.ToEncoreDate()}",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <IList <MonthlyPriceRange> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public IList <Product> GetProducts(GetProductsParameters requestParameters = null)
{
requestParameters = requestParameters ?? new GetProductsParameters();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/products",
Method = RequestMethod.Get,
Query = requestParameters,
};
var result = Executor.ExecuteApiWithWrappedResponse <List <Product> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public ResponseForPage <ExchangeRate> GetExchangeRates(ExchangeRatesParameters ratesParameters)
{
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/admin/exchange_rates",
Method = RequestMethod.Get,
Query = ratesParameters,
DateFormat = DateFormat,
};
var result = Executor.ExecuteApiWithWrappedResponse <ResponseForPage <ExchangeRate> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public IList <PriceBand> GetPriceBands(string productId, int quantity, DateTime?performanceDateTime = null)
{
ThrowArgumentExceptionIfProductIdNotSet(productId);
var queryParameters = new PriceBandsQueryParameters(performanceDateTime);
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/pricing/products/{productId}/quantity/{quantity}/bands",
Method = RequestMethod.Get,
Query = queryParameters,
};
var result = Executor.ExecuteApiWithWrappedResponse <IList <PriceBand> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Order CreateOrder(CreateOrderRequest orderRequest)
{
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/orders",
Method = RequestMethod.Post,
Body = orderRequest,
Deserializer = new JsonResponseToOrderDeserializer(),
};
var result = Executor.ExecuteApiWithWrappedResponse <Order>(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Models.Basket RemoveReservation(string basketReference, string reservationId)
{
ValidationHelper.ThrowArgumentExceptionIfNotSet(
("basket ID", basketReference),
("reservation ID", reservationId));
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/baskets/{basketReference}/reservations/{reservationId}",
Method = RequestMethod.Delete,
};
var response = Executor.ExecuteApiWithWrappedResponse <Models.Basket>(parameters);
return(response.DataOrException);
}
/// <inheritdoc />
public Models.Basket UpsertPromotion(string basketReference, Coupon coupon)
{
ThrowArgumentExceptionIfBasketReferenceNotSet(basketReference);
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/baskets/{basketReference}/applyPromotion",
Method = RequestMethod.Patch,
Body = new ApplyPromotionRequest {
Coupon = coupon
},
};
var result = Executor.ExecuteApiWithWrappedResponse <Models.Basket>(parameters);
return(GetUpsertPromotionResult(result, coupon, basketReference));
}
/// <inheritdoc />
public AvailabilityRange GetAvailabilityRange(string productId)
{
if (string.IsNullOrWhiteSpace(productId))
{
throw new ArgumentException("Product ID must be set");
}
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/products/{productId}/availability-range",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <AvailabilityRange>(parameters);
return(result.DataOrException);
}
private AccessToken JwtLogin()
{
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = Endpoint,
Method = RequestMethod.Post,
Body = new Credentials
{
Username = Context.UserName ?? string.Empty,
Password = Context.Password ?? string.Empty,
},
};
var result = Executor.ExecuteApiWithNotWrappedResponse <AccessToken>(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc/>
public IList <SeatDetailed> GetSeatAttributes(string venueId)
{
if (string.IsNullOrEmpty(venueId))
{
throw new ArgumentException("venue ID must be set");
}
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/venues/{venueId}/seats/attributes/detailed",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <List <SeatDetailed> >(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public IList <Availability> GetAvailabilities(string productId, int quantity, DateTime from, DateTime to)
{
if (string.IsNullOrWhiteSpace(productId))
{
throw new ArgumentException("Product ID must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/availability/products/{productId}/quantity/{quantity}/from/{from.ToEncoreDate()}/to/{to.ToEncoreDate()}",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <List <Availability> >(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Product GetProductById(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("product ID must be set");
}
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/products/{id}",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <Product>(parameters);
return(result.DataOrException);
}
/// <inheritdoc/>
public Models.Venue GetVenueById(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("venue ID must be set");
}
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/venues/{id}",
Method = RequestMethod.Get,
};
var result = Executor.ExecuteApiWithWrappedResponse <Models.Venue>(parameters);
return(result.DataOrException);
}
public SeatAvailability GetSeatAvailability(string productId, int quantity, SeatAvailabilityParameters parameters)
{
if (string.IsNullOrWhiteSpace(productId))
{
throw new ArgumentException("Product ID must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/europa/availability/products/{productId}/quantity/{quantity}/seats",
Method = RequestMethod.Get,
Query = new SeatAvailabilityQueryParameters(parameters),
};
var result = Executor.ExecuteApiWithWrappedResponse <SeatAvailability>(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc />
public PaymentInfo Checkout(BookingParameters bookingParameters)
{
if (bookingParameters == null)
{
throw new ArgumentException("booking parameters must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/checkout",
Method = RequestMethod.Post,
Body = new BookingQueryParameters(bookingParameters),
Serializer = new DefaultJsonSerializer(new DefaultNamingStrategy()),
};
var result = Executor.ExecuteApiWithWrappedResponse <PaymentInfo>(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc/>
public Models.Venue UpdateVenueById(Models.Venue venue)
{
if (string.IsNullOrEmpty(venue?.InternalId))
{
throw new ArgumentException("venue ID must be set");
}
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/admin/venues/{venue.InternalId}",
Method = RequestMethod.Post,
Body = venue,
};
var result = Executor.ExecuteApiWithWrappedResponse <Models.Venue>(parameters);
return(result.DataOrException);
}
/// <inheritdoc/>
public Attribute UpsertStandardAttributeByTitle(Attribute attribute)
{
if (string.IsNullOrEmpty(attribute?.Title))
{
throw new ArgumentException("attribute title must be set");
}
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/admin/attributes",
Method = RequestMethod.Patch,
Body = attribute,
};
var result = Executor.ExecuteApiWithWrappedResponse <Attribute>(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public Order UpdateOrder(string orderId, UpdateOrderRequest orderRequest)
{
if (string.IsNullOrWhiteSpace(orderId))
{
throw new ArgumentException("order ID must be set");
}
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/orders/{orderId}",
Method = RequestMethod.Patch,
Body = orderRequest,
Deserializer = new JsonResponseToOrderDeserializer(),
};
var result = Executor.ExecuteApiWithWrappedResponse <Order>(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public IList <Product> SearchProducts(string text)
{
if (string.IsNullOrWhiteSpace(text))
{
throw new ArgumentException("search text must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/search",
Method = RequestMethod.Get,
Query = new
{
query = text,
},
};
var result = Executor.ExecuteApiWithWrappedResponse <List <Product>, ProductSearchResponse, ProductSearchResponseContent>(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc />
public bool ConfirmBooking(string bookingReference, ConfirmBookingParameters bookingParameters)
{
if (string.IsNullOrWhiteSpace(bookingReference))
{
throw new ArgumentException("booking reference must not be empty");
}
if (bookingParameters == null)
{
throw new ArgumentException("parameters must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/bookings/{bookingReference}/confirm",
Method = RequestMethod.Post,
Body = bookingParameters,
};
var result = Executor.ExecuteApiWithWrappedResultsInResponse <string>(requestParameters);
return(result.DataOrException.Equals(ActionResultStatuses.Success, StringComparison.InvariantCultureIgnoreCase));
}
/// <inheritdoc />
public Order GetOrder(string channelId, string externalId)
{
if (string.IsNullOrWhiteSpace(channelId))
{
throw new ArgumentException("channel ID must be set");
}
if (string.IsNullOrWhiteSpace(externalId))
{
throw new ArgumentException("order external ID must be set");
}
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/orders/{channelId}/{externalId}",
Method = RequestMethod.Get,
Deserializer = new JsonResponseToOrderDeserializer(),
};
var result = Executor.ExecuteApiWithWrappedResponse <Order>(parameters);
return(result.DataOrException);
}
/// <inheritdoc />
public AggregateSeatAvailability GetAggregateSeatAvailability(string productId, AggregateSeatAvailabilityParameters parameters)
{
if (string.IsNullOrWhiteSpace(productId))
{
throw new ArgumentException("Product ID must be set");
}
if (parameters == null)
{
throw new ArgumentException("Parameters must be set");
}
var requestParameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/products/{productId}/areas",
Method = RequestMethod.Get,
Query = new AggregateSeatAvailabilityQueryParameters(parameters),
};
var result = Executor.ExecuteApiWithWrappedResponse <AggregateSeatAvailability>(requestParameters);
return(result.DataOrException);
}
/// <inheritdoc/>
public RestClientParameters CreateClientWrapperParameters(
ApiContext context,
string baseUrl,
ExecuteApiRequestParameters requestParameters)
{
var serializer = GetInitializedSerializer(requestParameters.Serializer, requestParameters.DateFormat);
var deserializer = GetInitializedSerializer(requestParameters.Deserializer, requestParameters.DateFormat);
return(new RestClientParameters
{
BaseUrl = baseUrl,
RequestUrl = requestParameters.Endpoint,
RequestMethod = requestParameters.Method,
RequestBody = requestParameters.Body,
RequestHeaders = GetHeaders(context),
RequestQueryParameters = GetQueryParameters(requestParameters.Query),
RequestDataFormat = serializer.SerializedDataFormat,
RequestDataSerializer = serializer,
ResponseDataFormat = deserializer.SerializedDataFormat,
ResponseDataDeserializer = deserializer,
});
}
/// <inheritdoc/>
public bool UpsertSeatAttributes(string venueId, IEnumerable <SeatDetailed> seatAttributes)
{
if (string.IsNullOrEmpty(venueId))
{
throw new ArgumentException("venue ID must be set");
}
TriggerAutomaticAuthentication();
var parameters = new ExecuteApiRequestParameters
{
Endpoint = $"v{ApiVersion}/admin/venues/{venueId}/seats/attributes",
Method = RequestMethod.Patch,
Body = new SeatAttributesRequest
{
Seats = seatAttributes ?? new List <SeatDetailed>(),
},
DateFormat = "yyyy-MM-dd",
Deserializer = new DefaultJsonSerializer(new[] { new SingleOrListToListConverter <string>() }),
};
var result = Executor.ExecuteApiWithWrappedResponse <List <string> >(parameters);
return(result.DataOrException?.Any(x =>
x.Equals(ActionResultStatuses.Success, StringComparison.InvariantCultureIgnoreCase)) ?? false);
}
public void CreateClientWrapperParameters_ReturnsParametersWithInitializedBaseProperties(ExecuteApiRequestParameters parameters)
{
var builder = new ApiRestClientBuilder();
var actual = builder.CreateClientWrapperParameters(It.IsAny <ApiContext>(), It.IsAny <string>(), parameters);
Assert.AreEqual(parameters.Endpoint, actual.RequestUrl);
Assert.AreEqual(parameters.Method, actual.RequestMethod);
Assert.AreEqual(parameters.Body, actual.RequestBody);
}
