public IActionResult Update(int id, EditCurrencyViewModel model)
{
if (id != 0)
{
model.CurrencyId = id;
}
if (ModelState.IsValid)
{
var ses = _databaseContext.Currency
.FirstOrDefault(m => m.CurrencyId == id);
ses.CurrencyName = model.CurrencyName;
var x = _databaseContext.Currency.Where(g => (g.CurrencyName == ses.CurrencyName && g.CurrencyId != id)).ToList();
if (x.Count > 0)
{
TempData[Constants.Message] = $"Valuta tog imena već postoji.\n";
TempData[Constants.ErrorOccurred] = true;
return(View("Edit", model));
}
TempData["Success"] = true;
_databaseContext.SaveChanges();
TempData[Constants.Message] = $"Valuta je promijenjena";
TempData[Constants.ErrorOccurred] = false;
return(RedirectToAction(nameof(Index)));
}
return(View("Edit", model));
}
public ActionResult Edit(EditCurrencyViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userOrg = this.userService.GetUserOrganisationId(this.User.Identity.GetUserId());
if (this.IsMegaAdmin())
{
userOrg = this.currencyService.GetById(model.Id).OrganisationId;
}
//Check is there a currency with the same code
if (this.currencyService.ExistUpdate(model.Code, model.Id, userOrg))
{
this.ModelState.AddModelError("Code", CurrencyTr.SameCodeError);
return(View(model));
}
this.currencyService.Update(new Currency
{
Description = model.Description,
Code = model.Code,
Id = model.Id
});
return(Redirect("/HelpModule/Currency/Index"));
}
public async Task <IActionResult> Update(EditCurrencyViewModel request)
{
try
{
var id = request.Currency.Id;
var currency = await _currencyRepository.GetByIdAsync(id);
var currencyHistory = new CurrencyHistory
{
OldName = currency.Name,
NewName = request.Currency.Name,
OldValue = currency.Value,
NewValue = request.Currency.Value,
Status = "Edited",
Time = DateTime.Now
};
await unitOfWork.currencyHistoryRepository.Add(currencyHistory);
currency.Name = request.Currency.Name;
currency.Value = request.Currency.Value;
unitOfWork.currencyRepository.Update(currency);
unitOfWork.Commit();
}
catch
{
unitOfWork.Rollback();
}
return(Redirect("/Currency"));
}
public ActionResult Edit(int id)
{
var model = new EditCurrencyViewModel();
PrepareViewModel(model, EvolutionResources.bnrAddEditCurrency);
model.Currency = LookupService.FindCurrencyModel(id);
model.LGS = LookupService.LockCurrency(model.Currency);
return(View(model));
}
public ViewResult Edit(int id)
{
var ses = _databaseContext.Currency
.FirstOrDefault(p => p.CurrencyId == id);
ViewData["Success"] = TempData["Success"];
var model = new EditCurrencyViewModel
{
CurrencyId = ses.CurrencyId,
CurrencyName = ses.CurrencyName
};
return(View(model));
}
public async Task <IActionResult> Edit(int id)
{
var currency = await _currencyRepository.GetByIdAsync(id);
var viewModel = new EditCurrencyViewModel
{
Currency = currency,
Old = new Currency
{
Name = currency.Name,
Value = currency.Value,
}
};
return(View(viewModel));
}
public async Task <IActionResult> Put(long id, [FromBody] EditCurrencyViewModel model)
{
if (model == null)
{
return(BadRequest());
}
if (model.Id != id)
{
return(BadRequest());
}
var currency = await _currencyRepo.GetAsync(id);
if (currency == null)
{
return(NotFound(Resources.Currencies.CurrencyResource.CurrencyNotFound));
}
if (await _currencyRepo.IsExistCodeAsync(currency.Id, model.Code))
{
ModelState.AddModelError("Code", Resources.Global.Common.ThisCodeExist);
}
if (await _currencyRepo.IsExistNameAsync(currency.Id, model.Name))
{
ModelState.AddModelError("Name", Resources.Global.Common.ThisNameExist);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetWithErrorsKey()));
}
currency = AutoMapper.Mapper.Map(model, currency);
var affectedRows = await _currencyRepo.EditAsync(currency);
if (affectedRows > 0)
{
var viewModel = _modelFactory.CreateViewModel(currency, _defaultKeysOptions.Value.CurrencyId);
return(CreatedAtRoute("GetCurrency", new { id = currency.Number }, viewModel));
}
return(BadRequest());
}
public ActionResult Edit(int id)
{
var currency = this.currencyService.GetById(id);
//Verify if asset is from user organisation
if (!this.IsMegaAdmin())
{
if (currency.OrganisationId != this.userService.GetUserOrganisationId(this.User.Identity.GetUserId()))
{
return(Redirect("/Home/NotAuthorized"));
}
}
var viewModel = new EditCurrencyViewModel
{
Code = currency.Code,
Description = currency.Description,
Id = currency.Id
};
return(View(viewModel));
}
public ActionResult Save(EditCurrencyViewModel model, string command)
{
if (command.ToLower() == "save")
{
var modelError = LookupService.InsertOrUpdateCurrency(model.Currency, CurrentUser, model.LGS);
if (modelError.IsError)
{
PrepareViewModel(model, EvolutionResources.bnrAddEditCurrency);
model.SetErrorOnField(ErrorIcon.Error,
modelError.Message,
"Currency_" + modelError.FieldName);
return(View("Edit", model));
}
else
{
return(RedirectToAction("Currencies"));
}
}
else
{
return(RedirectToAction("Currencies"));
}
}
public async Task <IActionResult> Store(EditCurrencyViewModel request)
{
var user = await _userManager.GetUserAsync(User);
try
{
var currencyHistory = new CurrencyHistory
{
OldName = "",
NewName = request.Currency.Name,
OldValue = 0,
NewValue = request.Currency.Value,
Status = "Created",
Time = DateTime.Now,
User = user
};
var currency = new Currency
{
Name = request.Currency.Name,
Value = request.Currency.Value
};
await unitOfWork.currencyHistoryRepository.Add(currencyHistory);
await unitOfWork.currencyRepository.Add(currency);
unitOfWork.Commit();
}
catch
{
unitOfWork.Rollback();
// return ex.InnerException.Message;
}
return(Redirect("/Currency"));
}
