public async void PostShouldReturnApiExceptionIfCalendarIsNotFoundByPassedCalendarCode()
{
// arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var calendarRepositoryMock = new Mock <ICalendarRepository>();
var noteRepositoryMock = new Mock <INoteRepository>();
var createNoteModel = new CreateNoteModel()
{
CalendarCode = "calendarCode",
Name = "Siuan",
FromDate = DateTime.Now,
ToDate = DateTime.Now.AddMonths(7),
Text = "Blue"
};
calendarRepositoryMock.Setup(x => x.SingleOrDefaultAsync(It.IsAny <Expression <Func <Calendar, bool> > >()))
.Returns(Task.FromResult <Calendar>(null));
unitOfWorkMock.Setup(x => x.Calendars).Returns(calendarRepositoryMock.Object);
unitOfWorkMock.Setup(x => x.Notes).Returns(noteRepositoryMock.Object);
var controller = new NotesController(unitOfWorkMock.Object, _logger, _mapper);
// act
Func <Task> result = () => controller.Post(createNoteModel);
// assert
await Assert.ThrowsAsync <ApiException>(result);
}
public async Task <ActionResult> CreateAsync([FromBody] CreateNoteModel model)
{
var ownerId = HttpContext.GetSessionUserId();
var note = await _noteService.CreateNoteAsync(model, ownerId);
return(Ok(note));
}
public IActionResult Get([FromBody] CreateNoteModel model)
{
var note = _mapper.Map <Note>(model);
note = _notes.Create(note);
var data = _mapper.Map <NoteModel>(note);
return(Ok(data));
}
private CreateNoteModel CreateNoteModel(CreateNoteRequest request, int userId)
{
var noteModel = new CreateNoteModel
{
CreatorId = userId,
NoteName = request.NoteName,
NoteDescription = request.NoteDescription
};
return(noteModel);
}
public ActionResult CreateNotePartial(CreateNoteModel createNoteModel)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
if (!ModelState.IsValid)
{
return(PartialView(createNoteModel));
}
User user = usersRep.LoadByLogin(User.Identity.Name);
if (user == null)
{
return(PartialView(createNoteModel));
}
var postedFile = createNoteModel.File;
DB.Models.File file = null;
if (postedFile != null)
{
string filename = Path.GetFileName(postedFile.FileName);
string path = "~/App_Data/Files/" + filename;
postedFile.SaveAs(HostingEnvironment.MapPath(path));
file = new DB.Models.File
{
Name = postedFile.FileName,
ContentType = postedFile.ContentType,
Path = path
};
filesRep.Save(file);
}
Note note = new Note()
{
Title = createNoteModel.Title,
Text = createNoteModel.Text,
Tags = createNoteModel.Tags,
Status = (NoteStatus)createNoteModel.Status,
User = user,
File = file
};
if (notesRep.SaveByProc(note))
{
Response.StatusCode = (int)HttpStatusCode.OK;
}
return(PartialView());
}
public void ShouldHaveErrorWhenToDateLessThenFromDate()
{
var model = new CreateNoteModel()
{
CalendarCode = "asdf",
Name = "Birthdays",
FromDate = DateTime.Now,
ToDate = DateTime.Now.AddHours(-1)
};
validator.ShouldHaveValidationErrorFor(x => x.ToDate, model);
}
public void ShouldHaveErrorWhenToDateHasDefaultValue()
{
var model = new CreateNoteModel()
{
CalendarCode = "asdf",
Name = "Birthdays",
FromDate = DateTime.Now,
ToDate = DateTime.MinValue
};
validator.ShouldHaveValidationErrorFor(x => x.ToDate, model);
}
public void ShouldNotHaveErrorWhenToDateIsNull()
{
var model = new CreateNoteModel()
{
CalendarCode = "asdf",
Name = "Birthdays",
FromDate = DateTime.Now,
ToDate = null
};
validator.ShouldNotHaveValidationErrorFor(x => x.ToDate, model);
}
public async Task Test_CreateNote()
{
string email = "*****@*****.**";
var signUpModel = new SignUpModel
{
Email = email,
Password = "******"
};
await SignUp(signUpModel);
var response = await SignIn(new SignInModel
{
Email = signUpModel.Email,
Password = signUpModel.Password
});
var responseModel = response.ToObject <LogInResult>();
_client.DefaultRequestHeaders.Add("Authorization", "Bearer " + responseModel.Token);
var model = new CreateNoteModel
{
Tags = new[] { "tag1", "tag2" },
Text = "Text",
Title = "Title"
};
var postNoteResponse = await _client.PostAsync($"notes", model.ToJsonContent());
postNoteResponse.EnsureSuccessStatusCode();
var responseNoteModel = postNoteResponse.ToObject <NoteModel>();
//Assert
var getNoteResponse = await _client.GetAsync($"notes");
getNoteResponse.EnsureSuccessStatusCode();
var responseGetNoteModels = getNoteResponse.ToObject <PaginatedResult <NoteModel> >();
Assert.AreEqual(responseGetNoteModels.TotalCount, 1);
var responseGetNoteModel = responseGetNoteModels.Items.First();
Assert.AreEqual(model.Title, responseNoteModel.Title);
Assert.AreEqual(model.Text, responseNoteModel.Text);
CollectionAssert.AreEquivalent(model.Tags, responseNoteModel.Tags);
Assert.AreEqual(responseGetNoteModel.Title, responseNoteModel.Title);
Assert.AreEqual(responseGetNoteModel.Text, responseNoteModel.Text);
CollectionAssert.AreEquivalent(responseGetNoteModel.Tags, responseNoteModel.Tags);
}
public async Task <NoteModel> CreateNoteAsync(CreateNoteModel model, Guid ownerId)
{
var user = await FindUserById(ownerId);
var noteToAdd = _mapper.Map <Note>(model);
noteToAdd.Owner = user;
noteToAdd.Tags = (await _tagRepository.InsertTagsAsync(model.Tags, ownerId)).ToList();
var noteAdded = await _noteRepository.InsertOrUpdateAsync(noteToAdd, ownerId);
return(_mapper.Map <Note, NoteModel>(noteAdded));
}
public async Task <IActionResult> CreateNote([FromBody] CreateNoteModel model)
{
if (model == null)
{
return(BadRequest());
}
var note = new Note
{
Text = model.Text,
PostID = model.PostId,
UserID = model.UserId,
};
var result = await _NoteRepository.Add(note);
return(Json(Ok(result)));
}
public async Task <ActionResult <CreateNoteResult> > CreateNote([FromBody] CreateNoteModel model)
{
try
{
if (model == null)
{
return(new CreateNoteResult
{
Successful = false,
Errors = new List <string>()
{
"Invalid player note model"
}
});
}
var newPlayerNote = new PlayerNote
{
NotedPlayerName = model.NotedPlayerName,
Description = model.Description,
UserId = _userManager.GetUserId(User)
};
var result = await _playerNotesRepository.UpdateNote(newPlayerNote);
if (result == null)
{
await _playerNotesRepository.AddNote(newPlayerNote);
}
return(Ok(new CreateNoteResult
{
Successful = true
}));
}
catch (Exception)
{
return(new CreateNoteResult
{
Successful = false,
Errors = new List <string>()
{
"Unexpected error occured. Try again or contact support"
}
});
}
}
public async void PostShouldReturnCreatedNote()
{
// arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var calendarRepositoryMock = new Mock <ICalendarRepository>();
var noteRepositoryMock = new Mock <INoteRepository>();
var createNoteModel = new CreateNoteModel()
{
CalendarCode = "calendarCode",
Name = "Siuan",
FromDate = DateTime.Now,
ToDate = DateTime.Now.AddMonths(7),
Text = "Blue"
};
calendarRepositoryMock.Setup(x => x.SingleOrDefaultAsync(It.IsAny <Expression <Func <Calendar, bool> > >()))
.ReturnsAsync(new Calendar()
{
Id = 2
});
noteRepositoryMock.Setup(x => x.Add(It.IsAny <Note>())).Callback <Note>(x =>
{
x.Id = 8;
_noteList.Add(x);
});
unitOfWorkMock.Setup(x => x.Calendars).Returns(calendarRepositoryMock.Object);
unitOfWorkMock.Setup(x => x.Notes).Returns(noteRepositoryMock.Object);
var controller = new NotesController(unitOfWorkMock.Object, _logger, _mapper);
// act
var result = await controller.Post(createNoteModel) as ObjectResult;
// assert
Assert.IsType <OkObjectResult>(result);
Assert.IsType <NoteModel>(result.Value);
Assert.Equal("Siuan", (result.Value as NoteModel).Name);
Assert.Contains(_noteList, x => x.Id == 8);
Assert.Equal(2, _noteList.SingleOrDefault(x => x.Id == 8).CalendarId);
}
public ActionResult Create(CreateNoteModel model)
{
var db = new SportNotesDbContext();
if (ModelState.IsValid)
{
var note = new Note()
{
Date = DateTime.UtcNow,
Content = model.Content,
Comment = model.Comment,
OwnerId = this.User.Identity.GetUserId()
};
db.Notes.Add(note);
db.SaveChanges();
return(RedirectToAction("Details", "Note", new { id = note.Id }));
}
return(View(model));
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Post([FromBody] CreateNoteModel model)
{
if (model is null)
{
throw new ApiException("Model is null.", StatusCodes.Status400BadRequest);
}
var calendar = await _unitOfWork.Calendars.SingleOrDefaultAsync(x => x.Code == model.CalendarCode);
if (calendar is null)
{
throw new ApiException("Calendar doesn't exist.", StatusCodes.Status404NotFound);
}
var entity = _mapper.Map <CreateNoteModel, Note>(model);
entity.CalendarId = calendar.Id;
_repository.Add(entity);
await _unitOfWork.CompleteAsync();
return(Ok(_mapper.Map <Note, NoteModel>(entity)));
}
public async Task <CreateNoteResult> Create(CreateNoteModel model)
{
var result = await _httpClient.PostJsonAsync <CreateNoteResult>("api/PlayerNote", model);
return(result);
}
