private StatusResponseModel SetPedidoNaoLocalizado(StatusRequestModel model)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Status.Add(EnumStatusResponse.CODIGO_PEDIDO_INVALIDO.ToString());
return(statusResponseModel);
}
public static dynamic DecodeMessage(MessageTypeEnum msgType, byte[] msgBytes)
{
switch (msgType)
{
case MessageTypeEnum.VarList:
return(VarTypeListModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.StatusError:
return(ErrorStatusModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.StatusOk:
return(OkStatusModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.StatusRequest:
return(StatusRequestModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.MonitorStart:
return(MonitorStartModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.MonitorStop:
return(MonitorStopModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.VarListRequest:
return(VarListRequestModel.DecodeByteArray(msgBytes));
case MessageTypeEnum.VarValues:
return(msgBytes);
case MessageTypeEnum.BTInput:
return(BTInputModel.DecodeByteArray(msgBytes));
default:
return(null);
}
}
private StatusResponseModel SetPedidoReprovado(StatusRequestModel model, PedidoEntity entity)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Status.Add(EnumStatusResponse.REPROVADO.ToString());
return(statusResponseModel);
}
public StatusResponseModel ChangeStatus(StatusRequestModel model)
{
StatusResponseModel responseModel = null;
var entity = _context.Pedidos.Include("Itens").FirstOrDefault(x => x.NumPedido.Equals(model.Pedido));
var enumStatus = this.StatusRequestValido(model);
if (entity != null)
{
switch (enumStatus)
{
case EnumStatusRequest.APROVADO:
responseModel = this.ValidarPedidoAprovado(model, entity);
break;
case EnumStatusRequest.REPROVADO:
responseModel = this.SetPedidoReprovado(model, entity);
break;
}
}
else
{
responseModel = this.SetPedidoNaoLocalizado(model);
}
return(responseModel);
}
// productive functions
internal void SendStatusRequest()
{
// message type
var msgType = MessageTypeEnum.StatusRequest;
// get model
var Model = new StatusRequestModel();
// send bytes
SendBytes(msgType, Model);
}
private EnumStatusRequest StatusRequestValido(StatusRequestModel model)
{
try
{
return((EnumStatusRequest)Enum.Parse(typeof(EnumStatusRequest), model.Status));
}
catch (Exception ex)
{
throw new Exception("Status informado não confere.", ex);
}
}
private StatusResponseModel ValidarPedidoAprovado(StatusRequestModel model, PedidoEntity entity)
{
var statusResponseModel = new StatusResponseModel();
statusResponseModel.Pedido = entity.NumPedido;
var valorTotalPedido = this.GetValorTotalPedido(entity);
var quantidadeItensPedido = this.GetQuantidadeTotalItensPedido(entity);
var isQtdItenAprovadosCorreto = model.ItensAprovados == quantidadeItensPedido;
var isValorAprovadoExato = model.ValorAprovado == valorTotalPedido;
if (isQtdItenAprovadosCorreto && isValorAprovadoExato)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO.ToString());
}
else
{
if (model.ValorAprovado < valorTotalPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_VALOR_A_MENOR.ToString());
}
if (model.ValorAprovado > valorTotalPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_VALOR_A_MAIOR.ToString());
}
if (model.ItensAprovados < quantidadeItensPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_QTD_A_MENOR.ToString());
}
if (model.ItensAprovados > quantidadeItensPedido)
{
statusResponseModel.Status.Add(EnumStatusResponse.APROVADO_QTD_A_MAIOR.ToString());
}
}
return(statusResponseModel);
}
public ActionResult Status([FromBody] StatusRequestModel model)
{
var token = _context.Tokens.SingleOrDefault(t => t.Token == model.Token);
if (token == null)
{
return(BadRequest());
}
var query = _context.QuestionsGroups.Where(qg => qg.IsEnabled && qg.Questions.Any());
query = query
.Include($"{nameof(QuestionsGroup.Questions)}")
.Include($"{nameof(QuestionsGroup.Questions)}.{nameof(Question.Options)}");
var sorter = new DeterministicRandomSorter(token.Id);
// fetch data
var preData = query
.Select(qg => new
{
Group = qg,
GroupItems = qg.Questions.Select(q => new
{
Question = q,
IsAnswered = q.GivenAnswers.Any(ga => ga.Owner == token),
AnswersIds = q.GivenAnswers.Where(ga => ga.Owner == token)
.SelectMany(ga => ga.SelectedQuestionOptions.Select(gao => gao.QuestionOptionId))
.ToArray()
})
})
.ToArray();
// agreggate result
var result = preData.Select(qg => new
{
Name = qg.Group.Name,
Questions = qg.GroupItems.Select(q =>
new QuestionStatusModel()
{
Id = q.Question.Id,
Content = q.Question.Content,
IsAnswered = q.IsAnswered,
Options = q.Question.Options.Select(o => new QuestionOptionStatusModel
{
Content = o.Content,
IsSelected = q.IsAnswered && q.AnswersIds.Contains(o.Id),
IsCorrect = q.IsAnswered && o.IsCorrect,
Id = o.Id
}).ToArray()
})
});
// sort randomly - but same each time for same user
foreach (var item in result.SelectMany(r => r.Questions))
{
var arrayToShuffle = item.Options;
sorter.Shuffle(item.Id, ref arrayToShuffle);
}
return(Ok(new { Groups = result }));
}
public IActionResult Post([FromBody] StatusRequestModel model)
{
return(Ok(this._statusService.ChangeStatus(model)));
}
