public async Task <IActionResult> Edit(int id, [Bind("CurrencyConvertId,Multiple,CurrencyFromCurrencyId,CurrencyToCurrencyId,DateValidFrom,DateValidTo,StatusCurrency")] CurrencyConvert currencyConvert)
{
if (id != currencyConvert.CurrencyConvertId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(currencyConvert);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CurrencyConvertExists(currencyConvert.CurrencyConvertId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CurrencyFromCurrencyId"] = new SelectList(_context.Currency, "CurrencyId", "Description", currencyConvert.CurrencyFromCurrencyId);
ViewData["CurrencyToCurrencyId"] = new SelectList(_context.Currency, "CurrencyId", "Description", currencyConvert.CurrencyToCurrencyId);
return(View(currencyConvert));
}
public async Task <CurrencyConverterDto> ConvertCurrency(CurrencyToExchange toExchange)
{
if (toExchange.Amount < 0)
{
throw new Exception("Amount to convert cannot be less than 0.");
}
if (toExchange.ToCurrency == "pln")
{
throw new Exception($"Currently convert to {toExchange.ToCurrency} is not supported.");
}
var baseCurrencyRequest = new RestRequest($"rates/a/{toExchange.FromCurrency}",
Method.GET, DataFormat.Json);
var toCurrencyRequest = new RestRequest($"rates/a/{toExchange.ToCurrency}",
Method.GET, DataFormat.Json);
var baseCurrencyResponse = await _client
.ExecuteTaskAsync <CurrencyTable>(baseCurrencyRequest);
var toCurrencyResponse = await _client
.ExecuteTaskAsync <CurrencyTable>(toCurrencyRequest);
await _repository.AddAsync(baseCurrencyResponse.Data);
await _repository.AddAsync(toCurrencyResponse.Data);
var currentDayConvertToPrice = toCurrencyResponse.Data.Rates.Select(x => x.Mid).Single();
if (toExchange.FromCurrency != "pln" && toExchange.ToCurrency != "pln")
{
var currentDayUnitPrice = baseCurrencyResponse.Data.Rates.Select(x => x.Mid).Single();
var pricePerUnit = currentDayUnitPrice / currentDayConvertToPrice;
var amountValue = currentDayUnitPrice * toExchange.Amount;
var convertedValue = amountValue / currentDayConvertToPrice;
var finalResponse = new CurrencyConvert()
{
FromCurrency = toExchange.FromCurrency,
ToCurrency = toExchange.ToCurrency,
PricePerUnit = Math.Round(pricePerUnit, 2),
BaseCurrencyValue = toExchange.Amount,
ConvertedCurrencyValue = Math.Round(convertedValue, 2)
};
await _currencyRepository.AddAsync(finalResponse);
return(_mapper.Map <CurrencyConverterDto>(finalResponse));
}
var responseFromPlnExchange = new CurrencyConvert()
{
FromCurrency = toExchange.FromCurrency,
ToCurrency = toExchange.ToCurrency,
PricePerUnit = currentDayConvertToPrice,
BaseCurrencyValue = toExchange.Amount,
ConvertedCurrencyValue = toExchange.Amount * currentDayConvertToPrice
};
await _currencyRepository.AddAsync(responseFromPlnExchange);
return(_mapper.Map <CurrencyConverterDto>(responseFromPlnExchange));
}
public async Task <IActionResult> Create([Bind("Id,CarModel,ReleaseDate,Description,Photo,Price,Currency,PriceGel,Photoname,CarSpecs")] Car car, IFormCollection collection)
{
double exchangerate = CurrencyConvert.ExchangeRate(car.Currency) * car.Price;
car.PriceGel = (int)exchangerate;
if (ModelState.IsValid)
{
string unique_filename = null;
if (car.Photo != null)
{
string uploadsFolder = Path.Combine(env.WebRootPath, "images");
unique_filename = Guid.NewGuid().ToString() + "_" + car.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, unique_filename);
car.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
car.Photoname = unique_filename;
}
}
if (!string.IsNullOrEmpty(collection["CarSpecs"]))
{
string carSpecs = collection["CarSpecs"];
car.CarSpecs = carSpecs;
}
if (ModelState.IsValid)
{
_context.Add(car);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
public async Task <IActionResult> Create([Bind("CurrencyConvertId,Multiple,CurrencyFromCurrencyId,CurrencyToCurrencyId,DateValidFrom,DateValidTo,StatusCurrency")] CurrencyConvert currencyConvert)
{
if (ModelState.IsValid)
{
_context.Add(currencyConvert);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CurrencyFromCurrencyId"] = new SelectList(_context.Currency, "CurrencyId", "Description", currencyConvert.CurrencyFromCurrencyId);
ViewData["CurrencyToCurrencyId"] = new SelectList(_context.Currency, "CurrencyId", "Description", currencyConvert.CurrencyToCurrencyId);
return(View(currencyConvert));
}
public HttpResponseMessage GetConvertion(CurrencyConvert target)
{
try
{
Rate.CalculateConversion(target.Currency);
TotalTransaction[] total = Transaction.GetTotalTransaction();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
{
Code = CommonConstants.SuccessCode,
Description = null,
Data = total
});
return(response);
}
catch (ExceptionOperation ex)
{
Log.Error(ex.Message, ex);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
{
Code = CommonConstants.ErrorCode,
Description = null,
Data = ex.Message
});
return(response);
}
catch (Exception ex)
{
Log.Error(HelperMessage.GetMessage(CodeMessage.TRN_001), ex);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
{
Code = CommonConstants.ErrorCode,
Description = null,
Data = HelperMessage.GetMessage(CodeMessage.TRN_001)
});
return(response);
}
finally
{
if (Transaction != null)
{
Transaction.Dispose();
}
if (Rate != null)
{
Rate.Dispose();
}
}
}
public async Task ExecuteOrderAuction()
{
var roiEquals = _initInfo.Deficit * 100 / _initInfo.Supply;
if (_initInfo.AuctionBondBalance > 0 && !string.IsNullOrEmpty(_auctionControlState.OrderFirst))
{
Logger.Info("Execute order for auction");
long totalExecute = 0;
var nextOrder = _auctionControlState.OrderFirst;
while (!string.IsNullOrEmpty(nextOrder))
{
var roi = _auctionControlState.RoiByOrder[nextOrder];
if (roiEquals < roi)
{
return;
}
var total = _auctionControlState.TotalByOrder[nextOrder];
var totalFilled = _auctionControlState.FilledTotalByOrder?.GetValueOrDefault(nextOrder) ?? 0;
var amount = CurrencyConvert.NeutrinoToBond(total - totalFilled) * 100 /
_auctionControlState.PriceByOrder[nextOrder];
if (totalExecute >= _initInfo.AuctionBondBalance)
{
break;
}
totalExecute += amount;
var exTxId = await _neutrinoApi.ExecuteOrderAuction();
Logger.Info($"Execute auction order tx id:{exTxId}");
nextOrder = _auctionControlState.NextOrderByOrder?.GetValueOrDefault(nextOrder);
}
}
else if (_initInfo.AuctionBondBalance > _initInfo.Supply)
{
var exTxId = await _neutrinoApi.ExecuteOrderAuction();
Logger.Info($"Execute auction order tx id:{exTxId}");
}
}
public async Task InitOrUpdate()
{
_initInfo = new InitPacemakerInfo();
_neutrinoAccountState =
AccountDataConverter.ToNeutrinoAccountData(
await _wavesHelper.GetDataByAddress(_neutrinoSettings.NeutrinoAddress));
_auctionControlState =
AccountDataConverter.ToAuctionAccountData(
await _wavesHelper.GetDataByAddress(_neutrinoSettings.AuctionAddress));
_liquidationAccountState =
AccountDataConverter.ToLiquidationAccountData(
await _wavesHelper.GetDataByAddress(_neutrinoSettings.LiquidationAddress));
_initInfo.TotalNeutrinoSupply = await _wavesHelper.GetTotalSupply(_neutrinoAccountState.NeutrinoAssetId);
_initInfo.NeutrinoBalance = await _wavesHelper.GetBalance(_neutrinoSettings.NeutrinoAddress,
_neutrinoAccountState.NeutrinoAssetId);
_initInfo.WavesBalance = await _wavesHelper.GetBalance(_neutrinoSettings.NeutrinoAddress);
_initInfo.Height = await _wavesHelper.GetHeight();
var price = await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress, "price");
Logger.Info("New height: " + _initInfo.Height);
Logger.Info($"Price:{price.Value}");
_initInfo.LiquidationNeutrinoBalance = await _wavesHelper.GetBalance(_neutrinoSettings.LiquidationAddress,
_neutrinoAccountState.NeutrinoAssetId);
_initInfo.AuctionBondBalance =
await _wavesHelper.GetBalance(_neutrinoSettings.AuctionAddress, _neutrinoSettings.BondAssetId);
_initInfo.Supply = _neutrinoAccountState.BalanceLockNeutrino + _initInfo.TotalNeutrinoSupply -
_initInfo.NeutrinoBalance - _initInfo.LiquidationNeutrinoBalance;
_initInfo.Reserve = _initInfo.WavesBalance - _neutrinoAccountState.BalanceLockWaves;
_initInfo.Deficit =
_initInfo.Supply - CurrencyConvert.WavesToNeutrino(_initInfo.Reserve, (long)price.Value);
Logger.Debug($"Init info: {JsonConvert.SerializeObject(_initInfo)}");
}
public async Task TransferToAuction()
{
var auctionNBAmount = _initInfo.Supply - _initInfo.AuctionBondBalance;
var deficitInBonds = CurrencyConvert.NeutrinoToBond(_initInfo.Deficit);
var surplus = deficitInBonds * -1;
var liquidationContractBalanceInBonds =
CurrencyConvert.NeutrinoToBond(_initInfo.LiquidationNeutrinoBalance);
var requireSurplusBonds = surplus - liquidationContractBalanceInBonds;
if (auctionNBAmount >= 1 || requireSurplusBonds > 1)
{
Logger.Info("Transfer to auction");
var transferTxId = await _neutrinoApi.TransferToAuction();
Logger.Info($"Transfer to auction tx id:{transferTxId}");
}
}
public async Task ExecuteOrderLiquidation()
{
var surplusInBonds = -1 * CurrencyConvert.NeutrinoToBond(_initInfo.Deficit);
var liquidationContractBalanceInBonds =
CurrencyConvert.NeutrinoToBond(_initInfo.LiquidationNeutrinoBalance);
if (surplusInBonds > 0 && !string.IsNullOrEmpty(_liquidationAccountState.OrderFirst) &&
liquidationContractBalanceInBonds > 1)
{
Logger.Info("Execute order for liquidation");
long totalExecute = 0;
var nextOrder = _liquidationAccountState.OrderFirst;
while (!string.IsNullOrEmpty(nextOrder))
{
var total = _liquidationAccountState.TotalByOrder[nextOrder];
var totalFilled = _liquidationAccountState.FilledTotalByOrder?.GetValueOrDefault(nextOrder) ?? 0;
var amount = total - totalFilled;
if (totalExecute >= surplusInBonds)
{
break;
}
totalExecute += amount;
var exTxId = await _neutrinoApi.ExecuteOrderLiquidation();
Logger.Info($"Execute liquidation order tx id:{exTxId}");
nextOrder = _liquidationAccountState.NextOrderByOrder?.GetValueOrDefault(nextOrder);
}
}
else if (surplusInBonds <= 0 && !string.IsNullOrEmpty(_liquidationAccountState.OrderFirst) &&
liquidationContractBalanceInBonds > 1)
{
var exTxId = await _neutrinoApi.ExecuteOrderLiquidation();
Logger.Info($"Return liquidation balance tx id:{exTxId}");
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,CarModel,ReleaseDate,Description,Photo,Price,Currency,PriceGel,Photoname")] Car car, IFormCollection collection)
{
double exchangerate = CurrencyConvert.ExchangeRate(car.Currency) * car.Price;
car.PriceGel = (int)exchangerate;
if (!string.IsNullOrEmpty(collection["CarSpecs"]))
{
string carSpecs = collection["CarSpecs"];
car.CarSpecs = carSpecs;
}
if (id != car.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(car);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarExists(car.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
private async Task SetTotalMoneyCostConsumption()
{
var TripsFile = await storageFolder.GetFileAsync("Trips.txt");
var TripsJSON = await FileIO.ReadTextAsync(TripsFile);
var allTrips = JsonConvert.DeserializeObject <List <Models.Trip> >(TripsJSON);
List <Models.Trip> selectedCarTrips = new List <Models.Trip>();
foreach (var t in allTrips)
{
if (t.Vehicle == selectedTrip.Vehicle)
{
selectedCarTrips.Add(t);
}
}
var totalMoneySpent = 0d;
var currency = selectedTrip.MoneySpent.Split().ToArray()[1];
foreach (var t in selectedCarTrips)
{
var money = double.Parse(t.MoneySpent.Split().ToArray()[0]);
var curr = t.MoneySpent.Split().ToArray()[1];
if (curr == currency)
{
totalMoneySpent += money;
}
else
{
totalMoneySpent += CurrencyConvert.GetConvertedCurrency(money, curr, currency);
}
}
tMoneyCost = $"{totalMoneySpent} {currency}";
}
static async Task Main(string[] args)
{
var exchangeRate = await CurrencyConvert.GetExchangeRate(new List <string> {
"EUR", "GBP", "ILS"
});
}
public async Task WithdrawAllUser()
{
var currentPriceIndex = (long)(await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress, "price_index")).Value;
var addresses = new List <string>();
if (_neutrinoAccountState.BalanceLockNeutrinoByUser != null)
{
addresses.AddRange(_neutrinoAccountState.BalanceLockNeutrinoByUser.Where(x => x.Value > 0)
.Select(x => x.Key));
}
if (_neutrinoAccountState.BalanceLockWavesByUser != null)
{
addresses.AddRange(_neutrinoAccountState.BalanceLockWavesByUser?.Where(x => x.Value > 0)
.Select(x => x.Key));
}
foreach (var address in addresses)
{
var withdrawBlock = _neutrinoAccountState.BalanceUnlockBlockByAddress.GetValueOrDefault(address);
if (_initInfo.Height < withdrawBlock)
{
continue;
}
var priceHeight = (long)(await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress,
"price_index_" + currentPriceIndex)).Value;
if (withdrawBlock >= priceHeight)
{
continue;
}
long index = 0;
for (var i = currentPriceIndex; i > 0; i--)
{
priceHeight = (long)(await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress,
"price_index_" + i)).Value;
if (withdrawBlock == priceHeight)
{
index = currentPriceIndex;
break;
}
if (withdrawBlock > priceHeight)
{
index = currentPriceIndex - 1;
break;
}
}
var foundHeight = (long)(await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress, "price_index_" + index)).Value;
var priceByHeight = (long)(await _wavesHelper.GetDataByAddressAndKey(_neutrinoSettings.ControlAddress, "price_" + foundHeight)).Value;
var withdrawNeutrinoAmount = _neutrinoAccountState.BalanceLockNeutrinoByUser?.GetValueOrDefault(address) ?? 0;
if (withdrawNeutrinoAmount > 0)
{
var neutrinoContractBalance =
await _wavesHelper.GetDetailsBalance(_neutrinoSettings.NeutrinoAddress);
var wavesAmount = CurrencyConvert.NeutrinoToWaves(withdrawNeutrinoAmount, priceByHeight);
if (wavesAmount > neutrinoContractBalance.Available)
{
if (!_leasingSettings.IsLeasingProvider)
{
continue;
}
var totalLeasingCancelAmount = 0L;
var activeLeaseTxs = await _wavesHelper.GetActiveLease(_leasingSettings.NodeAddress);
var neededAmount = wavesAmount - neutrinoContractBalance.Available;
foreach (var leasingTx in activeLeaseTxs.OrderByDescending(x => x.Timestamp)
.Where(x => x.Sender == _neutrinoSettings.NeutrinoAddress))
{
if (totalLeasingCancelAmount >= neededAmount)
{
break;
}
totalLeasingCancelAmount += leasingTx.Amount;
var cancelLeaseTxId = await _neutrinoApi.CancelLease(leasingTx.Id);
Logger.Info($"Cancel lease tx:{cancelLeaseTxId} (LeaseId:{cancelLeaseTxId})");
}
}
}
var withdrawTxId = await _neutrinoApi.Withdraw(address, index);
Logger.Info($"Withdraw tx id:{withdrawTxId} (Address:{address})");
}
}
public string GetData(string currencyAmount)
{
CurrencyConvert converter = new CurrencyConvert(currencyAmount);
return(converter.Convert());
}
public async Task <IActionResult> Create()
{
try
{
Customer customer = await GetCurrentUserAsync();
List <Cart> itemsInCart = await GetItemsInCart(customer);
bool inactiveItemsInCart = itemsInCart.Any(c => !c.Item.Active);
if (inactiveItemsInCart)
{
_flashMessage.Danger("Some items in cart are no longer available");
return(RedirectToAction("Index", "Carts"));
}
const int defaultPaymentCost = 10;
double itemsCost = itemsInCart.Aggregate <Cart, double>(0, (current, cart) => current + cart.Item.Price * cart.Quantity);
if (itemsCost == 0)
{
_flashMessage.Danger("Your cart does no longer has items, please add items to cart before proceed to checkout");
return(RedirectToAction("Index", "Carts"));
}
var totalCost = itemsCost + defaultPaymentCost;
customer.Address ??= new Address();
var currencies = await CurrencyConvert.GetExchangeRate(new List <string>
{
"EUR", "GBP", "ILS"
});
foreach (CurrencyInfo currency in currencies)
{
currency.Total = totalCost * currency.Value;
}
var itemsIdsInCartList = new List <int>();
foreach (Cart itemInCart in itemsInCart)
{
for (var i = 1; i <= itemInCart.Quantity; i++)
{
itemsIdsInCartList.Add(itemInCart.ItemId);
}
}
var viewModel = new CreateOrderViewModel
{
Cart = itemsInCart,
Customer = customer,
ShippingAddress = customer.Address,
Payment = new Payment
{
ShippingCost = defaultPaymentCost,
ItemsCost = itemsCost,
Total = totalCost
},
ItemsInCart = await CountItemsInCart(),
Currencies = currencies,
ItemsIdsInCartList = itemsIdsInCartList
};
_flashMessage.Warning("Please verify your items before placing the order");
return(View(viewModel));
}
catch (Exception e)
{
_flashMessage.Danger("Your order could not be placed. Please contact support for help");
_logger.LogError($"an order could not be created, e: {e}");
return(View(new CreateOrderViewModel()
{
ItemsInCart = await CountItemsInCart()
}));
}
}
