public IList <Atendimento> BuscaPet(Atendimento atendimento)
{
AtendimentoDAO atendDao = new AtendimentoDAO();
if (atendimento.Pet.CodPet > 0)
{
IList <Atendimento> petTemp = atendDao.BuscaPet(atendimento.Pet.CodPet);
return(petTemp);
//atendimento.AtendimentoCod = petTemp.AtendimentoCod;
//atendimento.Servico.Codservico =petTemp.Servico.Codservico;
//atendimento.Pet.CodPet = petTemp.Pet.CodPet;
//atendimento.Funcionario.Cod = petTemp.Funcionario.Cod;
//atendimento.Situacao = petTemp.Situacao;
//atendimento.DataHora = petTemp.DataHora;
}
else
{
return(null);
}
}
private void btnBuscaPet_Click(object sender, EventArgs e)
{
Atendimento atendimento = new Atendimento();
AtendimentoBO atendimentoBO = new AtendimentoBO();
try
{
atendimento.Pet.CodPet = Convert.ToInt16(txtCodPet.Text);
dgvDados.DataSource = atendimentoBO.BuscaPet(atendimento);
atendimentoBO.BuscaPet(atendimento);
//txtCodAtend.Text = Convert.ToString(atendimento.AtendimentoCod);
//txtCodServ.Text = Convert.ToString(atendimento.Servico.Codservico);
//txtCodPet.Text = Convert.ToString (atendimento.Pet.CodPet);
//txtCodFun.Text = Convert.ToString (atendimento.Funcionario.Cod);
//cmbSituacao.SelectedItem = Convert.ToString (atendimento.Situacao);
//dtpDataHora.Value = atendimento.DataHora;
}
catch
{
MessageBox.Show("Preencha corretamente as informações!!");
}
}
private void Cadastra_Click(object sender, EventArgs e)
{
try
{
Atendimento A = new Atendimento();
A.Descricao = richTextBoxDescricao.Text;
A.Agenda.CodigoAgenda = ((KeyValuePair <int, string>)comboBoxAgenda.SelectedItem).Key;
A.Status = ((KeyValuePair <string, string>)comboBoxStatus.SelectedItem).Key;
A.Funcionario.Matricula = ((KeyValuePair <int, string>)comboBoxFuncionario.SelectedItem).Key;
new Service1Client().InserirAtendimento(A);
richTextBoxDescricao.Clear();
textBoxCPF.Clear();
comboBoxAnimal.DataSource = null;
comboBoxStatus.DataSource = null;
comboBoxAgenda.DataSource = null;
comboBoxFuncionario.DataSource = null;
lb_Logradouro.Text = " ";
lb_Estado.Text = " ";
lb_Cidade.Text = " ";
lb_Bairro.Text = " ";
lb_Numero.Text = " ";
lb_Complemento.Text = " ";
MessageBox.Show("Cadastrada com sucesso");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public HttpResponseMessage PostAtendimento(Atendimento atendimento)
{
if (atendimento == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
else if (!(atendimento.ClienteId > 0))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Necessário informar o Id do Cliente"));
}
var atendAberto = db.Atendimentos.Where(x => x.MomConclusao == null && x.ClienteId == atendimento.ClienteId).ToList();
if (atendAberto.Count > 0)
{
//return Request.CreateResponse(HttpStatusCode.InternalServerError, "Cliente possui atendimento não concluído.");
}
try
{
db.Atendimentos.Add(atendimento);
db.SaveChanges();
var result = atendimento;
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Falha ao tentar abrir um novo atendimento"));
}
}
public ExamesDoAtendimento BuscaPorAtendimento(Atendimento objAtendimento)
{
SqlCommand comando = new SqlCommand();
comando.CommandType = CommandType.Text;
comando.CommandText = "Select * From ExamesDoAtendimento Where examesDoAtendimentoID=@id";
comando.Parameters.AddWithValue("@id", objAtendimento.Id);
Conexao con = new Conexao();
SqlDataReader dr = con.Selecionar(comando);
ExamesDoAtendimento objExamesDoAtendimento = new ExamesDoAtendimento(objAtendimento);
if (dr.HasRows)
{
dr.Read();
//preenche o objeto
objExamesDoAtendimento.Id = (int)dr["examesDoAtendimentoID"];
objExamesDoAtendimento.DataExame = (DateTime)dr["dataExame"];
objExamesDoAtendimento.Status = (string)dr["status"];
objExamesDoAtendimento.ObjAtendimento = objAtendimento;
objExamesDoAtendimento.ObjExame = new ExameDAO().SelecionaPorID((int)dr["exameID"]);
}
else
{
objExamesDoAtendimento = null;
}
return(objExamesDoAtendimento);
}
public IList <ExamesDoAtendimento> BuscarExamesDoAtendimento(Atendimento objAtendimento)
{
IList <ExamesDoAtendimento> listaExamesDoAtendimentos = new List <ExamesDoAtendimento>();
var comando = new SqlCommand();
comando.CommandType = CommandType.Text;
comando.CommandText = "SELECT * FROM ExamesDoAtendimento Where atendimentoID=@IdAtendimento";
comando.Parameters.AddWithValue("@IdAtendimento", objAtendimento.Id);
Conexao con = new Conexao();
SqlDataReader dr = con.Selecionar(comando);
if (dr.HasRows)
{
while (dr.Read())
{
ExamesDoAtendimento objExamesDoAtendimento = new ExamesDoAtendimento(objAtendimento);
objExamesDoAtendimento.Id = (int)dr["examesDoAtendimentoID"];
objExamesDoAtendimento.DataExame = (DateTime)dr["dataExame"];
objExamesDoAtendimento.Status = (string)dr["status"];
objExamesDoAtendimento.ObjAtendimento = objAtendimento;
objExamesDoAtendimento.ObjExame = new ExameDAO().SelecionaPorID((int)dr["exameID"]);
listaExamesDoAtendimentos.Add(objExamesDoAtendimento);
} //fim while
} //fim if
else
{
listaExamesDoAtendimentos = null;
}//fim else
dr.Close();
return(listaExamesDoAtendimentos);
}
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);
}
public ServicosListagemViewModel(Atendimento atendimento)
{
this.Atendimento = atendimento;
this.ItensAtendimento = new ObservableCollection<AtendimentoItem>();
atendimentoItemDAL = new AtendimentoItemDAL(atendimento, DependencyService.Get<IDBPath>().GetDbPath());
RegistrarCommands();
}
private void LimparFormulario()
{
txtID.Clear();
txtHora.Clear();
lstServicos.Clear();
lblHoraAte.Content = "";
cboDono.SelectedIndex = -1;
cboAnimal.SelectedIndex = -1;
cboFuncionario.SelectedIndex = -1;
cboServico.SelectedIndex = -1;
atendimento = new Atendimento();
lstOcupados = null;
dtpDia.SelectedDate = null;
dtaOcupado.ItemsSource = null;
dtaServicos.ItemsSource = null;
cboDono.Focus();
btnRemover.IsEnabled = false;
btnCadastrar.IsEnabled = btnBuscar.IsEnabled = btnAdd.IsEnabled = txtID.IsEnabled = dtaServicos.CanUserDeleteRows = true;
}
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 List <Atendimento> ConsultaAtendimentosDAO()
{
try
{
List <Atendimento> List = new List <Atendimento>();
SqlDataReader Dr = null;
using (SqlConnection Con = new Conexao().ConexaoDB())
{
SqlCommand Cmd = new SqlCommand(@"
SELECT *
FROM [dbo].[Atendimento]
WHERE ativo = 1", Con);
Dr = Cmd.ExecuteReader();
while (Dr.Read())
{
Atendimento Usr = FactoryAtendimento.GetNew();
Usr.Id = Dr.GetInt32(0);
List.Add(Usr);
}
return(List);
}
}
catch (SqlException)
{
throw;
}
}
public async Task <IActionResult> Edit(int id, [Bind("horaInicio,horaFim,atendePlano,atendeDia,Id")] Atendimento atendimento)
{
if (id != atendimento.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(atendimento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AtendimentoExists(atendimento.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(atendimento));
}
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 static bool DefinirClienteScopeEhValido(this Atendimento atendimento, Guid?idCliente)
{
return(AssertionConcern.IsSatisfiedBy
(
AssertionConcern.AssertNotNull(idCliente, ErrorMessage.ClienteInvalido)
));
}
private async void ProcessarOpcaoRespondida(Atendimento atendimento, string result)
{
if (result.Equals("Consultar") || result.Equals("Alterar"))
{
var title = result + " Atendimento " + atendimento.AtendimentoID;
await Navigation.PushAsync(new CRUDView(atendimento, title));
}
else if (result.Equals("Registrar Entrega"))
{
await viewModel.RegistrarEntrega(atendimento);
//await viewModel.AtualizarAtendimentos();
await DisplayAlert("Informação", "Entrega registrada com sucesso.", "Ok");
listView.SelectedItem = null;
}
else if (result.Equals("Remover OS"))
{
if (await DisplayAlert("Confirmação",
$"Confirma remoção da OS {atendimento.AtendimentoID}?", "Yes", "No"))
{
await viewModel.EliminarAtendimentoAsync(atendimento);
//await viewModel.AtualizarAtendimentos();
await DisplayAlert("Informação", "Atendimento removido com sucesso", "Ok");
}
}
}
/// <summary>
/// Atualiza um atendimento existente
/// </summary>
/// <param name="idAtendimento">ID do atendimento que será atualizado</param>
/// <param name="atendimentoAtualizado">Objeto com as novas informações</param>
public void Atualizar(int idAtendimento, Atendimento atendimentoAtualizado)
{
Atendimento atendimentoBuscado = BuscarPorId(idAtendimento);
if (atendimentoAtualizado.IdPet > 0)
{
atendimentoBuscado.IdPet = atendimentoAtualizado.IdPet;
}
if (atendimentoAtualizado.IdVeterinario > 0)
{
atendimentoBuscado.IdVeterinario = atendimentoAtualizado.IdVeterinario;
}
if (atendimentoAtualizado.IdSituacao > 0)
{
atendimentoBuscado.IdSituacao = atendimentoAtualizado.IdSituacao;
}
if (atendimentoAtualizado.Descricao != null)
{
atendimentoBuscado.Descricao = atendimentoAtualizado.Descricao;
}
if (atendimentoAtualizado.DataAtendimento >= DateTime.Now)
{
atendimentoBuscado.DataAtendimento = atendimentoAtualizado.DataAtendimento;
}
ctx.Atendimentos.Update(atendimentoBuscado);
ctx.SaveChanges();
}
private void dgvAtendimento_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (e.ColumnIndex == dgvAtendimento.Columns["btnEncerrar"].Index && e.RowIndex >= 0)
{
DialogResult result;
result = MessageBox.Show("Deseja encerrar o atendimento?", "Encerrar", MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (result == DialogResult.Yes)
{
Atendimento atendimento = new Atendimento();
SGAPContexto contexto = new SGAPContexto();
atendimento.id = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["id"].Value);
atendimento.numeroProcon = dgvAtendimento.SelectedRows[0].Cells["numeroProcon"].Value.ToString();
atendimento.consumidorID = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["consumidorID"].Value);
atendimento.fornecedorID = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["fornecedorID"].Value);
atendimento.tipoAtendimentoID = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["tipoAtendimentoID"].Value);
atendimento.tipoReclamacaoID = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["tipoReclamacaoID"].Value);
atendimento.problemaPrincipalID = Convert.ToInt32(dgvAtendimento.SelectedRows[0].Cells["problemaPrincipalID"].Value);
atendimento.reclamacao = dgvAtendimento.SelectedRows[0].Cells["reclamacao"].Value.ToString();
atendimento.dataInicio = Convert.ToDateTime(dgvAtendimento.SelectedRows[0].Cells["dataInicio"].Value.ToString());
atendimento.dataEncerramento = DateTime.Now;
contexto.Entry(atendimento).State = EntityState.Modified;
contexto.SaveChanges();
FuncGeral.trigger(atendimento, menu.usuario);
carregarGridAtendimento();
}
}
}
private static object ObjetoResposta(Usuario usuario, Atendimento conversa = null)
{
var atendimento = conversa != null ? new
{
Id = conversa.Id,
Mensagens = conversa.Mensagens
.Select(mensagem =>
new
{
Texto = mensagem.Texto,
Remetente = new
{
Nome = mensagem.Remetente.Nome,
mensagem.Remetente.ChaveAcesso
}
}),
Login = usuario.Login
} : null;
object objetoResposta = new
{
Usuario = new
{
Nome = usuario.Nome,
Login = usuario.Login
},
Conversa = atendimento,
UsuarioDesconectado = usuario.SessaoSocketAtiva == null
};
return(objetoResposta);
}
public List <Atendimento> Update(int id, Atendimento a)
{
cmd.Connection = con.Connect();
//IdPet e IdVet trocam de valores quando atualizados por este metodo
//Não tentei resolver ainda
cmd.CommandText =
"UPDATE Atendimento SET " +
"Descricao = @Descricao , " +
"DataAtendimento = @DtaAtendimento ," +
"IdPet = @IdPet ," +
"IdVet = @IdVeterinario " +
"WHERE IdAtendimento = @IdAtendimento";
cmd.Parameters.AddWithValue("IdAtendimento", id);
cmd.Parameters.AddWithValue("IdPet", a.IdPet);
cmd.Parameters.AddWithValue("IdVeterinario", a.IdVet);
cmd.Parameters.AddWithValue("Descricao", a.Descricao);
cmd.Parameters.AddWithValue("DtaAtendimento", a.DataAtendimento);
SqlDataReader data = cmd.ExecuteReader();
con.Desconnect();
return(ReadAll());
}
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 List <Atendimento> GetAtendimentos(int idProcedimento)
{
cmd.Connection = conn;
cmd.CommandText = $"SELECT * FROM atendimentoprocedimentos ap INNER JOIN atendimento a ON ap.idAtendimento = a.idAtendimento WHERE ap.idProcedimento = {idProcedimento}";
cmd.Parameters.AddWithValue("@ID", idProcedimento);
try
{
conn.Open();
MySqlDataReader reader = cmd.ExecuteReader();
List <Atendimento> atendimentos = new List <Atendimento>();
while (reader.Read())
{
Atendimento temp = new Atendimento();
temp.Colaborador = new Colaborador();
temp.Paciente = new Paciente();
temp.Id = Convert.ToInt32(reader["idAtendimento"]);
temp.Paciente.Id = Convert.ToInt32(reader["idPaciente"]);
temp.Colaborador.Id = Convert.ToInt32(reader["idColaborador"]);
atendimentos.Add(temp);
}
return(atendimentos);
}
catch (Exception)
{
throw new Exception("Erro no Banco de dados.Contate o administrador.");
}
finally
{
conn.Dispose();
}
}
/// <summary>
/// Exibe MessageBox
/// </summary>
/// <param name="message">passa messagem por parametro</param>
private void AsyncMessageBox(string message, bool retornook)
{
BlackBox = Visibility.Collapsed;
StarProgress = false;
TextMsgBox = message;
ShowMsgBox = Visibility.Visible;
System.Media.SystemSounds.Exclamation.Play();
Task.Factory.StartNew(() => Freezetime(10)).ContinueWith(taskmsg =>
{
if (taskmsg.IsCompleted)
{
ShowMsgBox = Visibility.Collapsed;
if (retornook == true)
{
Atendimento.Clear();
PF.Clear();
PJ.Clear();
Protocolo = NProtocolo();
Atendimento.Operador = AccountOn.Identificador;
AreaTransferencia.Limpar();
ns.GoBack();
}
}
}, System.Threading.CancellationToken.None,
TaskContinuationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext());
}
public frmAtendimentoAlterar(Atendimento atendimento)
{
objAtendimento = atendimento;
InitializeComponent();
CarregaPaciente();
CarregaGridExamesDoAtendimento();
}
public async Task <IActionResult> Edit(long id, [Bind("Id,HoraInicio,HoraFim,AtendePlano,AtendeDia,DiaSemanaId,MedicoId,AtendimentoDaConsultaId")] Atendimento atendimento)
{
if (id != atendimento.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(atendimento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AtendimentoExists(atendimento.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AtendimentoDaConsultaId"] = new SelectList(_context.Consulta, "Id", "Tipo", atendimento.AtendimentoDaConsultaId);
ViewData["DiaSemanaId"] = new SelectList(_context.DiaSemana, "Id", "Nome", atendimento.DiaSemanaId);
ViewData["MedicoId"] = new SelectList(_context.Medico, "Id", "CRM", atendimento.MedicoId);
return(View(atendimento));
}
public async Task <ActionResult> Edit(
[Bind(Include =
"AtendimentoId,ClienteId,AtendenteId,TipoAtendimentoId,Solicitante,Status,Prioridade,DescricaoAtendimento,DescricaoConclusao,Observacao,DataPrevisao,DataConclusao")]
Atendimento atendimento)
{
#region Validações
if ((atendimento.Status == Status.Concluido) && (atendimento.DataConclusao == null))
{
ModelState.AddModelError("Conclusao", "É necessário preencher a data de conclusão para alterar este status");
}
#endregion
if (ModelState.IsValid)
{
db.Entry(atendimento).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.AtendenteId = new SelectList(db.Atendentes, "AtendenteId", "Nome", atendimento.AtendenteId);
ViewBag.ClienteId = new SelectList(db.Clientes, "ClienteId", "Fantasia", atendimento.ClienteId);
ViewBag.TipoAtendimentoId = new SelectList(db.TiposAtendimento, "TipoAtendimentoId", "Descricao",
atendimento.TipoAtendimentoId);
return(View(atendimento));
}
/////////////////////[Metodos internos]//////////////////////////////////////////////
private void distribui_atendimento_solicitado(Atendimento atend)
{
if (atend.Aten_ID > 0)
{
atend = regra_atendimento.puxar_atendimento(atend);
//DEFINE O PROVEDOR
filial.Fili_ID = atend.Fili_ID;
cb_provedor.Text = atend.Fili_descricao;
//cb_provedor_ID.Text = filial.Fili_ID.ToString();
//DEFINO O CLIENTE
cliente.Clie_ID = atend.cliente.Clie_ID;
cx_codCliente.Text = atend.cliente.Clie_codigo.ToString();
cx_nomeCliente.Text = atend.cliente.Clie_nome;
//DEFINE A CATEGORIA
liberar_categoria(true, filial);
cb_categoria_descricao.Text = atend.categoria.Cate_descricao;
//cb_categoria_ID.Text = atend.categoria.Cate_ID.ToString();
//DEFINE A SUBCATEGORIA
categoria.Cate_ID = atend.categoria.Cate_ID;
liberar_subcategoria(categoria);
cb_subcategoria_descricao.Text = atend.subcategoria.Sub_descricao;
//cb_subcategoria_ID.Text = atend.subcategoria.Sub_descricao;
//DEFINE OBS...
cx_obs.Text = atend.Atend_descricao;
//INFORMA QUEM SOLICITOU
cx_solicitado.Text = atend.recepcao.Rec_nome;
//Data da solicitação
cx_dataHora.Text = atend.Atend_data_solicitado;
}
}
public IActionResult AlterarAtendimento(Atendimento atendimento)
{
if (!ModelState.IsValid)
{
ViewBag.Bichinhos = new SelectList(bichinhoRepo.ListaBichinhos(), "Id", "Nome");
ViewBag.Veterinarios = new SelectList(veterinarioRepo.ListaVeterinarios(), "Id", "Nome");
return(View(atendimento));
}
var indisponivel = atendimentoRepo.DataIndisponivel(atendimento.Data, atendimento.Id);
if (indisponivel || atendimento.Data.Hour < 8 || atendimento.Data.Hour > 18)
{
ViewBag.Bichinhos = new SelectList(bichinhoRepo.ListaBichinhos(), "Id", "Nome");
ViewBag.Veterinarios = new SelectList(veterinarioRepo.ListaVeterinarios(), "Id", "Nome");
ModelState.AddModelError("Data", "Horário indisponivel. Das 8h-18h com 15 minutos de intervalo entre atendimentos.");
return(View(atendimento));
}
var atend = atendimentoRepo.ObterAtendimentoPorId(atendimento.Id);
atend.BichinhoId = atendimento.BichinhoId;
atend.VeterinarioId = atendimento.VeterinarioId;
atend.Data = atendimento.Data;
atend.Observacao = atendimento.Observacao;
atendimentoRepo.Alterar(atend);
return(RedirectToAction("ListaAtendimentos"));
}
public EmailViewModel CarregarTratar(long emailId, string userId)
{
var email = _emailServico.ObterEmailCompletoPor(emailId, null);
var model = new EmailViewModel
{
Assunto = email.Assunto,
DataEmail = email.CriadoEm,
DataEntrada = email.Atividade.CriadoEm,
EmailRemetente = email.Remetente,
Html = email.CorpoDoEmail,
Para = email.Para,
Copia = email.Copia,
CopiaOculta = email.CopiaOculta
};
if (email.Atividade.AtendimentoId == null)
{
var canal = _servicoCanal.ObterPorNome("email");
var atendimento = new Atendimento(userId, _servicoAtendimento.GerarNumeroProtocolo(DateTime.Now),
canal != null ? canal.FirstOrDefault().Id : (int?)null, null);
_servicoAtendimento.Adicionar(atendimento);
_servicoAtividade.AtualizarAtendimentoId(email.Atividade.Id, atendimento.Id);
model.NumeroProtocolo = atendimento.Protocolo;
model.AtendimentoId = atendimento.Id;
}
//if (email.Atividade != null)
//{
// var AtividadeCompleto = _servicoAtividade.ObterAtividadeCompletaPor(email.Atividade.id);
//}
return(model);
}
public static bool DefinirEstabelecimentoScopeEhValido(this Atendimento atendimento, Guid?idEstabelecimento)
{
return(AssertionConcern.IsSatisfiedBy
(
AssertionConcern.AssertNotNull(idEstabelecimento, ErrorMessage.EstabelecimentoObrigatorio)
));
}
public static void AtribuirComandaAoAtendimento(Atendimento atd)
{
String sqlUpdate = @"UPDATE ATENDIMENTO SET NUMEROCOMANDA = :NUMEROCOMANDA, NUMEROVENDA = :NUMEROVENDA WHERE CODIGO = :CODIGO";
OracleConnection conexao = PersistenciaOracle.ObterConexao();
conexao.Open();
OracleCommand comando = new OracleCommand(sqlUpdate);
comando.Connection = conexao;
comando.Parameters.Add("NUMEROCOMANDA", atd.NumeroComanda);
comando.Parameters.Add("NUMEROVENDA", atd.NumeroVenda);
comando.Parameters.Add("CODIGO", atd.Codigo);
comando.Prepare();
comando.ExecuteNonQuery();
conexao.Close();
}
private void GravarRegistroAlteracao(Atendimento atd, decimal CodOperador,
string NomeOperador, string DescricaoOperacao, Agendamento agd)
{
HistoricoAlteracaoAtendimento histalt = new HistoricoAlteracaoAtendimento();
histalt.NomeCliente = atd.Cliente.Nome;
histalt.CodigoCliente = atd.CodigoCliente;
histalt.CodigoOperador = CodOperador;
histalt.DataOperacao = DateTime.Now;
histalt.DescricaoOperacao = DescricaoOperacao;
histalt.DtHoraInicial = agd.DataHoraAgendamento;
histalt.NomeAtendente = atd.NomeAtendente;
histalt.NomeOperador = NomeOperador;
histalt.NomeServico = agd.ServicoAgendado.Nome.ToUpper();
Persistencia.PersistenciaHistoricoAlteracao.Gravar(histalt);
}
private HistoricoAlteracaoAtendimento ObterBaseHistAlteracaoAtendimento(Atendimento atd,
decimal CodOperador, string NomeOperador, string DescricaoOperacao)
{
HistoricoAlteracaoAtendimento hist = new HistoricoAlteracaoAtendimento();
hist.CodigoOperador = CodOperador;
hist.CodigoCliente = atd.CodigoCliente;
hist.DataOperacao = DateTime.Now;
hist.DescricaoOperacao = DescricaoOperacao;
hist.NomeAtendente = atd.NomeAtendente;
hist.NomeCliente = atd.Cliente.Nome;
hist.NomeOperador = NomeOperador;
return hist;
}
private Atendimento ObterAtendimento()
{
Atendimento atd = null;
if (this.Atendimento == null)
{
atd = new Atendimento();
atd.DataAtendimento = this.DataAtendimento;
atd.NomeAtendente = this.NomeAtendente;
atd.HoraInicialAtendimento = this.HorarioInicioPrimeiroAtendimento;
}
else
{
atd = this.Atendimento;
}
atd.Cliente = this.ObterClienteDaTela();
atd.Agendamentos = this.ObterAgendamentosDaTela();
if (chkAtendimentoPreferencial.IsChecked.GetValueOrDefault())
{
atd.FlagPreferencial = "S";
}
else
{
atd.FlagPreferencial = "N";
}
if (atd.TipoAtendimento == StatusAtendimento.Normal)
{
atd.TipoAtendimento = chkAtendimentoPreferencial.IsChecked.GetValueOrDefault() ? StatusAtendimento.Preferencial : StatusAtendimento.Normal;
}
return atd;
}
private void GravarRegistroAlteracao(Atendimento atd, decimal CodOperador, string NomeOperador,
string DescricaoOperacao)
{
foreach (Agendamento agd in atd.Agendamentos)
{
HistoricoAlteracaoAtendimento histalt =
this.ObterBaseHistAlteracaoAtendimento(atd, CodOperador, NomeOperador, DescricaoOperacao);
histalt.NomeServico = agd.ServicoAgendado.Nome;
histalt.DtHoraInicial = agd.DataHoraAgendamento;
Persistencia.PersistenciaHistoricoAlteracao.Gravar(histalt);
}
}
private void AtualizarAgendamentos(Atendimento Atd)
{
Persistencia.PersistenciaAtendimento.ExcluirAgendamentos(Atd);
Persistencia.PersistenciaAtendimento.GravarAgendamentos(Atd);
}
