public async Task CreateAsync_NoteValidationSucceed_CreatesNote() { // Arrange var note = new NoteUpdateModel(); var expected = new Note(); var visitorService = new Mock <IVisitorService>(); visitorService.Setup(x => x.ValidateAsync(note)); var sessionService = new Mock <ISessionService>(); sessionService.Setup(x => x.ValidateAsync(note)); var filmService = new Mock <IFilmService>(); filmService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); noteDAL.Setup(x => x.InsertAsync(note)).ReturnsAsync(expected); var noteService = new NoteService(noteDAL.Object, visitorService.Object, sessionService.Object, filmService.Object); // Act var result = await noteService.CreateAsync(note); // Assert result.Should().Be(expected); }
public async Task CreateAsync_NoteValidationDoctorFailed_ThrowsError() { // Arrange var fixture = new Fixture(); var note = new NoteUpdateModel(); var expected = fixture.Create <string>(); var byerService = new Mock <IByerService>(); byerService.Setup(x => x.ValidateAsync(note)); var ownerService = new Mock <IOwnerService>(); ownerService.Setup(x => x.ValidateAsync(note)) .Throws(new InvalidOperationException(expected)); var pictureService = new Mock <IPictureService>(); pictureService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); var noteService = new NoteService(noteDAL.Object, byerService.Object, ownerService.Object, pictureService.Object); var action = new Func <Task>(() => noteService.CreateAsync(note)); // Assert await action.Should().ThrowAsync <InvalidOperationException>().WithMessage(expected); noteDAL.Verify(x => x.InsertAsync(note), Times.Never); }
public async Task Update(NoteUpdateModel model, bool updateRaw = false) { try { if (_key == null) { await SetKey(); } var note = await _connection.GetAsync <Note>(model.Id); if (updateRaw) { note.Text = model.Text; note.Title = model.Title; } else { note.Text = SecureService.EncryptString(_key, model.Text); note.Title = SecureService.EncryptString(_key, model.Title); } note.Modified = DateTime.Now; note.Version++; await _connection.UpdateAsync(note); } catch (Exception ex) { throw new Exception("Database error: " + ex.Message); } }
public async Task CreateAsync_NoteValidationSessionFailed_ThrowsError() { // Arrange var fixture = new Fixture(); var note = new NoteUpdateModel(); var expected = fixture.Create <string>(); var visitorService = new Mock <IVisitorService>(); visitorService.Setup(x => x.ValidateAsync(note)); var sessionService = new Mock <ISessionService>(); sessionService.Setup(x => x.ValidateAsync(note)) .Throws(new InvalidOperationException(expected)); var filmService = new Mock <IFilmService>(); filmService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); var noteService = new NoteService(noteDAL.Object, visitorService.Object, sessionService.Object, filmService.Object); var action = new Func <Task>(() => noteService.CreateAsync(note)); // Assert await action.Should().ThrowAsync <InvalidOperationException>().WithMessage(expected); noteDAL.Verify(x => x.InsertAsync(note), Times.Never); }
public IActionResult Update(int id) { var service = CreateNoteService(); try { var entity = service.GetNoteById(id); var model = new NoteUpdateModel { NoteId = entity.NoteId, Title = entity.Title, Content = entity.Content }; return(View(model)); } catch (InvalidOperationException) { TempData["NoResult"] = "The Note could not be found"; return(RedirectToAction("Index")); } catch (UnauthorizedAccessException) { TempData["NoResult"] = "You can only alter your notes"; return(RedirectToAction("Index")); } }
public async Task CreateAsync_NoteValidationSucceed_CreatesNote() { // Arrange var note = new NoteUpdateModel(); var expected = new Note(); var patientService = new Mock <IPatientService>(); patientService.Setup(x => x.ValidateAsync(note)); var doctorService = new Mock <IDoctorService>(); doctorService.Setup(x => x.ValidateAsync(note)); var diseaseService = new Mock <IDiseaseService>(); diseaseService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); noteDAL.Setup(x => x.InsertAsync(note)).ReturnsAsync(expected); var noteService = new NoteService(noteDAL.Object, patientService.Object, doctorService.Object, diseaseService.Object); // Act var result = await noteService.CreateAsync(note); // Assert result.Should().Be(expected); }
public async Task CreateAsync_NoteValidationSucceed_CreatesNote() { // Arrange var note = new NoteUpdateModel(); var expected = new Note(); var consumerService = new Mock <IConsumerService>(); consumerService.Setup(x => x.ValidateAsync(note)); var barberService = new Mock <IBarberService>(); barberService.Setup(x => x.ValidateAsync(note)); var haircutService = new Mock <IHaircutService>(); haircutService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); noteDAL.Setup(x => x.InsertAsync(note)).ReturnsAsync(expected); var noteService = new NoteService(noteDAL.Object, consumerService.Object, barberService.Object, haircutService.Object); // Act var result = await noteService.CreateAsync(note); // Assert result.Should().Be(expected); }
public async Task CreateAsync_NoteValidationbarberFailed_ThrowsError() { // Arrange var fixture = new Fixture(); var note = new NoteUpdateModel(); var expected = fixture.Create <string>(); var consumerService = new Mock <IConsumerService>(); consumerService.Setup(x => x.ValidateAsync(note)); var barberService = new Mock <IBarberService>(); barberService.Setup(x => x.ValidateAsync(note)) .Throws(new InvalidOperationException(expected)); var haircutService = new Mock <IHaircutService>(); haircutService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); var noteService = new NoteService(noteDAL.Object, consumerService.Object, barberService.Object, haircutService.Object); var action = new Func <Task>(() => noteService.CreateAsync(note)); // Assert await action.Should().ThrowAsync <InvalidOperationException>().WithMessage(expected); noteDAL.Verify(x => x.InsertAsync(note), Times.Never); }
public async Task CreateAsync_Note() { var update = new NoteUpdateModel(); update.Name = "test"; var identity = new NoteIdentityModel(0); var expected = new Note(); expected.Name = "test"; //mock var noteDataAccess = new Mock <IDataAccessor <Note, INoteIdentity, NoteUpdateModel> >(); noteDataAccess.Setup(x => x.InsertAsync(update)).ReturnsAsync(expected); var noteReminderGetService = new Mock <IGetService <NoteReminder, INoteReminderIdentity> >(); var noteReminderDeleteService = new Mock <IDeleteService <INoteReminderIdentity> >(); //setup var noteServices = new NoteServices(noteDataAccess.Object, noteReminderDeleteService.Object, noteReminderGetService.Object); //action var result = await noteServices.CreateAsync(update); //result result.Should().Be(expected); }
public async Task CreateAsync_NoteValidationSucceed_CreatesNote() { // Arrange var note = new NoteUpdateModel(); var expected = new Note(); var byerService = new Mock <IByerService>(); byerService.Setup(x => x.ValidateAsync(note)); var ownerService = new Mock <IOwnerService>(); ownerService.Setup(x => x.ValidateAsync(note)); var pictureService = new Mock <IPictureService>(); pictureService.Setup(x => x.ValidateAsync(note)); var noteDAL = new Mock <INoteDAL>(); noteDAL.Setup(x => x.InsertAsync(note)).ReturnsAsync(expected); var noteService = new NoteService(noteDAL.Object, byerService.Object, ownerService.Object, pictureService.Object); // Act var result = await noteService.CreateAsync(note); // Assert result.Should().Be(expected); }
public bool UpdateNote(NoteUpdateModel model) { var entity = GetNoteHelper(model.NoteId); entity.Title = model.Title; entity.Content = model.Content; return(_context.SaveChanges() == 1); }
public async Task <Note> CreateAsync(NoteUpdateModel note) { await this.VisitorService.ValidateAsync(note); await this.SessionService.ValidateAsync(note); await this.FilmService.ValidateAsync(note); return(await this.NoteDAL.InsertAsync(note)); }
public async Task <Note> CreateAsync(NoteUpdateModel note) { await this.PatientService.ValidateAsync(note); await this.DoctorService.ValidateAsync(note); await this.DiseaseService.ValidateAsync(note); return(await this.NoteDAL.InsertAsync(note)); }
public async Task <Note> CreateAsync(NoteUpdateModel note) { await this.ConsumerService.ValidateAsync(note); await this.BarberService.ValidateAsync(note); await this.HaircutService.ValidateAsync(note); return(await this.NoteDAL.InsertAsync(note)); }
public async Task <BarbershopWebApp.Domain.Note> InsertAsync(NoteUpdateModel note) { Note new_obj = this.Mapper.Map <Note>(note); new_obj.DateVisit = DateTime.Today; var result = await this.Context.AddAsync(new_obj); await this.Context.SaveChangesAsync(); return(this.Mapper.Map <BarbershopWebApp.Domain.Note>(result.Entity)); }
public async Task <BarbershopWebApp.Domain.Note> UpdateAsync(NoteUpdateModel note) { var existing = await this.Get(note); var result = this.Mapper.Map(note, existing); this.Context.Update(result); await this.Context.SaveChangesAsync(); return(this.Mapper.Map <BarbershopWebApp.Domain.Note>(result)); }
public async Task <IActionResult> UpdateNote([FromBody] NoteUpdateModel model) { try { if (!ModelState.IsValid) { throw new Exception("Model not valid."); } return(Ok(await _noteService.Update(model, GetUserId()))); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> UpdateNoteImage(NoteUpdateModel noteModel) { Note note = await noteManager.GetNote(noteModel.Id); if (note == null) { return(StatusCode(400)); } else { note.MainPhotourl = noteModel.MainPhotourl; int result = await noteManager.Update(note); return(Ok(result)); } }
public IActionResult UpdateNote(NoteUpdateModel model) { if (!ModelState.IsValid) { return(View(model)); } var service = CreateNoteService(); if (service.UpdateNote(model)) { TempData["SaveResult"] = "Your Note was updated"; return(RedirectToAction("Index", "Note")); } return(View(model)); }
public async Task <NoteGetModel> Update(NoteUpdateModel model, int userId) { var note = _context.Note.Find(model.Id); if (note != null) { if (note.ApplicationUserId != userId) { throw new Exception("Note does not belong to the user."); } note.Text = model.Text; note.Title = model.Title; note.Modified = model.Modified; note.Version++; await _context.SaveChangesAsync(); return(_mapper.Map <NoteGetModel>(note)); } throw new Exception("Note does not exist."); }
public IActionResult UpdateNote([FromBody] NoteUpdateModel model) { if (model.LastUpdated == null) { model.LastUpdated = DateTime.Now; } var noteQuery = _noteService.GetNoteQuery(model.NoteId); var basicUpdateResponse = _dbHelper.UpdateObject(noteQuery, model); if (basicUpdateResponse.Success) { var updatedResponse = _dbHelper.GetObjectByQuery <Notes, NoteUpdateModel>(noteQuery); return(ApiResult(updatedResponse)); } else { return(ApiResult(basicUpdateResponse)); } }
public async Task <IActionResult> UpdateNote(NoteUpdateModel noteModel) { Note note = await noteManager.GetNote(noteModel.Id); if (note == null) { return(StatusCode(400)); } else { note.MainPhotourl = noteModel.MainPhotourl; note.Title = noteModel.Title; note.Text = noteModel.Text; note.IsDraft = noteModel.isDraft; note.Description = noteModel.Description; int result = await noteManager.Update(note); return(Ok(result)); } }
public NoteDetailViewModel(NoteUpdateModel note) { Title = "Browse Notes"; Note = note; }
public async Task <ActionResult <int> > CreateNote(int folderId, [FromBody] NoteUpdateModel model) => await Execute(async operation => { return(await noteFolderService.CreateNote(operation, folderId, UserId ?? 0, model.ToEntity())); });
internal static NoteUpdateEntity ToEntity(this NoteUpdateModel model) => new NoteUpdateEntity { Title = model.Title, Text = model.Text, ProjectIds = model.ProjectIds };
public async Task <ActionResult <int> > UpdateNote(int folderId, int noteId, [FromBody] NoteUpdateModel model) => await Execute(async operation => { await noteFolderService.UpdateNote(operation, folderId, noteId, model.ToEntity()); });
public async Task <Note> UpdateAsync(NoteUpdateModel note) { return(await this.NoteDAL.UpdateAsync(note)); }