public PartialViewResult CurrencyConvertorTool(CurrencyToolViewModel model)
{
model.OutputAmount = _currencyService.Convert(model.InputAmount, model.CurrencyTypeFrom, model.CurrencyTypeTo);
var rates = _currencyService.GetCurrencyConversions().Where(c => c.CurrencyTypeTo != c.CurrencyTypeFrom);
model.CurrencyTypesList = new SelectList(rates, "CurrencyTypeTo", "CurrencyTypeTo");
return(PartialView("_CurrencyConvertorTool", model));
}
public RecipeCostSummary Resolve(Recipe source, object dest, RecipeCostSummary destMember, ResolutionContext context)
{
RecipeIngredient[] validRecipeIngredients = source.RecipeIngredients
.Where(x => x.Amount.HasValue &&
x.Ingredient.Price.HasValue &&
((x.Ingredient.ProductSizeIsOneUnit && x.Unit == null) || (!x.Ingredient.ProductSizeIsOneUnit && x.Unit != null)))
.ToArray();
var costSummary = new RecipeCostSummary();
var currency = (string)context.Items["Currency"];
foreach (var recipeIngredient in validRecipeIngredients)
{
costSummary.IngredientIds.Add(recipeIngredient.Ingredient.Id);
short productSize = recipeIngredient.Ingredient.ProductSize;
bool productSizeIsOneUnit = recipeIngredient.Ingredient.ProductSizeIsOneUnit;
float amount = recipeIngredient.Amount.Value;
string unit = recipeIngredient.Unit;
decimal price = _currencyService.Convert(recipeIngredient.Ingredient.Price.Value, recipeIngredient.Ingredient.Currency, currency, DateTime.UtcNow.Date);
costSummary.Cost = AddPricePerAmount(costSummary.Cost, price, productSize, productSizeIsOneUnit, amount, unit);
}
if (costSummary.Cost.HasValue)
{
costSummary.IsSet = true;
costSummary.CostPerServing = costSummary.Cost.Value / source.Servings;
}
return(costSummary);
}
public async Task <TipsOrderEntity> GetTipsOrder(string sku, string currency)
{
var transactions = await transactionsRepository.GetTransactionsBySku(sku).ConfigureAwait(false);
if (!transactions.Any())
{
return(null);
}
var rates = await ratesRepository.GetRates().ConfigureAwait(false);
var transactionsResult = currencyService.Convert(currency, transactions, rates);
var tipsTransactions = transactionsResult.Select(transactionEntity => new TipsTransactionEntity
{
Sku = transactionEntity.Sku,
Amount = Math.Round(transactionEntity.Amount, 2),
Currency = transactionEntity.Currency,
Tip = Math.Round(transactionEntity.Amount * TIP_PORCENTAGE, 2)
}).ToList();
var result = new TipsOrderEntity
{
Currency = Currencies.Euro,
TotalTipAmount = Math.Round(transactionsResult.Sum(t => t.Amount) * TIP_PORCENTAGE, 2),
Transactions = tipsTransactions
};
return(result);
}
public BaseResponse MoveMoney(MoveMoneyParameter param)
{
var result = new BaseResponse();
try
{
result = MinusMoney(new MoneyParameter()
{
Money = param.From, User = param.User
});
if (!result.IsError)
{
param.From.Amount = cr.Convert(param.From.Currency, param.ToCurrency, param.From.Amount);
param.From.Currency = param.ToCurrency;
result = PlusMoney(new MoneyParameter()
{
Money = param.From, User = param.User
});
}
}
catch (Exception e)
{
result.IsError = true;
result.ErrorMessage = e.Message;
}
return(result);
}
private async Task <CatalogItemViewModel> CreateCatalogItemViewModel(CatalogItem catalogItem, CancellationToken cancellationToken = default(CancellationToken))
{
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
PictureUri = catalogItem.PictureUri,
Price = await _currencyService.Convert(catalogItem.Price, default_price_unit, user_price_unit, cancellationToken),
ShowPrice = catalogItem.ShowPrice,
PriceUnit = user_price_unit,
PriceSymbol = CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol
});
}
public async Task <IActionResult> CreateInternal(InternalMoneyTransferViewModel model)
{
if (!ModelState.IsValid)
{
model.Accounts =
(List <Core.Entities.Account>) await _accountService.GetAccountsAsync(
Guid.Parse(GetCurrentUserId()));
return(View(model));
}
var fromAccount = await _accountService.GetAccountAsync(model.AccountId.Value, true);
var toAccount = await _accountService.GetAccountAsync(model.ToAccountId.Value, true);
var currency = await _currencyService.Convert(fromAccount.Currency.Code, toAccount.Currency.Code, model.Amount);
await _transactionService.CreateTransactionAsync(fromAccount, toAccount, currency.Rate, model.Amount,
model.Description, fromAccount.Currency.Code, toAccount.Currency.Code);
return(RedirectToHome());
}
public async Task <IActionResult> Index(CurrencyInputModel model)
{
if (model.GbpValue == null)
{
return(Content("You should provide valid input!"));
}
if (model.FromCurrency == model.ToCurrency)
{
return(Content("You should select different currencies!"));
}
var result = await _currencyService.Convert(model.UserName, model.GbpValue.Value, model.FromCurrency, model.ToCurrency);
model.Result = result;
return(Content($"Your converted value is : {model.Result}"));
}
private async Task <CatalogItemViewModel> CreateCatalogItemViewModel(CatalogItem catalogItem, bool convertPrice, CancellationToken cancellationToken = default(CancellationToken))
{
var price = await(convertPrice?_currencyService.Convert(catalogItem.Price, default_price_unit, user_price_unit, cancellationToken):Task.FromResult(catalogItem.Price));
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
PictureUri = catalogItem.PictureUri,
Price = Math.Round(price, 2),
ShowPrice = catalogItem.ShowPrice,
PriceUnit = user_price_unit,
PriceSymbol = CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol
});
}
/// <summary>
/// Create a catalog item view model from a catalog item data model
/// </summary>
/// <param name="catalogItem">Catalog item</param>
/// <returns>CatalogItemViewModel</returns>
private async Task <CatalogItemViewModel> CreateCatalogItemViewModelAsync(CatalogItem catalogItem, bool convertPrice = true, CancellationToken cancellationToken = default(CancellationToken))
{
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
StoreName = catalogItem.StoreName,
Stock = catalogItem.Stock,
PictureUri = catalogItem.PictureUri,
Price = await(convertPrice
? _currencyService.Convert(catalogItem.Price, default_price_unit, user_price_unit, cancellationToken)
: Task.FromResult(catalogItem.Price)),
ShowPrice = catalogItem.ShowPrice,
PriceUnit = user_price_unit
});
}
/// <summary>
/// Create a catalog item view model from a catalog item data model
/// </summary>
/// <param name="catalogItem">Catalog item</param>
/// <returns>CatalogItemViewModel</returns>
private async Task <CatalogItemViewModel> CreateCatalogItemViewModelAsync(
CatalogItem catalogItem,
bool convertPrice = true,
CancellationToken cancellationToken = default(CancellationToken))
{
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
PictureUri = catalogItem.PictureUri,
Price = await(convertPrice
? _currencyService.Convert(catalogItem.Price, DEFAULT_PRICE_UNIT, USER_PRICE_UNIT, cancellationToken)
: Task.FromResult(catalogItem.Price)),
ShowPrice = catalogItem.ShowPrice,
PriceUnit = USER_PRICE_UNIT
});
}
/// <summary>
/// Create a catalog item view model from a catalog item data model
/// </summary>
/// <param name="catalogItem">Catalog item</param>
/// <param name="cancellationToken">Cancellation Token</param>
/// <returns>CatalogItemViewModel</returns>
private async Task <CatalogItemViewModel> CreateCatalogItemViewModel(CatalogItem catalogItem, bool convertPrice = true, CancellationToken cancellationToken = default(CancellationToken))
{
Enum.TryParse(new RegionInfo(CultureInfo.CurrentCulture.Name).ISOCurrencySymbol, true, out userPriceUnit);
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
PictureUri = catalogItem.PictureUri,
Price = await(convertPrice ? _currencyService.Convert(catalogItem.Price, DEFAULT_PRICE_UNIT, userPriceUnit, cancellationToken) : Task.FromResult(catalogItem.Price)),
ShowPrice = catalogItem.ShowPrice,
CatalogBrandId = catalogItem.CatalogBrandId,
CatalogTypeId = catalogItem.CatalogTypeId,
PriceUnit = userPriceUnit
// Stocks = catalogItem.StockPerStore
});
}
/// <summary>
/// Create a catalog item view model from a catalog item data model
/// </summary>
/// <param name="catalogItem">Catalog item</param>
/// <returns>CatalogItemViewModel</returns>
private async Task <CatalogItemViewModel> CreateCatalogItemViewModelAsync(
CatalogItem catalogItem,
bool convertPrice = true,
CancellationToken cancellationToken = default(CancellationToken))
{
return(new CatalogItemViewModel()
{
Id = catalogItem.Id,
Name = catalogItem.Name,
PictureUri = catalogItem.PictureUri,
Price = await(convertPrice
? _currencyService.Convert(catalogItem.Price, DEFAULT_PRICE_UNIT, USER_PRICE_UNIT, cancellationToken)
: Task.FromResult(catalogItem.Price)),
ShowPrice = catalogItem.ShowPrice,
PriceUnit = USER_PRICE_UNIT
// ,
// Stocks = catalogItem.Stocks.Select(cis => new StockInStore {
// StoreName = cis.Store.Name,
// Stock = cis.Stock}).ToList()
});
}
public async Task <WalletApiResponse> Transfer(int userId, [FromBody] TransferRequest convertMoneyRequest)
{
try
{
if (convertMoneyRequest.Sum <= 0)
{
return(new WalletApiErrorResponse("Нельзя создать перевод с суммой меньшей или равной нулю"));
}
if (convertMoneyRequest.SourceWalletId == convertMoneyRequest.TargetWalletId)
{
return(new WalletApiErrorResponse("Нельзя создать перевод в этот же кошлек"));
}
using (var trans = _context.Database.BeginTransaction())
{
var sourceWallet = await _context.Wallets.FirstOrDefaultAsync(x => x.UserId == userId && x.Id == convertMoneyRequest.SourceWalletId);
if (sourceWallet == null)
{
return(new WalletApiErrorResponse($"Не существует кошелька с Id = {convertMoneyRequest.SourceWalletId}"));
}
var targetWallet = await _context.Wallets.FirstOrDefaultAsync(x => x.Id == convertMoneyRequest.TargetWalletId);
if (targetWallet == null)
{
return(new WalletApiErrorResponse($"Не существует кошелька с Id = {convertMoneyRequest.TargetWalletId}"));
}
var convertedSum = _currencyService.Convert(convertMoneyRequest.Sum, sourceWallet.Currency, targetWallet.Currency);
var transactionDate = DateTime.Now;
sourceWallet.CacheSum -= convertMoneyRequest.Sum;
if (sourceWallet.CacheSum < 0)
{
return(new WalletApiErrorResponse("Не хватает денег"));
}
sourceWallet.Operations.Add(new WalletOperation()
{
Mov = -convertMoneyRequest.Sum,
CreateDate = transactionDate,
Comment = $"Перевод на кошелек {targetWallet.Id}"
});
targetWallet.CacheSum += convertedSum;
targetWallet.Operations.Add(new WalletOperation()
{
Mov = convertedSum,
CreateDate = transactionDate,
Comment = $"Перевод с кошелька {sourceWallet.Id}"
});
await _context.SaveChangesAsync();
await trans.CommitAsync();
return(new TransferResponse(sourceWallet, targetWallet));
}
}
catch (DbUpdateConcurrencyException)
{
return(new WalletApiErrorResponse("Ошибка операции, состояние кошелька было изменено, во время операции"));
}
catch (Exception ex)
{
return(new WalletApiErrorResponse(ex));
}
}
public async Task <ActionResult <decimal> > CheckCurrency(string from, string to, decimal ammount)
{
return(Ok(await _currencyService.Convert(ammount, from, to)));
}
public Dinero Sumar(Dinero aSumar)
{
var monedaLocal = !Moneda.Equals(aSumar.Moneda) ? _convertCurrencyService.Convert(aSumar, Moneda) : aSumar;
return(new Dinero(Moneda, Monto + monedaLocal.Monto));
}
public async Task ConvertTest()
{
var result = await currencyService.Convert("U", 1, "GBP", "USD");
Assert.Equal(1.27m, result);
}
