public IActionResult Load(long id)
{
var result = _providerService.GetById(id);
UpdateViewModel model;
if (result.HasErrors())
{
model = new UpdateViewModel()
{
Message = result.GetFailure()
};
return(View(model));
}
model = new UpdateViewModel()
{
Id = id,
Name = result.GetPayload().Name,
CountryCode = result.GetPayload().Country
};
return(View(model));
}
public async Task <RepositoryResponse <UpdateViewModel> > CreateAsync(int moduleId)
{
var getModule = await Lib.ViewModels.MixModules.ReadListItemViewModel.Repository.GetSingleModelAsync(
m => m.Id == moduleId && m.Specificulture == _lang).ConfigureAwait(false);
if (getModule.IsSucceed)
{
var ModuleData = new UpdateViewModel(
new MixModuleData()
{
ModuleId = moduleId,
Specificulture = _lang,
Fields = getModule.Data.Fields
});
return(new RepositoryResponse <UpdateViewModel>()
{
IsSucceed = true,
Data = ModuleData
});
}
else
{
return(new RepositoryResponse <UpdateViewModel>()
{
IsSucceed = false,
Data = null,
Exception = getModule.Exception,
Errors = getModule.Errors
});
}
}
public async Task <IActionResult> Update([FromBody] UpdateViewModel saleModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (saleModel.IdClient <= 0)
{
return(BadRequest());
}
try
{
await _saleService.UpdateSale(saleModel);
}
catch (DbUpdateException)
{
// check out if exists
if (!(await _saleService.SaleExists(saleModel.IdSale)))
{
return(NotFound());
}
else
{
return(BadRequest());
}
}
return(Ok());
}
public async Task<IActionResult> Update([FromBody] UpdateViewModel model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (model.rolId <= 0)
{
return BadRequest();
}
var rols = await _context.Rols.FirstOrDefaultAsync(r => r.rolId == model.rolId);
if (rols == null)
{
return NotFound();
}
rols.rolname = model.rolname;
rols.roldesc = model.roldesc;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return BadRequest();
}
return Ok();
}
public IActionResult Update(long accountId, long id, UpdateViewModel model)
{
model.Options = GetTransactionTypes();
if (!ModelState.IsValid)
{
return(View("Load", model));
}
var transaction = new Transaction()
{
Id = id,
AccountId = accountId,
TransactionTypeId = model.TransactionTypeId,
Date = model.Date,
Description = model.Description,
Currency = model.Currency,
Amount = model.Amount
};
var result = _transactionService.Update(transaction);
if (result.HasErrors())
{
model.Message = result.GetFailure();
return(View("Load", model));
}
return(RedirectToAction("Index"));
}
public IActionResult Update(long id, UpdateViewModel model)
{
model.AccountTypes = GetAccountTypes();
model.Providers = GetProviders();
if (!ModelState.IsValid)
{
return(View("Load", model));
}
var account = new Account()
{
Id = id,
AccountTypeId = model.AccountTypeId,
ProviderId = model.ProviderId,
Name = model.Name,
AccountNumber = model.Number
};
var result = _accountService.Update(account);
if (result.HasErrors())
{
model.Message = result.GetFailure();
return(View("Load", model));
}
return(RedirectToAction("Index"));
}
public ActionResult AlterarSenha(UpdateViewModel model)
{
if (ModelState.IsValid)
{
try
{
var d = new UsuarioDAL();
Usuario u = d.ConsultarUsuario(model.Login.ToLower(), model.SenhaAntiga);
if (u != null)
{
d.AtualizarSenha(model.Senha, u.IdUsuario);
ViewBag.Sucesso = true;
ViewBag.Mensagem = "Senha alterada com sucesso";
ModelState.Clear();
}
else
{
ViewBag.Sucesso = false;
ViewBag.Mensagem = "Não foi possível completar a operação, usuário ou senha incorretos ou usuário inativo";
}
}
catch (Exception e)
{
ViewBag.Sucesso = false;
ViewBag.Mensagem = $"Erro não esperado, por favor entre em contato com o administrador do sistema. Erro: {e.Message}";
}
}
return(View());
}
/// <summary>
/// Пустой конструктор делаем privat, чтобы его нельзя было вызвать, а это можно создать только с UserViewModel и при момощи :this сначала вызывает закрытый (пустой) а потом это и уже с Юзером
/// </summary>
public MainWindowViewModel()
{
NewOrganization = new NewOrganizationViewModel();
Search = new SearchViewModel();
WorkUser = WorkUserSingleton.sourse.WorkUser;
Update = new UpdateViewModel();
}
public async Task <IActionResult> Update([FromBody] UpdateViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.categoryId <= 0)
{
return(BadRequest());
}
var category = await _context.Categories.FirstOrDefaultAsync(c => c.categoryId == model.categoryId);
if (category == null)
{
return(NotFound());
}
category.categoryname = model.categoryname;
category.categorydesc = model.categorydesc;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public IHttpActionResult Update(string website, [FromBody] UpdateViewModel viewModel)
{
var domain = GetDomain(website);
if (domain == null)
{
var createViewModel = new CreateViewModel()
{
Website = website,
MaximumLength = viewModel.MaximumLength,
SpecialCharacters = viewModel.SpecialCharacters,
};
return(Create(createViewModel));
}
domain.MaximumLength = viewModel.MaximumLength;
domain.LastModifiedOn = DateTime.UtcNow;
domain.SpecialCharacters = viewModel.SpecialCharacters;
if (_context.SaveChanges() != 1)
{
return(BadRequest());
}
return(Ok(domain));
}
public async Task <IActionResult> Update(UpdateViewModel model)
{
if (ModelState.IsValid)
{
// Retrieve Identity user
var user = _abstractUserService.GetUserByEmail(User.Identity.Name);
if (user == null)
{
ModelState.AddModelError(string.Empty, "Dit email is nog niet bekend in het systeem dus uw account kan niet worden geupdate");
}
// Retrieve Client user
var client = _clientService.GetClientByEmail(User.Identity.Name);
if (client == null)
{
ModelState.AddModelError(string.Empty, "Dit email is nog niet bekend in het systeem dus uw account kan niet worden geupdate");
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.ConfirmPassword = model.ConfirmPassword;
user.UserName = model.Email;
user.Email = model.Email;
client.FirstName = model.FirstName;
client.LastName = model.LastName;
client.Email = model.Email;
client.Birthday = model.Birthday;
client.City = model.City;
client.Street = model.Street;
client.HouseNumber = model.HouseNumber;
client.Addition = model.Addition;
client.PostalCode = model.PostalCode;
client.Gluten = model.Gluten;
client.Diabetes = model.Diabetes;
client.Salt = model.Salt;
var x = await _userManager.ChangePasswordAsync(user, user.Password, model.Password);
if (x.Succeeded)
{
user.Password = model.Password;
}
var result = await _userManager.UpdateAsync(user);
_clientService.UpdateClient(client);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "Failed to update your account!");
}
return(View(model));
}
public async Task <IActionResult> Update([FromBody] UpdateViewModel orderModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (orderModel.IdOrderIncome <= 0)
{
return(BadRequest());
}
try
{
await _orderService.UpdateOrderIncome(orderModel);
}
catch (DbUpdateException)
{
// check out if exists
if (!(await _orderService.OrderIncomeExists(orderModel.IdOrderIncome)))
{
return(NotFound());
}
else
{
return(BadRequest());
}
}
return(Ok());
}
public async Task <IActionResult> UpdateProcess(UpdateViewModel vm)
{
if (ModelState.IsValid)
{
var idea = context.Ideas.Include(r => r.Stats).FirstOrDefault(r => r.Id == vm.Process);
try {
var update = new Update {
Text = vm.Text,
DateTime = DateTime.Now,
Images = ((vm.JsonImages != null) ? JsonConvert.DeserializeObject <List <Image> >(vm.JsonImages) : null)
};
idea.Updates.Add(update);
idea.LatestUpdate = DateTime.Now;
Stats.AddUpdate(idea);
await context.SaveChangesAsync();
} catch (Exception ex) {
var exs = ex;
}
return(RedirectToAction("Details", "Home", new { id = idea.Id }));
}
else
{
return(RedirectToAction("UpdateProcess", "Home", new { id = vm.Process }));
}
}
public async Task <IActionResult> UpdateProcess(int id)
{
if (id == null)
{
return(RedirectToAction("Home", "Update"));
}
var owner = await userManager.GetUserAsync(HttpContext.User);
var appuser = AppUser.ApplicationUserToAppUser(owner);
var idea = IdeaEx.IdeaById(id, owner, context);
if (idea.Authorized && idea.Idea.Owner.Id == owner.Id)
{
var vm = new UpdateViewModel {
JsonData = JsonConvert.SerializeObject(idea, Formatting.Indented, new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
})
};
return(View(vm));
}
else
{
return(RedirectToAction("Account", "Login"));
}
}
public UpdateWindow()
{
InitializeComponent();
ViewModel = new UpdateViewModel();
this.DataContext = ViewModel;
}
public IActionResult Update(int id, [FromBody] UpdateViewModel model)
{
var data = userService.GetOne(id);
if (data == null)
{
return(BadRequest());
}
User existingAnotherUser = userService.GetOne(model.Email);
if (existingAnotherUser != null && existingAnotherUser.ID != id)
{
ModelState.AddModelError("Email", localizer[ResourceKeys.UserExists].Value);
Response.StatusCode = 400;
}
if (!ModelState.IsValid)
{
return(new Helpers.UnprocessableEntityObjectResult(ModelState));
}
User entity = mapper.Map(model, data);
userService.Update(entity);
if (!userService.Save())
{
throw new Exception("Updating application failed on save.");
}
return(NoContent());
}
private void UpdateApp()
{
Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.UpdateApp,
(confirmed) =>
{
if (confirmed)
{
UpdateViewModel viewModel = null;
Messenger.Default.Send(new NotificationMessageAction <UpdateViewModel>(Messages.GetUpdateAppData, vm => viewModel = vm));
var worker = new BackgroundWorker {
WorkerReportsProgress = true
};
SetProgressTitle("Update Application");
worker.ProgressChanged += WorkerProgressChanged;
worker.DoWork += (s, e) =>
{
worker.ReportProgress(10, "Updating Application: " + viewModel.SelectedApplication.Name);
ProviderResponse <bool> result = provider.Update(
viewModel.SelectedCloud, viewModel.SelectedApplication, viewModel.PushFromDirectory);
if (!result.Response)
{
worker.ReportProgress(-1, result.Message);
return;
}
worker.ReportProgress(75, "Refreshing Application: " + viewModel.SelectedApplication.Name);
ProviderResponse <Application> appResult = provider.GetApplication(viewModel.SelectedApplication, viewModel.SelectedCloud);
if (appResult.Response == null)
{
worker.ReportProgress(-1, appResult.Message);
return;
}
e.Result = appResult.Response;
};
worker.RunWorkerCompleted += (s, e) =>
{
var result = e.Result as Application;
if (result == null)
{
return;
}
Cloud cloud = provider.Clouds.SingleOrDefault((c) => c.ID == viewModel.SelectedCloud.ID);
if (cloud != null)
{
Application application = cloud.Applications.SingleOrDefault((i) => i.Name == result.Name);
if (application != null)
{
application.Merge(result);
}
}
Messenger.Default.Send(new ProgressMessage(100, "Application Updated."));
};
worker.RunWorkerAsync();
Messenger.Default.Send(new NotificationMessageAction <bool>(Messages.Progress, c => { }));
}
}));
}
public UpdatePage()
{
ViewModel = new UpdateViewModel();
this.InitializeComponent();
this.Loaded += UpdatePage_Loaded;
_coreDispatcher = Window.Current.Dispatcher;
}
public IActionResult Updates(UpdateViewModel model)
{
if (model.attachment != null)
{
//write file to a physical path
var uniqueFileName = model.attachment.FileName;
var uploads = Path.Combine(_hostingEnvironment.WebRootPath, "updates");
string subpath = uploads + "\\" + uniqueFileName.Split('.')[0] + "_" + model.version;
System.IO.Directory.CreateDirectory(subpath);
var filePath = Path.Combine(subpath, uniqueFileName);
model.attachment.CopyTo(new FileStream(filePath, FileMode.Create));
//save the attachment to the database
Models.Installer_Update attachment = new Models.Installer_Update();
attachment.installer_ID = model.installer_ID;
attachment.version = model.version;
attachment.update_location = "wwwroot\\updates" + "\\" + uniqueFileName.Split('.')[0] + "_" + model.version + "\\" + uniqueFileName;
_appContext.updates.Add(attachment);
//retrieve system record
Models.Installer_Info installer = new Models.Installer_Info();
installer = _appContext.installers.Select(m => m).Where(m => m.ID == model.installer_ID).FirstOrDefault();
installer.cur_version = model.version;
_appContext.installers.Update(installer);
_appContext.SaveChanges();
}
return(RedirectToAction("index"));
}
public ActionResult EditUser(UpdateViewModel user)
{
var roleStore = new RoleStore <IdentityRole>(context);
var roleMngr = new RoleManager <IdentityRole>(roleStore);
var roles = roleMngr.Roles.ToList();
ViewBag.UserRoles = new SelectList(roles, "Name", "Name");
ApplicationUser appUser = context.Users.FirstOrDefault(m => m.Id == user.UserId);
appUser.PhoneNumber = user.PhoneNumber;
appUser.Email = user.Email;
appUser.UserName = user.UserName;
var oldRoleId = appUser.Roles.FirstOrDefault().RoleId;
var oldRoleName = context.Roles.FirstOrDefault(r => r.Id == oldRoleId).Name;
if (oldRoleName != user.UserRoles)
{
UserManager.RemoveFromRole(appUser.Id, oldRoleName);
UserManager.AddToRole(appUser.Id, user.UserRoles);
}
context.SaveChanges();
TempData["Message"] = "User Updated Successfully";
return(RedirectToAction("Index"));
}
public IActionResult Update(int id)
{
var data = _classifyService.Get(id);
var result = UpdateViewModel.Convert(data.Id, data.Content);
return(View("_Update", result));
}
public async Task <ActionResult <UpdateViewModel> > UpdateUser(int id, [FromBody] UpdateViewModel userobj)
{
if (userobj == null)
{
return(NotFound());
}
var user = _mapper.Map <User>(userobj);
if (userobj.ActPassword == true)
{
var resultPassword = await _userRepository.CrearPasswordHash(userobj.Password);
user.Password_Hash = resultPassword.Item1;
user.Password_Salt = resultPassword.Item2;
}
var resultado = await _userRepository.Update(user);
if (!resultado)
{
return(BadRequest());
}
return(userobj);
}
public IActionResult Load(long accountId, long id)
{
var model = new UpdateViewModel()
{
Options = GetTransactionTypes()
};
var result = _transactionService.GetById(id);
if (result.HasErrors())
{
model.Message = result.GetFailure();
return(View(model));
}
var transaction = result.GetPayload();
model.AccountId = accountId;
model.AccountName = transaction.AccountName;
model.AccountNumber = transaction.AccountNumber;
model.TransactionTypeId = transaction.TransactionTypeId;
model.Date = transaction.Date;
model.Description = transaction.Description;
model.Currency = transaction.Currency;
model.Amount = transaction.Amount;
return(View(model));
}
public async Task <IActionResult> Update([FromBody] UpdateViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.IdCandidate <= 0)
{
return(BadRequest());
}
try
{
await _candidateRepository.UpdateCandidate(model);
}
catch (NullReferenceException ex)
{
if (!(await _candidateRepository.CandidateExists(model.IdCandidate)))
{
return(NotFound(ex));
}
}
catch (DbUpdateException ex)
{
return(BadRequest(ex));
}
return(Ok());
}
public async Task <RepositoryResponse <UpdateViewModel> > SaveByName(string moduleName, [FromBody] JObject data)
{
var getModule = await Lib.ViewModels.MixModules.ReadListItemViewModel.Repository.GetSingleModelAsync(
m => m.Name == moduleName && m.Specificulture == _lang).ConfigureAwait(false);
if (getModule.IsSucceed)
{
var moduleData = new UpdateViewModel(
new MixModuleData()
{
ModuleId = getModule.Data.Id,
Specificulture = _lang,
Fields = getModule.Data.Fields
});
foreach (var item in moduleData.DataProperties)
{
moduleData.JItem[item.Name]["value"] = data[item.Name]?.Value <string>();
}
return(await moduleData.SaveModelAsync());
}
else
{
return(new RepositoryResponse <UpdateViewModel>()
{
IsSucceed = false,
Data = null,
Exception = getModule.Exception,
Errors = getModule.Errors
});
}
}
public IActionResult Update(UpdateViewModel Update, int id)
{
int?UserId = HttpContext.Session.GetInt32("UserId");
if (UserId == null)
{
return(RedirectToAction("Dashboard"));
}
UserModel loggedIn = _context.Users.Where(u => u.UserId == UserId).SingleOrDefault();
if (!loggedIn.Admin)
{
return(RedirectToAction("Dashboard"));
}
UserModel submission = _context.Users.Where(u => u.UserId == id).SingleOrDefault();
UserModel Query;
if (submission.Email.ToLower() == Update.EditForm.Email)
{
Query = null;
}
else
{
string check = submission.Email == null ? null : submission.Email.ToLower();
Query = _context.Users.Where(user => user.Email.ToLower() == check).FirstOrDefault();
}
if (ModelState.IsValid && Query == null)
{
submission.FirstName = Update.EditForm.FirstName;
submission.LastName = Update.EditForm.LastName;
submission.Email = Update.EditForm.Email;
submission.Admin = Update.EditForm.Admin;
_context.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
TempData["fname"] = Update.EditForm.FirstName;
TempData["lname"] = Update.EditForm.LastName;
TempData["emailAddress"] = Update.EditForm.Email;
foreach (string key in ModelState.Keys)
{
if (key == "id")
{
continue;
}
string field = key.Substring(9);
System.Console.WriteLine(field);
ModelStateEntry entry = ModelState[key];
string error = entry.Errors.Select(e => e.ErrorMessage).FirstOrDefault();
System.Console.WriteLine(error);
TempData[field] = error;
}
if (Query != null && TempData["Email"] == null)
{
TempData["Email"] = "Email is not unique.";
}
return(RedirectToAction("EditUser"));
}
}
public IActionResult Update(long id, UpdateViewModel model)
{
model.Options = BuildTypes();
if (!ModelState.IsValid)
{
return(View("Load", model));
}
var transactionType = new TransactionType()
{
Id = id,
Name = model.Name,
Credit = model.Equals("C") ? true : false
};
var result = _transactionTypeService.Update(transactionType);
if (result.HasErrors())
{
model.Message = result.GetFailure();
return(View("Load", model));
}
return(RedirectToAction("Index"));
}
public IActionResult Update(int id, [FromBody] UpdateViewModel model)
{
// map model to entity and set id
var user = _mapper.Map <User>(model);
user.Id = id;
if (user == null)
{
return(NotFound());
}
try
{
// update user
_userService.Update(user, model.Password);
_log.LogInformation("User updated", $"User with Name {model.Username} has been updated.");
return(Ok());
}
catch (AppException ex)
{
_log.LogError("Error occured while updating User", "", $"{ex.Message}");
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <RepositoryResponse <UpdateViewModel> > Save([FromBody] UpdateViewModel model)
{
if (model != null)
{
model.CreatedBy = User.Claims.FirstOrDefault(c => c.Type == "Username")?.Value;
var result = await base.SaveAsync <UpdateViewModel>(model, true);
if (result.IsSucceed)
{
if (model.Status == MixEnums.MixContentStatus.Schedule)
{
DateTime dtPublish = DateTime.UtcNow;
if (model.PublishedDateTime.HasValue)
{
dtPublish = model.PublishedDateTime.Value;
}
MixService.SetConfig(MixConstants.ConfigurationKeyword.NextSyncContent, dtPublish);
MixService.SaveSettings();
MixService.Reload();
}
}
return(result);
}
return(new RepositoryResponse <UpdateViewModel>()
{
Status = 501
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Competency sComp = (Competency)e.Parameter;
if (viewModel == null)
{
viewModel = new UpdateViewModel(sComp);
this.Student = viewModel.Student;
this.sQual = viewModel.Qualification;
App.tempComp = sComp;
stackComp.DataContext = sComp;
stackStudentDetail.DataContext = Student;
tbkQual.Text = sQual.QualName;
listView1.ItemsSource = viewModel.Qualifications;
foreach (var qual in viewModel.Qualifications)
{
List <Competency> compList = new List <Competency>();
compList = Competency.GetCompetencyList(Student.UserID, qual.QualCode).Where(c => c.CompletionStatus == "C").ToList();
qual.Competencies = compList;
}
}
else
{
//Frame.Navigate(typeof(views.MainPage));
}
}
