public EvaluationScore CreateAnswers(EvaluationScore answers)
{
answers.Id = Guid.NewGuid();
Memory.Answers.List.Add(answers);
return(Memory.Answers.Get(answers.Id));
}
public async Task <ActionResult <EvaluationScore> > PostEvaluationScore(EvaluationScore evaluationScore)
{
_context.EvaluationScore.Add(evaluationScore);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEvaluationScore", new { id = evaluationScore.Id }, evaluationScore));
}
public async Task <IActionResult> PutEvaluationScore(int id, EvaluationScore evaluationScore)
{
if (id != evaluationScore.Id)
{
return(BadRequest());
}
_context.Entry(evaluationScore).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EvaluationScoreExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public EvaluationScore CreateAnswers(Guid idEvaluation, EvaluationAnswer answersList)
{
return(ServiceErrorHandler.Handle(() =>
{
Log.Info($"Checking if evaluation with id {idEvaluation} exists");
var answersDao = this.answersDaoBuilder.Create();
var evaluationsDao = this.evaluationsDaoBuilder.Create();
var templatesDao = this.templatesDaoBuilder.Create();
if (!evaluationsDao.EvaluationExists(idEvaluation))
{
throw new ItemNotFoundServiceException($"Unable to find an evaluation with id {idEvaluation}");
}
var evaluation = evaluationsDao.GetEvaluation(idEvaluation);
var template = templatesDao.GetTemplate(evaluation.IdTemplate);
var evaluationTemplate = EvaluationScoreHelpers.GenerateEvaluationTemplate(template, evaluation);
evaluationTemplate.AppendAnswers(answersList);
var scoreService = ServicesFacade.Instance.GetScoreService();
var caluculatedEvaluation = scoreService.CalculateScore(evaluationTemplate);
Log.Info($"Creating answers for evaluation {idEvaluation}");
caluculatedEvaluation.IdEvaluation = idEvaluation;
caluculatedEvaluation.Date = DateTime.Now.ToUniversalTime();
EvaluationScore newAnswers = answersDao.CreateAnswers(caluculatedEvaluation);
Log.Info($"Evaluation answers created succesfully, Id {newAnswers.Id}");
return newAnswers;
}));
}
public void CreateAnswers_WhenSendAValidObject_ShouldCreateAndReturnObject()
{
var connectionMock = new CassandraConnection("answers", "localhost");
var mapperMock = new Mock <IMapper>();
var expected = new EvaluationScore()
{
Id = Guid.NewGuid(),
IdEvaluation = Guid.NewGuid(),
Qualification = Guid.NewGuid(),
Date = DateTime.Now,
Name = "TestName",
Owner = "TestOwner",
Score = 50,
ScoreFormula = "Formula",
Weight = 12,
QuestionList = new List <QuestionScore>()
{
new QuestionScore()
{
IdQuestion = Guid.NewGuid(),
Answers = new List <Guid>(),
Score = 5,
ScoreFormula = "QS1",
OptionList = new List <OptionScore>()
{
new OptionScore()
{
IdOption = Guid.NewGuid(), IsAnswer = true, Sequence = 1, UserSelected = false, Weight = 3
}
}
},
new QuestionScore()
{
IdQuestion = Guid.NewGuid(),
Answers = new List <Guid>(),
Score = 5,
ScoreFormula = "QS2",
OptionList = new List <OptionScore>()
},
},
QualificationRanges = new List <QualificationRange>()
{
new QualificationRange()
{
Id = Guid.NewGuid(), Start = 100, End = 0, Qualification = "GOOD"
}
},
};
mapperMock.Setup(m => m.Insert(expected, null)).Verifiable();
mapperMock.Setup(m => m.Single <EvaluationScore>(It.IsAny <string>(), It.IsAny <Guid>())).Returns(expected);
var answerDao = new AnswersDao(MockUtils.MockConnectionFactory(mapperMock));
var response = answerDao.CreateAnswers(expected);
Assert.Equal(expected.Id, response.Id);
}
public EvaluationScore CalculateScore(EvaluationScore evaluationScore)
{
return(ServiceErrorHandler.Handle(() =>
{
var calculator = new MathParserCalculator(evaluationScore);
var calculated = calculator.Calculate();
this.CalculateQualification(calculated);
return calculated;
}));
}
private void CalculateQualification(EvaluationScore evaluationScore)
{
var qualification = evaluationScore.QualificationRanges.Where(range =>
evaluationScore.Score <= range.End && evaluationScore.Score >= range.Start).FirstOrDefault();
if (qualification != null)
{
evaluationScore.Qualification = qualification.Id;
}
}
public EvaluationScore CreateAnswers(EvaluationScore answersList)
{
answersList.Id = Guid.NewGuid();
return(this.Execute((mapper) =>
{
mapper.Insert(answersList);
var answer = mapper.Single <EvaluationScore>("WHERE id = ?", answersList.Id);
return answer;
}));
throw new NotImplementedException();
}
public EvaluationScore GetAnswer(Guid idAnswer)
{
var answers = new EvaluationScore()
{
Id = idAnswer,
IdEvaluation = Guid.Parse("11111111-1111-1111-1111-111111111112"),
Date = DateTime.Parse("2019-02-28T12:12:00.5973309Z"),
Score = 0.0,
Owner = "anonymous"
};
return(answers);
}
public static void AppendAnswers(this EvaluationScore evaluationTemplate, EvaluationAnswer answers)
{
evaluationTemplate.Date = answers.Date;
evaluationTemplate.Owner = answers.Owner;
var questionAnswers = answers.Sections.SelectMany(p => p.QuestionAnswers);
questionAnswers.Join(
evaluationTemplate.QuestionList,
questionAnswer => questionAnswer.IdQuestion,
evaluationQuestion => evaluationQuestion.IdQuestion,
(questionAnswer, evaluationAnswer) =>
{
evaluationAnswer.Answers = questionAnswer.SelectedAnswersIds;
return(true);
}).ToArray();
}
public EvaluationScore EvaluatePositionScore([NotNull] GameBoard board)
{
if (board is null)
{
throw new ArgumentNullException(nameof(board));
}
_gameControlInfo.CheckInterruptions();
switch (board.State)
{
case GameState.Checkmate:
return(-EvaluationScore.Mate);
case GameState.Stalemate:
return(EvaluationScore.Zero);
case GameState.Default:
{
var autoDrawType = board.GetAutoDrawType();
if (autoDrawType != AutoDrawType.None)
{
return(EvaluationScore.Zero);
}
}
break;
case GameState.Check:
case GameState.DoubleCheck:
break;
default:
throw board.State.CreateEnumValueNotImplementedException();
}
var gamePhase = GetGamePhase(board);
var materialAndItsPosition = EvaluateMaterialAndItsPosition(board, gamePhase);
var mobility = EvaluateMobility(board);
var kingTropism = EvaluateKingTropism(board, board.ActiveSide)
- EvaluateKingTropism(board, board.ActiveSide.Invert());
var result = new EvaluationScore(materialAndItsPosition + mobility + kingTropism);
return(result);
}
public static EvaluationScore GenerateEvaluationTemplate(Template template, Evaluation evaluation)
{
var evaluationTemplate = new EvaluationScore()
{
IdEvaluation = evaluation.Id,
ScoreFormula = template.ScoreFormula,
Name = evaluation.Name,
QualificationRanges = evaluation.QualificationRanges
};
if (template.Id != evaluation.IdTemplate)
{
return(evaluationTemplate);
}
evaluationTemplate.QuestionList = JoinQuestionLists(template.Body, evaluation.Body);
return(evaluationTemplate);
}
public void TestTranspositionTable()
{
var transpositionTable = new TranspositionTable(FakeLogger.Instance, TranspositionTableHelper.SizeInMegaBytesRange.Lower);
Assert.That(transpositionTable.Version, Is.Not.EqualTo(0));
const long Key = 0x12345678ABCDEF01L;
const long OtherKey = 0x987654321L;
const ScoreBound Bound = ScoreBound.Exact;
const int Depth = CommonEngineConstants.MaxPlyDepthUpperLimit;
var bestMove = GameMove.FromStringNotation("b2b1q");
var score = EvaluationScore.Mate;
var localScore = new EvaluationScore(-789);
var entry = new TranspositionTableEntry(Key, bestMove, score, localScore, Bound, Depth);
transpositionTable.Save(ref entry);
Assert.That(entry.Version, Is.EqualTo(transpositionTable.Version));
Assert.That(transpositionTable.ProbeCount, Is.EqualTo(0));
Assert.That(transpositionTable.HitCount, Is.EqualTo(0));
var foundEntry1 = transpositionTable.Probe(Key);
Assert.That(transpositionTable.ProbeCount, Is.EqualTo(1));
Assert.That(transpositionTable.HitCount, Is.EqualTo(1));
Assert.That(foundEntry1.HasValue, Is.True);
Assert.That(foundEntry1.Value.Key, Is.EqualTo(Key));
Assert.That(foundEntry1.Value.BestMove, Is.EqualTo(bestMove));
Assert.That(foundEntry1.Value.Score, Is.EqualTo(score));
Assert.That(foundEntry1.Value.LocalScore, Is.EqualTo(localScore));
Assert.That(foundEntry1.Value.Bound, Is.EqualTo(Bound));
Assert.That(foundEntry1.Value.Depth, Is.EqualTo(Depth));
Assert.That(foundEntry1.Value.Version, Is.EqualTo(transpositionTable.Version));
var foundEntry2 = transpositionTable.Probe(OtherKey);
Assert.That(transpositionTable.ProbeCount, Is.EqualTo(2));
Assert.That(transpositionTable.HitCount, Is.EqualTo(1));
Assert.That(foundEntry2.HasValue, Is.False);
}
public void TestTranspositionTableEntryConstruction()
{
const long Key = 0x12345678ABCDEF01L;
const ScoreBound Bound = ScoreBound.Exact;
const int Depth = CommonEngineConstants.MaxPlyDepthUpperLimit;
var bestMove = GameMove.FromStringNotation("b2b1q");
var score = EvaluationScore.Mate;
var localScore = new EvaluationScore(-789);
var entry = new TranspositionTableEntry(Key, bestMove, score, localScore, Bound, Depth);
Assert.That(entry.Key, Is.EqualTo(Key));
Assert.That(entry.BestMove, Is.EqualTo(bestMove));
Assert.That(entry.Score, Is.EqualTo(score));
Assert.That(entry.LocalScore, Is.EqualTo(localScore));
Assert.That(entry.Bound, Is.EqualTo(Bound));
Assert.That(entry.Depth, Is.EqualTo(Depth));
Assert.That(entry.Version, Is.EqualTo(0));
}
public TranspositionTableEntry(
long key,
[CanBeNull] GameMove bestMove,
EvaluationScore score,
EvaluationScore localScore,
ScoreBound bound,
int depth)
{
Key = key;
_bestMoveEncoded = (ushort)(bestMove is null
? 0
: (bestMove.From.SquareIndex & ChessConstants.MaxSquareIndex) << 9
| (bestMove.To.SquareIndex & ChessConstants.MaxSquareIndex) << 3
| (int)bestMove.PromotionResult & 0x7);
_scoreValue = score.Value;
_localScoreValue = localScore.Value;
Bound = bound;
Depth = depth;
Version = 0;
}
public EvaluationScore CalculateScore(EvaluationScore evaluationTemplate)
{
return(evaluationTemplate);
}
internal static EvaluationScore ConvertValueFromTT(this EvaluationScore score, int plyDistance)
{
return(score.ToRelative(plyDistance));
}
internal static EvaluationScore ConvertValueForTT(this EvaluationScore score, int plyDistance)
{
return(score.ToLocal(plyDistance));
}
public MathParserCalculator(EvaluationScore evaluation)
{
this.Evaluation = evaluation;
}
