public async Task <IActionResult> Editar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Error), new { message = "Mensagem personalizada" }));
}
var obj = await _atendimentoServico.BuscaPorIdAsync(id.Value);
if (obj == null)
{
return(RedirectToAction(nameof(Error), new { message = "Mensagem personalizada" }));
}
var sistemas = await _sistemaServico.ListarTudosAsync();
var revendedores = await _revendedorServico.ListarTudosAsync();
var usuarios = await _usuarioServico.ListarTudosAsync();
var viewModel = new AtendimentoViewModel {
Atendimento = obj, Sistemas = sistemas, Revendedores = revendedores, Usuarios = usuarios
};
return(View(viewModel));
}
public ViewResult FormStatusAtendimento(string id)
{
AtendimentoViewModel modelo = new AtendimentoViewModel();
modelo.contexto = this.contexto;
try
{
Atendimento retorno = new Atendimento();
if (!String.IsNullOrEmpty(id))
{
//campo que sempre contém valor
retorno = atendimentoData.Get(new Guid(id));
if (retorno != null)
{
modelo.atendimento = retorno;
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 3, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormStatusAtendimento-get", ex.Message);
}
return(View(modelo));
}
public IActionResult FormUpdateAtendimento(AtendimentoViewModel entrada)
{
Atendimento modelo = new Atendimento();
entrada.contexto = this.contexto;
try
{
if (AtendimentoRules.AtendimentoUpdate(entrada, out modelo))
{
atendimentoData.Update(modelo);
//Se fechar o Atendimento insere o faturamento
if (entrada.atendimento.statusAtendimento == CustomEnumStatus.StatusAtendimento.atendido && entrada.atendimento.CondicaoPagamento == CustomEnum.codicaoPagamento.Avista)
{
FaturamentoRules.InsereFaturamento(modelo, contexto.idOrganizacao);
}
StatusMessage = "Registro Atualizado com Sucesso!";
return(RedirectToAction("FormUpdateAtendimento", new { id = modelo.id.ToString() }));
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 3, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateAtendimento-post", ex.Message);
}
return(RedirectToAction("FormUpdateAtendimento", new { id = modelo.id.ToString() }));
}
public ActionResult Edit(AtendimentoViewModel model, int id)
{
var atendimento = db.Atendimentos.Find(model.Atendimento_id);
if (atendimento == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
atendimento.Texto = atendimento.Texto;
atendimento.Dt_Atendimento = atendimento.Dt_Atendimento;
atendimento.Alteracao = DateTime.UtcNow;
atendimento.Clienteid = atendimento.Clienteid;
atendimento.Status_Atendimento_id = atendimento.Status_Atendimento_id;
atendimento.Valor_ofertado = atendimento.Valor_ofertado;
atendimento.Procon = atendimento.Procon;
atendimento.Boleto_Enviado = atendimento.Boleto_Enviado;
db.SaveChanges();
atendimento.Texto = model.Texto;
atendimento.Dt_Atendimento = model.Dt_Atendimento;
atendimento.Clienteid = model.Clienteid;
atendimento.Status_Atendimento_id = model.Status_Atendimento_id;
atendimento.Valor_ofertado = model.Valor_ofertado;
atendimento.Procon = model.Procon;
atendimento.Boleto_Enviado = model.Boleto_Enviado;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ViewResult FormCreateAtendimento(string idCliente)
{
SqlGeneric sqlServices = new SqlGeneric();
SqlGenericData sqlData = new SqlGenericData();
AtendimentoViewModel modelo = new AtendimentoViewModel();
modelo.contexto = contexto;
modelo.atendimento = new Atendimento();
modelo.atendimento.status = CustomEnumStatus.Status.Ativo;
modelo.atendimento.criadoEm = DateTime.Now;
modelo.atendimento.criadoPorName = contexto.nomeUsuario;
//Se passar o id carrega o cliente
if (!String.IsNullOrEmpty(idCliente))
{
modelo.cliente = sqlData.RetornaRelacaoCliente(new Guid(idCliente));
}
try
{
modelo.profissional = sqlData.RetornaRelacaoProfissional(new Guid(sqlServices.RetornaidProfissionalPorIdUsuario(contexto.idUsuario.ToString())));
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 3, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreateAtendimento-get", ex.Message);
}
return(View(modelo));
}
public string ResponderTicket(AtendimentoViewModel viewModel)
{
try
{
if (!string.IsNullOrEmpty(viewModel.Resposta))
{
viewModel.IdCliente = PixCoreValues.UsuarioLogado.idCliente;
if (viewModel.ID == 0)
{
viewModel.UsuarioCriacao = PixCoreValues.UsuarioLogado.IdUsuario;
}
viewModel.UsuarioEdicao = PixCoreValues.UsuarioLogado.IdUsuario;
viewModel.Ativo = true;
if (EnviaAtendimento(viewModel))
{
ModelState.Clear();
return("ok");
}
}
return("Não foi possível realizar o atendimento.");
}
catch (Exception e)
{
return("Não foi possível realizar o atendimento.");
}
}
public static bool AtendimentoCreate(AtendimentoViewModel entrada, out Atendimento modelo, ContextPage contexto)
{
modelo = new Atendimento();
modelo = entrada.atendimento;
modelo.status = CustomEnumStatus.Status.Ativo;
modelo.codigo = AutoNumber.GeraCodigo(3, contexto.idOrganizacao);
modelo.idCliente = entrada.cliente.id;
modelo.idServico = entrada.servico.id;
if (entrada.profissional != null)
{
modelo.idProfissional = entrada.profissional.id;
}
if (modelo.codigo != null)
{
//************ Objetos de controle de acesso ******************
modelo.criadoEm = DateTime.Now;
modelo.criadoPor = contexto.idUsuario;
modelo.criadoPorName = contexto.nomeUsuario;
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = contexto.idUsuario;
modelo.modificadoPorName = contexto.nomeUsuario;
modelo.idOrganizacao = contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
public static bool AtendimentoUpdate(AtendimentoViewModel entrada, out Atendimento modelo)
{
modelo = new Atendimento();
modelo = entrada.atendimento;
if (entrada.cliente != null)
{
modelo.idCliente = entrada.cliente.id;
}
if (entrada.profissional != null)
{
modelo.idProfissional = entrada.profissional.id;
}
modelo.idServico = entrada.servico.id;
if (entrada.atendimento.statusAtendimento == CustomEnumStatus.StatusAtendimento.atendido || entrada.atendimento.statusAtendimento == CustomEnumStatus.StatusAtendimento.cancelado)
{
modelo.dataFechamento = DateTime.Now;
}
//************ Objetos de controle de acesso *******************
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = entrada.contexto.idUsuario;
modelo.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
private bool EnviaAtendimento(AtendimentoViewModel model)
{
try
{
var keyUrl = ConfigurationManager.AppSettings["UrlAPI"].ToString();
var url = keyUrl + "/Seguranca/wpAtendimento/TicketResposta/" + model.IdCliente + "/" + PixCoreValues.UsuarioLogado.IdUsuario;
var atendimento = new Atendimento(model.IdCliente, model.Resposta, model.TicketId)
{
IdCliente = model.IdCliente,
Nome = model.Numero,
UsuarioCriacao = PixCoreValues.UsuarioLogado.IdUsuario,
UsuarioEdicao = PixCoreValues.UsuarioLogado.IdUsuario,
Status = 1,
Descricao = model.Descricao,
};
object envio = new
{
atendimento,
};
var helper = new ServiceHelper();
var result = helper.Post <string>(url, envio);
return(true);
}
catch (Exception e)
{
throw new Exception("Não foi possível responder o ticket.", e);
}
}
public ActionResult Create(AtendimentoViewModel o)
{
try
{
sv.Agendar(UsuarioLogado.IdEmpresa, o.DataHora, o.IdServico, o.IdCliente, o.IdFuncionario, UsuarioLogado.Id);
TempData["Acao"] = "agendado";
AtendimentoReportViewModel reporFilter = new AtendimentoReportViewModel();
if (reporFilter.DataHoraInicial > o.DataHora)
{
reporFilter.DataHoraInicial = o.DataHora.FirstHourOfDay();
}
if (reporFilter.DataHoraFinal < o.DataHora)
{
reporFilter.DataHoraFinal = o.DataHora.LastHourOfDay();
}
return(RedirectToAction("Index", reporFilter));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
FillView(ref o);
return(View(o));
}
}
public ActionResult salvar(AtendimentoClienteDTO atendimento)
{
AtendimentoViewModel model = new AtendimentoViewModel();
AtendimentoDAO dao = new AtendimentoDAO();
string idUser = User.Identity.GetUserId();
atendimento.idVendedor = idUser;
atendimento.idCliente = Convert.ToInt32(Session["idCliente"].ToString());
if (atendimento.Id == 0)
{
dao.Salvar(atendimento);
}
else
{
dao.Atualizar(atendimento);
}
model.tiposAtendimento = new TipoAtendimentoDAO().listarTipoAtendimento();
model.atendimentoClienteDTOs = dao.buscaHistoricoAtendimento(Session["idCliente"].ToString(), idUser);
return(RedirectToAction("Index"));
}
private AtendimentoViewModel Carregar(int inputConvenio, int inputTipoAtendimento)
{
AtendimentoViewModel model = new AtendimentoViewModel();
var procedimentos = context.ProcedimentosConvenios
.Where(o => o.ConvenioId == inputConvenio)
.Include(o => o.Convenio)
.Select(o => o.Procedimento)
.Include(o => o.TipoAtendimento)
.Where(o => o.TipoAtendimentoId == inputTipoAtendimento);
foreach (var proced in procedimentos)
{
model.Procedimentos.Add(new SelectListItem {
Text = proced.Descricao, Value = proced.ProcedimentoId.ToString()
});
model.TipoAtendimentos.Add(new SelectListItem {
Text = proced.TipoAtendimento.Descricao, Value = proced.TipoAtendimento.TipoAtendimentoId.ToString()
});
}
return(model);
}
public ActionResult Create()
{
AtendimentoViewModel atendimento = new AtendimentoViewModel();
FillView(ref atendimento);
return(View(atendimento));
}
public AtendimentoViewModel SalvarAtendimento(AtendimentoViewModel model, long atividadeId)
{
var retorno = new Atendimento(model.criadoPorUserId, _atendimento.GerarNumeroProtocolo(DateTime.Now),
null, null);
var modelView = _atendimento.InserirAtendimento(retorno);
_atividadeServico.AtualizarAtendimentoId(atividadeId, modelView.Id);
return(new AtendimentoViewModel(modelView.Id, modelView.Protocolo, modelView.CriadoEm));
}
public ActionResult Create(int id)
{
ViewBag.Atendimento = db.Status_Atendimentos;
ViewBag.Pagamento = db.Status_Pagamentos;
ViewBag.Lance = db.Status_Lance;
var model = new AtendimentoViewModel();
return(View(model));
}
public ActionResult Edit(long id)
{
AtendimentoModel a = sv.Find(id);
AtendimentoViewModel atendimento = _mapp.Map <AtendimentoViewModel>(a);
FillView(ref atendimento);
return(View(atendimento));
}
public ActionResult Editar(int id)
{
ViewBag.Id = id;
var result = GetTicket(id);
var ticket = JsonConvert.DeserializeObject <Ticket>(result);
var model = new AtendimentoViewModel(ticket.Email, ticket.Origem, ticket.Tipo.Nome, ticket.Numero, ticket.Descricao, ticket.ID, ticket.TicketStatusID);
return(View(model));
}
//
// GET: /Atendimentos/Criar
public ActionResult Criar()
{
ViewBag.PossibleConvenios = context.Convenios;
ViewBag.PossibleTiposAtendimentos = context.TiposAtendimentos;
ViewBag.PossibleProcedimentos = context.Procedimentos;
AtendimentoViewModel model = new AtendimentoViewModel();// = Carregar();
model.Codigo = ProximoCodigo();
return(View(model));
}
//
// GET: /Atendimentos/Editar/5
public ActionResult Editar(int id)
{
Atendimento atendimento = context.Atendimentos.Single(x => x.AtendimentoId == id);
ViewBag.PossibleConvenios = context.Convenios;
ViewBag.PossibleTiposAtendimentos = context.TiposAtendimentos;
ViewBag.PossibleProcedimentos = context.Procedimentos;
AtendimentoViewModel atendimentoVM = new AtendimentoViewModel();
return(View(atendimentoVM));
}
public ActionResult Create(AtendimentoViewModel model, int id)
{
if (ModelState.IsValid)
{
var atendimento = new Atendimento();
Cliente cliente = db.Clientes.Find(id);
atendimento.Clienteid = id;
atendimento.Status_Pagamento_id = 0;
atendimento.Status_Atendimento_id = model.Status_Atendimento_id;
atendimento.Boleto_Enviado = model.Boleto_Enviado;
atendimento.Dt_Atendimento = DateTime.Now;
atendimento.Texto = model.Texto;
atendimento.Status_Lance_id = model.Status_Lance_id;
atendimento.Atendente_id = 1;
if (model.Status_Atendimento_id == 0)
{
cliente.HasAtendimento = 0;
}
else
{
cliente.HasAtendimento = 1;
cliente.Status_Atendimento_Id = model.Status_Atendimento_id;
}
atendimento.Valor_ofertado = model.Valor_ofertado;
atendimento.Procon = model.Procon;
atendimento.Contatado = model.Contatado;
try
{
db.Atendimentos.Add(atendimento);
db.SaveChanges();
return(RedirectToAction("Index", "Cliente"));
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
return(View(model));
}
public List <AtendimentoViewModel> FindAtendimento()
{
AtendimentoDao dao = new AtendimentoDao();
DataTable dt = dao.FindAtendimento();
//List<AtendimentoViewModel> lista = new List<AtendimentoViewModel>(Parser.LoadViewAtendimento(dt));
DateTime date = DateTime.Now;
List <AtendimentoViewModel> retorno = InitListDefault(date);
var ListAtendimento = dt.AsEnumerable()
.Select(y =>
new
{
DataAtendimento = y.Field <DateTime>("dataAtendimento"),
NomeCliente = y.Field <String>("nomeCliente"),
NomeProfissional = y.Field <String>("nomeProfissional"),
IdProfissional = y.Field <Int32>("idProfissional").ToString()
}).GroupBy(x => x.NomeProfissional).Select(z => z.ToList())
.ToList();
for (int i = 0; i < ListAtendimento.Count(); i++)
{
for (int x = 0; x < ListAtendimento[i].Count; x++)
{
AtendimentoViewModel item = new AtendimentoViewModel
{
NomeProfissional = ListAtendimento[i][x].NomeProfissional,
NomeCliente = ListAtendimento[i][x].NomeCliente,
IdProfissional = ListAtendimento[i][x].IdProfissional,
DataAtendimento = ListAtendimento[i][x].DataAtendimento
//NomeProcedimento = ListAtendimento[0][i].n,
//NomeProcedimento = dt_.Rows[i]["nomeProcedimento"].ToString(),
//NomeCliente = dt_.Rows[i]["nomeCliente"].ToString(),
//DataAtendimento = DateTime.Parse(dt_.Rows[i]["dataAtendimento"].ToString()),
//ValorProcedimento = Double.Parse(dt_.Rows[i]["valorDesconto"].ToString())
};
item_ = retorno.FindIndex(f => string.Equals(f.NomeProfissional, item.NomeProfissional) &&
CompareHour(f.DataAtendimento, item.DataAtendimento)
);
if (item_ != -1)
{
retorno.RemoveAt(item_);
retorno.Add(item);
}
}
}
return(retorno.OrderBy(x => x.DataAtendimento).ToList());
}
private void FillView(ref AtendimentoViewModel view)
{
List <FiltrosReportView> clientes = svCliente.ListarFiltro(UsuarioLogado.IdEmpresa).ToList();
view.Clientes = new SelectList(clientes, "Id", "Nome");
List <FiltrosReportView> Servicos = svServico.ListarFiltros(UsuarioLogado.IdEmpresa).ToList();
view.Servicos = new SelectList(Servicos, "Id", "Nome");
List <FiltrosReportView> Funcionarios = svFuncionario.ListarFiltros(UsuarioLogado.IdEmpresa).ToList();
view.Funcionarios = new SelectList(Funcionarios, "Id", "Nome");
}
public async Task <IActionResult> Incluir()
{
var sistemas = await _sistemaServico.ListarTudosAsync();
var revendedores = await _revendedorServico.ListarTudosAsync();
var usuarios = await _usuarioServico.ListarTudosAsync();
var viewModel = new AtendimentoViewModel {
Sistemas = sistemas, Revendedores = revendedores, Usuarios = usuarios
};
return(View(viewModel));
}
public void FinalizarAtendimento(AtendimentoViewModel model)
{
var atendimentoEntity = _atendimento.ObterPorId(model.atendimentoID);
var atend = new AtendimentoViewModel(model.atendimentoID, atendimentoEntity.Protocolo,
atendimentoEntity.CriadoEm);
atendimentoEntity = _atendimento.ObterPorId(atend.id);
if (atendimentoEntity == null)
{
return;
}
atendimentoEntity.FinalizadoEm = DateTime.Now;
atendimentoEntity.FinalizadoPorUserId = model.finalizadoPorUserID;
atendimentoEntity.CanalOrigemId = model.canalOrigemID;
_atendimento.Atualizar(atendimentoEntity);
}
public ActionResult EditarAtendimento(string id)
{
AtendimentoViewModel modedetail = new AtendimentoViewModel();
AtendimentoDAO dao = new AtendimentoDAO();
modedetail.tiposAtendimento = new TipoAtendimentoDAO().listarTipoAtendimento();
AtendimentoClienteDTO cliente = new AtendimentoDAO().buscaAtendimento(id);
modedetail.atendimento = dao.buscaAtendimento(id);
return(View("EditarAtendimento", modedetail));
}
public ActionResult Details(long id)
{
try
{
AtendimentoModel a = sv.Find(id);
AtendimentoViewModel aVM = _mapp.Map <AtendimentoViewModel>(a);
aVM.UsuarioAgendou = User.Identity.GetName();
return(View(aVM));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View());
}
}
public ActionResult Cadastrar(AtendimentoViewModel viewModel)
{
ViewBag.NomePagina = "Finalização de Atendimento - Token";
if (viewModel.Valido())
{
// Cadastro de Atendimento.
Atendimento atendimento = Mapper.Map<AtendimentoViewModel, Atendimento>(viewModel);
atendimento.DataAtendimento = DateTime.Now;
atendimento.CodigoMedico = Convert.ToInt32(UserAuthentication.ObterCodigoInternoUsuarioLogado());
atendimento = this.AtendimentoRepository.Cadastrar(atendimento);
// Geração do Token.
string codigoToken = Utils.GenerateRandomNumber();
string codigoTokenBase64 = Utils.Base64Encode(codigoToken);
TokenAtendimento token = new TokenAtendimento(atendimento.NumeroAtendimento, codigoTokenBase64);
this.TokenAtendimentoRepository.Cadastrar(token);
// Envio de Email para paciente com token de verificação
PessoaFisica pessoa = this.PessoaFisicaRepository.Obter(atendimento.CodigoPessoaFisica);
EspecialidadeAtendimento especialidade = this.EspecialidadeAtendimentoRepository.Obter(atendimento.CodigoEspecialidade);
Medico medico = this.MedicoRepository.Obter(atendimento.CodigoMedico);
if (pessoa == default(PessoaFisica))
return Json("Paciente não encontrado");
if (especialidade == default(EspecialidadeAtendimento))
return Json("Especialidade não encontrado");
if (medico == default(Medico))
return Json("Médico não encontrado");
Utils.SendEmail(pessoa.Email, $"Olá, {pessoa.Nome}, seu atendimento realidado com o(a) Dr(a). {medico.NomeGuerra} da especialidade {especialidade.DescricaoEspecialidade} realidado dia {atendimento.DataAtendimento.ToString("dd/MM/yyyy HH:mm:ss")} gerou um token de validação: {codigoToken}", $" #{atendimento.NumeroAtendimento} Atendimento Realizado");
ViewBag.CodigoAtendimento = atendimento.NumeroAtendimento;
ViewBag.NomePessoa = pessoa.Nome;
return View("FinalizarCadastro");
}
return RedirectToAction("Index", "Atendimento");
}
public ActionResult Concluir(AtendimentoViewModel o)
{
try
{
sv.Concluir(o.Id, o.Valor);
TempData["Acao"] = "concluido";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
FillView(ref o);
return(View(o));
}
}
public ActionResult Editar(AtendimentoViewModel atendimentoVM)
{
Atendimento atendimento = new Atendimento()
{
Codigo = atendimentoVM.Codigo
};
if (ModelState.IsValid)
{
context.Entry(atendimento).State = EntityState.Modified;
context.SaveChanges();
return(RedirectToAction(nameof(AtendimentosController.Indice)));
}
ViewBag.PossibleConvenios = context.Convenios;
ViewBag.PossibleTiposAtendimentos = context.TiposAtendimentos;
ViewBag.PossibleProcedimentos = context.Procedimentos;
return(View(atendimentoVM));
}
public async Task <IActionResult> Incluir(Atendimento atendimento)
{
if (!ModelState.IsValid)
{
var sistemas = await _sistemaServico.ListarTudosAsync();
var revendedores = await _revendedorServico.ListarTudosAsync();
var usuarios = await _usuarioServico.ListarTudosAsync();
var viewModel = new AtendimentoViewModel {
Atendimento = atendimento, Sistemas = sistemas, Revendedores = revendedores, Usuarios = usuarios
};
return(View(viewModel));
}
await _atendimentoServico.IncluirAsync(atendimento);
return(RedirectToAction(nameof(Index)));
}
