public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
Coupon coupon;
try
{
coupon = await _repository.GetDiscount(request.ProductName);
if (coupon == null)
{
_logger.LogError($"Discount with ProductName: {request.ProductName} was not found.");
throw new RpcException(new Status(StatusCode.NotFound,
$"Discount with ProductName: {request.ProductName} was not found."));
}
}
catch (Exception ex)
{
throw new Exception($"Something went wrong", ex);
}
_logger.LogInformation($"Successfully received: {coupon}");
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public async Task <CouponModel> GetDiscount(int id)
{
var discountRequest = new GetDiscountRequest {
Id = id
};
return(await _discountProtoService.GetDiscountAsync(discountRequest));
}
public async Task <DiscountModel> GetDiscount(string discountCode)
{
var discountRequest = new GetDiscountRequest {
DiscountCode = discountCode
};
return(await _discountProtoService.GetDiscountAsync(discountRequest));
}
public async Task <CouponModel> GetDiscount(string productName)
{
var discountRequest = new GetDiscountRequest {
ProductName = productName
};
return(await _discountProtoService.GetDiscountAsync(discountRequest));
}
public async Task <CouponResponse> GetDiscount(string productId)
{
var discountRequest = new GetDiscountRequest {
ProductId = productId
};
return(await _discountProtoService.GetDiscountAsync(discountRequest));
}
public async Task <IActionResult> GetDiscount([FromQuery] GetDiscountRequest request)
{
var query = _mapper.Map <GetDiscountQuery>(request);
var result = await _mediator.Send(query);
var response = _mapper.Map <GetDiscountResponse>(result);
return(Ok(response));
}
public async Task <CouponModel> GetDiscount(string productName)
{
var discountRequest = new GetDiscountRequest {
ProductName = productName
};
//dohvaćamo getdiscount grpc service
return(await _discountProtoServiceClient.GetDiscountAsync(discountRequest));
}
public async Task <DiscountModel> GetDiscount(string code)
{
var request = new GetDiscountRequest
{
DiscountCode = code
};
return(await _discountProtoServiceClient.GetDiscountAsync(request));
}
/// <summary>
/// Get discount for particular product from Discount.Grpc service.
/// </summary>
/// <param name="productName">Name of particular product.</param>
/// <returns></returns>
public async Task <CouponModel> GetDiscount(string productName)
{
var discountRequest = new GetDiscountRequest {
ProductName = productName
};
// AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
return(await _discountProtoServiceClient.GetDiscountAsync(discountRequest));
}
public override async Task <CouponDTO> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _discountRepository.GetCouponByProductName(request.ProductName);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Coupon not found"));
}
return(_mapper.Map <CouponDTO>(coupon));
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
Coupon coupon = await _discountRepository.GetDiscount(request.ProductName);
CouponModel couponModel = GetCouponModel(coupon, request.ProductName);
_logger.LogInformation("Discount is retrieved for ProductName : {productName}, Amount : {amount}", coupon.ProductName, coupon.Amount);
return(couponModel);
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _repository.GetDiscount(request.ProductName) ??
throw new RpcException(new Status(StatusCode.NotFound, $"Discount with ProductName={request.ProductName} is not found."));
_logger.LogInformation("Discount is retrieved for ProductName : {productName}, Amount : {amount}", coupon.ProductName, coupon.Amount);
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public async Task <ShoppingCart> UpdateBasketAsync(ShoppingCart basket)
{
foreach (var item in basket.Items)
{
var discount_request = new GetDiscountRequest {
ProductName = item.ProductName
};
var discount = _discountClient.GetDiscount(discount_request);
item.Price -= decimal.Parse(discount.Amount.ToString());
}
return(await _basketRepository.UpdateBasketAsync(basket));
}
public override async Task <DiscountModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var discountFromDb = await _discountContext.Discounts.FirstOrDefaultAsync(x => x.Code == request.DiscountCode);
if (discountFromDb == null)
{
throw new RpcException(new Status(StatusCode.NotFound, "Invalid Code Request"));
}
var discountModel = _mapper.Map <DiscountModel>(discountFromDb);
return(await Task.FromResult(discountModel));
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _repository.GetDiscount(request.ProductName);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Discount with ProductName={request.ProductName} is not found."));
}
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _repository.GetCoupon(request.Id, false);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Discount with Id {request.Id} not found"));
}
_logger.LogInformation("Coupon is retrieved for CategoryName : {categoryName}, Discount : {discount}%", coupon.Id, coupon.DiscountPercentage);
return(_mapper.Map <CouponModel>(coupon));
}
public override Task <DiscountModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var discount = DiscountContext.Discounts.FirstOrDefault(d => d.Code == request.DiscountCode);
_logger.LogInformation($"Discount is operated with the {discount.Code} code and the amount is : {discount.Amount}");
return(Task.FromResult(new DiscountModel
{
DiscountId = discount.DiscountId,
Code = discount.Code,
Amount = discount.Amount
}));
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
return(await Task.Run(() =>
{
var coupon = _couponService.GetCouponByProductId(request.ProductId);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Discount not found with product identifier:{request.ProductId}"));
}
var model = coupon.ToModel <CouponModel>();
return model;
}));
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _repo.GetDiscount(request.ProductName);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound,
$"Discount with ProductName={request.ProductName} cannot be found."));
}
_logger.LogInformation(
$"Discount is being retrieved fro ProductName : {coupon.ProductName}, Amount: {coupon.Amount}");
return(_mapper.Map <CouponModel>(coupon));
}
public override async Task <CouponModel> GetDiscount(GetDiscountRequest request, global::Grpc.Core.ServerCallContext context)
{
var coupon = await _repository.GetDiscount(request.ProductName);
if (coupon == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Discunt for product {request.ProductName} was not found"));
}
_logger.LogInformation(
"Discount is retrieved for ProductName : {productName}, Amount : {amount}", coupon.ProductName, coupon.Amount);
var couponModel = _mapper.Map <CouponModel>(coupon);
return(couponModel);
}
public async Task NegativeResponsesAreValid()
{
var jsonOpts = LikePharmaClientOptions.CreateDefaultJsonSerializerOptions();
var protSet = ProtocolSettings.CreateOlekstra();
var req = new GetDiscountRequest
{
PosId = "12345",
PharmacyId = "123",
CardNumber = "1234567890",
PhoneNumber = "+79000000000",
AnyData = "abc",
};
var jsonText = LikePharmaClient.SerializeJson(req, protSet, jsonOpts);
var jsonBytes = Encoding.UTF8.GetBytes(jsonText);
using var body = new MemoryStream();
body.Write(jsonBytes, 0, jsonBytes.Length);
body.Position = 0;
context.Request.Method = "POST";
context.Request.Path = "/get_discount";
context.Request.ContentType = "application/json";
context.Request.Body = body;
context.Response.Body = new MemoryStream();
await middleware.InvokeAsync(context).ConfigureAwait(false);
Assert.Equal(200, context.Response.StatusCode);
context.Response.Body.Position = 0;
using var sr = new StreamReader(context.Response.Body);
var respText = await sr.ReadToEndAsync().ConfigureAwait(false);
var resp = LikePharmaClient.DeserializeJson <GetDiscountResponse>(respText, protSet, jsonOpts);
var validator = new LikePharmaValidator(protSet);
var valid = validator.TryValidateObject(resp, out var results);
Assert.Empty(results);
Assert.True(valid);
}
public override async Task <CouponResponse> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var coupon = await _discountRepository.GetDiscount(request.ProductId);
if (coupon == null)
{
_logger.LogError(new RpcException(new Status(StatusCode.NotFound,
$"Error finding result for productId={request.ProductId}")),
$"Discount with ProductId={request.ProductId} is not found.");
return(null);
}
_logger.LogInformation($"Discount retrieved for ProductId: {coupon.ProductId} - Amount: {coupon.Amount}");
var couponResponse = _mapper.Map <CouponResponse>(coupon);
return(couponResponse);
}
public override Task <DiscountModel> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
var discount = DiscountContext.Discounts
.FirstOrDefault(r => r.Code == request.DiscountCode);
if (discount == null)
{
throw new RpcException(new Status(StatusCode.NotFound,
$"Discount with {request.DiscountCode} code was not found"));
}
var response = new DiscountModel
{
Amount = discount.Amount,
Code = discount.Code,
DiscountId = discount.DiscountId
};
return(Task.FromResult(response));
}
/// <inheritdoc />
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (validationContext == null)
{
throw new ArgumentNullException(nameof(validationContext));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var(card, phone) = value switch
{
GetDiscountRequest val => (val.CardNumber, val.PhoneNumber),
GetDiscountResponse val => (val.CardNumber, val.PhoneNumber),
ConfirmPurchaseRequest val => (val.CardNumber, val.PhoneNumber),
CancelPurchaseRequest val => (val.CardNumber, val.PhoneNumber),
_ => throw new ArgumentException(ValidationMessages.CardOrPhoneNumberAttribute_InvalidValue, nameof(value)),
};
var haveCard = !string.IsNullOrEmpty(card);
var havePhone = !string.IsNullOrEmpty(phone);
var policy = (ProtocolSettings)validationContext.GetService(typeof(ProtocolSettings));
if (policy == null)
{
throw new ApplicationException(ValidationMessages.ValidationPolicyNotFound);
}
switch (policy.CardAndPhoneUsage)
{
case CardAndPhoneUsage.CardOnly:
if (!haveCard)
{
return(new ValidationResult(string.Format(CultureInfo.InvariantCulture, ValidationMessages.ValueRequired, CardNumberFieldName)));
}
if (havePhone)
{
return(new ValidationResult(string.Format(CultureInfo.InvariantCulture, ValidationMessages.ValueProhibited, PhoneNumberFieldName)));
}
return(ValidationResult.Success);
case CardAndPhoneUsage.PhoneOnly:
if (!havePhone)
{
return(new ValidationResult(string.Format(CultureInfo.InvariantCulture, ValidationMessages.ValueRequired, PhoneNumberFieldName)));
}
if (haveCard)
{
return(new ValidationResult(string.Format(CultureInfo.InvariantCulture, ValidationMessages.ValueProhibited, CardNumberFieldName)));
}
return(ValidationResult.Success);
case CardAndPhoneUsage.CardOrPhone:
if (!haveCard && !havePhone)
{
return(new ValidationResult(ValidationMessages.NeedCardOrPhone));
}
return(ValidationResult.Success);
case CardAndPhoneUsage.CardXorPhone:
if (haveCard == havePhone)
{
return(new ValidationResult(ValidationMessages.NeedEitherCardOrPhone));
}
return(ValidationResult.Success);
case CardAndPhoneUsage.CardAndPhone:
if (!haveCard || !havePhone)
{
return(new ValidationResult(ValidationMessages.NeedCardAndPhone));
}
return(ValidationResult.Success);
default:
throw new ApplicationException(string.Format(CultureInfo.InvariantCulture, ValidationMessages.InvalidCardAndPhoneUsageValue, policy.CardAndPhoneUsage));
}
}
public override async Task <VoucherContract> GetDiscount(GetDiscountRequest request, ServerCallContext context)
{
return(_mapper.Map <VoucherContract>(await _discountRepository.GetVoucher(request.ProductName)));
}
// <inheritdocs />
public Task <GetDiscountResponse> GetDiscountAsync(GetDiscountRequest request, string user)
{
throw new NotImplementedException();
}
