public IActionResult Create(CurrencyViewModel model)
{
if (ModelState.IsValid)
{
var ses = new Currency {
CurrencyName = model.CurrencyName
};
var x = _databaseContext.Currency.FirstOrDefault(g => g.CurrencyName == ses.CurrencyName);
if (x != null)
{
TempData[Constants.Message] = $"Valuta tog imena već postoji.\n";
TempData[Constants.ErrorOccurred] = true;
return(View("Add", model));
}
_databaseContext.Currency.Add(ses);
TempData["Success"] = true;
_databaseContext.SaveChanges();
TempData[Constants.Message] = $"Valuta je dodana";
TempData[Constants.ErrorOccurred] = false;
return(RedirectToAction(nameof(Index)));
}
return(View("Add", model));
}
public override ExternalTransferOrder GetNewData()
{
DivisionViewModel orderDivision = DivisionDataUtil.GetDivision(client);
DivisionViewModel deliveryDivision = DivisionDataUtil.GetDivision(client);
CurrencyViewModel currency = CurrencyDataUtil.GetCurrencyIDR(client);
return(new ExternalTransferOrder
{
OrderDivisionId = orderDivision._id,
OrderDivisionCode = orderDivision.code,
OrderDivisionName = orderDivision.name,
DeliveryDivisionId = deliveryDivision._id,
DeliveryDivisionCode = deliveryDivision.code,
DeliveryDivisionName = deliveryDivision.name,
OrderDate = DateTime.Now,
DeliveryDate = DateTime.Now,
CurrencyId = currency._id,
CurrencyDescription = currency.description,
CurrencyCode = currency.code,
CurrencySymbol = currency.symbol,
CurrencyRate = currency.rate,
ExternalTransferOrderItems = new List <ExternalTransferOrderItem> {
externalTransferOrderItemDataUtil.GetNewData()
}
});
}
public async Task <IActionResult> CurrencyEdit(Guid?currencyGuid)
{
ViewBag.Title = "Edit Currency";
ViewBag.Heading = "Edit Currency";
CurrencyViewModel model = new CurrencyViewModel();
if (currencyGuid.HasValue)
{
ICurrency currency = await dataManager.FetchCurrency(currencyGuid.Value);
model.Guid = currency.Guid;
model.Title = currency.Title;
model.Code = currency.Code;
//var node = SiteMaps.Current.FindSiteMapNodeFromKey("CurrencyEdit");
//if (node != null)
//{
// node.Title = "Edit Currency";
//}
}
return(View(model));
}
public ActionResult Edit(string id)
{
CurrencyViewModel model =
new CurrencyViewModel(service.GetSingle(id, AuthenticationHelper.User.CompanyId));
return(View(model));
}
public async Task <IActionResult> Edit(int id, CurrencyViewModel currency)
{
if (id != currency.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(currency.GetModel());
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CurrencyExists(currency.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
currency.loadLists(_context);
return(View(currency));
}
public IActionResult NewIndex()
{
CurrencyViewModel cvm = new CurrencyViewModel();
cvm.ErrorMessage = "Unable to retrieve current exchange rate.";
return(View(cvm));
}
public async Task <ActionResult> CurrenciesRate()
{
var dailyRate = await _cbrClient.GetDailyRateAsync();
ViewData["Date"] = dailyRate.TimeStamp.ToString("d");
return(View(dailyRate.Currencies.Select(s => CurrencyViewModel.Create(s.Value))));
}
public ActionResult Currency(CurrencyViewModel curr)
{
if (curr.Amount == 0)
{
ModelState.AddModelError("Amount", "Amount is required");
}
if (string.IsNullOrEmpty(curr.Currency))
{
ModelState.AddModelError("Currency", "Currency is required");
}
Double calrate = 0;
if (ModelState.IsValid)
{
calrate = _currentService.CalculateCurrency(curr);
var vm = new CurrencyRateViewModel()
{
Amount = curr.Amount,
CalRateAmount = calrate,
currency = curr.Currency
};
//TempData["Name"] = vm.Name;
return(View("CurrencyDisplayRate", vm));
}
return(View(curr));
}
public virtual async Task <CurrencyViewModel> GetScopeCurrencyAsync(GetScopeCurrencyParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
var p = new GetScopeParam
{
Scope = param.Scope
};
var scope = await ScopeRepository.GetScopeAsync(p).ConfigureAwait(false);
CurrencyViewModel vm = null;
if (scope?.Currency != null)
{
vm = ViewModelMapper.MapTo <CurrencyViewModel>(scope.Currency, param.CultureInfo);
}
return(vm);
}
public void SetTotalPriceWithAlbum_emptyAlbum_120()
{
//// Set Currency
var userCurrency = new CurrencyViewModel();
userCurrency.Code = 840;
userCurrency.ShortName = "USD";
//// Set TrackPrices
var priceTrack = new PriceViewModel();
priceTrack.Currency = userCurrency;
priceTrack.Amount = 120;
//// Create track with price = 120
var track1 = new TrackDetailsViewModel()
{
Name = "SuperTrack",
Price = priceTrack
};
//// Create empty album
var album1 = new AlbumDetailsViewModel();
//// Create and set CartView model
var myCartView = new CartViewModel()
{
Tracks = new List <TrackDetailsViewModel>(),
Albums = new List <AlbumDetailsViewModel>()
};
myCartView.Tracks.Add(track1);
myCartView.Albums.Add(album1);
CartViewModelService.SetTotalPrice(myCartView, userCurrency);
Assert.IsTrue(myCartView.TotalPrice == 120);
}
/// <summary>
/// Set TotalPrice for cart
/// </summary>
/// <param name="userCurrency">
/// Валюта, которую выбрал пользователь.
/// </param>
/// <returns> Успешно ли прошла операция подсчёта</returns>
public static bool SetTotalPrice(CartViewModel userCart, CurrencyViewModel userCurrency)
{
if (userCart == null || userCurrency == null)
{
return(false);
}
userCart = CheckCount(userCart);
foreach (TrackDetailsViewModel anyTrack in userCart.Tracks)
{
if (anyTrack.Price == null)
{
return(false);
}
userCart.TotalPrice += anyTrack.Price.Amount;
}
foreach (AlbumDetailsViewModel anyAlbum in userCart.Albums)
{
if (anyAlbum.Price == null)
{
return(false);
}
userCart.TotalPrice += anyAlbum.Price.Amount;
}
return(true);
}
// GET: Currencies/Create
public IActionResult Create()
{
CurrencyViewModel vm;
vm = new CurrencyViewModel(_context);
return(View(vm));
}
/// <summary>
/// Получение курса валют
/// </summary>
/// <returns></returns>
public async Task <List <CurrencyViewModel> > GetCurrencyRate()
{
Logger.LogInformation(message: $"{nameof(GetCurrencyRate)} called");
var specification = new CurrencyWithRateSpecification();
IReadOnlyList <Currency> listCurrency = await _currencyRepository.ListAsync(specification : specification).ConfigureAwait(continueOnCapturedContext: true);
List <CurrencyViewModel> list = listCurrency.Select(selector: currency => new
{
currency,
lastUpdate = currency.ExchangeRates.Last()
}).Select(selector: t =>
{
var model = new CurrencyViewModel();
model.Id = t.currency.Id;
model.Name = t.currency.ShortName;
model.BuyRate = t.lastUpdate.RateBuy;
model.SaleRate = t.lastUpdate.RateSale;
return(model);
}).ToList();
Logger.LogInformation(message: $"Was returned {list.Count} currency view models.");
return(list);
}
public void Should_Success_Instantiate()
{
int id = 1;
string code = "code test";
string BankCode = "BankCode test";
string AccountName = "AccountName test";
string AccountNumber = "AccountNumber test";
string BankName = "BankName test";
CurrencyViewModel cvm = new CurrencyViewModel();
AccountBankViewModel viewmodel = new AccountBankViewModel()
{
Id = id,
Code = code,
BankCode = BankCode,
AccountName = AccountName,
AccountNumber = AccountNumber,
BankName = BankName,
Currency = cvm
};
Assert.Equal(id, viewmodel.Id);
Assert.Equal(code, viewmodel.Code);
Assert.Equal(BankCode, viewmodel.BankCode);
Assert.Equal(AccountName, viewmodel.AccountName);
Assert.Equal(AccountNumber, viewmodel.AccountNumber);
Assert.Equal(cvm, viewmodel.Currency);
}
public void Should_Success_Instantiate()
{
int id = 1;
string code = "code test";
string BankCode = "BankCode test";
string AccountName = "AccountName test";
string AccountNumber = "AccountNumber test";
string BankName = "BankName test";
CurrencyViewModel cvm = new CurrencyViewModel();
AccountBankViewModel abvm = new AccountBankViewModel();
abvm.Id = id;
abvm.Code = code;
abvm.BankCode = BankCode;
abvm.AccountName = AccountName;
abvm.AccountNumber = AccountNumber;
abvm.BankName = BankName;
abvm.Currency = cvm;
Assert.Equal(id, abvm.Id);
Assert.Equal(code, abvm.Code);
Assert.Equal(BankCode, abvm.BankCode);
Assert.Equal(AccountName, abvm.AccountName);
Assert.Equal(AccountNumber, abvm.AccountNumber);
Assert.Equal(cvm, abvm.Currency);
}
private static Currency getEntityByModel(CurrencyViewModel model)
{
if (model == null)
{
return(null);
}
Currency entity = new Currency();
if (model.Id == 0)
{
entity.CreateBy = AuthenticationHelper.UserId;
entity.CreateDate = DateTime.Now;
entity.CompanyId = AuthenticationHelper.CompanyId.Value;
}
else
{
entity.CreateBy = model.CreateBy;
entity.CreateDate = model.CreateDate;
entity.CompanyId = model.CompanyId;
}
entity.CurrencyCode = model.CurrencyCode;
entity.Id = model.Id;
entity.Name = model.Name;
entity.Precision = model.Precision;
entity.SOBId = model.SOBId;
entity.UpdateBy = AuthenticationHelper.UserId;
entity.UpdateDate = DateTime.Now;
return(entity);
}
public ActionResult Create()
{
CurrencyViewModel model = new CurrencyViewModel();
model.SOBId = SessionHelper.SOBId;
return(View("Edit", model));
}
public void SetTotalPrice_120and120_240()
{
//// Set Currency
var userCurrency = new CurrencyViewModel();
userCurrency.Code = 840;
userCurrency.ShortName = "USD";
//// Set TrackPrices
var priceTrack = new PriceViewModel();
priceTrack.Currency = userCurrency;
priceTrack.Amount = 120;
//// Create two tracks
var track1 = new TrackDetailsViewModel()
{
Name = "SuperTrack",
Price = priceTrack
};
var track2 = new TrackDetailsViewModel()
{
Name = "SuperTrack",
Price = priceTrack
};
//// Create and set CartView model
var myCartView = new CartViewModel()
{
Tracks = new List <TrackDetailsViewModel>()
};
myCartView.Tracks.Add(track1);
myCartView.Tracks.Add(track2);
CartViewModelService.SetTotalPrice(myCartView, userCurrency);
Assert.IsTrue(myCartView.TotalPrice == 240);
}
public ActionResult Create(long sobId)
{
CurrencyViewModel model = new CurrencyViewModel();
model.SOBId = sobId;
return(View(model));
}
public ActionResult AddCurrency()
{
CurrencyViewModel currencyVM = new CurrencyViewModel();
currencyVM.IsUpdate = false;
//currencyVM.CurrencyRate = 1;
return(PartialView("_CurrencyPopup", currencyVM));
}
public IActionResult Update([FromBody] CrudViewModel <CurrencyViewModel> payload)
{
CurrencyViewModel value = payload.value;
var result = _functionalService
.Update <CurrencyViewModel, Currency>(value, Convert.ToInt32(value.CurrencyId));
return(Ok());
}
public async Task <CurrencyViewModel> EncodeCurrencyId(CurrencyViewModel currency)
{
return(await Task.Run(() =>
{
currency.CurrencyId = GuidEncoder.Encode(currency.CurrencyId);
return currency;
}));
}
public Currency()
{
InitializeComponent();
var model = new CurrencyViewModel();
DataContext = model;
}
private void OnItemClick(object sender, ItemClickEventArgs e)
{
// The clicked item it is the new selected contact
CurrencyViewModel selectedCurrency = e.ClickedItem as CurrencyViewModel;
Ratelist.Clear();
Ratelist.Add(new CurrencyRate("2019-5-12", selectedCurrency.Name, "2.34"));
gridCurrency.ItemsSource = Ratelist;
}
public IActionResult Index()
{
var currencies = new ConverterOfCurrency().ConvertDTOToCurrencyModel(_converter.GetAllCurrencies());
CurrencyViewModel currencyViewModel = new CurrencyViewModel()
{
Currencies = currencies
};
return(View(currencyViewModel));
}
public async Task ShowCurrency(CurrencyViewModel currencyViewModel)
{
if (currencyViewModel == null)
return;
_ = NavigationWalletsListPage.Navigation.PopToRootAsync(false);
CurrentPage = NavigationWalletsListPage;
await NavigationWalletsListPage.PushAsync(new CurrencyPage(currencyViewModel));
}
/// <summary>
/// Delete an entity.
/// </summary>
/// <param name="model"></param>
public void Delete(CurrencyViewModel model)
{
var entity = model.ToEntity();
this._CurrencysRepository.Delete(entity);
#region Commit Changes
this._unitOfWork.Commit();
#endregion
}
// GET: Currency
public ActionResult Index()
{
var model = new CurrencyViewModel();
using (var service = new CurrencyDataService())
{
model.CurrencyList = service.GetAllCurrencyData();
}
return(View(model));
}
// GET: CurrencyRate/Details/5
public ActionResult Details(string currencyCode)
{
DateTime date = DateTime.Now;
CurrencyViewModel cvm = new CurrencyViewModel();
cvm.CurrentRate = this._currencyRateService.GetCurrentRateByCode(currencyCode);
cvm.RangeCurrencyRate = this._currencyRateService.GetCurrencyFromRange(new DateTime(date.Year, date.Month, 1), date, currencyCode);
return(View(cvm));
}
public CurrencyViewModel GetCurrencies()
{
CurrencyViewModel vm = new CurrencyViewModel();
repository.Execute(session =>
{
var currencies = session.Query <Entities.Lookup.SelCurrency>().Where(x => x.IsActive == true).ToList();
vm.Currencies = AutoMapper.Mapper.Map <List <Cherries.Models.Lookup.Currency> >(currencies);
});
return(vm);
}
