// map entity to contract
public static EquityQuestionTemplateContract QuestionTemplateEntityToContract(EquityQuestionTemplate entity)
{
var contract = new EquityQuestionTemplateContract
{
Id = entity.Id,
CreatedBy = entity.CreatedBy,
IsActive = entity.IsActive,
Question = entity.Question
};
return(contract);
}
// map contract to entity
public static EquityQuestionTemplate QuestionTemplateContractToEntity(EquityQuestionTemplateContract contract)
{
var entity = new EquityQuestionTemplate
{
Id = contract.Id,
CreatedBy = contract.CreatedBy,
IsActive = contract.IsActive,
Question = contract.Question
};
return(entity);
}
public async Task<ActionResult> CreateQuestion()
{
var employees = await DirectoryHelper.GetDirectoryEmployees();
ViewBag.Employees = employees.OrderBy(x => x.MenuName).ToList();
var employee = employees.FirstOrDefault(x => x.Id == GetUserId());
ViewBag.AddQuestion = true;
var question = new EquityQuestionTemplateContract
{
CreatedBy = employee.Name,
IsActive = false,
Id = 0,
Question = string.Empty
};
return View("Question", question);
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public async Task PutQuestionTemplateAsync(EquityQuestionTemplateContract model)
{
var updatedQuestion = await Context.EquityQuestionTemplates.FindAsync(model.Id);
if (updatedQuestion == null)
{
throw new CannotFindIdException("questionTemplate", model.Id);
}
var editedQuestion = EquityMapper.QuestionTemplateContractToEntity(model);
Context.Entry(updatedQuestion).CurrentValues.SetValues(editedQuestion);
Context.Entry(updatedQuestion).State = EntityState.Modified;
if (await Context.SaveChangesAsync() <= 0)
{
throw new CannotSaveToDatabaseException("questionTemplate");
}
}
public async Task<ActionResult> CreateQuestion(EquityQuestionTemplateContract questionTemplate)
{
if(!ModelState.IsValid)
{
ViewBag.AddQuestion = true;
return View("Question", questionTemplate);
}
//TODO: What if Id == null?
if(questionTemplate.Id == 0)
{
await _proxy.PostNewQuestionTemplateAsync(questionTemplate);
}
else
{
await _proxy.PutExistingQuestionTemplateAsync(questionTemplate);
}
return RedirectToAction("AdminQuestions");
}
/// <summary>
/// post new equity question template
/// </summary>
/// /// <param EquityQuestionTemplateContract="model"></param>
/// <returns></returns>
public async Task <int> PostQuestionTemplateAsync(EquityQuestionTemplateContract model)
{
if (Context.EquityQuestionTemplates.Find(model.Id) != null)
{
throw new EntityConflictException("questionTemplate", model.Id);
}
var newQuestion = EquityMapper.QuestionTemplateContractToEntity(model);
Context.EquityQuestionTemplates.Add(newQuestion);
Context.Entry(newQuestion).State = EntityState.Added;
var saved = await Context.SaveChangesAsync();
if (saved <= 0)
{
throw new CannotSaveToDatabaseException("questionTemplate");
}
var questionId = newQuestion.Id;
return(questionId);
}
/// <summary>
/// puts edited equity questions
/// </summary>
/// /// <param EquityQuestionsContract="model"></param>
/// <returns></returns>
public async Task PutExistingQuestionTemplateAsync(EquityQuestionTemplateContract model)
{
await _client.PutAsync($"{EquityQuestionTemplatesDiscoveryRoute}", model);
}
/// <summary>
/// post new equity question
/// </summary>
/// /// <param EquityQuestionContract="model"></param>
/// <returns></returns>
public async Task <int> PostNewQuestionTemplateAsync(EquityQuestionTemplateContract model)
{
var response = await _client.PostWithResultAsync <int>(EquityQuestionTemplatesDiscoveryRoute, model);
return(response);
}
public async Task <IHttpActionResult> PutExistingQuestionTemplateAsync([FromBody] EquityQuestionTemplateContract model)
{
await _repository.PutQuestionTemplateAsync(model);
return(new NoContentResponse());
}
public async Task <IHttpActionResult> PostNewQuestionTemplateAsync(EquityQuestionTemplateContract model)
{
var questionId = await _repository.PostQuestionTemplateAsync(model);
return(CreatedAtRoute("QuestionTemplateById", new { id = questionId }, questionId));
}
