public async Task <PagedList <Goal> > GetGoalsForReport(CommunParams communParams)
{
var goals = RepositoryContext.Goals.Include(g => g.AxisInstance)
.ThenInclude(a => a.EvaluationFileInstance)
.ThenInclude(s => s.Owner)
.ThenInclude(o => o.Department)
.ThenInclude(d => d.Pole)
.AsQueryable();
if (communParams.Year != 0)
{
goals = goals.Where(g => g.AxisInstance.EvaluationFileInstance.Year == communParams.Year);
}
if (communParams.UserToSearch != null && communParams.UserToSearch != "")
{
goals = goals.Where(g => g.AxisInstance.EvaluationFileInstance.Owner.FirstName.ToLower().Contains(communParams.UserToSearch.ToLower()) ||
g.AxisInstance.EvaluationFileInstance.Owner.LastName.ToLower().Contains(communParams.UserToSearch.ToLower()));
}
if (communParams.PoleId != 0)
{
goals = goals.Where(s => s.AxisInstance.EvaluationFileInstance.Owner.Department.Pole.Id == communParams.PoleId);
}
if (communParams.UserStatusId != 0)
{
goals = goals.Where(s => s.AxisInstance.EvaluationFileInstance.Owner.UserStatusId == communParams.UserStatusId);
}
return(await PagedList <Goal> .CreateAsync(goals, communParams.PageNumber, communParams.PageSize));
}
public async Task <IEnumerable <BehavioralSkill> > GetBehavioralSkills(CommunParams behavioralSkillParams)
{
var behavioralSkills = FindAll().Include(bs => bs.CreatedBy)
.OrderByDescending(s => s.Created)
.AsQueryable();
switch (behavioralSkillParams.Status)
{
case Constants.PUBLISHED:
behavioralSkills = behavioralSkills.Where(s => s.Status == Constants.PUBLISHED);
break;
case Constants.DRAFT:
behavioralSkills = behavioralSkills.Where(s => s.Status == Constants.DRAFT && s.CreatedById == behavioralSkillParams.OwnerId);
break;
case Constants.REVIEW:
behavioralSkills = behavioralSkills.Where(s => s.Status == Constants.REVIEW);
break;
case Constants.ARCHIVED:
behavioralSkills = behavioralSkills.Where(s => s.Status == Constants.ARCHIVED);
break;
default:
behavioralSkills = behavioralSkills.Where(s => (s.Status == Constants.DRAFT && s.CreatedById == behavioralSkillParams.OwnerId) ||
s.Status == Constants.REVIEW || s.Status == Constants.PUBLISHED || s.Status == Constants.ARCHIVED);
break;
}
return(await behavioralSkills.ToListAsync());
}
public async Task <IActionResult> GetMyCollaboratorsSheets(int userId, [FromQuery] CommunParams communParams)
{
try
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var evaluatees = await _repo.User.LoadEvaluatees(userId);
IList <int> evaluateeIds = new List <int>();
foreach (var evaluatee in evaluatees)
{
evaluateeIds.Add(evaluatee.Id);
}
var sheetsTovalidateFromRepo = await _repo.EvaluationFileInstance.GetEvaluationFileInstancesToValidate(evaluateeIds, communParams);
var sheetsToValidate = _mapper.Map <IEnumerable <EvaluationFileInstanceToReturnDto> >(sheetsTovalidateFromRepo);
sheetsToValidate = await SetGoalsStatus((List <EvaluationFileInstanceToReturnDto>) sheetsToValidate);
return(Ok(sheetsToValidate));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetMyCollaboratorsSheets endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
public async Task <IActionResult> GetEvaluationModelList([FromQuery] CommunParams evaluationFileParams)
{
try
{
var evaluationFilesWithBehaviorSkillsFromRepo = await _repo.EvaluationFile.GetEvaluationFiles(evaluationFileParams);
return(Ok(evaluationFilesWithBehaviorSkillsFromRepo));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetEvaluationModelList endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
public async Task <IActionResult> GetBehavioralSkillList([FromQuery] CommunParams behavioralSkillParams)
{
try
{
var behavioralSkillsFromRepo = await _repo.BehavioralSkill.GetBehavioralSkills(behavioralSkillParams);
var behavioralSkillsToReturn = _mapper.Map <IEnumerable <BehavioralSkillToReturnDto> >(behavioralSkillsFromRepo);
return(Ok(behavioralSkillsToReturn));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetBehavioralSkillList endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IEnumerable <EvaluationViewModel> > GetEvaluationFiles(CommunParams evaluationFileParams)
{
var evaluationFilesWithBehavioralSkills = (from evaluationFile in RepositoryContext.EvaluationFiles.Include(ef => ef.Strategy).Include(ef => ef.Owner)
select new EvaluationViewModel()
{
Id = evaluationFile.Id,
Title = evaluationFile.Title,
Year = evaluationFile.Year,
Strategy = evaluationFile.Strategy,
CreatedById = evaluationFile.OwnerId,
CreatedByName = evaluationFile.Owner.FirstName.FullName(evaluationFile.Owner.LastName),
BehavioralSkills = (from evaluationFileBehavioralSkill in evaluationFile.BehavioralSkills
join bs in RepositoryContext.BehavioralSkills on evaluationFileBehavioralSkill.BehavioralSkillId equals bs.Id
select bs).ToList(),
Created = evaluationFile.Created,
Status = evaluationFile.Status,
Sealed = evaluationFile.Sealed,
SealedDate = evaluationFile.SealedDate
}).OrderByDescending(u => u.Created)
.AsQueryable();
switch (evaluationFileParams.Status)
{
case Constants.PUBLISHED:
evaluationFilesWithBehavioralSkills = evaluationFilesWithBehavioralSkills.Where(s => s.Status == Constants.PUBLISHED);
break;
case Constants.DRAFT:
evaluationFilesWithBehavioralSkills = evaluationFilesWithBehavioralSkills.Where(s => s.Status == Constants.DRAFT && s.CreatedById == evaluationFileParams.OwnerId);
break;
case Constants.REVIEW:
evaluationFilesWithBehavioralSkills = evaluationFilesWithBehavioralSkills.Where(s => s.Status == Constants.REVIEW);
break;
case Constants.ARCHIVED:
evaluationFilesWithBehavioralSkills = evaluationFilesWithBehavioralSkills.Where(s => s.Status == Constants.ARCHIVED);
break;
default:
evaluationFilesWithBehavioralSkills = evaluationFilesWithBehavioralSkills.Where(s => (s.Status == Constants.DRAFT && s.CreatedById == evaluationFileParams.OwnerId) ||
s.Status == Constants.REVIEW || s.Status == Constants.PUBLISHED || s.Status == Constants.ARCHIVED);
break;
}
return(await evaluationFilesWithBehavioralSkills.ToListAsync());
}
public async Task <IActionResult> GetStrategies([FromQuery] CommunParams strategyParams)
{
try
{
var strategies = await _repo.Strategy.GetStrategies(strategyParams);
var strategiesToReturn = _mapper.Map <IEnumerable <StrategyForListDto> >(strategies);
Response.AddPagination(strategies.CurrentPage, strategies.PageSize, strategies.TotalCount, strategies.TotalPages);
return(Ok(strategiesToReturn));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetStrategies endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> GetGoalsForReport([FromQuery] CommunParams communParams)
{
try
{
var goalsForReportsFromRepo = await _repo.Goal.GetGoalsForReport(communParams);
var goalsForReportsToReturn = _mapper.Map <IEnumerable <GoalForReportToReturnDto> >(goalsForReportsFromRepo);
Response.AddPagination(goalsForReportsFromRepo.CurrentPage, goalsForReportsFromRepo.PageSize, goalsForReportsFromRepo.TotalCount, goalsForReportsFromRepo.TotalPages);
return(Ok(goalsForReportsToReturn));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetGoalsForReport endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
public async Task <IActionResult> GetEvaluationSheetList([FromQuery] CommunParams communParams)
{
try
{
var sheetsFromRepo = await _repo.EvaluationFileInstance.GetEvaluationFileInstances(communParams);
var evaluationSheetsToReturn = _mapper.Map <IEnumerable <EvaluationSheetToReturnDto> >(sheetsFromRepo);
Response.AddPagination(sheetsFromRepo.CurrentPage, sheetsFromRepo.PageSize, sheetsFromRepo.TotalCount, sheetsFromRepo.TotalPages);
return(Ok(evaluationSheetsToReturn));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetEvaluationSheetList endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error: " + ex.Message));
}
}
public async Task<IActionResult> GetMySheetsForUser(int userId, [FromQuery]CommunParams communParams)
{
try
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) return Unauthorized();
communParams.OwnerId = userId;
var sheetsFromRepo = await _repo.EvaluationFileInstance.GetEvaluationFileInstancesForUser(communParams);
var sheets = _mapper.Map<IEnumerable<EvaluationFileInstanceToReturnDto>>(sheetsFromRepo);
Response.AddPagination(sheetsFromRepo.CurrentPage, sheetsFromRepo.PageSize, sheetsFromRepo.TotalCount, sheetsFromRepo.TotalPages);
return Ok(sheets);
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetMySheetsForUser endpoint: {ex.Message}");
return StatusCode(500, "Internal server error");
}
}
public async Task <IActionResult> GetPublishedBehavioralSkills()
{
try
{
CommunParams communParams = new CommunParams()
{
Status = Constants.PUBLISHED
};
var behavioralSkills = await _repo.BehavioralSkill.GetBehavioralSkills(communParams);
var publishedBehavioralSkillsToReturnList = _mapper.Map <IEnumerable <BehavioralSkill>, IEnumerable <BehavioralSkillToReturnDto> >(behavioralSkills);
return(Ok(publishedBehavioralSkillsToReturnList));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetPublishedBehavioralSkills endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> GetPublishedStrategies()
{
try
{
CommunParams strategyParams = new CommunParams()
{
Status = Constants.PUBLISHED
};
var strategies = await _repo.Strategy.GetStrategies(strategyParams);
var publishedStrategiesToReturnList = _mapper.Map <IEnumerable <Strategy>, IEnumerable <StrategyToReturnDto> >(strategies);
return(Ok(publishedStrategiesToReturnList));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside GetPublishedStrategies endpoint: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <PagedList <Strategy> > GetStrategies(CommunParams strategyParams)
{
var strategies = RepositoryContext.Strategies
.Include(u => u.Owner)
.Include(s => s.AxisList)
.ThenInclude(a => a.AxisPoles)
.ThenInclude(p => p.Pole)
.OrderByDescending(s => s.Created)
.AsQueryable();
switch (strategyParams.Status)
{
case Constants.PUBLISHED:
strategies = strategies.Where(s => s.Status == Constants.PUBLISHED);
break;
case Constants.DRAFT:
strategies = strategies.Where(s => s.Status == Constants.DRAFT && s.OwnerId == strategyParams.OwnerId);
break;
case Constants.REVIEW:
strategies = strategies.Where(s => s.Status == Constants.REVIEW);
break;
case Constants.ARCHIVED:
strategies = strategies.Where(s => s.Status == Constants.ARCHIVED);
break;
default:
strategies = strategies.Where(s => (s.Status == Constants.DRAFT && s.OwnerId == strategyParams.OwnerId) ||
s.Status == Constants.REVIEW || s.Status == Constants.PUBLISHED || s.Status == Constants.ARCHIVED);
break;
}
return(await PagedList <Strategy> .CreateAsync(strategies, strategyParams.PageNumber, strategyParams.PageSize));
}
public async Task <PagedList <EvaluationFileInstance> > GetEvaluationFileInstancesForUser(CommunParams communParams)
{
var sheets = FindByCondition(s => s.OwnerId == communParams.OwnerId).Include(s => s.Owner).AsQueryable();
sheets = sheets.OrderByDescending(d => d.Created);
if (communParams.Year != 0)
{
sheets = sheets.Where(s => s.Year == communParams.Year);
}
return(await PagedList <EvaluationFileInstance> .CreateAsync(sheets, communParams.PageNumber, communParams.PageSize));
}
public async Task <PagedList <EvaluationFileInstance> > GetEvaluationFileInstances(CommunParams communParams)
{
var sheets = RepositoryContext.EvaluationFileInstances.Include(efi => efi.AxisInstances)
.ThenInclude(ai => ai.Goals)
.ThenInclude(g => g.GoalEvaluations)
.Include(efi => efi.Owner)
.ThenInclude(u => u.Department)
.ThenInclude(d => d.Pole)
.Include(efi => efi.BehavioralSkillInstances)
.ThenInclude(efibsi => efibsi.BehavioralSkillInstance)
.ThenInclude(bsi => bsi.BehavioralSkillEvaluations)
.AsQueryable();
if (communParams.Year != 0)
{
sheets = sheets.Where(s => s.Year == communParams.Year);
}
if (communParams.UserToSearch != null && communParams.UserToSearch != "")
{
sheets = sheets.Where(s => s.Owner.FirstName.ToLower().Contains(communParams.UserToSearch.ToLower()) || s.Owner.LastName.ToLower().Contains(communParams.UserToSearch.ToLower()));
}
if (communParams.PoleId != 0)
{
sheets = sheets.Where(s => s.Owner.Department.Pole.Id == communParams.PoleId);
}
if (communParams.UserStatusId != 0)
{
sheets = sheets.Where(s => s.Owner.UserStatusId == communParams.UserStatusId);
}
return(await PagedList <EvaluationFileInstance> .CreateAsync(sheets, communParams.PageNumber, communParams.PageSize));
}
public async Task <IEnumerable <EvaluationFileInstance> > GetEvaluationFileInstancesToValidate(IEnumerable <int> evaluateeIds, CommunParams communParams)
{
var sheets = RepositoryContext.EvaluationFileInstances.Include(efi => efi.AxisInstances)
.Include(efi => efi.EvaluationFile)
.ThenInclude(ef => ef.Parameters)
.Include(efi => efi.Owner).ThenInclude(p => p.Photos)
.Include(efi => efi.Owner).ThenInclude(u => u.Department).ThenInclude(d => d.Pole)
.OrderByDescending(d => d.Created)
.Where(efi => evaluateeIds.Contains(efi.OwnerId))
.AsQueryable();
if (communParams.Year != 0)
{
sheets = sheets.Where(s => s.Year == communParams.Year);
}
return(await sheets.ToListAsync());
}
