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)); } }