/// <inheritdoc />
public async Task CreateScoreAsync(ScoreDomainModel scoreDomainModel)
{
try
{
_logger.Info($"Looking for good with id: {scoreDomainModel.GoodId}");
await this._context.Goods.SingleAsync(g => g.Id == scoreDomainModel.GoodId);
_logger.Info($"Good with id: {scoreDomainModel.GoodId} exists in database.");
}
catch (InvalidOperationException ex)
{
throw new ArgumentException($"Good with specified id: {scoreDomainModel.GoodId} doesn't exist.", ex);
}
try
{
this._scoreDomainModelValidator.ValidateAndThrow(scoreDomainModel);
}
catch (ValidationException ex)
{
throw new ArgumentException($"Error when validating {scoreDomainModel}.", ex);
}
var score = this._mapper.Map <Score>(scoreDomainModel);
_logger.Info("Adding score to database");
this._context.Scores.Add(score);
_logger.Info("Saving changes to database");
await this._context.SaveChangesAsync();
}
public void UpdateScore_ValidModel_ReturnsValidModel()
{
var testScoreEntity = ScoreFactory.Create_ScoreEntity_ValidMinimum(Guid.NewGuid());
var testScore = new ScoreDomainModel(testScoreEntity);
var testClass = ServiceFactory.Create_ScoreService();
var result = testClass.UpdateScore(testScore);
result.GetType().ShouldNotBe(typeof(ErrorDomainModel));
}
public void UpdateScore_EmptyGuid_ReturnsErrorModel()
{
var testScore = new ScoreDomainModel {
Id = Guid.Empty
};
var testClass = ServiceFactory.Create_ScoreService();
var result = testClass.UpdateScore(testScore);
result.GetType().ShouldBe(typeof(ErrorDomainModel));
}
public ScoreViewModel(ScoreDomainModel domainModel)
{
Id = domainModel.Id;
Name = domainModel.Name;
Date = domainModel.Date;
EvaluationId = domainModel.EvaluationId;
PointsPossible = domainModel.PointsPossible;
PointsEarned = domainModel.PointsEarned;
PointsGrade = domainModel.PointsGrade * 100;
_lastModified = domainModel.LastModified;
CreatedOn = domainModel.CreatedOn;
}
private static ScoreEntity ConvertModelToEntity(ScoreDomainModel createModel)
{
return(new ScoreEntity
{
Id = createModel.Id,
Name = createModel.Name,
EvaluationId = createModel.EvaluationId,
Date = createModel.Date,
PointsPossible = createModel.PointsPossible,
PointsEarned = createModel.PointsEarned
});
}
public IDomainModel GetScore(Guid scoreId)
{
var scoreModel = new ScoreDomainModel();
try
{
var scoreEntity = Interactor.GetScore(scoreId);
scoreModel = new ScoreDomainModel(scoreEntity);
}
catch (GradeTrackerException e)
{
var errorModel = new ErrorDomainModel(e, false);
return(errorModel);
}
return(scoreModel);
}
public IDomainModel DeleteScore(Guid scoreId)
{
var deletedScoreModel = new ScoreDomainModel();
try
{
var score = Interactor.GetScore(scoreId);
Interactor.DeleteScore(scoreId);
deletedScoreModel = new ScoreDomainModel {
EvaluationId = score.EvaluationId
};
}
catch (GradeTrackerException gte)
{
return(new ErrorDomainModel(gte, false));
}
return(deletedScoreModel);
}
public IDomainModel CreateNewScore(CreateScoreDomainModel createModel)
{
var scoreModel = new ScoreDomainModel();
var newScoreEntity = ConvertModelToEntity(createModel);
try
{
CalculateGrade(newScoreEntity);
var scoreId = Interactor.CreateScore(newScoreEntity);
scoreModel = (ScoreDomainModel)GetScore(scoreId);
}
catch (ObjectAlreadyExistsException oae)
{
var errorModel = new ErrorDomainModel(oae, true);
return(errorModel);
}
return(scoreModel);
}
public IDomainModel UpdateScore(ScoreDomainModel updatedScoreModel)
{
var returnModel = new ScoreDomainModel();
try
{
var entityToUpdate = ConvertModelToEntity(updatedScoreModel);
CalculateGrade(entityToUpdate);
Interactor.UpdateScore(entityToUpdate);
var updatedEntity = Interactor.GetScore(entityToUpdate.Id);
returnModel = new ScoreDomainModel(updatedEntity);
}
catch (GradeTrackerException gte)
{
return(new ErrorDomainModel(gte, true));
}
return(returnModel);
}
public async Task <IHttpActionResult> Post(ScoreDomainModel scoreDomainModel)
{
_logger.Info($"Start process of adding score to database.");
try
{
await this._scoreService.CreateScoreAsync(scoreDomainModel);
}
catch (ArgumentException ex)
{
_logger.Info(ex, ex.ToString());
return(this.BadRequest(ex.Message));
}
catch (Exception ex)
{
_logger.Error(ex, ex.ToString());
return(this.InternalServerError());
}
string messageIfSuccess = $"Score has been successfully added.";
_logger.Info(messageIfSuccess);
return(this.Ok(scoreDomainModel));
}
private static CreateOrEditScoreViewModel ConvertToCreateOrEditScoreViewModel(ScoreDomainModel domainModel)
{
return(new CreateOrEditScoreViewModel
{
Id = domainModel.Id,
EvaluationId = domainModel.EvaluationId,
Name = domainModel.Name,
Date = domainModel.Date,
PointsEarned = domainModel.PointsEarned,
PointsPossible = domainModel.PointsPossible
});
}
public ActionResult Complete(ScoreDomainModel scoreModel)
{
var scoreViewModel = new ScoreViewModel(scoreModel);
return(View("ScoreAdded", scoreViewModel));
}
