public async Task <ApiResponse <List <Option> > > GetOptionsByQuestion(Guid questionId, Guid userExamId)
{
var result = new ApiResponse <List <Option> >();
try
{
var response = dbContext.Options.
Where(o => o.Question.Id == questionId).ToList()
.Select(e => { e.IsCorrect = false; return(e); }).ToList();
var optionSelected = dbContext.UserAnswers
.Where(e => (e.Option.QuestionId == questionId && e.UserExamId == userExamId));
if (optionSelected.Count() == 0)
{
result.Data = response;
result.AddSuccess();
}
else
{
result.Data = null;
result.AddMessage("Question answered already");
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <ExamQuestionViewModel> > > GetQuestionsByExam(Guid examId)
{
var result = new ApiResponse <List <ExamQuestionViewModel> >();
try
{
var oList = await dbContext.ExamQuestions
.Where(ex => ex.ExamId == examId)
.Include(e => e.Question)
.Include(e => e.Exam)
.Select(e => new ExamQuestionViewModel
{
ExamId = e.ExamId,
QuestionId = e.QuestionId,
Exam = e.Exam.Title,
Question = e.Question.Title,
Type = e.Question.Type,
RatePolicy = e.Question.RatePolicy
})
.ToListAsync();
result.Data = oList;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <bool> > UpdateUserExamStatus(Guid userExamId)
{
var result = new ApiResponse <bool>();
try
{
var userExam = await dbContext.UserExams.FirstOrDefaultAsync(e => e.Id == userExamId);
if (userExam != null)
{
userExam.Status = Models.DB.Exams.enums.Status.Completed;
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
}
else
{
result.Data = false;
result.AddMessage("Exam not enrolled yet");
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <QuestionViewModel> > > Get()
{
var result = new ApiResponse <List <QuestionViewModel> >();
try
{
result.Data = await dbContext.Questions
.Include(a => a.Options)
.Select(q => new QuestionViewModel
{
Id = q.Id,
Title = q.Title,
Type = q.Type,
Options = q.Options,
RatePolicy = q.RatePolicy
})
.ToListAsync();
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <bool> > UdpateExam(ExamViewModel exam)
{
var result = new ApiResponse <bool>();
try
{
var oExam = new Exam
{
Id = exam.Id,
Title = exam.Title,
Status = exam.Status,
Description = exam.Description,
Duration = exam.Duration,
ImageUrl = exam.ImageUrl
};
dbContext.Exams.Update(oExam);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <ExamViewModel> > > Get()
{
var result = new ApiResponse <List <ExamViewModel> >();
try
{
result.Data = await dbContext.Exams
.Select(e => new ExamViewModel
{
Id = e.Id,
Title = e.Title,
Description = e.Description,
Duration = e.Duration,
ImageUrl = e.ImageUrl,
Status = e.Status,
CreatedDate = e.CreatedDate
})
.ToListAsync();
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <bool> > SubmitUserAnswer(List <UserAnswerViewModel> userAnswer)
{
var result = new ApiResponse <bool>();
try
{
var proceed = false;
for (var i = 0; i < userAnswer.Count; i++)
{
var currentUseranswer = await dbContext.UserAnswers
.FirstOrDefaultAsync(a => (a.OptionId == userAnswer[0].OptionId &&
a.UserExamId == userAnswer[0].UserExamId));
if (currentUseranswer == null)
{
var checkAnswer = await dbContext.Options.FindAsync(userAnswer[0].OptionId);
if (checkAnswer.IsCorrect)
{
var checkUserExam = await dbContext.UserExams.FirstOrDefaultAsync(ue => ue.Id == userAnswer[0].UserExamId);
checkUserExam.Score = checkUserExam.Score + checkAnswer.Score;
}
var oUserAnswer = new UserAnswer
{
OptionId = userAnswer[i].OptionId,
UserExamId = userAnswer[i].UserExamId
};
await dbContext.AddAsync(oUserAnswer);
result.AddSuccess();
result.Data = true;
proceed = true;
}
else
{
result.Data = false;
result.AddMessage("Answer Already Exist");
}
}
if (proceed)
{
await dbContext.SaveChangesAsync();
}
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <T> > > Get()
{
var response = new ApiResponse <List <T> >();
try
{
response.Data = await dbContext.Set <T>().ToListAsync();
response.AddSuccess();
return(await Task.FromResult(response));
}
catch (Exception)
{
response.AddError(ex: "Unable to fetch records");
return(await Task.FromResult(response));
}
}
public async Task <ApiResponse <DashboardDTO> > Get()
{
var result = new ApiResponse <DashboardDTO>();
var dashboard = new DashboardDTO();
try
{
dashboard.AllExams = dbContext.Exams.Count().ToString();
dashboard.Questions = dbContext.Questions.Count().ToString();
result.Data = dashboard;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <bool> > EnrollUserExam(UserExamViewModel userExam)
{
var result = new ApiResponse <bool>();
try
{
var oUserExam = await dbContext.UserExams
.FirstOrDefaultAsync(e => (e.ExamId == userExam.ExamId && e.ApplicationUserId == this.CurrentUser().Id)) as UserExam;
if (oUserExam == null)
{
var userExamd = new UserExam
{
ApplicationUserId = this.CurrentUser().Id,
ExamId = userExam.ExamId,
Status = userExam.Status,
StartDate = userExam.StartDate,
EndDate = userExam.EndDate,
Score = userExam.Score
};
await dbContext.UserExams.AddAsync(userExamd);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
result.AddMessage("You are Enrolled Succesfully");
return(await Task.FromResult(result));
}
else
{
result.Data = false;
result.AddMessage("You have already been enrolled successfully");
return(await Task.FromResult(result));
}
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <Question> > GetQuestionsById(Guid examId)
{
var result = new ApiResponse <Question>();
try
{
var response = await dbContext.Questions
.Include(e => e.Options).ToListAsync();
var oList = response.SingleOrDefault(e => e.Id == examId);
result.Data = oList;
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <List <UserExam> > > Get()
{
var result = new ApiResponse <List <UserExam> >();
try
{
result.Data = await dbContext.UserExams
.Include(ue => ue.Exam)
.Include(u => u.ApplicationUser).Where(u => u.ApplicationUserId == this.CurrentUser().Id)
.ToListAsync();
result.AddSuccess();
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <bool> > Delete(Guid id)
{
var response = new ApiResponse <bool>();
try
{
var question = await dbContext.Questions.FindAsync(id);
var options = await dbContext.Options.Where(q => q.QuestionId == id).ToListAsync();
foreach (var i in options)
{
dbContext.Options.Remove(i);
}
await dbContext.SaveChangesAsync();
if (question == null)
{
response.Data = false;
response.AddMessage("Questions not found");
return(await Task.FromResult(response));
}
dbContext.Questions.Remove(question);
await dbContext.SaveChangesAsync();
response.Data = true;
response.AddSuccess();
return(await Task.FromResult(response));
}
catch (Exception ex)
{
response.AddError(ex);
return(await Task.FromResult(response));
}
}
public async Task <ApiResponse <bool> > DeleteUserExam(Guid id, Guid examId)
{
var result = new ApiResponse <bool>();
try
{
var entity = await dbContext.UserExams.FirstOrDefaultAsync(a => (a.Id == id && a.ExamId == examId && a.ApplicationUserId == this.CurrentUser().Id));
dbContext.UserExams.Remove(entity);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
result.AddMessage("You left the exam..");
return(await Task.FromResult(result));
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ApiResponse <UserExamViewModel> > GetUserExamById(Guid id, Guid examId)
{
var result = new ApiResponse <UserExamViewModel>();
try
{
var entity = await dbContext.UserExams
.Select(u => new UserExamViewModel
{
ExamId = u.ExamId,
ApplicationUserId = u.ApplicationUserId,
EndDate = u.EndDate,
StartDate = u.StartDate,
Score = u.Score,
Status = u.Status,
Id = u.Id
})
.FirstOrDefaultAsync(a => (a.Id == id && a.ExamId == examId && a.ApplicationUserId == this.CurrentUser().Id));
if (entity != null)
{
result.Data = entity;
result.AddSuccess();
return(await Task.FromResult(result));
}
else
{
result.Data = entity;
result.AddMessage("No Exam Available");
return(await Task.FromResult(result));
}
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
public async Task <ActionResult <ApiResponse> > Calculate([FromQuery] double initialValue, double months)
{
var apiResponse = new ApiResponse();
try
{
var calculo = await _interestApplication.Calculate(initialValue, months);
// Instâncias de Option<T> encapsulam um valor que pode ou não existir. Este valor só pode ser acessado através do método Match.
// Ver mais ref. este pacote em: https://gabriel-schade-cardoso.gitbook.io/tango-br/tipos/introduction-1
if (calculo.IsSome)
{
double amount = calculo
.Match((a) => amount = a, () => 0);
return(Ok(apiResponse.AddSuccess(amount)));
}
return(BadRequest(apiResponse.AddFailure("Erro ao calcular os juros. Por favor, tente novamente.")));
}
catch (Exception e)
{
return(BadRequest(apiResponse.AddFailure(e.Message, e)));
}
}
