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