private ActionResult ProcessarGravacaoDadosProfissional(
Profissional profissional, bool inclusao)
{
string CampoInconsistente = null;
string DescricaoInconsistencia = null;
if (ModelState.IsValid && !Profissional_BO
.ValidarDadosProfissional(profissional,
out CampoInconsistente,
out DescricaoInconsistencia))
{
ModelState.AddModelError(CampoInconsistente,
DescricaoInconsistencia);
}
if (!ModelState.IsValid)
{
ViewBag.Ocupacoes = Ocupacao_BO.ListarOcupacoes();
return(View(profissional));
}
if (inclusao)
{
Profissional_BO.IncluirDadosProfissional(profissional);
}
else
{
Profissional_BO.AtualizarDadosProfissional(profissional);
}
return(RedirectToAction("Index"));
}
public ActionResult Excluir(int id)
{
Profissional profissional =
Profissional_BO.ObterDadosProfissional(id);
return(View(profissional));
}
public void Editar(Profissional profissional)
{
try
{
_connection.Conexao.Open();
var sql = Resource.Profissional.Update;
var command = new SqlCommand(sql, _connection.Conexao);
command.Parameters.AddWithValue("@IdProfissional", profissional.IdProfissional);
command.Parameters.AddWithValue("@Nome", profissional.Nome);
command.Parameters.AddWithValue("@Nascimento", profissional.Nascimento);
command.Parameters.AddWithValue("@Numero", profissional.Numero);
command.Parameters.AddWithValue("@Status", EnumUtils <Status> .GetValue <string>(profissional.Status));
command.Parameters.AddWithValue("@Telefone", profissional.Telefone);
command.Parameters.AddWithValue("@Endereco", profissional.Endereco);
command.Parameters.AddWithValue("@Bairro", profissional.Bairro);
command.Parameters.AddWithValue("@Email", profissional.Email);
command.Parameters.AddWithValue("@Cidade", profissional.Cidade);
command.Parameters.AddWithValue("@Celular", profissional.Celular);
command.Parameters.ConvertToDbNull();
command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception("Ocorreu um erro ao Inserir o profissional", ex);
}
finally
{
_connection.Conexao.Close();
}
}
public async Task Deve_Adicionar_Nova_Entrada_De_Regra_No_Banco_Desenv()
{
//Arrange
IRepositorioDeRegras repo = TesteInfraService.ServiceProvider.GetService <IRepositorioDeRegras>();
Mock <IFavorecimento> favorecimentoMock = new Mock <IFavorecimento>();
favorecimentoMock.SetupAllProperties();
Profissional funcionario1 = new Profissional(1, null, "Fernando");
Profissional funcionario2 = new Profissional(2, null, "Bronze");
Profissional funcionario3 = new Profissional(3, null, "Cinco");
Profissional[] funcionarios = new Profissional[] { funcionario1, funcionario2, funcionario3 };
ParametrosDeRegraDeRemuneracao parametros = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 50, vigencia: new PeriodoSimples(new DateTime(2018, 05, 01), new DateTime(2018, 08, 24)));
RegraPorHora regraHora = null;//new RegraPorHora(parametros);
int idInserido;
//Act
idInserido = await repo.InserirAsync(regraHora);
throw new NotImplementedException();
//IRegraDeRemuneracao[] regraObtida = await repo.ObterAsync(new int[] { idInserido });
////Assert
//Assert.IsNotNull(regraObtida[0]);
//Assert.AreEqual(regraHora.Tipo, regraObtida[0].Tipo);
}
public async Task <ActionResult <Profissional> > Insert([FromServices] DataContext context, [FromBody] Profissional model)
{
try
{
if (ModelState.IsValid)
{
var pessoa = new Pessoa();
pessoa.Nome = model.Pessoa.Nome;
pessoa.Idade = model.Pessoa.Idade;
pessoa.Sexo = model.Pessoa.Sexo;
var profissional = new Profissional();
profissional.Funcao = model.Funcao;
profissional.Num_Carteira = model.Num_Carteira;
profissional.Pessoa = pessoa;
context.Profissionais.Add(model);
await context.SaveChangesAsync();
return(Ok(model));
}
else
{
throw new Exception("Não foi possivel inserir os Dados!");
}
}catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public override string Executar(object entidade)
{
Profissional user = (Profissional)entidade;
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
fachada.SalvaConexaoAtiva(this.conexao); // Manter conexão anterior
fachada.SalvaTransacaoAtiva(this.transacao); // Manter transação anterior
fachada.DefineTemQueFecharConexao(false); // Não fechar ao finalizar
IList <Profissional> codigoUsuarioRetonornado = fachada.Consultar(user);
if (codigoUsuarioRetonornado != null)
{
string retorna = "Usuário já cadastrado.";
return(retorna);
}
return(null);
}
public fDetalheProfissional(Profissional profissional)
: this()
{
_profissional = profissional;
MontaProfissional();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,Conselho,UserId,Biografia")] Profissional profissional)
{
if (id != profissional.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(profissional);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProfissionalExists(profissional.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(profissional));
}
public Profissional Create()
{
if (_dt == null)
{
return(null);
}
var profissional = new Profissional
{
IdProfissional = _dt.FieldExist(string.Concat(_nome, "IdProfissional")) ? _dt[string.Concat(_nome, "IdProfissional")].DefaultDbNull <int>(0) : 0,
Endereco = _dt.FieldExist(string.Concat(_nome, "Endereco")) ? _dt[string.Concat(_nome, "Endereco")].DefaultDbNull <string>(null) : string.Empty,
Bairro = _dt.FieldExist(string.Concat(_nome, "Bairro")) ? _dt[string.Concat(_nome, "Bairro")].DefaultDbNull <string>(null) : string.Empty,
Celular = _dt.FieldExist(string.Concat(_nome, "Celular")) ? _dt[string.Concat(_nome, "Celular")].DefaultDbNull <string>(null) : string.Empty,
Cidade = _dt.FieldExist(string.Concat(_nome, "Cidade")) ? _dt[string.Concat(_nome, "Cidade")].DefaultDbNull <string>(null) : string.Empty,
Nome = _dt.FieldExist(string.Concat(_nome, "Nome")) ? _dt[string.Concat(_nome, "Nome")].DefaultDbNull <string>(null) : string.Empty,
Numero = _dt.FieldExist(string.Concat(_nome, "Numero")) ? _dt[string.Concat(_nome, "Numero")].DefaultDbNull <string>(null) : string.Empty,
Telefone = _dt.FieldExist(string.Concat(_nome, "Telefone")) ? _dt[string.Concat(_nome, "Telefone")].DefaultDbNull <string>(null) : string.Empty,
Email = _dt.FieldExist(string.Concat(_nome, "Email")) ? _dt[string.Concat(_nome, "Email")].DefaultDbNull <string>(null) : string.Empty,
Nascimento = _dt.FieldExist(string.Concat(_nome, "Nascimento")) ? _dt[string.Concat(_nome, "Nascimento")].DefaultDbNull <DateTime?>(null) : null,
ParticipaAgenda = _dt.FieldExist(string.Concat(_nome, "ParticipaAgenda")) ? EnumUtils <SimNao> .FromValue(_dt[string.Concat(_nome, "ParticipaAgenda")].DefaultDbNull <string>(null)) : SimNao.Nao,
Status = _dt.FieldExist(string.Concat(_nome, "Status")) ? EnumUtils <Status> .FromValue(_dt[string.Concat(_nome, "Status")].DefaultDbNull <string>(null)) : Status.NaoInformado,
};
if (_objects != null)
{
}
return(profissional);
}
//Carrega agenda dp Paciente
public static DataTable gridCarregaAgenda(string _rh)
{
using (OdbcConnection cnn = new OdbcConnection(ConfigurationManager.ConnectionStrings["HospubConn"].ToString()))
{
OdbcCommand cmm = cnn.CreateCommand();
cmm.CommandText = "select am1106,am1101a, am1101b, am1101c, am1104, am1103 from am11 where am1110 = 1 and am1108 = " + _rh + " Order By am1106";
cnn.Open();
OdbcDataReader dr1 = cmm.ExecuteReader();
DataTable dt = new DataTable();
dt.Columns.Add("Data", System.Type.GetType("System.String"));
dt.Columns.Add("Consulta", System.Type.GetType("System.String"));
dt.Columns.Add("Especialidade", System.Type.GetType("System.String"));
dt.Columns.Add("Profissional", System.Type.GetType("System.String"));
while (dr1.Read())
{
string data = dr1.GetString(0);
int ano = Convert.ToInt32(data.Substring(0, 4));
int mes = Convert.ToInt32(data.Substring(4, 2));
int dia = Convert.ToInt32(data.Substring(6, 2));
data = dia + "/" + mes + "/" + ano;
string consulta = /* dr1.GetString(1) + */ dr1.GetString(2) + dr1.GetString(3);
string espec = dr1.GetString(4);
espec = Especialidade.getespec(espec);
string profissional = Profissional.getNome(dr1.GetString(5));
dt.Rows.Add(new String[] { data, consulta, espec, profissional });
}
return(dt);
}
}
public ActionResult ConsultarUsuario(string CodigoUsuario)
{
Profissional usuarioProcurado = new Profissional();
usuarioProcurado.Codigo = CodigoUsuario;
if (usuarioProcurado.Codigo == null || usuarioProcurado.Codigo.Trim() == "")
{
ViewBag.Mensagem = "Informe o código";
return(View("ConsultarUsuario"));
}
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
IList <Profissional> retorno = fachada.Consultar(usuarioProcurado);
if (retorno == null)
{
ViewBag.Message = "Usuário " + usuarioProcurado.Codigo + " não existe";
return(View("ConsultarUsuario"));
}
AlterarOuSalvarUsuarioView view = new AlterarOuSalvarUsuarioView();
view.PreencherDadosView(retorno[0]);
view.ActionDestino = "/Profissional/AlterarUsuario";
return(View("CadastrarUsuario", view));
}
public ViewResult FormUpdateProfissional(string id)
{
ProfissionalViewModel modelo = new ProfissionalViewModel();
modelo.profissional = new Profissional();
modelo.profissional.id = new Guid(id);
Profissional retorno = new Profissional();
if (!String.IsNullOrEmpty(id))
{
retorno = profissionalData.Get(modelo.profissional.id);
modelo.banco = sqlData.RetornaRelacaoBanco(retorno.idBanco);
if (retorno.idUsuario != null)
{
modelo.usuario = sqlData.RetornaRelacaoUsuario(retorno.idUsuario);
}
if (retorno != null)
{
modelo.profissional = retorno;
//apresenta mensagem de registro atualizado com sucesso
modelo.StatusMessage = StatusMessage;
}
}
return(View(modelo));
}
public static bool ProfissionalCreate(ProfissionalViewModel entrada, out Profissional profissional, ContextPage contexto)
{
profissional = new Profissional();
profissional = entrada.profissional;
SqlGeneric sqlservice = new SqlGeneric();
profissional.codigo = sqlservice.RetornaNovaPosicao(17, contexto.idOrganizacao);
profissional.idBanco = entrada.banco.id;
profissional.idUsuario = entrada.usuario.id;
if (profissional.idUsuario != null)
{
//************ Objetos de controle de acesso ******************
profissional.criadoEm = DateTime.Now;
profissional.criadoPor = contexto.idUsuario;
profissional.criadoPorName = contexto.nomeUsuario;
profissional.modificadoEm = DateTime.Now;
profissional.modificadoPor = contexto.idUsuario;
profissional.modificadoPorName = contexto.nomeUsuario;
profissional.idOrganizacao = contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
public ActionResult AlterarUsuario(AlterarOuSalvarUsuarioView dados)
{
#region Decidir se deve proseguir com a requisição
ActionResult urlRetorno = DecideUrlFormulários("/Profissional/AlterarUsuario", "ConsultarUsuario");
if (urlRetorno != null)
{
return(urlRetorno); // ação que deve ser retornada para o browser
}
#endregion
Profissional usuario = new Profissional();
usuario = dados.CriarModelo();
IFachada <Profissional> fachada = new FachadaAdmWeb <Profissional>();
string retorno = fachada.Alterar(usuario);
if (retorno != null)//se não retornar null, é porque ocorreu um erro de validação
{
ViewBag.Mensagem = retorno;
AlterarOuSalvarUsuarioView modelo = new AlterarOuSalvarUsuarioView();
modelo.PreencherDadosView(usuario);
dados.ActionDestino = "/Profissional/AlterarUsuario";
return(View("CadastrarUsuario", modelo));
}
ViewBag.Mensagem = "Alterado com sucesso!";
return(View("../Home/Index"));
}
public Profissional Recuperar(Profissional profissional)
{
try
{
var lista = new Profissional();
_connection.Conexao.Open();
var sql = Resource.Profissional.RecuperarLista;
var command = new SqlCommand(sql, _connection.Conexao);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
lista = new ProfissionalCreator(reader, "", null).Create();
}
}
return(lista);
}
catch (Exception ex)
{
throw new Exception("Ocorreu um erro ao RecuperarLista dos profissionais", ex);
}
finally
{
_connection.Conexao.Close();
}
}
private void ItemProfissional(Profissional prof)
{
NavigationParameters param = new NavigationParameters();
param.Add("profissional", prof);
_navigationService.NavigateAsync("DetalheProfissional", param);
}
public static void CriarMassaDados()
{
var realm = Realm.GetInstance();
var count = realm.All <Profissional>().Count();
if (count == 0)
{
realm.Write(() => {
for (int i = 0; i < 20; i++)
{
Profissional prof = new Profissional()
{
Nome = "Prof " + i, Descricao = "Descri " + i, Especialidade = "Especialidade " + i, Img = "http://designinspirador.com.br/wp-content/uploads/2017/02/imagem-de-perfil-1.jpg"
};
realm.Add <Profissional>(prof);
for (int j = 0; j < 3; j++)
{
Comentario coment = new Comentario()
{
profissional = prof, Autor = string.Format("Autor {0} {1}", i, j), Data = DateTimeOffset.Now, Descricao = string.Format("Descricao {0} {1}", i, j)
};
realm.Add <Comentario>(coment);
}
}
});
}
}
public void fullDataTest()
{
Profissional drGervasio = new Profissional("Gervasio", "10as20");
Servico servico1 = new Servico("tratamento x", 2, "antibioticos", 10, drGervasio);
Assert.AreEqual("tratamento x" + " " + "2 dias" + " " + "antibioticos" + " " + "10€" + " " + drGervasio.Nome, servico1.fullData(), "fullData output unexpected");
}
public static List <Comentario> GeradorComentarios(Profissional profissional)
{
return(new List <Comentario> {
new Comentario {
Autor = "Michael",
Id = 1,
Data = DateTime.Now,
Descricao = "blablabla blablabla",
Profi = profissional
},
new Comentario {
Autor = "Michael",
Id = 1,
Data = DateTime.Now,
Descricao = "blablabla blablabla",
Profi = profissional
},
new Comentario {
Autor = "Michael",
Id = 1,
Data = DateTime.Now,
Descricao = "blablabla blablabla",
Profi = profissional
},
new Comentario {
Autor = "Michael",
Id = 1,
Data = DateTime.Now,
Descricao = "blablabla blablabla",
Profi = profissional
}
});
}
public ActionResult Save(Profissional profissional) // recebemos um cliente
{
if (!ModelState.IsValid)
{
var viewModel = new ProfissionalFormViewModel
{
Profissional = profissional,
};
return(View("ProfissionalForm", viewModel));
}
if (profissional.Id == 0)
{
_context.Profissionais.Add(profissional);
}
else
{
var pacienteInDb = _context.Profissionais.Single(c => c.Id == profissional.Id);
pacienteInDb.Nome = profissional.Nome;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Profissional"));
}
public List <Servico> RecuperarListaPorProfissional(Profissional profissional)
{
try
{
var list = new List <Servico>();
_connection.Conexao.Open();
var sql = Resource.Servico.RecuperarServicosPorProfissional;
var command = new SqlCommand(sql, _connection.Conexao);
command.Parameters.AddWithValue("@IdProfissional", profissional.IdProfissional);
var reader = command.ExecuteReader();
while (reader.Read())
{
list.Add(new ServicoCreator(reader, "", null).Create());
}
return(list);
}
catch (Exception ex)
{
throw new Exception("Ocorreu um erro ao recuperar a lista de serviços do Profissional", ex);
}
finally
{
_connection.Conexao.Close();
}
}
public async Task <IActionResult> Edit(long id, [Bind("Nome,Cpf,DataNascimento,Profissao,Email,Telefone1,Telefone2,Telefone3,Cep,Rua,Numero,Complemento,Bairro,Cidade,Estado,Id,Criado,CriadoData,Modificado,ModificadoData")] Profissional profissional)
{
if (id != profissional.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(profissional);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProfissionalExists(profissional.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(profissional));
}
public IHttpActionResult DeleteProfissional(int id)
{
Profissional profissional = db.Profissional.Find(id);
if (profissional == null)
{
return(NotFound());
}
List <Profissional_Conhecimento> ProfissionalConhecimento = db.Profissional_Conhecimento.Where(x => x.Profissional_ID == profissional.ID).ToList();
foreach (var item in ProfissionalConhecimento)
{
db.Profissional_Conhecimento.Remove(item);
db.SaveChanges();
}
List <Proposta> ProfissionalProposta = db.Proposta.Where(x => x.Profissional_ID == profissional.ID).ToList();
foreach (var item in ProfissionalProposta)
{
db.Proposta.Remove(item);
db.SaveChanges();
}
db.Profissional.Remove(profissional);
db.SaveChanges();
return(Ok(profissional));
}
public bool ValidarDadosProfissional(
Profissional profissional,
out string CampoInconsistente,
out string DescricaoInconsistencia)
{
CampoInconsistente = null;
DescricaoInconsistencia = null;
if (!ValidarCPF(profissional.CPF))
{
CampoInconsistente = "CPF";
DescricaoInconsistencia = "CPF inválido.";
return(false);
}
if (DAO.CPFJaExistente(profissional.Id.HasValue ?
profissional.Id.Value : 0,
profissional.CPF))
{
CampoInconsistente = "CPF";
DescricaoInconsistencia =
"CPF já cadastrado anteriormente.";
return(false);
}
return(true);
}
public IHttpActionResult PutProfissional(int id, Profissional profissional)
{
if (profissional == null)
{
return(BadRequest(ModelState));
}
if (id != profissional.ID)
{
return(BadRequest());
}
db.Entry(profissional).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ProfissionalExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Favorecido(Profissional profissional, Categoria categoria, Periodo periodoDeFavorecimento)
{
Id = profissional.Id;
Profissional = profissional;
Categoria = categoria;
PeriodoDeFavorecimento = periodoDeFavorecimento;
}
public ActionResult Editar([Bind(Include = "Id,IdSalao,Nome,Telefone,Email")] Profissional profissional, HttpPostedFileBase image)
{
try
{
profissional.AlteradoEm = DateTime.Now;
TryUpdateModel(profissional);
if (ModelState.IsValid)
{
int id = _service.Gravar(profissional);
SetImage(image, id);
return(RedirectToAction("Index", new { idSalao = profissional.IdSalao }));
}
ViewBag.SalaoFantasia = profissional.Salao.Fantasia;
ViewBag.SalaoEndereco = string.Format("{0}, {1}", profissional.Salao.Endereco.Logradouro, profissional.Salao.Endereco.Numero);
ViewBag.Image = GetImage(profissional.Id);
return(View(profissional));
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
ViewBag.SalaoFantasia = profissional.Salao.Fantasia;
ViewBag.SalaoEndereco = string.Format("{0}, {1}", profissional.Salao.Endereco.Logradouro, profissional.Salao.Endereco.Numero);
ViewBag.Image = GetImage(profissional.Id);
return(View(profissional));
}
}
private void btGravar_Click(object sender, EventArgs e)
{
if (!Valida())
{
return;
}
var profissional = new Profissional()
{
Nome = txtNome.Text,
Nascimento = cboNascimento.Text != string.Empty ? cboNascimento.DateTime : (DateTime?)null,
Bairro = txtBairro.Text,
Celular = txtCelular.Text,
Cidade = txtCidade.Text,
Numero = txtNumero.Text,
Telefone = txtTelefone.Text,
Email = txtEmail.Text,
Endereco = txtEndereco.Text,
ParticipaAgenda = EnumUtils <SimNao> .FromDescription(cboAgenda.SelectedText)
};
if (_profissional == null)
{
_profissionalServSevico.Inserir(profissional);
}
else
{
profissional.IdProfissional = _profissional.IdProfissional;
_profissionalServSevico.Editar(profissional);
}
DialogResult = DialogResult.OK;
this.Close();
}
public void Deve_Remunerar_Linearmente_Proporcional_Ao_Percentual_Configurado_Para_a_Regra()
{
//Arrange
Random rnd = new Random();
decimal multiplicador = rnd.Next(0, 100) / 100.0M;
var valorHora = new Dinheiro(valor: 100M, moeda: Moeda.Real);
Mock <ITabelaDePreco <int> > tabelaMock = GeraTabelaMock(valorHora);
Profissional favorecido = LOMock.GeraProfissionalMock(id: 1, categoria: new Categoria(), nome: "LeMock");
IFavorecimento favorecimento = LOMock.GeraFavorecimentoMock(new[] { favorecido });
ParametrosDeRegraDeRemuneracao parametrosRegra1 = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 100);
ParametrosDeRegraDeRemuneracao parametrosRegra2 = LOMock.GeraParametrosDeRegraDeRemuneracaoPorHoraMock(percentual: 100 * multiplicador);
IRegraDeRemuneracao regra1 = LOMock.ConstroiRegraPorHora(parametrosRegra1, favorecimento, tabelaMock.Object);
IRegraDeRemuneracao regra2 = LOMock.ConstroiRegraPorHora(parametrosRegra2, favorecimento, tabelaMock.Object);
Mock <IHoraPreProcessada> entregaMock = ConfiguraMockEntregaRemuneravel(5, favorecido);
//Act
IEnumerable <IRemuneracao> remuneracoesA = regra1.CalculaRemuneracoes(new IEntregaPreProcessada[] { entregaMock.Object });
IEnumerable <IRemuneracao> remuneracoesB = regra2.CalculaRemuneracoes(new IEntregaPreProcessada[] { entregaMock.Object });
IEnumerator <IRemuneracao> enumeratorA = remuneracoesA.GetEnumerator();
IRemuneracao RemuneracaoA = remuneracoesA.First();
IEnumerator <IRemuneracao> enumeratorB = remuneracoesB.GetEnumerator();
IRemuneracao RemuneracaoB = remuneracoesB.First();
//Assert
Assert.AreEqual(multiplicador * RemuneracaoA.ValorAjustado.Valor, RemuneracaoB.ValorAjustado.Valor);
}
//INSERE UM NOVO REGISTRO OU ATUALIZA UM DETERMINDO REGISTRO JÁ EXISTENTE.
public void InsertUpdateProfissional(Profissional ObjProfissional)
{
try
{
string NomeProc;
Validacoes Valida = new Validacoes();
Database db = DatabaseFactory.CreateDatabase();
if (ObjProfissional.id != 0)
{
NomeProc = "ProfissionalUpdate";
}
else
{
NomeProc = "ProfissionalInsert";
}
DbCommand command = db.GetStoredProcCommand(NomeProc);
if (ObjProfissional.id != 0)
{
db.AddInParameter(command, "@ID", DbType.Int32, ObjProfissional.id);
}
db.AddInParameter(command, "@idTipoProfissional", DbType.String, ObjProfissional.idTipoProfissional);
db.AddInParameter(command, "@CPF", DbType.String, ObjProfissional.CPF);
db.AddInParameter(command, "@RG", DbType.String, Valida.TextoNull(ObjProfissional.RG));
db.AddInParameter(command, "@idOrgaoExpeditor", DbType.Int32, Valida.TextoNull(ObjProfissional.idOrgaoExpeditor));
db.AddInParameter(command, "@DtExpedicao", DbType.Date, ObjProfissional.DtExpedicao);
db.AddInParameter(command, "@RgUFemissao", DbType.String, Valida.TextoNull(ObjProfissional.RgUFemissao));
db.AddInParameter(command, "@Nome", DbType.String, Valida.TextoNull(ObjProfissional.Nome));
db.AddInParameter(command, "@DtNascimento", DbType.Date, Valida.TextoNull(ObjProfissional.DtNascimento));
db.AddInParameter(command, "@Sexo", DbType.String, Valida.TextoNull(ObjProfissional.Sexo));
db.AddInParameter(command, "@Email", DbType.String, Valida.TextoNull(ObjProfissional.Email));
db.AddInParameter(command, "@EstadoCivil", DbType.String, Valida.TextoNull(ObjProfissional.EstadoCivil));
db.AddInParameter(command, "@EndResidencia", DbType.String, Valida.TextoNull(ObjProfissional.EndResidencia));
db.AddInParameter(command, "@Numero", DbType.String, Valida.TextoNull(ObjProfissional.Numero));
db.AddInParameter(command, "@Complemento", DbType.String, Valida.TextoNull(ObjProfissional.Complemento));
db.AddInParameter(command, "@Bairro", DbType.String, Valida.TextoNull(ObjProfissional.Bairro));
db.AddInParameter(command, "@CEP", DbType.String, Valida.TextoNull(ObjProfissional.CEP));
db.AddInParameter(command, "@Cidade", DbType.String, Valida.TextoNull(ObjProfissional.Cidade));
db.AddInParameter(command, "@UF", DbType.String, Valida.TextoNull(ObjProfissional.UF));
db.AddInParameter(command, "@DDDtel", DbType.String, Valida.TextoNull(ObjProfissional.DDDtel));
db.AddInParameter(command, "@Telefone", DbType.String, Valida.TextoNull(ObjProfissional.Telefone));
db.AddInParameter(command, "@DDDcel", DbType.String, Valida.TextoNull(ObjProfissional.DDDcel));
db.AddInParameter(command, "@Celular", DbType.String, Valida.TextoNull(ObjProfissional.Celular));
db.AddInParameter(command, "@ConselhoProfissional", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoProfissional));
db.AddInParameter(command, "@ConselhoNumero", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoNumero));
db.AddInParameter(command, "@ConselhoUF", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoUF));
db.AddInParameter(command, "@CBOS_1", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_1));
db.AddInParameter(command, "@CBOS_2", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_2));
db.AddInParameter(command, "@CBOS_3", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_3));
db.AddInParameter(command, "@CBOS_4", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_4));
db.AddInParameter(command, "@CBOS_5", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_5));
db.AddInParameter(command, "@CBOS_6", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_6));
db.ExecuteNonQuery(command);
}
catch (Exception e)
{
throw e;
}
}
public void SalvaDados(Profissional ObjProfissional)
{
try
{
ProfissionalDAL ObjProfissionalDAL = new ProfissionalDAL();
ObjProfissionalDAL.InsertUpdateProfissional(ObjProfissional);
}
catch(Exception ex)
{
throw ex;
}
}
protected void BtnSalvar_Click(object sender, EventArgs e)
{
try
{
Profissional ObjProfissional = new Profissional();
Validacoes Valida = new Validacoes();
ObjProfissional.id = Convert.ToInt32(Request.QueryString["idProfissional"]);
ObjProfissional.idTipoProfissional = Valida.TextoNull(ddlTipoProfissional.ValorInformado);
ObjProfissional.CPF = Valida.TextoNull(txtCPF.Text);
ObjProfissional.RG = Valida.TextoNull(txtRG.Text);
ObjProfissional.DtExpedicao = Valida.TextoNull(txtDtExpedicao.Text);
ObjProfissional.RgUFemissao = Valida.TextoNull(ddlRgUFemissao.ValorInformado);
ObjProfissional.idOrgaoExpeditor = Valida.TextoNull(ddlOrgaoExpeditor.Text);
ObjProfissional.Nome = Valida.TextoNull(txtNome.Text);
ObjProfissional.DtNascimento = Valida.TextoNull(txtDtNascimento.Text);
ObjProfissional.Sexo = Valida.TextoNull(ddlSexo.Text);
ObjProfissional.EstadoCivil = Valida.TextoNull(ddlEstadoCivil.Text);
ObjProfissional.EndResidencia = Valida.TextoNull(txtEndResidencia.Text);
ObjProfissional.Numero = Valida.TextoNull(txtNumero.Text);
ObjProfissional.Complemento = Valida.TextoNull(txtComplemento.Text);
ObjProfissional.Cidade = Valida.TextoNull(txtCidade.Text);
ObjProfissional.Bairro = Valida.TextoNull(txtBairro.Text);
ObjProfissional.UF = Valida.TextoNull(ddlEstados.ValorInformado);
ObjProfissional.CEP = Valida.TextoNull(txtCEP.Text);
ObjProfissional.DDDtel = Valida.TextoNull(txtDDDtel.Text);
ObjProfissional.Telefone = Valida.TextoNull(txtTelefone.Text);
ObjProfissional.DDDcel = Valida.TextoNull(txtDDDcel.Text);
ObjProfissional.Celular = Valida.TextoNull(txtCelular.Text);
ObjProfissional.Email = Valida.TextoNull(txtEmail.Text);
ObjProfissional.ConselhoProfissional = Valida.TextoNull(ddlConselhoProfissional.ValorInformado);
ObjProfissional.ConselhoNumero = Valida.TextoNull(txtConselhoNumero.Text);
ObjProfissional.ConselhoUF = Valida.TextoNull(ddlConselhoUF.ValorInformado);
ObjProfissional.CBOS_1 = Valida.TextoNull(ddlCBOS_1.ValorInformado);
ObjProfissional.CBOS_2 = Valida.TextoNull(ddlCBOS_2.ValorInformado);
ObjProfissional.CBOS_3 = Valida.TextoNull(ddlCBOS_3.ValorInformado);
ObjProfissional.CBOS_4 = Valida.TextoNull(ddlCBOS_4.ValorInformado);
ObjProfissional.CBOS_5 = Valida.TextoNull(ddlCBOS_5.ValorInformado);
ObjProfissional.CBOS_6 = Valida.TextoNull(ddlCBOS_6.ValorInformado);
ProfissionalBO ObjProfissionalBO = new ProfissionalBO();
ObjProfissionalBO.SalvaDados(ObjProfissional);
}
catch (Exception erro)
{
Response.Write(erro);
Response.End();
}
Response.Redirect("ProfissionalPrincipal.aspx");
}
//INSERE UM NOVO REGISTRO OU ATUALIZA UM DETERMINDO REGISTRO JÁ EXISTENTE.
public void InsertUpdateProfissional(Profissional ObjProfissional)
{
try
{
string NomeProc;
Validacoes Valida = new Validacoes();
Database db = DatabaseFactory.CreateDatabase();
if (ObjProfissional.id != 0) { NomeProc = "ProfissionalUpdate"; } else { NomeProc = "ProfissionalInsert"; }
DbCommand command = db.GetStoredProcCommand(NomeProc);
if (ObjProfissional.id != 0) { db.AddInParameter(command, "@ID", DbType.Int32, ObjProfissional.id); }
db.AddInParameter(command, "@idTipoProfissional", DbType.String, ObjProfissional.idTipoProfissional);
db.AddInParameter(command, "@CPF", DbType.String, ObjProfissional.CPF);
db.AddInParameter(command, "@RG", DbType.String, Valida.TextoNull(ObjProfissional.RG));
db.AddInParameter(command, "@idOrgaoExpeditor", DbType.Int32, Valida.TextoNull(ObjProfissional.idOrgaoExpeditor));
db.AddInParameter(command, "@DtExpedicao", DbType.Date, ObjProfissional.DtExpedicao);
db.AddInParameter(command, "@RgUFemissao", DbType.String, Valida.TextoNull(ObjProfissional.RgUFemissao));
db.AddInParameter(command, "@Nome", DbType.String, Valida.TextoNull(ObjProfissional.Nome));
db.AddInParameter(command, "@DtNascimento", DbType.Date, Valida.TextoNull(ObjProfissional.DtNascimento));
db.AddInParameter(command, "@Sexo", DbType.String, Valida.TextoNull(ObjProfissional.Sexo));
db.AddInParameter(command, "@Email", DbType.String, Valida.TextoNull(ObjProfissional.Email));
db.AddInParameter(command, "@EstadoCivil", DbType.String, Valida.TextoNull(ObjProfissional.EstadoCivil));
db.AddInParameter(command, "@EndResidencia", DbType.String, Valida.TextoNull(ObjProfissional.EndResidencia));
db.AddInParameter(command, "@Numero", DbType.String, Valida.TextoNull(ObjProfissional.Numero));
db.AddInParameter(command, "@Complemento", DbType.String, Valida.TextoNull(ObjProfissional.Complemento));
db.AddInParameter(command, "@Bairro", DbType.String, Valida.TextoNull(ObjProfissional.Bairro));
db.AddInParameter(command, "@CEP", DbType.String, Valida.TextoNull(ObjProfissional.CEP));
db.AddInParameter(command, "@Cidade", DbType.String, Valida.TextoNull(ObjProfissional.Cidade));
db.AddInParameter(command, "@UF", DbType.String, Valida.TextoNull(ObjProfissional.UF));
db.AddInParameter(command, "@DDDtel", DbType.String, Valida.TextoNull(ObjProfissional.DDDtel));
db.AddInParameter(command, "@Telefone", DbType.String, Valida.TextoNull(ObjProfissional.Telefone));
db.AddInParameter(command, "@DDDcel", DbType.String, Valida.TextoNull(ObjProfissional.DDDcel));
db.AddInParameter(command, "@Celular", DbType.String, Valida.TextoNull(ObjProfissional.Celular));
db.AddInParameter(command, "@ConselhoProfissional", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoProfissional));
db.AddInParameter(command, "@ConselhoNumero", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoNumero));
db.AddInParameter(command, "@ConselhoUF", DbType.String, Valida.TextoNull(ObjProfissional.ConselhoUF));
db.AddInParameter(command, "@CBOS_1", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_1));
db.AddInParameter(command, "@CBOS_2", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_2));
db.AddInParameter(command, "@CBOS_3", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_3));
db.AddInParameter(command, "@CBOS_4", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_4));
db.AddInParameter(command, "@CBOS_5", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_5));
db.AddInParameter(command, "@CBOS_6", DbType.String, Valida.TextoNull(ObjProfissional.CBOS_6));
db.ExecuteNonQuery(command);
}
catch (Exception e)
{
throw e;
}
}
//CARREGA OS REGISTROS PARA EDIÇÃO
public void CarregaDadosProfissionais()
{
try
{
Profissional ObjProfissional = new Profissional();
ProfissionalBO ObjProfissionalBO = new ProfissionalBO();
Validacoes Valida = new Validacoes();
ObjProfissional = ObjProfissionalBO.CarregaProfissional(Convert.ToInt32(Request.QueryString["idProfissional"])) as Profissional;
ddlTipoProfissional.ValorInformado = Valida.TextoNull(Convert.ToString(ObjProfissional.idTipoProfissional));
txtCPF.Text = ObjProfissional.CPF;
txtRG.Text = ObjProfissional.RG;
txtDtExpedicao.Text = ObjProfissional.DtExpedicao;
ddlRgUFemissao.ValorInformado = ObjProfissional.RgUFemissao;
ddlOrgaoExpeditor.Text = Valida.TextoNull(ObjProfissional.idOrgaoExpeditor);
txtNome.Text = ObjProfissional.Nome;
txtDtNascimento.Text = ObjProfissional.DtNascimento;
ddlSexo.Text = ObjProfissional.Sexo;
ddlEstadoCivil.Text = ObjProfissional.EstadoCivil;
txtEndResidencia.Text = ObjProfissional.EndResidencia;
txtNumero.Text = ObjProfissional.Numero;
txtComplemento.Text = ObjProfissional.Complemento;
txtCidade.Text = ObjProfissional.Cidade;
txtBairro.Text = ObjProfissional.Bairro;
ddlEstados.ValorInformado = ObjProfissional.UF;
txtCEP.Text = ObjProfissional.CEP;
txtDDDtel.Text = ObjProfissional.DDDtel;
txtTelefone.Text = ObjProfissional.Telefone;
txtDDDcel.Text = ObjProfissional.DDDcel;
txtCelular.Text = ObjProfissional.Celular;
txtEmail.Text = ObjProfissional.Email;
ddlConselhoProfissional.ValorInformado = ObjProfissional.ConselhoProfissional;
txtConselhoNumero.Text = ObjProfissional.ConselhoNumero;
ddlConselhoUF.ValorInformado = ObjProfissional.ConselhoUF;
ddlCBOS_1.ValorInformado = ObjProfissional.CBOS_1;
ddlCBOS_2.ValorInformado = ObjProfissional.CBOS_2;
ddlCBOS_3.ValorInformado = ObjProfissional.CBOS_3;
ddlCBOS_4.ValorInformado = ObjProfissional.CBOS_4;
ddlCBOS_5.ValorInformado = ObjProfissional.CBOS_5;
ddlCBOS_6.ValorInformado = ObjProfissional.CBOS_6;
}
catch (Exception erro)
{
Response.Write(erro);
Response.End();
}
}
//SELECIONA UM DETERMINADO REGISTRO PARA ALTERAÇÃO DE DADOS.
public object SelectProfissionalByID(int idProfissional)
{
try
{
Database db = DatabaseFactory.CreateDatabase();
DbCommand command = db.GetStoredProcCommand("ProfissionalSelectByID");
db.AddInParameter(command, "@id", DbType.Int32, idProfissional);
using (IDataReader dr = db.ExecuteReader(command))
{
Profissional ObjProfissional = new Profissional();
if (dr.Read())
{
Validacoes ObjValidacoes = new Validacoes();
ObjProfissional.idTipoProfissional = Convert.ToString(dr["idTipoProfissional"]);
ObjProfissional.CPF = Convert.ToString(dr["CPF"]);
ObjProfissional.RG = Convert.ToString(dr["RG"]);
ObjProfissional.idOrgaoExpeditor = Convert.ToString(dr["idOrgaoExpeditor"]);
ObjProfissional.DtExpedicao = Convert.ToString(dr["DtExpedicao"]);
ObjProfissional.RgUFemissao = Convert.ToString(dr["RgUFemissao"]);
ObjProfissional.Nome = Convert.ToString(dr["Nome"]);
ObjProfissional.DtNascimento = Convert.ToString(dr["DtNascimento"]);
ObjProfissional.Sexo = Convert.ToString(dr["Sexo"]);
ObjProfissional.Email = Convert.ToString(dr["Email"]);
ObjProfissional.EstadoCivil = Convert.ToString(dr["EstadoCivil"]);
ObjProfissional.EndResidencia = Convert.ToString(dr["EndResidencia"]);
ObjProfissional.Numero = Convert.ToString(dr["Numero"]);
ObjProfissional.Complemento = Convert.ToString(dr["Complemento"]);
ObjProfissional.Bairro = Convert.ToString(dr["Bairro"]);
ObjProfissional.CEP = Convert.ToString(dr["CEP"]);
ObjProfissional.Cidade = Convert.ToString(dr["Cidade"]);
ObjProfissional.UF = Convert.ToString(dr["UF"]);
ObjProfissional.DDDtel = Convert.ToString(dr["DDDtel"]);
ObjProfissional.Telefone = Convert.ToString(dr["Telefone"]);
ObjProfissional.DDDcel = Convert.ToString(dr["DDDcel"]);
ObjProfissional.Celular = Convert.ToString(dr["Celular"]);
ObjProfissional.ConselhoProfissional = ObjValidacoes.TextoNull(Convert.ToString(dr["ConselhoProfissional"]));
ObjProfissional.ConselhoNumero = Convert.ToString(dr["ConselhoNumero"]);
ObjProfissional.ConselhoUF = Convert.ToString(dr["ConselhoUF"]);
ObjProfissional.CBOS_1 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_1"]));
ObjProfissional.CBOS_2 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_2"]));
ObjProfissional.CBOS_3 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_3"]));
ObjProfissional.CBOS_4 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_4"]));
ObjProfissional.CBOS_5 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_5"]));
ObjProfissional.CBOS_6 = ObjValidacoes.TextoNull(Convert.ToString(dr["CBOS_6"]));
}
return ObjProfissional;
}
}
catch (Exception ex)
{
throw ex;
}
}
