/// <summary>
/// Metodo responsavel por consultar um HistoricoDependente.
/// </summary>
/// <param name="id">Id a ser consultado.</param>
/// <returns>retorna um HistoricoDependente com o Id informado.</returns>
public HistoricoDependente Consultar(int id)
{
UtilBD banco = new UtilBD();
SqlConnection conexao = banco.ObterConexao();
HistoricoDependente historicoDependente = null;
try
{
SqlCommand comando = new SqlCommand(QUERY_SELECT_ID, conexao);
SqlDataReader resultado;
comando.Parameters.AddWithValue("@Id", id);
conexao.Open();
resultado = comando.ExecuteReader();
resultado.Read();
if (resultado.HasRows)
{
historicoDependente = this.CriarHistoricoDependente(resultado);
}
resultado.Close();
}
catch (SqlException e)
{
throw new ErroBanco(e.Message);
}
finally
{
banco.FecharConexao(conexao);
}
return(historicoDependente);
}
/// <summary>
/// Metodo responsavel por inserir um HistoricoDependente.
/// </summary>
/// <param name="historicoDependente">Objeto do tipo HistoricoDependente a ser inserido</param>
/// <returns>retorna o HistoricoDependente inserido.</returns>
public HistoricoDependente Inserir(HistoricoDependente historicoDependente)
{
UtilBD banco = new UtilBD();
SqlConnection conexao = banco.ObterConexao();
try
{
SqlCommand comando = new SqlCommand(QUERY_INSERT, conexao);
comando.Parameters.AddWithValue("@DataNascimento", historicoDependente.DependenteHistorico.DataNascimento);
comando.Parameters.AddWithValue("@Nome", historicoDependente.DependenteHistorico.Nome);
comando.Parameters.AddWithValue("@Parentesco", historicoDependente.DependenteHistorico.Parentesco);
comando.Parameters.AddWithValue("@Religiao", historicoDependente.DependenteHistorico.Religiao);
comando.Parameters.AddWithValue("@Status", (int)historicoDependente.DependenteHistorico.Status);
comando.Parameters.AddWithValue("@PercentualCobertura", historicoDependente.DependenteHistorico.PercentualCobertura);
comando.Parameters.AddWithValue("@TitularId", historicoDependente.DependenteHistorico.TitularId);
comando.Parameters.AddWithValue("@DependenteId", historicoDependente.Dependente.Id);
comando.Parameters.AddWithValue("@DataAlteracao", historicoDependente.DataAlteracao);
comando.Parameters.AddWithValue("@UsuarioId", historicoDependente.Usuario.Id);
comando.Parameters.AddWithValue("@Descricao", historicoDependente.Descricao);
conexao.Open();
int regitrosAfetados = comando.ExecuteNonQuery();
// historicoDependente.DependenteHistorico.Id = this.ObterMaximoId();
}
catch (SqlException e)
{
throw new ErroBanco(e.Message);
}
finally
{
banco.FecharConexao(conexao);
}
return(historicoDependente);
}
/// <summary>
/// Metodo para montar um HistoricoDependente recebendo um SqlDataReader como parametro.
/// </summary>
/// <param name="resultado">SqlDataReader</param>
/// <returns>Retorna um HistoricoDependente</returns>
private HistoricoDependente CriarHistoricoDependente(SqlDataReader resultado)
{
HistoricoDependente historicoDependente = new HistoricoDependente();
if (resultado["Id"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.Id = Convert.ToInt32(resultado["Id"]);
}
if (resultado["DataNascimento"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.DataNascimento = Convert.ToDateTime(resultado["DataNascimento"]);
}
if (resultado["Nome"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.Nome = Convert.ToString(resultado["Nome"]);
}
if (resultado["Status"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.Status = (StatusControle)Convert.ToInt32(resultado["Status"]);
}
if (resultado["Parentesco"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.Parentesco = Convert.ToString(resultado["Parentesco"]);
}
if (resultado["PercentualCobertura"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.PercentualCobertura = Convert.ToInt32(resultado["PercentualCobertura"]);
}
if (resultado["Religiao"] != DBNull.Value)
{
historicoDependente.DependenteHistorico.Religiao = Convert.ToString(resultado["Religiao"]);
}
if (resultado["DependenteId"] != DBNull.Value)
{
historicoDependente.Dependente.Id = Convert.ToInt32(resultado["DependenteId"]);
}
if (resultado["TitularId"] != DBNull.Value)
{
historicoDependente.Dependente.TitularId = Convert.ToInt32(resultado["TitularId"]);
}
if (resultado["DataAlteracao"] != DBNull.Value)
{
historicoDependente.DataAlteracao = Convert.ToDateTime(resultado["DataAlteracao"]);
}
if (resultado["UsuarioId"] != DBNull.Value)
{
historicoDependente.Usuario.Id = Convert.ToInt32(resultado["UsuarioId"]);
}
if (resultado["Descricao"] != DBNull.Value)
{
historicoDependente.Descricao = Convert.ToString(resultado["Descricao"]);
}
return(historicoDependente);
}
/// <summary>
/// Metodo responsavel por alterar um Dependente.
/// </summary>
/// <param name="dependente">Objeto do tipo Dependente a ser alterado</param>
/// <param name="TitularId">Id do Titular do Dependente.</param>
/// <exception cref="ExecaoNegocio">Lançara a ExecaoNegocio caso o objeto seja nulo ou o Dependente não seja encontrado.</exception>
public void Alterar(Dependente dependente, Usuario usuario)
{
Dependente dependenteAntigo = this.Consultar(dependente.Id);
if (dependenteAntigo != null && dependente != null)
this.repDependente.Alterar(dependente);
else
throw new ExcecaoNegocio("Dependente não existente.");
HistoricoDependente hd = new HistoricoDependente();
hd.DataAlteracao = new DateTime();
hd.DataAlteracao = DateTime.Now;
hd.Usuario = usuario;
string descricao = "Alterado\n";
if (dependenteAntigo.DataNascimento != dependente.DataNascimento)
{
descricao += "Data de Nascimento\n";
}
if (dependenteAntigo.Nome != dependente.Nome)
{
descricao += "Nome\n";
}
if (dependenteAntigo.Parentesco != dependente.Parentesco)
{
descricao += "Parentesco\n";
}
if (dependenteAntigo.PercentualCobertura != dependente.PercentualCobertura)
{
descricao += "Percentual de Cobertura\n";
}
if (dependenteAntigo.Religiao != dependente.Religiao)
{
descricao += "Religiao\n";
}
if (dependenteAntigo.Status != dependente.Status)
{
descricao += "Status\n";
}
hd.Descricao = descricao;
hd.DependenteHistorico = dependente;
hd.Dependente = dependente;
this.InserirHistorico(hd);
}
/// <summary>
/// Metodo responsavel por inserir um Dependente.
/// </summary>
/// <param name="dependente">Objeto do tipo Dependente a ser inserido</param>
/// <param name="TitularId">Id do Titular do Dependente.</param>
/// <exception cref="ExecaoNegocio">Lançara a ExecaoNegocio caso o objeto seja nulo.</exception>
/// <returns>retorna o Dependente inserido.</returns>
public Dependente Inserir(Dependente dependente, Usuario usuario)
{
if (dependente == null)
throw new ExcecaoNegocio("Valor Inválido.");
Dependente d = this.repDependente.Inserir(dependente);
HistoricoDependente hd = new HistoricoDependente();
hd.DataAlteracao = new DateTime();
hd.DataAlteracao = DateTime.Now;
hd.Usuario = usuario;
hd.Descricao = "Inserido";
hd.DependenteHistorico = d;
hd.Dependente = d;
this.InserirHistorico(hd);
return d;
}
/// <summary>
/// Metodo responsavel por inserir um HistoricoDependente.
/// </summary>
/// <param name="historicoDependente">Objeto do tipo HistoricoDependente a ser inserido</param>
/// <param name="TitularId">Id do Titular do HistoricoDependente.</param>
/// <returns>retorna o HistoricoDependente inserido.</returns>
public HistoricoDependente InserirHistorico(HistoricoDependente historicoDependente)
{
return this.repHistoricoDependente.Inserir(historicoDependente);
}
