示例#1
0
        public void Update(int idUser, NoteModel noteModel)
        {
            var note = Find(idUser, noteModel.NoteId);

            if (note != null)
            {
                note.NoteName         = noteModel.NoteName;
                note.NoteText         = noteModel.NoteText;
                note.Image            = noteModel.Image;
                note.Update           = DateTime.Now;
                _db.Entry(note).State = EntityState.Modified;

                _db.SaveChanges();
            }
        }
        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 void TestPUT()
        {
            ClearDB();
            Note tmpNote = new Note();

            tmpNote.Text = "TestnotePUTOriginal";
            var actionResult0         = _controller.PostNote(tmpNote);
            var createdAtActionResult = actionResult0.Result as CreatedAtActionResult;
            var oritinalNote          = createdAtActionResult.Value as Note;

            Note modifiedNote = new Note();

            modifiedNote.Text = "TestnotePUTModified";
            modifiedNote.ID   = oritinalNote.ID;
            var actionResult1 = _controller.PutNote(oritinalNote.ID, modifiedNote);

            _context.Entry(tmpNote).Reload();

            var actionResult2       = _controller.GetNote(oritinalNote.ID);
            var okObjectResult      = actionResult2.Result as OkObjectResult;
            var modifiedNoteFromGet = okObjectResult.Value as Note;

            Assert.Equal(modifiedNote.Text, modifiedNoteFromGet.Text);
            ClearDB();
        }
示例#4
0
 /// <summary>
 /// Deletes the note.
 /// </summary>
 /// <param name="UserID">The user identifier.</param>
 /// <param name="noteID">The note identifier.</param>
 /// <returns></returns>
 public bool DeleteNote(long UserID, long noteID)
 {
     try
     {
         if (NotesDB.Notes.Any(n => n.NoteId == noteID && n.UserId == UserID))
         {
             var note = NotesDB.Notes.Find(noteID);
             if (note.IsTrash)
             {
                 NotesDB.Entry(note).State = EntityState.Deleted;
             }
             else
             {
                 note.IsTrash   = true;
                 note.IsPin     = false;
                 note.IsArchive = false;
             }
             NotesDB.SaveChanges();
             return(true);
         }
         return(false);
     }
     catch (Exception)
     {
         throw;
     }
 }
示例#5
0
        public IHttpActionResult PutNote(int id, Note note)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != note.Id)
            {
                return(BadRequest());
            }

            db.Entry(note).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!NoteExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
示例#6
0
        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());
        }
示例#7
0
        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());
        }
示例#8
0
 public static void SaveNote(Note note)
 {
     using (var context = new NotesContext())
     {
         context.Entry(note).State = EntityState.Modified;
         context.SaveChanges();
     }
 }
 public ActionResult Edit([Bind(Include = "ID,DueDate,DueTime,HomeworkTitle,Priority,Department,CourseNumber,Notes")] HWnotes hWnotes)
 {
     if (ModelState.IsValid)
     {
         db.Entry(hWnotes).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(hWnotes));
 }
示例#10
0
 public ActionResult Edit([Bind(Include = "ID,Title,Text,Now")] Notes notes)
 {
     if (ModelState.IsValid)
     {
         db.Entry(notes).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(notes));
 }
示例#11
0
 public ActionResult Edit([Bind(Include = "FeaturedJamID,Title,Author,DatePublished,Content")] FeaturedJam featuredJam)
 {
     if (ModelState.IsValid)
     {
         db.Entry(featuredJam).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(featuredJam));
 }
 public ActionResult Edit([Bind(Include = "ID,Category")] Group group)
 {
     if (ModelState.IsValid)
     {
         db.Entry(group).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(group));
 }
示例#13
0
 public ActionResult Edit([Bind(Include = "NoteId,NoteBody")] Note note)
 {
     if (ModelState.IsValid)
     {
         db.Entry(note).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(note));
 }
示例#14
0
 public void Update(Notes notes)
 {
     using (notesContext = new NotesContext())
     {
         var item = notesContext.Notes.Find(notes.Id);
         if (item != null)
         {
             notesContext.Entry(item).CurrentValues.SetValues(notes);
             notesContext.SaveChanges();
         }
     }
 }
 public void Edit(UserProfile user)
 {
     try
     {
         db.Entry(user).State = EntityState.Modified;
         db.SaveChanges();
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 public void Edit(Note note)
 {
     try
     {
         db.Entry(note).State = EntityState.Modified;
         db.SaveChanges();
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
示例#17
0
 public bool Update(int id, Note note)
 {
     try
     {
         note.Id = id;
         _context.Entry(note).State = EntityState.Modified;
         _context.SaveChanges();
         return(true);
     }
     catch (System.Exception)
     {
         return(false);
     }
 }
        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());
        }
        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());
        }
示例#20
0
 public bool ResetAccountPassword(ResetPasswordModel user)
 {
     try
     {
         var NewPassword = passwordEncryption.EncryptPassword(user.NewPassword);
         var LoginUser   = UserDB.UserAccounts.FirstOrDefault(u => u.Email.Equals(user.Email));
         if (user != null)
         {
             LoginUser.Password = NewPassword;
             UserDB.Entry(LoginUser).Property(x => x.Password).IsModified = true;
             UserDB.SaveChanges();
             return(true);
         }
     }
     catch (Exception)
     {
         throw;
     }
     return(false);
 }
        // PUT api/Note/5
        public HttpResponseMessage PutNote(int id, Note note)
        {
            if (ModelState.IsValid && id == note.Id)
            {
                db.Entry(note).State = EntityState.Modified;

                try
                {
                    db.SaveChanges();
                }
                catch (DbUpdateConcurrencyException)
                {
                    return(Request.CreateResponse(HttpStatusCode.NotFound));
                }

                return(Request.CreateResponse(HttpStatusCode.OK));
            }
            else
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
        }
        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());
        }
示例#23
0
        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());
        }
示例#24
0
        public virtual void Add(T entity)
        {
            EntityEntry dbEntityEntry = _context.Entry <T>(entity);

            _context.Set <T>().Add(entity);
        }