public async Task <IActionResult> Edit(int id, [Bind("Id,WordCount,Text,PostedOn")] Blog blog) { if (id != blog.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(blog); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BlogExists(blog.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(blog)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Nickname,Description,PostedOn,PostId")] Comment comment) { if (id != comment.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(comment); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CommentExists(comment.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["PostId"] = new SelectList(_context.Posts, "Id", "AppUserId", comment.PostId); return(View(comment)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Description")] Category category) { if (id != category.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(category); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(category.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task <Response> UpdateAsync(string slug, UpdatePostRequest request) { var query = _context.Posts.AsQueryable(); query = ApplyInclude(query); var post = await query.SingleOrDefaultAsync(i => i.Slug == slug); if (post == null) { return(null); } _context.Posts.Attach(post); _context.Posts.Update(post); _mapper.Map(request.BlogPost, post); _context.Update(post); await _context.SaveChangesAsync(); var response = _mapper.Map <PostModel>(post); return(new PostResponse { BlogPost = response }); }
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Content,AuthorEmail")] BgModel bgModel) { if (id != bgModel.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(bgModel); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BgModelExists(bgModel.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(bgModel)); }
public async Task <IActionResult> Edit(int id, [Bind("ID,BlogId,Title,Content,Date")] Post post) { if (id != post.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(post); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PostExists(post.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["BlogId"] = new SelectList(_context.Set <Blog>(), "ID", "ID", post.BlogId); return(View(post)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Content,CreatedAt,AutorEmail")] Blog blog) //Blog ist der bearbeitete Datensatz { if (id != blog.Id) { return(NotFound()); } if (ModelState.IsValid) //Ist der Datensatz nach der modifizierung noch Valide? { try { _context.Update(blog); //Markiere, dass ein Datenatz modifiziert wird await _context.SaveChangesAsync(); //Modifizerungen werden in DB übertragen } catch (DbUpdateConcurrencyException) { if (!BlogExists(blog.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(blog)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Description,Published,Modified,AppUserId,CommentId")] Post post) { if (id != post.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(post); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PostExists(post.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AppUserId"] = new SelectList(_context.AppUsers, "Id", "Id", post.AppUserId); return(View(post)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Content,CreatedAt,CreatedBy")] Blog blog) { if (id != blog.Id) { return(NotFound()); } if (ModelState.IsValid) { try { //_context.Attach(Blog).State = EntityState.Modified; = #ältere Schreibvariante _context.Update(blog); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BlogExists(blog.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(blog)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Content,DateTime,UserId")] Publication publication) { if (id != publication.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(publication); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PublicationExists(publication.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(publication)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Pacc,SubmissionDate,Address1,Address2,City,State,ZIP,Phone,AddressID,IssueType,ComplaintDescription,PublicNotes,PrivateNotes,HumanSafety,Notes")] Complaint complaint) { if (id != complaint.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(complaint); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ComplaintExists(complaint.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(complaint)); }
public async Task UpdatePost(int Id, Post post) { if (Id == post.ID) { _context.Update(post); await _context.SaveChangesAsync(); } }
public async Task <IActionResult> Edit(int id, EntryViewModel vm) { var entry = vm.Entry; if (id != entry.Id) { return(NotFound()); } if (ModelState.IsValid) { try { entry.ModifiedOn = DateTime.UtcNow; _ctx.Update(entry); await _ctx.SaveChangesAsync(); var updatedCategoryIds = vm.Categories.Where(c => c.Id != 0).Select(s => s.Id); var entryCats = _ctx.BlogEntryCategories.Where(w => w.EntryId == entry.Id); foreach (var ec in entryCats) { if (!updatedCategoryIds.Contains(ec.CategoryId)) { _ctx.BlogEntryCategories.Remove(ec); } } await _ctx.SaveChangesAsync(); foreach (var categoryId in updatedCategoryIds) { if (!entryCats.Any(a => a.CategoryId == categoryId)) { _ctx.BlogEntryCategories.Add(new EntryCategory(entry.Id, categoryId)); } } await _ctx.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EntryExists(entry.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Admin")); } return(View(vm)); }
public void UpdateBlogPostSettings(string blogPostId, bool isPrivate, bool commentsAllowed = false, bool commentsModerated = false) { // NOTE: Comment Settings are not versioned, so is okay to update the model directly var existingBlogPost = _blogDbContext.BlogPosts.FirstOrDefault(x => x.Id == blogPostId); if (existingBlogPost == null) { throw new NullReferenceException($"Could not update Blog Post settings: Id {blogPostId} not found"); } existingBlogPost.IsPrivate = isPrivate; // TODO - Simplify comments settings - no need for Private vs Public since // "private" blog posts would only be viewed by authorized users anyway existingBlogPost.PrivateCommentsAllowed = commentsAllowed; existingBlogPost.PublicCommentsAllowed = commentsAllowed; existingBlogPost.PublicCommentsModerated = commentsModerated; existingBlogPost.PrivateCommentsModerated = commentsModerated; _blogDbContext.Update(existingBlogPost); _blogDbContext.SaveChanges(); }
public async Task <ActionResult <User> > Put(User user) { if (user == null) { return(BadRequest()); } if (!db.Users.Any(x => x.Id == user.Id)) { return(NotFound()); } db.Update(user); await db.SaveChangesAsync(); return(Ok(user)); }
public async Task <ActionResult <Post> > Put(Post post) { if (post == null) { return(BadRequest()); } if (!db.Posts.Any(x => x.Id == post.Id)) { return(NotFound()); } db.Update(post); await db.SaveChangesAsync(); return(Ok(post)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Content,CategoryId")] Post post) { if (id != post.Id) { return(NotFound()); } var oldPost = await _context.Posts.FindAsync(id); if (oldPost == null) { return(NotFound()); } oldPost.Slug = _slugger.Sluggify(post.Title); oldPost.Updated = DateTime.Now; oldPost.CategoryId = post.CategoryId; oldPost.Title = post.Title; oldPost.Content = post.Content; if (ModelState.IsValid) { try { _context.Update(oldPost); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PostExists(post.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["CategoryId"] = new SelectList(_context.Categories, "Id", "Title", post.CategoryId); return(View(post)); }
public async Task <IActionResult> EditRole(string id, RoleViewModel model) { if (ModelState.IsValid) { bool isExist = !String.IsNullOrEmpty(id); if (!isExist) { return(NotFound()); } var role = await _roleManager.FindByIdAsync(id); role.Name = model.Name; role.Description = model.Description; _dbContext.Update(role); await _dbContext.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(model)); }
public async Task <IActionResult> AddOrUpdate(int postId, [FromForm] EditablePost newPost) { bool isNew = postId == 0; if (isNew && _blogContext.Posts.Any(c => c.UrlSegment == newPost.UrlSegment)) { ModelState.AddModelError("Blog.ViewModels.NewPost.Permalink", string.Format("Url Segment {0} already exists", newPost.UrlSegment)); } if (ModelState.IsValid) { var dbPost = _mapper.Map <Data.Models.Post>(newPost); dbPost.LastModifiedDate = DateTime.Today; _blogContext.Update(dbPost); // Performs add or update await _blogContext.SaveChangesAsync(); return(Ok(isNew ? "Post Added" : "Post Updated")); } return(BadRequest(ModelState)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Title")] Category category) { if (id != category.Id) { return(NotFound()); } var oldCategory = await _context.Categories.FindAsync(id); if (category == null) { return(NotFound()); } oldCategory.Updated = DateTime.Now; oldCategory.Title = category.Title; oldCategory.Slug = _slugger.Sluggify(category.Title); if (ModelState.IsValid) { try { _context.Update(oldCategory); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(category.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task Update(TEntity entity) { dbContext.Update(entity); await dbContext.SaveChangesAsync(); }
public async Task <IActionResult> Edit(int id, [Bind("ProductId,Name,Description,Price,DateCreated,DateUpdated,ProductPicture")] Product product) { if (id != product.ProductId) { return(NotFound()); } if (SelectedCategories.Length == 0) { ModelState.AddModelError(String.Empty, "Phải ít nhất một loại sản phẩm"); } if (ModelState.IsValid) { // Lấy nội dung từ DB var productUpdate = await _context.Products.Where(p => p.ProductId == id) .Include(p => p.ProductCategories) .ThenInclude(c => c.Category).FirstOrDefaultAsync(); if (productUpdate == null) { return(NotFound()); } productUpdate.Name = product.Name; productUpdate.Description = product.Description; productUpdate.Price = product.Price; productUpdate.ProductPicture = product.ProductPicture; productUpdate.DateUpdated = DateTime.Now; // Các danh mục không có trong selectedCategories var listcateremove = productUpdate.ProductCategories .Where(p => !SelectedCategories.Contains(p.CategoryID)) .ToList(); listcateremove.ForEach(c => productUpdate.ProductCategories.Remove(c)); // Các ID category chưa có trong postUpdate.PostCategories var listCateAdd = SelectedCategories .Where( id => !productUpdate.ProductCategories.Where(c => c.CategoryID == id).Any() ).ToList(); listCateAdd.ForEach(id => { productUpdate.ProductCategories.Add(new ProductCategory() { ProductID = productUpdate.ProductId, CategoryID = id }); }); try { _context.Update(productUpdate); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductExists(product.ProductId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } var categories = await _context.Categories.ToListAsync(); ViewData["categories"] = new MultiSelectList(categories, "Id", "Name", SelectedCategories); return(View(product)); }
public async Task UpdateAsync(T entity) { using var context = new BlogDbContext(); context.Update(entity); await context.SaveChangesAsync(); }