private void CreateMindfightResult()
{
var team = _context.Teams.IgnoreQueryFilters().FirstOrDefault(t => t.Name == "Demo");
var mindfight = _context.Mindfights.IgnoreQueryFilters().FirstOrDefault(t => t.Title == "Demo");
var mindfightResult = _context.MindfightResults.IgnoreQueryFilters()
.FirstOrDefault(t => t.Mindfight == mindfight);
if (team != null && mindfight != null && mindfightResult == null)
{
mindfightResult = new MindfightResult(30, false, team, mindfight);
_context.MindfightResults.Add(mindfightResult);
_context.SaveChanges();
}
}
public async Task UpdateResult(long mindfightId, long teamId)
{
var currentMindfight = await _mindfightRepository
.GetAll()
.Include(x => x.Registrations)
.ThenInclude(x => x.Team)
.FirstOrDefaultAsync(x => x.Id == mindfightId);
if (currentMindfight == null)
{
throw new UserFriendlyException("Protmūšis su nurodytu id neegzistuoja!");
}
if (!(currentMindfight.CreatorId == _userManager.AbpSession.UserId ||
_permissionChecker.IsGranted("ManageMindfights")))
{
throw new AbpAuthorizationException("Jūs neturite teisių kurti rezultatus!");
}
var currentTeam = await _teamRepository
.GetAll()
.FirstOrDefaultAsync(x => x.Id == teamId);
if (currentTeam == null)
{
throw new UserFriendlyException("Komanda su nurodytu id neegzistuoja!");
}
if (!currentMindfight.Registrations.Any(x => x.TeamId == teamId && x.IsConfirmed))
{
throw new UserFriendlyException("Nurodytos komandos registracija nėra patvirtinta!");
}
var teamRegistration = _registrationRepository
.GetAll()
.FirstOrDefaultAsync(x => x.TeamId == teamId && x.MindfightId == mindfightId);
if (teamRegistration == null)
{
throw new UserFriendlyException("Komanda neužsiregistravo į protmūšį!");
}
var teamResult = await _resultRepository
.GetAllIncluding(x => x.Team)
.FirstOrDefaultAsync(x => x.MindfightId == mindfightId && x.TeamId == teamId);
if (teamResult == null)
{
throw new UserFriendlyException("Komanda dar nebaigė žaisti protmūšio!");
}
var mindfightTours = await _tourRepository
.GetAll()
.Where(tour => tour.MindfightId == currentMindfight.Id)
.ToListAsync();
if (mindfightTours.Count <= 0)
{
throw new UserFriendlyException("Protmūšis neturi nei vieno turo!");
}
var questions = await _questionRepository
.GetAll()
.Where(question => mindfightTours.Any(tour => tour.Id == question.TourId))
.OrderByDescending(x => x.OrderNumber)
.ToListAsync();
if (questions.Count <= 0)
{
throw new UserFriendlyException("Protmūšis neturi nei vieno klausimo!");
}
var teamAnswers = await _teamAnswerRepository
.GetAll()
.Where(teamAnswer => questions.Any(y => y.Id == teamAnswer.QuestionId) && teamAnswer.TeamId == teamId)
.ToListAsync();
if (questions.Count != teamAnswers.Count)
{
throw new UserFriendlyException("Komanda dar nebaigė žaisti protmūšio!");
}
if (teamAnswers.Any(x => !x.IsEvaluated))
{
throw new UserFriendlyException("Nevisi komandos klausimai yra įvertinti!");
}
var earnedPoints = teamAnswers.Sum(teamAnswer => teamAnswer.EarnedPoints);
var teamPlayers = await _userManager.Users
.Include(x => x.Team)
.Include(u => u.MindfightResults)
.Where(u => u.TeamId == teamId && u.IsActiveInTeam)
.ToListAsync();
var currentResult = await _resultRepository
.FirstOrDefaultAsync(result => result.TeamId == currentTeam.Id && result.MindfightId == currentMindfight.Id);
if (currentResult != null)
{
currentResult.EarnedPoints = earnedPoints;
currentResult.Team = currentTeam;
currentResult.Mindfight = currentMindfight;
currentResult.IsEvaluated = true;
}
else
{
currentResult = new MindfightResult(earnedPoints, true, currentTeam, currentMindfight);
}
await _resultRepository.InsertOrUpdateAsync(currentResult);
await UpdateMindfightPlaces(mindfightId);
foreach (var player in teamPlayers)
{
var currentUserMindfightResult = player.MindfightResults.FirstOrDefault(result => result.MindfightResultId == currentResult.Id);
var userMindfightResult = new UserMindfightResult(player, currentResult);
if (currentUserMindfightResult != null)
{
currentUserMindfightResult.MindfightResult = currentResult;
currentUserMindfightResult.MindfightResultId = currentResult.Id;
}
else
{
player.MindfightResults.Add(userMindfightResult);
}
}
}
public async Task <List <long> > CreateTeamAnswer(List <TeamAnswerDto> teamAnswers, long mindfightId)
{
var insertedTeamAnswerIds = new List <long>();
var currentMindfight = await _mindfightRepository
.GetAll()
.Include(x => x.Registrations)
.ThenInclude(x => x.Team)
.FirstOrDefaultAsync(x => x.Id == mindfightId);
if (currentMindfight == null)
{
throw new UserFriendlyException("Protmūšis su nurodytu id neegzistuoja!");
}
var user = await _userManager.Users
.IgnoreQueryFilters()
.Include(x => x.Team)
.FirstOrDefaultAsync(u => u.Id == _userManager.AbpSession.UserId);
if (user == null)
{
throw new UserFriendlyException("Vartotojas neegzistuoja!");
}
if (user.Team == null)
{
throw new UserFriendlyException("Vartotojas neturi komandos!");
}
var currentTeam = await _teamRepository
.GetAll()
.FirstOrDefaultAsync(x => x.Id == user.Team.Id);
if (currentTeam.LeaderId != _userManager.AbpSession.UserId)
{
throw new UserFriendlyException("Vartotojas nėra komadnos kapitonas!");
}
if (!currentMindfight.Registrations.Any(x => x.TeamId == user.Team.Id && x.IsConfirmed))
{
throw new UserFriendlyException("Komandos registracija nėra patvirtinta");
}
foreach (var answer in teamAnswers)
{
var currentQuestion = await _questionRepository
.FirstOrDefaultAsync(x => x.Id == answer.QuestionId);
if (currentQuestion == null)
{
continue;
}
var teamAnswer = await _teamAnswerRepository
.GetAll()
.Where(x => answer.QuestionId == x.QuestionId && answer.TeamId == user.TeamId)
.FirstOrDefaultAsync();
if (teamAnswer != null)
{
continue;
}
var teamAnswerToInsert = new Models.TeamAnswer(currentQuestion, user.Team, answer.EnteredAnswer, false);
var insertedTeamAnswerId = await _teamAnswerRepository.InsertAndGetIdAsync(teamAnswerToInsert);
insertedTeamAnswerIds.Add(insertedTeamAnswerId);
}
var currentMindfightResult = await _resultRepository
.FirstOrDefaultAsync(result => result.TeamId == currentTeam.Id && result.MindfightId == currentMindfight.Id);
if (currentMindfightResult == null)
{
currentMindfightResult = new MindfightResult(0, false, currentTeam, currentMindfight);
await _resultRepository.InsertOrUpdateAsync(currentMindfightResult);
}
var teamPlayers = await _userManager.Users
.IgnoreQueryFilters()
.Include(x => x.Team)
.Include(u => u.MindfightResults)
.Where(u => u.TeamId == user.Team.Id && u.IsActiveInTeam)
.ToListAsync();
foreach (var player in teamPlayers)
{
var currentUserMindfightResult = player.MindfightResults.FirstOrDefault(result => result.MindfightResultId == currentMindfightResult.Id);
var userMindfightResult = new UserMindfightResult(player, currentMindfightResult);
if (currentUserMindfightResult == null)
{
player.MindfightResults.Add(userMindfightResult);
}
}
return(insertedTeamAnswerIds);
}
