/// <summary>
/// Price Request/Response
/// </summary>
/// <param name="priceWmRequest"></param>
/// <returns></returns>
public PriceResponse GetPrice(PriceRequest priceWmRequest)
{
var priceResponse = new PriceResponse();
var request = priceWmRequest.ToWmPriceRequest();
var backup = new BackupLogEntry(request, "PriceRequest");
LogRequest(request, "PriceRequest");
var wmPriceResponse = _soapStoreFrontWebService.PriceWebServiceAsync(request).Result;
backup.AddResponse(wmPriceResponse);
_repository.InsertOne(backup);
LogResponse(wmPriceResponse);
var failedProducts = new List <FailedProduct>();
while (wmPriceResponse.ErrorReturn != null)
{
var productId = GetProductFromMaterialErrorMessage(wmPriceResponse.ErrorReturn.Error);
if (productId == Empty)
{
priceResponse.ErrorMessage = wmPriceResponse.ErrorReturn.Error;
return(priceResponse);
}
Log($"{ErrorMessages.ERRORS_CONTAINED_IN_RESPONSE} for product {productId}");
var failedProduct = new FailedProduct {
ErrorMessage = wmPriceResponse.ErrorReturn.Error, PartNumber = productId
};
failedProducts.Add(failedProduct);
var newProductLists = request.PricingRequest.ProductList.Where(val => val.ProductID != productId).ToArray();
//I don't see why or how this will be needed (if no edge case is reported by 1/1/2020, remove this line altogether)
//if (newProductLists.Length == request.PricingRequest.ProductList.Length) break;
request.PricingRequest.ProductList = newProductLists;
if (newProductLists.Length == 0)
{
break;
}
Log(InfoMessages.SEND_DATA_CORRECTED_INPUT_REQUEST);
var backup2 = new BackupLogEntry(request, "PriceRequest");
LogRequest(request, "Additional PriceRequests (to handle failed products)");
wmPriceResponse = _soapStoreFrontWebService.PriceWebServiceAsync(request).Result;
backup2.AddResponse(wmPriceResponse);
_repository.InsertOne(backup2);
LogResponse(wmPriceResponse);
}
priceResponse = wmPriceResponse.ToPriceResponse();
if (failedProducts.Count == 0)
{
return(priceResponse);
}
priceResponse.FailedProducts = failedProducts;
priceResponse.ErrorMessage = "We were not able to obtain prices for all requested products. Please see list of failed products.";
return(priceResponse);
}
public void TestGetPrice()
{
decimal actualPrice = Decimal.Parse("92.67");
decimal actualTax = Decimal.Parse("11.1204");
string actualInsurer = "zxcvbnm";
var request = new PriceRequest()
{
RiskData = new RiskData()
{
DOB = DateTime.Parse("1980-01-01"),
FirstName = "John",
LastName = "Smith",
Make = "Cool New Phone",
Value = 500
}
};
decimal tax = 0;
string insurer = "";
string error = "";
var expectedPrice = priceEngine.GetPrice(request, out tax, out insurer, out error);
Assert.AreEqual(actualPrice, expectedPrice);
Assert.AreEqual(actualTax, tax);
Assert.AreEqual(actualInsurer, insurer);
}
public async IAsyncEnumerable <string> Subscribe(
string uic,
string assetType,
[EnumeratorCancellation]
CancellationToken cancellationToken)
{
var url = Environment.GetEnvironmentVariable("PRICING_STREAM_ENDPOINT");
using var channel = GrpcChannel.ForAddress(url);
var client = new Pricing.PricingClient(channel);
var request = new PriceRequest {
Uic = uic, AssetType = assetType
};
var streamReader = client.Subscribe(request).ResponseStream;
yield return($"Info: Opened channel to : {url}");
yield return("Info: Waiting for data from gRPC server");
while (await streamReader.MoveNext())
{
cancellationToken.ThrowIfCancellationRequested();
yield return($"Data: {streamReader.Current}");
}
Console.WriteLine("Gracefully ended.");
}
public async System.Threading.Tasks.Task GetPrice_GBP_Books_Cost_Match()
{
var bookList = new PriceRequest()
{
BookList = new BookList
{
Book1 = 2,
Book2 = 2,
Book3 = 2,
Book4 = 1,
Book5 = 1
}
};
var priceResponse = new PriceResponse
{
GBP = 51.20m,
Euro = 56.32m
};
var request = new GetPrice(bookList);
var cancellationToken = new CancellationToken();
var expected = new GetPriceResponse(priceResponse).PriceResponse.GBP;
var actual = await _getPriceHandler.Handle(request, cancellationToken).ConfigureAwait(false);
Assert.AreEqual(actual.PriceResponse.GBP, expected);
}
public void Test_CalculatePrice_ReturnsWithoutDiscount()
{
var priceRequest = new PriceRequest
{
UserType = (long)UserTypeEnum.NormalUser,
GoldPrice = 10,
Weight = 5
};
var priceResponse = new PriceCalculatorResponse
{
GoldPrice = priceRequest.GoldPrice,
Weight = priceRequest.Weight,
TotalPrice = priceRequest.GoldPrice * priceRequest.Weight,
Discount = null
};
PriceCalculatorService service = new PriceCalculatorService(repositoryMock.Object, factoryMock.Object);
var arg = new AbstractPriceCreateArg
{
UserType = (UserTypeEnum)priceRequest.UserType,
PriceCalculatorService = service
};
var product = new AbstractPriceCreateResponse
{
Product = new NormalPriceProduct(service)
};
factoryMock.Setup(p => p.Create(arg)).Returns(product);
var result = product.Product.CalculatePrice(priceRequest);
Assert.NotNull(result);
Assert.Null(result.Discount);
Assert.True(result.TotalPrice == priceResponse.TotalPrice);
}
public void Price_CustomerIdIsEmpty_ThrowsUserIdInvalidException()
{
decimal dec = 1;
_rideService.CalculatePriceAsync(null, null, RideType.SoloRide).ReturnsForAnyArgs(dec);
//Setup the user so we have access to the claim stored in 'Constants.UserIdClaim'
_ridesController.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(Constants.UserIdClaim, "") //This would be the id of the customer
}))
}
};
var request = new PriceRequest
{
EndAddress = null,
RideType = RideType.SoloRide,
StartAddress = null
};
Assert.That(() => _ridesController.Price(null, request), Throws.TypeOf <UserIdInvalidException>());
}
public void Test_CalculatePrice_ReturnsWithoutDiscount()
{
var priceRequest = new PriceRequest
{
UserType = (long)UserTypeEnum.NormalUser,
GoldPrice = 10,
Weight = 5
};
var priceResponse = new PriceCalculatorResponse
{
GoldPrice = priceRequest.GoldPrice,
Weight = priceRequest.Weight,
TotalPrice = priceRequest.GoldPrice * priceRequest.Weight,
Discount = null
};
serviceMock.Setup(p => p.CalculatePrice(priceRequest)).Returns(priceResponse);
PriceCalculatorController controller = new PriceCalculatorController(serviceMock.Object);
var result = controller.Post(priceRequest);
Assert.NotNull(result);
Assert.Null(result.Discount);
Assert.True(result.TotalPrice == priceResponse.TotalPrice);
}
static async Task Main(string[] args)
{
var sw = new Stopwatch();
const string host = "https://workshop.ursatile.com:5003";
using var channel = GrpcChannel.ForAddress(host);
var client = new Pricing.PricingEngine.PricingEngineClient(channel);
var req = new PriceRequest {
Make = "Ferrari",
Model = "F40",
Year = 1981
};
while (true)
{
sw.Stop();
sw.Reset();
sw.Start();
var reply = await client.GetPriceAsync(req);
sw.Stop();
Console.Write(reply);
Console.Write("gRPC call took {0}ms", sw.ElapsedMilliseconds);
Console.ReadKey(false);
}
}
public override Task <PriceReply> GetPrice(PriceRequest request, ServerCallContext context)
{
(int price, string currency) = CalculatePrice(request.Make, request.Model, request.Year, request.Colour);
return(Task.FromResult(new PriceReply {
Price = price, Currency = currency
}));
}
public async Task Price_Success_ReturnsOkResponse()
{
decimal dec = 1;
_rideService.CalculatePriceAsync(null, null, RideType.SoloRide).ReturnsForAnyArgs(dec);
//Setup the user so we have access to the claim stored in 'Constants.UserIdClaim'
_ridesController.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(Constants.UserIdClaim, "SomeCustomerId") //This would be the id of the customer
}))
}
};
var request = new PriceRequest
{
EndAddress = null,
RideType = RideType.SoloRide,
StartAddress = null
};
var response = await _ridesController.Price(null, request) as ObjectResult;
Assert.That(response.StatusCode, Is.EqualTo(StatusCodes.Status200OK));
}
public ActionResult <PriceResponseModel> GetPrice([FromBody] PriceRequest request)
{
if (request == null)
{
Log(InfoMessage.ERROR_MSG_INVALID_PRICE_REQUEST);
return(BadRequest(InfoMessage.ERROR_MSG_INVALID_PRICE_REQUEST));
}
if (!ModelState.IsValid)
{
Log(InfoMessage.ERROR_MSG_INVALID_PRICE_REQUEST_MODEL);
return(BadRequest(ModelState));
}
var priceResponseEntity = _productService.GetPrice(request);
if (priceResponseEntity == null)
{
Log(InfoMessage.ERROR_MSG_UNABLE_TO_GET_PRICE_RESPONSE);
return(NotFound(InfoMessage.ERROR_MSG_UNABLE_TO_GET_PRICE_RESPONSE));
}
return(Ok(priceResponseEntity));
//return Ok(new PriceResponseModel(priceResponseEntity));
}
public async System.Threading.Tasks.Task GetPrice_Euro_Match()
{
var bookList = new PriceRequest()
{
BookList = new BookList
{
Book1 = 0,
Book2 = 0,
Book3 = 0,
Book4 = 0,
Book5 = 0
}
};
var priceResponse = new PriceResponse
{
GBP = 0m,
Euro = 0m
};
var request = new GetPrice(bookList);
var cancellationToken = new CancellationToken();
var expected = new GetPriceResponse(priceResponse).PriceResponse.Euro;
var actual = await _getPriceHandler.Handle(request, cancellationToken).ConfigureAwait(false);
Assert.AreEqual(actual.PriceResponse.Euro, expected);
}
/// <summary>
///
/// </summary>
/// <param name="agentcode"></param>
/// <param name="express_service"></param>
/// <param name="sku"></param>
/// <param name="warehouse"></param>
/// <param name="to_region"></param>
/// <param name="to_country"></param>
/// <param name="to_zip_code"></param>
/// <param name="to_city"></param>
/// <param name="weight"></param>
/// <param name="size"></param>
/// <returns></returns>
public SummaryInfo GetDirectExpressShippingFee(PriceRequest requst)
{
Dictionary <string, string> param = new Dictionary <string, string>();
param.Add("Packing", requst.Packing.Length.ToString() + "*" + requst.Packing.Width.ToString() + "*" + requst.Packing.Height.ToString());
param.Add("weight_in_gram", requst.Weight.ToString());
param.Add("Country", requst.ShipToCountryName);
param.Add("service", requst.ExpressService);
CK1V3Request request = new CK1V3Request
{
Category = "direct-express",
Handler = "package",
Action = "pricing",
Parameters = param
};
//Packing packing = new Packing();
string json = ResponseJson(request);
PriceResponse response = JsonConvert.DeserializeObject <PriceResponse>(json);
SummaryInfo summary = new SummaryInfo();
summary = response.body.Summary[0];
return(summary);
}
//Funcion para insertar un nuevo registro
public String InsertPrice(PriceRequest priceRequest)
{
try
{
PriceResponse priceResponse = GetPriceByVehicleType(priceRequest.idVehicleType);
if (priceResponse == null)
{
Price price = new Price();
price.idVehicleType = priceRequest.idVehicleType;
price.valueMinute = priceRequest.valueMinute;
price.valueMonth = priceRequest.valueMonth;
db.Price.Add(price);
db.SaveChanges();
mensaje = "OK";
}
else
{
mensaje = "PRICE_EXIST_FOR_THIS_VEHICLE_TYPE";
}
}
catch (DbEntityValidationException e)
{
mensaje = "Error al crear un precio" + e;
}
return(mensaje);
}
public void Validate_StartDate_ShouldBeValidated(string startDate, bool expectedValid)
{
var model = new PriceRequest {
StartDate = startDate
};
AssertValidationResult(request => request.StartDate, model, expectedValid);
}
public void Validate_ApprenticeshipHashedId_ShouldBeValidated(string apprenticeshipHashedId, bool expectedValid)
{
var model = new PriceRequest {
ApprenticeshipHashedId = apprenticeshipHashedId
};
AssertValidationResult(request => request.ApprenticeshipHashedId, model, expectedValid);
}
public void Validate_EmployerAccountLegalEntityPublicHashedId_ShouldBeValidated(string employerAccountLegalEntityPublicHashedId, bool expectedValid)
{
var model = new PriceRequest {
EmployerAccountLegalEntityPublicHashedId = employerAccountLegalEntityPublicHashedId
};
AssertValidationResult(request => request.EmployerAccountLegalEntityPublicHashedId, model, expectedValid);
}
public void ThenProviderIdIsValidated(long providerId, bool expectedValid)
{
var request = new PriceRequest {
ProviderId = providerId
};
AssertValidationResult(x => x.ProviderId, request, expectedValid);
}
// GET: Price
public async Task <ActionResult> Index(PriceRequest req)
{
return(new JsonResult()
{
Data = await new PriceLogic().Get(req.Address, req.ShipmentType, req.Vehicle),
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public decimal CalculatePricePerUnit(PriceRequest model)
{
var m = measureUnitApp.GetAll().Result;
var pType = m.FirstOrDefault(m => m.MeasureUnitId == model.ProductMeasureUnit).MeasureUnitTypeId;
var qType = m.FirstOrDefault(m => m.MeasureUnitId == model.QuantityMeasureUnit).MeasureUnitTypeId;
return(pricingApp.CalculatePricePerUnit(model, pType, qType));
}
public void Validate_EndDate_ShouldBeValidated(string endDate, bool expectedValid)
{
var model = new PriceRequest {
EndDate = endDate
};
AssertValidationResult(request => request.EndDate, model, expectedValid);
}
public virtual PriceCalculatorResponse CalculatePrice(PriceRequest request)
{
return(new PriceCalculatorResponse
{
GoldPrice = request.GoldPrice,
Weight = request.Weight,
TotalPrice = request.GoldPrice * request.Weight
});
}
private PriceReply GetPriceForVehicle(PriceRequest request)
{
//TODO: calculate prices properly
return(new PriceReply {
StatusCode = "OK",
Price = 50,
CurrencyCode = "GBP"
});
}
public override Task <PriceResponse> GetPrice(PriceRequest request, ServerCallContext context)
{
var price = GetPrice(request.Make, request.Model, request.Year);
return(Task.FromResult(new PriceResponse {
Price = price.Item1,
Currency = price.Item2
}));
}
public double GetPriceByTerm(PriceRequest request)
{
var priceValue = _context.Prices
.Where(p => p.PackageId == request.PackageId)
.Where(p => p.TermId == request.TermId)
.Select(p => p.PriceValue)
.FirstOrDefault();
return(priceValue);
}
public override Task <PriceReply> GetPrice(PriceRequest request, ServerCallContext context)
{
if (request.Manufacturer == "ASTON MARTIN")
{
}
var reply = GetPriceForVehicle(request);
return(Task.FromResult(reply));
}
public void UnsubscribePrices(string symbol)
{
PriceRequest pr = new PriceRequest
{
Channel = ChannelType.Prices,
Action = ActionType.Unsubscribe,
Symbol = symbol
};
AddMessageToQueue(pr);
}
public override PriceCalculatorResponse CalculatePrice(PriceRequest request)
{
var price = base.CalculatePrice(request);
var discount = _priceCalculatorService.GetDiscount(request.UserType);
price.Discount = discount.Discount;
var finalPrice = price.TotalPrice - ((price.TotalPrice * discount.Discount) / 100) ?? 0;
price.TotalPrice = Math.Round(finalPrice, 2, MidpointRounding.AwayFromZero);
return(price);
}
private dynamic mapRequest(PriceRequest priceRequest)
{
dynamic systemRequest2 = new ExpandoObject();
systemRequest2.FirstName = priceRequest.RiskData.FirstName;
systemRequest2.LastName = priceRequest.RiskData.LastName;
systemRequest2.Make = priceRequest.RiskData.Make;
systemRequest2.Value = priceRequest.RiskData.Value;
return(systemRequest2);
}
private PriceRequest CreatePriceRequest(Submission submission)
{
var priceRequest = new PriceRequest()
{
RessourceUsage = submission.RessourceUsage,
DateTime = submission.DateTime,
UnitOfMeassure = submission.UnitOfMeassure
};
return(priceRequest);
}
