public async Task <IActionResult> PutCategory([FromRoute] int id, [FromBody] Category category) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != category.ID) { return(BadRequest()); } _context.Entry(category).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutNote([FromRoute] string id, [FromBody] Note note) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != note.Title) { return(BadRequest()); } _context.Entry(note).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NoteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutNote(int id, Note note) { if (id != note.IdNote) { return(BadRequest()); } _context.Entry(note).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NoteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <Note> AddNote(Note note) { _context.Note.Add(note); await _context.SaveChangesAsync(); return(note); }
public async Task <IActionResult> Post([FromBody] Note note) { await _dbContext.Notes.AddAsync(note); await _dbContext.SaveChangesAsync(HttpContext.User); return(Ok(note.Id)); }
public async Task <IActionResult> Create([Bind("ID,Email,Name,CreatedOn")] User user) { if (ModelState.IsValid) { _context.Add(user); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(user)); }
public async Task <IActionResult> Create([Bind("Id,Owner,NoteTitle,NoteContent")] Notes notes) { if (ModelState.IsValid) { _context.Add(notes); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(notes)); }
public async Task <IActionResult> Create([Bind("ID,Name")] Category category) { if (ModelState.IsValid) { _context.Add(category); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task <IActionResult> Create([Bind("ID,Title,Body")] Note note) { if (ModelState.IsValid) { _context.Add(note); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(note)); }
public async Task <IActionResult> Create([Bind("Id,Name,UrlSlug,Description")] Tag tag) { if (ModelState.IsValid) { _context.Add(tag); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(tag)); }
public async Task <ActionResult <Note> > Post(Note note) { if (note == null) { return(BadRequest()); } _context.Notes.Add(note); await _context.SaveChangesAsync(); return(Ok(note)); }
public async Task <IActionResult> Create([Bind("ID,Title,Notes,CreatedOn,CategoryId,UserId,IsDeleted")] Note note) { if (ModelState.IsValid) { _context.Add(note); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["CategoryId"] = new SelectList(_context.Categories, "ID", "ID", note.CategoryId); ViewData["UserId"] = new SelectList(_context.Users, "ID", "ID", note.UserId); return(View(note)); }
public Task <Core.Note> AddNoteAsync(Core.Note note) { if (note.Author is null) { throw new ArgumentException("Note must have author", nameof(note)); } return(AddNoteInternalAsync(note)); async Task <Core.Note> AddNoteInternalAsync(Core.Note note) { User author = await _context.Users.FindAsync(note.Author.Id); if (author is null) { throw new ArgumentException("Author does not exist", nameof(note)); } List <string> tags = await _context.Tags.Select(t => t.Name).ToListAsync(); var newNote = new Note { Id = note.Id, Author = author, Text = note.Text }; _context.Notes.Add(newNote); ISet <string> tagSet = tags.ToHashSet(); for (int i = 0; i < note.Tags.Count; i++) { if (!tagSet.Contains(note.Tags[i])) { _context.Tags.Add(new Tag { Name = note.Tags[i] }); } newNote.NoteTags.Add(new NoteTag { TagName = note.Tags[i], Order = i }); } await _context.SaveChangesAsync(); return(MapNoteWithAuthorAndTags(newNote)); } }
public async Task <IActionResult> Create([Bind("Id,Name,Text,Date_system,UrlNote,TagID,CategoryID")] Note note) { if (ModelState.IsValid) { _context.Add(note); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["CategoryID"] = new SelectList(_context.Category, "Id", "Name", note.CategoryID); ViewData["TagID"] = new SelectList(_context.Tag, "Id", "Name", note.TagID); return(View(note)); }
public static async Task SeedAsync(NotesContext context, ILogger <NotesContextSeed> logger) { try { using (context) { logger.LogInformation($"Starting migration of database on context {nameof(NotesContext)}"); context.Database.Migrate(); var retries = 3; var policy = Policy.Handle <SqlException>() .WaitAndRetryAsync( retries, (count, ctx) => TimeSpan.FromSeconds(3), (exception, timeSpan, retry, ctx) => { logger.LogError(exception, $"[NotesContextSeed] Exception {exception.GetType().Name} with message {exception.Message} on attempt {retry} of {retries}"); }); await policy.ExecuteAsync(async() => { if (!context.Tags.Any()) { context.Tags.AddRange(Tags); await context.SaveChangesAsync(); } if (!context.Notebooks.Any()) { Tags.ForEach(tag => { NoteList1.ForEach(note => note.AddTag(tag)); NoteList2.ForEach(note => note.AddTag(tag)); NoteList3.ForEach(note => note.AddTag(tag)); }); context.Notebooks.AddRange(Notebooks); await context.SaveChangesAsync(); } }); logger.LogInformation($"Finished migrating database on context {nameof(NotesContext)}"); } } catch (Exception ex) { logger.LogError(ex, $"An error occurred while migrating database on context {nameof(NotesContext)}"); } }
public async Task <IActionResult> Edit(Note phone) { db.Notes.Update(phone); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public async Task <IActionResult> Create(Note note) { db.Notes.Add(note); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public async Task DeleteTodo(ToDo toDo) { using (var dbContext = new NotesContext()) { dbContext.Remove(toDo); await dbContext.SaveChangesAsync(); } }
public async Task DeleteNote(Note note) { using (var dbContext = new NotesContext()) { dbContext.Remove(note); await dbContext.SaveChangesAsync(); } }
public async Task <IActionResult> Post([FromBody] Note model) { try { _logger.LogInformation($"Creating Note {model.Text}"); await _context.Notes.AddAsync(model); await _context.SaveChangesAsync(); return(Ok()); } catch (Exception e) { _logger.LogError(e, "Failed to create Note"); return(BadRequest()); } }
public async Task DeleteTodoAsync(Todo todo) { using (var dbContext = new NotesContext()) { dbContext.Remove(todo); await dbContext.SaveChangesAsync().ConfigureAwait(false); } }
public async Task <ActionResult <Note> > CreateNote(Note note) { await _db.Notes.AddAsync(note); var result = await _db.SaveChangesAsync(); return(Created($"api/notes/{note.Id}", note)); }
public async Task <IActionResult> PutNote(int id, Note note) { if (id != note.IdNote) { return(BadRequest()); } if (!NoteExists(id) || !NoteHistoryExists(id)) { return(NotFound()); } try { var version = await _context.NoteHistories.Where(n => n.IdNote == id).MaxAsync(n => n.Version); var noteHistory = await _context.NoteHistories.FindAsync(id, version); ++version; _context.NoteHistories.Add(new NoteHistory { IdNote = note.IdNote, Version = version, Title = note.Title, Content = note.Content, Created = noteHistory.Created }); await _context.SaveChangesAsync(); noteHistory = await _context.NoteHistories.FindAsync(id, version); note.Created = noteHistory.Created; note.Modified = DateTime.Now; _context.Entry(note).State = EntityState.Modified; await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NoteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
private void tagView_DragDrop(object sender, DragEventArgs e) { TreeNode NewNode; if (e.Data.GetDataPresent("System.Windows.Forms.TreeNode", false)) { Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y)); TreeNode DestinationNode = ((TreeView)sender).GetNodeAt(pt); NewNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode"); using (context.Database.BeginTransaction()) { if (DestinationNode == null) { ((Model.Tag)NewNode.Tag).ParentTag = null; } else if (CheckNoParent(NewNode, DestinationNode)) { //Remove Original Node ((Model.Tag)NewNode.Tag).ParentTag = ((Model.Tag)DestinationNode.Tag); } } context.SaveChangesAsync(); UpdateTagList(); } }
public async Task <IActionResult> Put([FromBody] Note note) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.Entry(note).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { throw; } return(NoContent()); }
public async Task <IActionResult> PutNotes([FromRoute] int id, [FromBody] Notes notes) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != notes.ID) { return(BadRequest()); } var user = _context.Users.Find(notes.User.ID); var category = _context.Categories.Find(notes.Category.ID); notes.User = user; notes.Category = category; _context.Entry(notes).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NotesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutManagedNotes(long id, ManagedNotesDTO managedNotesDTO) { if (id != managedNotesDTO.Id) { return(BadRequest()); } var managedNotes = await _context.Notes.FindAsync(id); if (managedNotes == null) { return(NotFound()); } managedNotes.IsComplete = managedNotesDTO.IsComplete; managedNotes.Name = managedNotesDTO.Name; _context.Entry(managedNotes).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ManagedNotesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutNote([FromRoute] int id, [FromBody] Note note) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != note.ID) { return(BadRequest()); } //GetNote().Where(i => i.ID == id).ForEachAsync(z => { z = note; }); _context.Note.Update(note); //_context.Entry(note).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NoteExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> Delete(int?id) { if (id != null) { Note note = await db.Notes.FirstOrDefaultAsync(p => p.Id == id); if (note != null) { db.Notes.Remove(note); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } } return(NotFound()); }
public async Task SaveTodoAsync(Todo todo) { using (var dbContext = new NotesContext()) { if (todo.Id == 0) { await dbContext.Todos.AddAsync(todo).ConfigureAwait(false); } else { dbContext.Todos.Update(todo); } await dbContext.SaveChangesAsync().ConfigureAwait(false); } }