public IActionResult RegisterOrder([FromBody] RegisterOrderModel registerOrderInfo)
{
try
{
var registerOrder = new RegisterOrder()
{
Amount = registerOrderInfo.Amount,
CardHolderName = registerOrderInfo.CardHolderName,
CardNumber = registerOrderInfo.CardNumber,
ExpiryDate = registerOrderInfo.ExpiryDate,
Address = registerOrderInfo.Address,
Email = registerOrderInfo.Email,
Name = registerOrderInfo.Name
};
using (var bus = RabbitMqConnectionHelper.Get())
{
bus.Publish(registerOrder, cfg => cfg.WithQueueName(RabbitMqServer.Registration.OrderQueue));
return(Ok());
}
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
}
public RegisterOrderUnitTest()
{
_mockIOrderGateway = new Mock <IOrderGateway>();
_mockIRestaurantGateway = new Mock <IRestaurantGateway>();
_registerOrder = new RegisterOrder(_mockIOrderGateway.Object, _mockIRestaurantGateway.Object);
}
/// <summary>
/// Converts two ModbusRegisters to 32 Bit Integer Value - Registers can be swapped
/// </summary>
/// <param name="registers">Two Register values received from Modbus</param>
/// <param name="registerOrder">Desired Word Order (Low Register first or High Register first</param>
/// <returns>Connecteds 32 Bit Integer value</returns>
public static Int32 ConvertRegistersToInt(int[] registers, RegisterOrder registerOrder)
{
int[] swappedRegisters = { registers[0], registers[1] };
if (registerOrder == RegisterOrder.HighLow)
{
swappedRegisters = new int[] { registers[1], registers[0] }
}
;
return(ConvertRegistersToInt(swappedRegisters));
}
/// <summary>
/// Converts 64 Bit double prec. Value to four ModbusRegisters - Registers can be swapped
/// </summary>
/// <param name="doubleValue">double value which has to be converted into four registers</param>
/// <param name="registerOrder">Desired Word Order (Low Register first or High Register first</param>
/// <returns>Register values</returns>
public static int[] ConvertDoubleToRegisters(double doubleValue, RegisterOrder registerOrder)
{
int[] registerValues = ConvertDoubleToRegisters(doubleValue);
int[] returnValue = registerValues;
if (registerOrder == RegisterOrder.HighLow)
{
returnValue = new int[] { registerValues[3], registerValues[2], registerValues[1], registerValues[0] }
}
;
return(returnValue);
}
/// <summary>
/// Converts 64 Bit Value to four ModbusRegisters - Registers can be swapped
/// </summary>
/// <param name="longValue">long value which has to be converted into four registers</param>
/// <param name="registerOrder">Desired Word Order (Low Register first or High Register first</param>
/// <returns>Register values</returns>
public static int[] ConvertLongToRegisters(Int64 longValue, RegisterOrder registerOrder)
{
int[] registerValues = ConvertLongToRegisters(longValue);
int[] returnValue = registerValues;
if (registerOrder == RegisterOrder.HighLow)
{
returnValue = new int[] { registerValues[3], registerValues[2], registerValues[1], registerValues[0] }
}
;
return(returnValue);
}
/// <summary>
/// Converts 32 Bit Value to two ModbusRegisters Registers - Registers can be swapped
/// </summary>
/// <param name="intValue">Double value which has to be converted into two registers</param>
/// <param name="registerOrder">Desired Word Order (Low Register first or High Register first</param>
/// <returns>Register values</returns>
public static int[] ConvertIntToRegisters(Int32 intValue, RegisterOrder registerOrder)
{
int[] registerValues = ConvertIntToRegisters(intValue);
int[] returnValue = registerValues;
if (registerOrder == RegisterOrder.HighLow)
{
returnValue = new Int32[] { registerValues[1], registerValues[0] }
}
;
return(returnValue);
}
private async Task HandleFinalizeOrderAsync(BasicDeliverEventArgs args, FinalizeOrder finalizeOrder)
{
using var scope = ServiceProvider.CreateScope();
var command = scope.ServiceProvider.GetRequiredService <FinalizeOrderCommand>();
command.Dishes = finalizeOrder.Dishes;
command.Order = finalizeOrder.Order;
var errors = command.Validate();
Message finalMessage;
if (errors.Count == 0)
{
var registrationMessage = new RegisterOrder
{
OrderId = finalizeOrder.Order.Id,
};
var registrationMessageProps =
CreateProperties(args.BasicProperties.CorrelationId, MessageType.RegisterOrder);
Channel.BasicPublish(string.Empty, args.BasicProperties.ReplyTo, registrationMessageProps,
registrationMessage.GetSerialized());
try
{
await command.HandleAsync();
}
catch
{
PublishErrorMessage(finalizeOrder.Order.Id, args);
return;
}
finalMessage = new FinalizingSuccess
{
OrderId = finalizeOrder.Order.Id,
DeliveryDateTime = DateTime.Now.AddMinutes(new Random().Next(30, 120)),
};
}
else
{
finalMessage = new FinalizingError
{
OrderId = finalizeOrder.Order.Id,
ErrorMessage = errors.Values.ToList().First(),
};
}
var replyProps = CreateProperties(args.BasicProperties.CorrelationId, finalMessage.MessageType);
Channel.BasicPublish(string.Empty,
args.BasicProperties.ReplyTo,
replyProps,
finalMessage.GetSerialized());
}
public IActionResult RegisterOrder(OrderViewModel model)
{
var registerOrderCommand = new RegisterOrder(model);
//Send RegisterOrderCommand
using (var rabbitMqManager = new RabbitMqManager())
{
rabbitMqManager.SendRegisterOrderCommand(registerOrderCommand);
}
return(View("Thanks"));
}
/// <summary>
/// Convert four 16 Bit Registers to 64 Bit double prec. value - Registers can be swapped
/// </summary>
/// <param name="registers">four Register values received from Modbus</param>
/// <param name="registerOrder">Desired Word Order (Low Register first or High Register first</param>
/// <returns>Connected double prec. float value</returns>
public static double ConvertRegistersToDouble(int[] registers, RegisterOrder registerOrder)
{
if (registers.Length != 4)
{
throw new ArgumentException("Input Array length invalid - Array langth must be '4'");
}
int[] swappedRegisters = { registers[0], registers[1], registers[2], registers[3] };
if (registerOrder == RegisterOrder.HighLow)
{
swappedRegisters = new int[] { registers[3], registers[2], registers[1], registers[0] }
}
;
return(ConvertRegistersToDouble(swappedRegisters));
}
public async Task <IActionResult> AddCard()
{
Uri domain = new Uri(Request.GetDisplayUrl());
Uri uri = new Uri(domain.Scheme + "://" + domain.Host + (domain.IsDefaultPort ? "" : ":" + domain.Port));
host = uri.ToString();
int id = Int32.Parse(User.Claims.First(c => c.Type == "UserId").Value);
try
{
string desc = "Card registration";
RegisterOrder registerOrder = new RegisterOrder(id, 10 * 100, host, desc);
OrderModel orderModel = await PaymentManager.RegisterOrder(registerOrder);
UserManager.AddOrder(orderModel.OrderId);
string url = orderModel.FormUrl.Replace("_binding", "").Replace(" ", " ");
return(Ok(url));
}
catch
{
return(BadRequest());
}
}
public async static Task <OrderModel> RegisterOrder(RegisterOrder registerOrder)
{
registerOrder.OrderNumber = (UserManager.CheckLastOrder() + 1) + "poasdrder11";
using (HttpClient http = new HttpClient())
{
string uri = $"https://ipay.arca.am/payment/rest/register.do?" +
$"description={registerOrder.Description}&userName={PaymentSettings.UserName}&password={PaymentSettings.Password}&amount={registerOrder.Amount}&language=ru&orderNumber={registerOrder.OrderNumber}&language=en&clientId={registerOrder.ClientId}&returnUrl={registerOrder.ReturnUrl}";
HttpResponseMessage response = await http.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
string s = await response.Content.ReadAsStringAsync();
OrderModel orderModel = JsonConvert.DeserializeObject <OrderModel>(s);
return(orderModel);
}
else
{
return(null);
}
}
}
public async Task <IActionResult> Pay(Payment payment)
{
int id = Int32.Parse(User.Claims.First(c => c.Type == "UserId").Value);
string api = "api/profile/addActivity";
try
{
string desc = "Payment with new card";
Uri domain = new Uri(Request.GetDisplayUrl());
Uri uri = new Uri(domain.Scheme + "://" + domain.Host + (domain.IsDefaultPort ? "" : ":" + domain.Port));
host = uri.ToString();
RegisterOrder registerOrder = new RegisterOrder(id, payment.Amount * 100, host, desc, api);
OrderModel orderModel = await PaymentManager.RegisterOrder(registerOrder);
UserManager.AddOrder(orderModel.OrderId);
string url = orderModel.FormUrl.Replace("_binding", "").Replace(" ", " ");
return(Ok(url));
}
catch
{
return(BadRequest());
}
}
public async Task <IActionResult> PayWithBinging(Payment payment)
{
int id = Int32.Parse(User.Claims.First(c => c.Type == "UserId").Value);
try
{
string desc = "Payment with binding";
RegisterOrder registerOrder = new RegisterOrder(id, payment.Amount * 100, host, desc);
OrderModel orderModel = await PaymentManager.RegisterOrder(registerOrder);
UserManager.AddOrder(orderModel.OrderId);
string result = await PaymentManager.Pay(payment, orderModel.OrderId);
OrderStatusModel orderStatus = await PaymentManager.GetOrderStatus(orderModel.OrderId);
orderStatus.Date = DateTime.Now.ToString();
ActivityManager.AddActivity(orderStatus, id);
return(Ok());
}
catch
{
return(BadRequest());
}
}
public OrderController(RegisterOrder registerOrder)
{
this._registerOrder = registerOrder;
}
