public async Task <IActionResult> CreateAjax(CourseClassViewModel model) //[Bind("Id,Title,CourseId")] CourseClass courseClass
{
System.Threading.Thread.Sleep(4000);
var courseClass = new CourseClass
{
Title = model.Title,
CourseId = model.CourseId
};
courseClass.CourseClassDay = new List <CourseClassDay>();
model.Days.ToList().ForEach(item =>
{
courseClass.CourseClassDay.Add(new CourseClassDay
{
Day = (Days)item.DayId,
StartTime = item.StartTime,
FinishTime = item.FinishTime
});
});
await _context.AddAsync(courseClass);
await _context.SaveChangesAsync();
var result = new AjaxActionResult <CourseClass>();
result.IsSuccess = true;
result.Message = "success...";
return(Ok(result));
}
public async Task <ActionResult> DeleteOldGames()
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.GameRepository.DeleteOldGames();
}
}
catch (Exception ex)
{ }
return(Json(AjaxActionResult.Json(true))); // we don`t care for the exception here!
}
public async Task <ActionResult> DeleteEntity(int idEntity)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.EntityRepository.DeleteEntity(idEntity);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
public async Task <ActionResult> UpdateEntityDescription(int idEntity, string newDescription)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.EntityRepository.UpdateEntityDescription(idEntity, newDescription);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
public async Task <ActionResult> GetQuestionsForAutocomplete(string needle)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
Question[] questionList = await unitOfWork.QuestionRepository.QuestionsNamedLike(needle);
return(Json(AjaxActionResult.Json(questionList)));
}
}
catch (Exception ex)
{
return(Json(AjaxActionResult.Fail(-1, "Error processing request!" + System.Environment.NewLine + ex.Message)));
}
}
public async Task <ActionResult> UpdateQuestionBody(int idQuestion, string newBody)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.QuestionRepository.UpdateQuestionBody(idQuestion, newBody);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
public async Task <ActionResult> UpdateQuestionEntityFitness(int idQuestionEntity, double newFitness)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.EntityQuestionsRepository.UpdateEntityQuestionFitness(idQuestionEntity, newFitness);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
public async Task <ActionResult> EntitiesNamedLike(string needle)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
return(Json(
AjaxActionResult.Json(
await unitOfWork.EntityRepository.EntitiesNamedLike(needle))));
}
}
catch (Exception ex)
{
return(Json(AjaxActionResult.Fail(-1, "Error processing request!" + System.Environment.NewLine + ex.Message)));
}
}
public async Task <JsonResult> JudgeTopGuess(string gameAccessId, int indexGuess)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.GameRepository.JudgeTopGuessAsync(gameAccessId, indexGuess);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(Json(AjaxActionResult.Fail(-1, "Error processing request!" + System.Environment.NewLine + ex.Message)));
}
}
public async Task <JsonResult> AnswerQuestion(string gameAccessId, int answer)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.GameQuestionsRepository.AnswerQuestionAndUpdateInstanceAsync(gameAccessId, (AnswerType)answer);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(Json(AjaxActionResult.Fail(-1, "Error processing request!" + System.Environment.NewLine + ex.Message)));
}
}
public async Task <ActionResult> ForceMajorityAnswer(int idEntityQuestion, string type)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.EntityQuestionsRepository.ForceMajorityAnswer(idEntityQuestion, type);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
public async Task <ActionResult> SetLockedStatus(int idEntityQuestion, bool setToLocked)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
await unitOfWork.EntityQuestionsRepository.SetLockedStatus(idEntityQuestion, setToLocked);
return(Json(AjaxActionResult.Json(true)));
}
}
catch (Exception ex)
{
return(this.Redirect("Error: " + ex.Message));
}
}
protected ActionResult AjaxResult(Func <AjaxActionResult> result)
{
try
{
AjaxActionResult ajaxResult = result();
return(Json(ajaxResult));
}
catch (Exception ex)
{
return(Json(
new AjaxActionResult()
{
ResultType = Enums.AjaxActionResultType.Error,
ErrorText = ex.Message
}
));
}
}
public async Task <IActionResult> GetCitiesWithProvinceId(int provinceId)
{
cityCacheKey = string.Format(cityCacheKey, provinceId);
System.Threading.Thread.Sleep(5000);
var result = new AjaxActionResult <List <City> >();
result.IsSuccess = true;
var cities = new List <City>();
if (!_cache.TryGetValue(cityCacheKey, out cities))
{
result.Data = await _context.City.Where(q => q.ProvinceId == provinceId).ToListAsync();
_cache.Set(cityCacheKey, result.Data);
}
else
{
result.Data = cities;
}
return(Ok(result));
}
public async Task <JsonResult> NextQuestion(string gameAccessId)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
GamePlayViewModel gamePlayVM = await unitOfWork.GameQuestionsRepository.GetGamePlayVMAsync(gameAccessId);
return(Json(
AjaxActionResult.List(
this.RenderPartialView("~/Views/Game/PlayPartial/_AnsweredQuestionsPartial.cshtml", gamePlayVM.AnsweredQuestions),
gamePlayVM.CurrentQuestion.QuestionBody,
gamePlayVM.AnsweredQuestions.Count + 1,
gamePlayVM.IsLastQuestion)));
}
}
catch (Exception ex)
{
return(Json(AjaxActionResult.Fail(-1, "Error processing request!" + System.Environment.NewLine + ex.Message)));
}
}
