public static Boolean ValidarCorreoUsuario(string correo_usuario)
{
BDConexion laConexion;
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
laConexion = new BDConexion();
parametros = new List<Parametro>();
List<String> elCorreo = new List<String>();
elParametro = new Parametro(RecursosBDModulo1.aliasCorreoUsuario, SqlDbType.VarChar, correo_usuario, false);
parametros.Add(elParametro);
DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
RecursosBDModulo1.ValidarCorreo, parametros);
foreach (DataRow row in dt.Rows)
{
elCorreo.Add(row[RecursosBDModulo1.aliasCorreoUsuario].ToString());
}
bool respuesta = false;
if (elCorreo.Count == 1)
respuesta = true;
else if (elCorreo.Count > 1)
throw new Exception(RecursosBDModulo1.exceptionCorreoMasUno);
return respuesta;
}
catch (Exception e)
{
throw e;
}
}
public Usuario buscar(String pNombreUsuario)
{
Usuario tmpUsuario = new Usuario();
try
{
String cmdText;
cmdText = "SELECT usuario,nombre,apellido1,apellido2 FROM usuarios WHERE usuario = valor01";
Parametro tmpParametro;
List<Parametro> parametros;
parametros = new List<Parametro>();
tmpParametro = new Parametro("valor01", pNombreUsuario);
parametros.Add(tmpParametro);
DaoObject.crearConexion(Properties.Resources.conexionStr);
SqlDataReader reader = DaoObject.accesoDatos.ejecutarSelect(cmdText, parametros, CommandBehavior.Default);
//recorror el data reader para ir creando las estructuras y agregarlas a la coleccion
while (reader.Read())
{
tmpUsuario.nombre = reader.GetValue(1).ToString();
tmpUsuario.apellido = reader.GetValue(2).ToString();
tmpUsuario.sApellido = reader.GetValue(3).ToString();
tmpUsuario.usuario = reader.GetValue(0).ToString();
}
reader.Close();
// accesoDatos.cerrarReader();
DaoObject.accesoDatos.cerrarConexion();
return tmpUsuario;
}
catch (SqlException e)
{
throw e;
}
}
/// <summary>
/// Método para consultar el detalle de una persona
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion detallada de una persona</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
PersonaM7 idPersona = (PersonaM7)parametro;
PersonaM7 persona;
try
{
if (idPersona.Id> 0)
{
parametros = new List<Parametro>();
persona = (PersonaM7)FabricaEntidades.ObtenerPersonaM7();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdUsuarioLogueado, SqlDbType.Int, idPersona.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultaPersonaXId, parametros);
foreach (DataRow row in dt.Rows)
{
persona.Nombre = row[RecursosDAOModulo7.AliasPersonaNombre].ToString();
persona.Apellido = row[RecursosDAOModulo7.AliasPersonaApellido].ToString();
persona.FechaNacimiento = DateTime.Parse(row[RecursosDAOModulo7.AliasPersonaFechaNacimiento].ToString());
persona.Direccion = row[RecursosDAOModulo7.AliasPersonaDireccion].ToString();
persona.DojoPersona = int.Parse(row[RecursosDAOModulo7.AliasPersonaDojoId].ToString());
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return persona;
}
public void insertarUsuario(Usuario pUsuario)
{
try
{
String cmdText;
cmdText = "INSERT INTO usuarios(nombre,apellido1,apellido2,usuario) VALUES(valor01,valor02,valor03,valor04)";
DaoObject.crearConexion(Properties.Resources.conexionStr);
Parametro tmpParametro;
List<Parametro> parametros;
parametros = new List<Parametro>();
tmpParametro = new Parametro("valor01", pUsuario.nombre);
parametros.Add(tmpParametro);
tmpParametro = new Parametro("valor02", pUsuario.apellido);
parametros.Add(tmpParametro);
tmpParametro = new Parametro("valor03", pUsuario.sApellido);
parametros.Add(tmpParametro);
tmpParametro = new Parametro("valor04", pUsuario.usuario);
parametros.Add(tmpParametro);
DaoObject.accesoDatos.ejecutar(cmdText, parametros);
DaoObject.accesoDatos.cerrarConexion();
}
catch (SqlException e)
{
throw e;
}
}
public static bool RestablecerContrasena(string usuarioId,string contraseña)
{
BDConexion laConexion;
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
laConexion = new BDConexion();
parametros = new List<Parametro>();
Cuenta laCuenta = new Cuenta();
elParametro = new Parametro(RecursosBDModulo1.AliasIdUsuario, SqlDbType.Int, usuarioId, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDModulo1.AliasContrasena, SqlDbType.VarChar,contraseña, false);
parametros.Add(elParametro);
laConexion.EjecutarStoredProcedureTuplas(
RecursosBDModulo1.CambiarContraseña, parametros);
return true;
}
catch (Exception e)
{
throw e;
}
}
public static List<Rol> consultarRolesUsuario(string idUsuario)
{
BDConexion laConexion;
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
laConexion = new BDConexion();
parametros = new List<Parametro>();
List<Rol> losRoles = new List<Rol>();
elParametro = new Parametro(RecursosBDModulo2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
parametros.Add(elParametro);
DataTable dt= laConexion.EjecutarStoredProcedureTuplas(RecursosBDModulo2.ConsultarRolesUsuario, parametros);
foreach (DataRow row in dt.Rows)
{
Rol rol = new Rol();
rol.Id_rol = int.Parse(row[RecursosBDModulo2.AliasIdRol].ToString());
rol.Descripcion = row[RecursosBDModulo2.AliasDescripcionRol].ToString();
rol.Nombre = row[RecursosBDModulo2.AliasNombreRol].ToString();
rol.Fecha_creacion = (DateTime)row[RecursosBDModulo2.aliasFechaCreacion];
losRoles.Add(rol);
}
return losRoles;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Implementación del método de la interfaz.
/// </summary>
public void saveResultado(Gestion gestion, Parametro tipo, string descripcion, DateTime fecha, Persona titular, Contacto contacto)
{
if (gestion != null) {
// Primero graba y actualiza algunas cosas
try {
long scn = Persistencia.Controlador.iniciarTransaccion();
gestion.FechaInicio = fecha;
gestion.Resultado = tipo;
gestion.ResultadoDesc = descripcion;
gestion.Contactado = titular;
gestion.Contacto = contacto;
gestion.Usuario = Sistema.Controlador.SecurityService.getUsuario();
gestion.Estado = _finalizada;
gestion.Cuenta.agregarGestion(gestion);
gestion.FechaCierre = DateTime.Now;
gestion.save();
Persistencia.Controlador.commitTransaccion(scn);
} catch (Exception e) {
Persistencia.Controlador.rollbackTransaccion();
throw new DataErrorException("DATA-SAVENOK", e.ToString());
}
// Finalmente ejecuta el resultado y finaliza la gestion
try {
ResultadoGestion.EjecutarResultado(gestion, gestion.Resultado);
gestion.save();
} catch (Exception e) {
throw new DataErrorException("ERROR-EJECUTAR-RESULTADO", e.ToString());
}
}
}
/// <summary>
/// Método para consultar el detalle de una cinta
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion de la cinta</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
CintaM7 idCinta = (CintaM7)parametro;
CintaM7 cinta = (CintaM7)FabricaEntidades.ObtenerCintaM7();
try
{
if (idCinta.Id > 0)
{
parametros = new List<Parametro>();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdCinta, SqlDbType.Int, idCinta.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultarCintaXId, parametros);
foreach (DataRow row in dt.Rows)
{
cinta.Id = int.Parse(row[RecursosDAOModulo7.AliasIdCinta].ToString());
cinta.Color_nombre = row[RecursosDAOModulo7.AliasCintaNombre].ToString();
cinta.Rango = row[RecursosDAOModulo7.AliasCintaRango].ToString();
cinta.Clasificacion = row[RecursosDAOModulo7.AliasCintaClasificacion].ToString();
cinta.Significado = row[RecursosDAOModulo7.AliasCintaSignificado].ToString();
cinta.Orden = int.Parse(row[RecursosDAOModulo7.AliasCintaOrden].ToString());
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return cinta;
}
/// <summary>
/// Se hace la conexion a la base de datos para Agregar un rol al usuario
/// </summary>
/// <param name="idUsuario">id del usuario que se le Agregar el rol</param>
/// <param name="idRol">id del rol a Agregar</param>
/// <returns> true si se pudo Agregar false si no se pudo Agregar el rol</returns>
public bool AgregarRol(string idUsuario, string idRol)
{
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
parametros = new List<Parametro>();
elParametro = new Parametro(RecursosBDM2.AliasIdRol, SqlDbType.VarChar, idRol, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDM2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
parametros.Add(elParametro);
this.EjecutarStoredProcedureTuplas(RecursosBDM2.AgregarRolProcedure, parametros);
return true;
}
catch (SqlException e)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, e);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
{
throw e;
}
catch (Exception e)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
}
}
/// <summary>
/// Método para consultar el detalle de una organizacion
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion detallada de una organizacion</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
OrganizacionM7 idOrganizacion = (OrganizacionM7)parametro;
OrganizacionM7 organizacion;
try
{
if (idOrganizacion.Id > 0)
{
parametros = new List<Parametro>();
organizacion = (OrganizacionM7)FabricaEntidades.ObtenerOrganizacionM7();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdOrganizacion, SqlDbType.Int, idOrganizacion.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultaOrganizacionXId, parametros);
foreach (DataRow row in dt.Rows)
{
organizacion.Id = int.Parse(row[RecursosDAOModulo7.AliasOrganizacionId].ToString());
organizacion.Nombre = row[RecursosDAOModulo7.AliasOrganizacionNombre].ToString();
organizacion.Direccion = row[RecursosDAOModulo7.AliasOrganizacionDireccion].ToString();
organizacion.Telefono = int.Parse(row[RecursosDAOModulo7.AliasOrganizacionTelefono].ToString());
organizacion.Email = row[RecursosDAOModulo7.AliasOrganizacionEmail].ToString();
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return organizacion;
}
private void button1_Click(object sender, EventArgs e)
{
Parametro parametro = new Parametro();
parametro.IdLancamento = cbTipoLAncamentoPadrao.SelectedValue.ToString();
parametro.CdEventoCredito = cbEventoCredito.SelectedValue.ToString();
parametro.CdHistoricoCredito = cbHistoricoCredito.SelectedValue.ToString();
parametro.CdEventoDebito = cbEventoDebito.SelectedValue.ToString();
parametro.CdHistoricoDebito = cbHistoricoDebito.SelectedValue.ToString();
if (ckTodosOrgaos.Checked)
{
DataTable dados = getUnidadesGestoras();
foreach (DataRow linha in dados.Rows)
{
parametro.CdUnidadeGestora = linha[0].ToString();
gravaRegistro(parametro);
}
}
else {
parametro.CdUnidadeGestora = cbUnidadeGestora.SelectedValue.ToString();
gravaRegistro(parametro);
}
MessageExcept.messageFacede("Registro(s) Salvo(s)", 2);
listaPareados();
}
/// <summary>
/// Se hace la conexion a la base de datos para cambiar la contraseña del usuario
/// </summary>
/// <param name="usuarioId"> Id del usuario que solicito el cambio de contraseña</param>
/// <param name="contraseña">nueva contraseña del usuario</param>
/// <returns></returns>
public bool RestablecerContrasena(string usuarioId, string contraseña)
{
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
parametros = new List<Parametro>();
Cuenta laCuenta = (Cuenta) laFabrica.ObtenerCuenta_M1();
elParametro = new Parametro(RecursosBDM1.AliasIdUsuario, SqlDbType.Int, usuarioId, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDM1.AliasContrasena, SqlDbType.VarChar, contraseña, false);
parametros.Add(elParametro);
this.EjecutarStoredProcedureTuplas(
RecursosBDM1.CambiarContraseña, parametros);
return true;
}
catch (SqlException e)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, e);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
{
throw e;
}
catch (Exception e)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
}
}
/// <summary>
/// Método para consultar el detalle de una ubicacion
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion detallada de la ubicacion</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
UbicacionM7 idUbicacion = (UbicacionM7)parametro;
UbicacionM7 ubicacion;
try
{
if (idUbicacion.Id > 0)
{
parametros = new List<Parametro>();
ubicacion = (UbicacionM7)FabricaEntidades.ObtenerUbicacionM7();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdUbicacion, SqlDbType.Int, idUbicacion.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultaUbicacionXId, parametros);
foreach (DataRow row in dt.Rows)
{
ubicacion.Id = int.Parse(row[RecursosDAOModulo7.AliasIdUbicacion].ToString());
ubicacion.Ciudad = row[RecursosDAOModulo7.AliasCiudad].ToString();
ubicacion.Estado = row[RecursosDAOModulo7.AliasEstado].ToString();
ubicacion.Direccion = row[RecursosDAOModulo7.AliasDireccion].ToString();
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return ubicacion;
}
public frmTomaActivo(string _Usuario, Inventario _Inventario, Parametro ubicacion, Empleado custodio)
{
InitializeComponent();
mUsuario = _Usuario;
mInventario = _Inventario;
pUbicacion = ubicacion;
eCustodio = custodio;
}
/// <summary>
/// Método para consultar el detalle de una matricula
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion de la matricula</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
MatriculaM7 idMatricula = (MatriculaM7)parametro;
MatriculaM7 matricula = (MatriculaM7)FabricaEntidades.ObtenerMatriculaM7();
try
{
if (idMatricula.Id > 0)
{
parametros = new List<Parametro>();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdMatricula, SqlDbType.Int, idMatricula.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultarMatriculaXId, parametros);
foreach (DataRow row in dt.Rows)
{
matricula.Id = int.Parse(row[RecursosDAOModulo7.AliasIdMatricula].ToString());
matricula.Identificador = row[RecursosDAOModulo7.AliasIdentificadorMatricula].ToString();
matricula.FechaCreacion = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaPagoMatricula].ToString());
matricula.UltimaFechaPago = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaUltimoPagoMatricula].ToString());
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return matricula;
}
/// <summary>
/// Método de Dao que se conecta a Base de Datos
/// para agregar un Actor
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad Actor
/// con los datos del actor a ser agregado</param>
/// <returns>True si lo agregó, false en caso contrario</returns>
public bool Agregar(Entidad parametro)
{
Actor actor = parametro as Actor;
List<Parametro> parametros = new List<Parametro>();
Parametro elParametro = new Parametro(RecursosDAOModulo6.NOMBRE_ACTOR,
SqlDbType.VarChar,actor.NombreActor,false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAOModulo6.DESC_ACTOR,SqlDbType.VarChar,
actor.DescripcionActor,false);
parametros.Add(elParametro);
//falta el id del proyecto
try
{
List<Resultado> tmp = EjecutarStoredProcedure(RecursosDAOModulo6.PROCEDURE_INSERTAR_ACTOR,
parametros);
return (tmp.ToArray().Length > 0);
}
catch (SqlException e)
{
AgregarActorBDDAOException exDaoActor = new AgregarActorBDDAOException(
RecursosDAOModulo6.CodigoExcepcionAgregarActorBD,
RecursosDAOModulo6.MensajeExcepcionAgregarActorBD,
e);
Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
exDaoActor);
throw exDaoActor;
}
catch (NullReferenceException e)
{
AgregarActorNuloDAOException exDaoActor = new AgregarActorNuloDAOException(
RecursosDAOModulo6.CodigoExcepcionAgregarActorNulo,
RecursosDAOModulo6.MensajeExcepcionAgregarActorNulo,
e);
Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
exDaoActor);
throw exDaoActor;
}
catch (Exception e)
{
AgregarActorDAOException exDaoActor = new AgregarActorDAOException(
RecursosDAOModulo6.CodigoExcepcionAgregarActorError,
RecursosDAOModulo6.MensajeExcepcionAgregarActorError,
e);
Logger.EscribirError(RecursosDAOModulo6.ClaseDAOActor,
exDaoActor);
throw exDaoActor;
}
}
/// <summary>
/// Metodo para agregar una restriccion de evento a la base de datos.
/// </summary>
/// <param name="parametro">objeto de tipo RestriccionEvento para agregar en bd</param>
/// <returns>true si fue agregado</returns>
public Boolean AgregarRestriccionEvento(DominioSKD.Entidad parametro)
{
DominioSKD.Entidades.Modulo8.RestriccionEvento laRestriccionEvento =
(DominioSKD.Entidades.Modulo8.RestriccionEvento)parametro;
try
{
List<Parametro> parametros = new List<Parametro>();
Parametro elParametro = new Parametro(RecursosDAORestriccionEvento.ParamDescripcionRestricionEvento, SqlDbType.VarChar,
laRestriccionEvento.Descripcion, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionEvento.ParamEdadMinimaRestricionEvento, SqlDbType.Int,
laRestriccionEvento.EdadMinima.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionEvento.ParamEdadMaximaRestricionEvento, SqlDbType.Int,
laRestriccionEvento.EdadMaxima.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionEvento.ParamSexoRestricionEvento, SqlDbType.VarChar,
laRestriccionEvento.Sexo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionEvento.ParamIdEvento, SqlDbType.Int,
laRestriccionEvento.IdEvento.ToString(), false);
parametros.Add(elParametro);
List<Resultado> resultados = this.EjecutarStoredProcedure(RecursosDAORestriccionEvento.AgregarRestriccionEvento
, parametros);
}
catch (SqlException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionEvento.CodigoErrorFormato,
RecursosDAORestriccionEvento.MensajeErrorFormato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw ex;
}
catch (Exception ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return true;
}
/// <summary>
/// Método para consultar el detalle de un tipo de evento
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion detallada del tipo de evento</returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
TipoEventoM7 idTipoEvento = (TipoEventoM7)parametro;
TipoEventoM7 tipoEvento;
try
{
if (idTipoEvento.Id > 0)
{
parametros = new List<Parametro>();
tipoEvento = (TipoEventoM7)FabricaEntidades.ObtenerTipoEventoM7();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdTipoEvento, SqlDbType.Int, idTipoEvento.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(
RecursosDAOModulo7.ConsultarTipoEventoXId, parametros);
foreach (DataRow row in dt.Rows)
{
tipoEvento.Id = int.Parse(row[RecursosDAOModulo7.AliasIdTipoEvento].ToString());
tipoEvento.Nombre = row[RecursosDAOModulo7.AliasTipoEventoNombre].ToString();
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return tipoEvento;
}
/// <summary>
/// Método para consultar el detalle de un horario
/// </summary>
/// <param name="parametro">Objeto de tipo Entidad que posee el id a consultar</param>
/// <returns>Retorna objeto de tipo Entidad con la informacion detallada del horario/returns>
public Entidad ConsultarXId(Entidad parametro)
{
List<Parametro> parametros;
Parametro parametroQuery = new Parametro();
HorarioM7 idHorario = (HorarioM7)parametro;
HorarioM7 horario;
try
{
if (idHorario.Id > 0)
{
parametros = new List<Parametro>();
horario = (HorarioM7)FabricaEntidades.ObtenerHorarioM7();
parametroQuery = new Parametro(RecursosDAOModulo7.ParamIdHorario, SqlDbType.Int, idHorario.Id.ToString(), false);
parametros.Add(parametroQuery);
DataTable dt = this.EjecutarStoredProcedureTuplas(RecursosDAOModulo7.ConsultarHorarioXId, parametros);
foreach (DataRow row in dt.Rows)
{
horario.Id = int.Parse(row[RecursosDAOModulo7.AliasIdHorario].ToString());
horario.FechaInicio = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaInicioHorario].ToString());
horario.FechaFin = DateTime.Parse(row[RecursosDAOModulo7.AliasFechaFinHorario].ToString());
horario.HoraInicio = int.Parse(row[RecursosDAOModulo7.AliasHoraInicioHorario].ToString());
horario.HoraFin = int.Parse(row[RecursosDAOModulo7.AliasHoraFinHorario].ToString());
}
}
else
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
}
catch (SqlException ex)
{
throw new ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,RecursoGeneralBD.Mensaje, ex);
}
catch (NumeroEnteroInvalidoException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (FormatException ex)
{
throw new NumeroEnteroInvalidoException(RecursosDAOModulo7.Codigo_Numero_Parametro_Invalido,
RecursosDAOModulo7.Mensaje_Numero_Parametro_invalido, new Exception());
}
catch (ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExceptionSKD(RecursosDAOModulo7.MensajeExceptionSKD, ex);
}
return horario;
}
protected override void LerObjetoTela()
{
base.LerObjetoTela();
obj = (Parametro)dtgDados.SelectedRows[0].DataBoundItem;
edtIDParametro.Text = obj.IDParametro.ToString();
edtNome.Text = obj.Nome;
edtComandoPLSQL.Text = obj.ComandoPLSQL;
edtObservacao.Text = obj.Observacao;
}
/// <summary>
/// Metodo que permite agregar la asistencia a un evento
/// </summary>
/// <param name="listaEntidad">lista de asistencia</param>
/// <returns>true si se pudo agregar</returns>
public bool AgregarAsistenciaCompetencia(List<Entidad> listaEntidad)
{
Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo10.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
int cont = 0;
try
{
foreach (Entidad asistencia in listaEntidad)
{
List<Parametro> parametros = new List<Parametro>();
Parametro parametro = new Parametro(RecursosDAOModulo10.ParametroIdCompetencia, SqlDbType.Int, ((DominioSKD.Entidades.Modulo10.Asistencia)asistencia).Competencia.Id.ToString(), false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo10.ParametroIdInscripcion, SqlDbType.Int, ((DominioSKD.Entidades.Modulo10.Asistencia)asistencia).Inscripcion.Id.ToString(), false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo10.ParametroAsistencia, SqlDbType.Char, ((DominioSKD.Entidades.Modulo10.Asistencia)asistencia).Asistio, false);
parametros.Add(parametro);
EjecutarStoredProcedure(RecursosDAOModulo10.ProcedimientoAgregarAsistenciaCompetencia, parametros);
cont++;
}
if (listaEntidad.Count.Equals(cont))
{
Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo10.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return true;
}
else
{
Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosDAOModulo10.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return false;
}
}
catch (SqlException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosDAOModulo10.CodigoErrorFormato,
RecursosDAOModulo10.MensajeErrorFormato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
catch (Exception ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
}
/// <summary>
/// Metodo para agregar una restriccion de cinta a la base de datos.
/// </summary>
/// <param name="parametro"></param>
/// <returns></returns>
public Boolean Agregar(DominioSKD.Entidad parametro)
{
DominioSKD.Entidades.Modulo8.RestriccionCinta laRestriccionCinta =
(DominioSKD.Entidades.Modulo8.RestriccionCinta)parametro;
try
{
List<Parametro> parametros = new List<Parametro>(); //declaras lista de parametros
Parametro elParametro = new Parametro(RecursosDAORestriccionCinta.ParamDescripcionRestricionCinta, SqlDbType.VarChar,
laRestriccionCinta.Descripcion, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamCintaNueva, SqlDbType.Int,
laRestriccionCinta.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamTiempoMinimo, SqlDbType.Int,
laRestriccionCinta.TiempoMinimo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamHorasDocentes, SqlDbType.Int,
laRestriccionCinta.TiempoDocente.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamPuntosMinimos, SqlDbType.Int,
laRestriccionCinta.PuntosMinimos.ToString(), false);
parametros.Add(elParametro);
BDConexion laConexion = new BDConexion();
laConexion.EjecutarStoredProcedure(RecursosDAORestriccionCinta.AgregarRestriccionCinta, parametros);
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionCompetencia.Codigo_Error_Formato,
RecursosDAORestriccionCompetencia.Mensaje_Error_Formato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return true;
}
public static Cuenta ObtenerUsuario(string nombre_usuario)
{
BDConexion laConexion;//COnsultar la persona
BDConexion laConexion2;//Consultar los roles de la persona
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
laConexion = new BDConexion();
laConexion2 = new BDConexion();
parametros = new List<Parametro>();
Cuenta laCuenta = new Cuenta();
elParametro = new Parametro(RecursosBDModulo1.AliasNombreUsuario,SqlDbType.VarChar,nombre_usuario,false);
parametros.Add(elParametro);
DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
RecursosBDModulo1.ConsultarNombreUsuarioContrasena, parametros);
foreach (DataRow row in dt.Rows)
{
laCuenta.Id_usuario = int.Parse(row[RecursosBDModulo1.AliasIdUsuario].ToString());
laCuenta.Nombre_usuario = row[RecursosBDModulo1.AliasNombreUsuario].ToString();
laCuenta.Contrasena = row[RecursosBDModulo1.AliasContrasena].ToString();
}
DataTable dt1 = laConexion2.EjecutarStoredProcedureTuplas(
RecursosBDModulo1.ConsultarRolesUsuario, parametros);
List<Rol> listaRol = new List<Rol>();
foreach (DataRow row in dt1.Rows)
{
Rol elRol = new Rol();
elRol.Id_rol =int.Parse(row[RecursosBDModulo1.AliasIdRol].ToString());
elRol.Nombre = row[RecursosBDModulo1.AliasNombreRol].ToString();
elRol.Descripcion = row[RecursosBDModulo1.AliasDescripcionRol].ToString();
elRol.Fecha_creacion = (DateTime)row[RecursosBDModulo1.AliasFechaCreacion];
listaRol.Add(elRol);
}
laCuenta.Roles = listaRol;
return laCuenta;
}
catch (Exception e)
{
throw e;
}
}
public static bool BuscarIDDojo(Dojo elDojo)
{
bool retorno = false;
BDConexion laConexion;
List<Parametro> parametros;
try
{
laConexion = new BDConexion();
parametros = new List<Parametro>();
Parametro elParametro = new Parametro(RecursosBDModulo4.ParamIdDojo, SqlDbType.Int
, elDojo.Id_dojo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDModulo4.ParamSalidaNumDojo, SqlDbType.Int, true);
parametros.Add(elParametro);
List<Resultado> resultados = laConexion.EjecutarStoredProcedure(RecursosBDModulo4.BuscarIdDojo
, parametros);
foreach (Resultado elResultado in resultados)
{
if (elResultado.etiqueta == RecursosBDModulo4.ParamSalidaNumDojo)
if (int.Parse(elResultado.valor) == 1)
retorno = true;
else
throw new ExcepcionesSKD.Modulo4.DojoInexistenteException(RecursosBDModulo4.Codigo_Dojo_Inexistente,
RecursosBDModulo4.Mensaje_Dojo_Inexistente, new Exception());
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
throw new ExcepcionesSKD.Modulo4.FormatoIncorrectoException(RecursosBDModulo4.Codigo_Error_Formato,
RecursosBDModulo4.Mensaje_Error_Formato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return retorno;
}
/// <summary>
/// Metodo que dado un rango de fecha retorna los eventos tipo ascenso que esten en el rango
/// </summary>
/// <param name="fecha">fecha inicio</param>
/// <returns>lista de eventos</returns>
public List<Entidad> AscensosPorFechaM10(string fecha)
{
List<Entidad> listaEventos = new List<Entidad>();
List<Parametro> parametros = new List<Parametro>();
Parametro parametro = new Parametro(RecursosDAOModulo11.ParametroFechaInicio, SqlDbType.Date, fecha, false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo11.ParametroFechaFin, SqlDbType.Date, fecha, false);
parametros.Add(parametro);
try
{
DataTable dt = EjecutarStoredProcedureTuplas(RecursosDAOModulo11.ProcedimientoAscensosPorFechaM10, parametros);
foreach (DataRow row in dt.Rows)
{
Entidad evento = DominioSKD.Fabrica.FabricaEntidades.ObtenerEventoM10();
((DominioSKD.Entidades.Modulo10.Evento)evento).Id = int.Parse(row[RecursosDAOModulo11.aliasIdEvento].ToString());
((DominioSKD.Entidades.Modulo10.Evento)evento).Nombre = row[RecursosDAOModulo11.aliasNombreEvento].ToString();
((DominioSKD.Entidades.Modulo10.Evento)evento).Descripcion = row[RecursosDAOModulo11.aliasDescripcionEvento].ToString();
((DominioSKD.Entidades.Modulo10.Evento)evento).Estado = Boolean.Parse(row[RecursosDAOModulo11.aliasEstadoEvento].ToString());
Entidad horario = DominioSKD.Fabrica.FabricaEntidades.ObtenerHorarioM10();
((DominioSKD.Entidades.Modulo10.Horario)horario).FechaInicio = DateTime.Parse(row[RecursosDAOModulo11.aliasFechaInicio].ToString());
((DominioSKD.Entidades.Modulo10.Horario)horario).FechaFin = DateTime.Parse(row[RecursosDAOModulo11.aliasFechaFin].ToString());
((DominioSKD.Entidades.Modulo10.Horario)horario).HoraInicio = int.Parse(row[RecursosDAOModulo11.aliasHoraInicio].ToString());
((DominioSKD.Entidades.Modulo10.Horario)horario).HoraFin = int.Parse(row[RecursosDAOModulo11.aliasHoraFin].ToString());
Entidad tipoEvento = DominioSKD.Fabrica.FabricaEntidades.ObtenerTipoEventoM10();
((DominioSKD.Entidades.Modulo10.TipoEvento)tipoEvento).Nombre = row[RecursosDAOModulo11.aliasTipoEvento].ToString();
((DominioSKD.Entidades.Modulo10.Evento)evento).Horario = horario as DominioSKD.Entidades.Modulo10.Horario;
((DominioSKD.Entidades.Modulo10.Evento)evento).TipoEvento = tipoEvento as DominioSKD.Entidades.Modulo10.TipoEvento;
listaEventos.Add(evento);
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
throw ex;
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return listaEventos;
}
private void Pesquisar()
{
List<ParametroVO> lParametro = new Parametro().Listar();
if (lParametro.Count > 0)
{
DadosParametro = (ParametroVO)lParametro[0];
ModoAlterar = true;
}
else
{
ModoAlterar = false;
}
}
/// <summary>
/// Metodo que permite agregar en la base de datos un resultado de un atleta en una competencia de especialidad kata
/// </summary>
/// <param name="parametro">lista de resultado kata</param>
/// <returns>true si se pudo agregar</returns>
public bool Agregar(List<DominioSKD.Entidad> parametro)
{
int cont = 0;
try
{
foreach (Entidad kata in parametro)
{
List<Parametro> parametros = new List<Parametro>();
Parametro parametro2 = new Parametro(RecursosDAOModulo11.ParametroResultadoJurado1, SqlDbType.Int, ((DominioSKD.Entidades.Modulo11.ResultadoKata)kata).Jurado1.ToString(), false);
parametros.Add(parametro2);
parametro2 = new Parametro(RecursosDAOModulo11.ParametroResultadoJurado2, SqlDbType.Int, ((DominioSKD.Entidades.Modulo11.ResultadoKata)kata).Jurado2.ToString(), false);
parametros.Add(parametro2);
parametro2 = new Parametro(RecursosDAOModulo11.ParametroResultadoJurado3, SqlDbType.Int, ((DominioSKD.Entidades.Modulo11.ResultadoKata)kata).Jurado3.ToString(), false);
parametros.Add(parametro2);
parametro2 = new Parametro(RecursosDAOModulo11.ParametroIdInscripcion, SqlDbType.Int, ((DominioSKD.Entidades.Modulo11.ResultadoKata)kata).Inscripcion.Id.ToString(), false);
parametros.Add(parametro2);
EjecutarStoredProcedure(RecursosDAOModulo11.ProcedimientoAgregarKata, parametros);
cont++;
}
if (parametro.Count.Equals(cont))
{
//Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo9.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return true;
}
else
{
//Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDModulo9.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return false;
}
}
catch (SqlException ex)
{
throw ex;
}
catch (FormatException ex)
{
throw ex;
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Se hace la conexion a la base de datos para obtener la lista de roles del usuario con sus respectivos atributos
/// </summary>
/// <param name="idUsuario">id del usuario que leconsultaran los roles</param>
/// <returns> lista de roles del usuario con sus respectivos atributos</returns>
public List<Rol> consultarRolesUsuario(string idUsuario)
{
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
parametros = new List<Parametro>();
List<Rol> losRoles = new List<Rol>();
elParametro = new Parametro(RecursosBDM2.aliasIdUsuario, SqlDbType.VarChar, idUsuario, false);
parametros.Add(elParametro);
DataTable dt = this.EjecutarStoredProcedureTuplas(RecursosBDM2.ConsultarRolesUsuario, parametros);
foreach (DataRow row in dt.Rows)
{
Rol rol = (Rol)laFabrica.ObtenerRol_M2();
rol.Id_rol = int.Parse(row[RecursosBDM2.AliasIdRol].ToString());
rol.Descripcion = row[RecursosBDM2.AliasDescripcionRol].ToString();
rol.Nombre = row[RecursosBDM2.AliasNombreRol].ToString();
rol.Fecha_creacion = (DateTime)row[RecursosBDM2.aliasFechaCreacion];
losRoles.Add(rol);
}
return losRoles;
}
catch (SqlException e)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, e);
}
catch (FormatException e)
{
throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosBDM1.Codigo_Error_Formato,
RecursosBDM1.Mensaje_Error_Formato, e);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD e)
{
throw e;
}
catch (Exception e)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, e);
}
}
/// <summary>
/// Metodo que devueve un tipoimplemnto dado su id
/// </summary>
/// <param name="Id_implemento">Indica el objeto a detallar</param>
/// <returns>Retorna un implemento en especifico con todos sus detalles</returns>
public static DominioSKD.Entidades.Modulo16.Implemento DetallarImplemento(int Id_implemento)
{
BDConexion laConexion;
List<Parametro> parametros;
Parametro elParametro = new Parametro();
try
{
laConexion = new BDConexion();
parametros = new List<Parametro>();
DominioSKD.Entidades.Modulo16.Implemento elImplemento = new DominioSKD.Entidades.Modulo16.Implemento();
elParametro = new Parametro(RecursosBDModulo16.PARAMETRO_ITEM, SqlDbType.Int, Id_implemento.ToString(),
false);
parametros.Add(elParametro);
DataTable dt = laConexion.EjecutarStoredProcedureTuplas(
RecursosBDModulo16.DETALLAR_IMPLEMENTO, parametros);
foreach (DataRow row in dt.Rows)
{
elImplemento.Imagen_implemento = row[RecursosBDModulo16.PARAMETRO_IMAGEN].ToString();
elImplemento.Nombre_Implemento = row[RecursosBDModulo16.PARAMETRO_NOMBRE].ToString();
elImplemento.Tipo_Implemento = row[RecursosBDModulo16.PARAMETRO_TIPO].ToString();
elImplemento.Marca_Implemento = row[RecursosBDModulo16.PARAMETRO_MARCA].ToString();
elImplemento.Color_Implemento = row[RecursosBDModulo16.PARAMETRO_COLOR].ToString();
elImplemento.Talla_Implemento = row[RecursosBDModulo16.PARAMETRO_TALLA].ToString();
elImplemento.Estatus_Implemento = row[RecursosBDModulo16.PARAMETRO_ESTATUS].ToString();
elImplemento.Precio_Implemento = int.Parse(row[RecursosBDModulo16.PARAMETRO_PRECIO].ToString());
elImplemento.Descripcion_Implemento = row[RecursosBDModulo16.PARAMETRO_DESCRIPCION].ToString();
}
return elImplemento;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Este método representa el punto de entrada a la api de Resultado de
/// Gestión. Se maneja como un método estático que obtiene todos lo que
/// se necesita desde sus párametros y con ello define qué resultado se
/// debe ejecutar y aplicar las acciones asociadas al mismo. Aqui no se
/// capturan las excepciones para se que vuelvan a la clase de gestión.
/// IMPORTANTE: el resultado de una gestion se ejecuta ANTES!!! de que
/// la misma se cierre y se agregue a la cuenta asociada. Esto es así
/// para que, si el resultado falla, la gestion no se modifique y no
/// se termine. IMPORTANTE2: POR ESTO ULTIMO, PRIMERO DEBE VERIFICAR
/// EL RESULTADO Y QUE DEBE Y PUEDE EJECUTARSE Y RECIEN DESPUES HACER
/// CAMBIOS!!!!!!!!!!!.
/// </summary>
/// <param name="gestion">
/// La gestión que se esta ejecutando.
/// </param>
/// <param name="resultado">
/// El resultado que se desea ejecutar para la gestión.
/// </param>
public static void EjecutarResultado(Gestion gestion, Parametro resultado)
{
// Primero se verifica si debe agregarse un gasto por esto
if (gestion.Tipo.Valordouble > 0)
AgregarGastoGestion(gestion);
// Luego se ejecuta la parte propia de cada resultado
if (resultado.Clave.Equals("RESULTADOGESTION.NOCONTACTADO"))
EjecutarResultadoNoContactado(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.PROMESAPAGO"))
EjecutarResultadoPromesaPago(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.PROMESAPAGOCUOTA"))
EjecutarResultadoPromesaPagoCuota(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.PROMESAVISITA"))
EjecutarResultadoPromesaVisita(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.PROMESASUCURSAL"))
EjecutarResultadoPromesaPagoSucursal(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.ALTACONVENIO"))
EjecutarResultadoAltaConvenio(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.FALLECIDO"))
EjecutarResultadoDeudorFallecido(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.SINVOLUNTAD"))
EjecutarResultadoSinVoluntad(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.AGOTADA"))
EjecutarResultadoAgotada(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.SOLICITACONTACTO"))
EjecutarResultadoSolicitaContacto(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.REINTENTARCONTACTO"))
EjecutarResultadoReintentoContacto(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.CONTACTOINVALIDO"))
EjecutarResultadoContactoInvalido(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.POSITIVA"))
EjecutarResultadoBusquedaPositiva(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.EMBARGO"))
EjecutarResultadoCuentaConEmbargo(gestion);
else if (resultado.Clave.Equals("RESULTADOGESTION.INSOLVENTE"))
EjecutarResultadoInsolvente(gestion);
}
public static ITRetConsStatServ ConsultarStatusServidor(SoapHttpClientProtocol oServico, ITConsStatServ oConsStatServ, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetConsStatServ, ITConsStatServ>(oServico, TService.Status, oConsStatServ, oParam, versao, "TRetConsStatServ"));
}
public static ITRetEnvEvento EnviarEnvelopeEvento(SoapHttpClientProtocol oServico, ITEnvEvento oEnvEvento, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetEnvEvento, ITEnvEvento>(oServico, TService.RecepcaoEvento, oEnvEvento, oParam, versao, "TRetEnvEvento"));
}
public static IRetDistDFeInt ConsultarDFe(SoapHttpClientProtocol oServico, IDistDFeInt xmlEnvio, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <IRetDistDFeInt, IDistDFeInt>(oServico, TService.ConsultaDFe, xmlEnvio, oParam, versao, "retDistDFeInt"));
}
public static ITRetConsSitNFe ConsultarSituacaoNFe(SoapHttpClientProtocol oServico, ITConsSitNFe oConsSitNFe, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetConsSitNFe, ITConsSitNFe>(oServico, TService.ConsultaProtocolo, oConsSitNFe, oParam, versao, "TRetConsSitNFe"));
}
public static ITRetEnviNFe EnviarEnvelope(SoapHttpClientProtocol oServico, ITEnviNFe oEnviNFe, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetEnviNFe, ITEnviNFe>(oServico, TService.Autorizacao, oEnviNFe, oParam, versao, "TRetEnviNFe"));
}
public ActionResult Create(Empresa empresa, HttpPostedFileBase file)
{
Contexto db = new Contexto();
empresa.Ativo = true;
if (db.Usuarios.Where(u => u.Email == empresa.EmailContato).Select(e => e.Email).FirstOrDefault() != null)
{
throw new Exception("O e-mail " + empresa.EmailContato + " já está sendo usado. Use outro e-mail para se cadastrar.");
}
db.Empresas.Add(empresa);
db.SaveChanges();
//Criação da parte de parametros para essa empresa
Parametro parametro = new Parametro()
{
EmpresaId = empresa.Id
};
db.Parametros.Add(parametro);
//Criação de um Perfil
Perfil perfil = new Perfil()
{
Descricao = "Administrador",
EmpresaId = empresa.Id
};
db.Perfis.Add(perfil);
db.SaveChanges();
// criação do convite
Convite convite = new Convite()
{
Email = empresa.EmailContato,
EmpresaId = empresa.Id,
Expirado = false,
PerfilId = perfil.Id
};
db.Convites.Add(convite);
// inclusão das permissões no perfil
foreach (var funcao in db.Funcoes)
{
Acesso acesso = new Acesso()
{
PerfilId = perfil.Id, FuncaoId = funcao.Id
};
db.Acessos.Add(acesso);
}
if (file != null)
{
using (MemoryStream ms = new MemoryStream())
{
file.InputStream.CopyTo(ms);
empresa.Logotipo = ms.ToArray();
}
}
try
{
db.SaveChanges();
}
catch (Exception e)
{
throw new Exception(e.InnerException.InnerException.Message);
}
TempData["Alerta"] = new Alerta()
{
Mensagem = "Um email com um link de ativação foi enviado. Verifique sua caixa de entrada para finalizar o cadastro.", Tipo = "success"
};
Util.EnviarConvite(convite, empresa.Id, "*****@*****.**");
return(RedirectToAction("Index", "Login"));
}
/// <summary>
/// Metodo para agregar los Acuerdos de una Minuta a la BD
/// </summary>
/// <param name="paramtreo">Parametro del tipo generico (clase Entidad) que representa el acuerdo a agregar</param>
/// <returns>Retorna un boolean para saber si se realizo con exito o no la operación</returns>
public bool AgregarAcuerdo(Entidad parametro, int idMinuta, string idProyecto)
{
Acuerdo elAcuerdo = (Acuerdo)parametro;
Fabrica.FabricaDAOSqlServer laFabrica = new FabricaDAOSqlServer();
IntefazDAO.Modulo8.IDaoInvolucradosMinuta DAOInvolucradosMinuta = laFabrica.ObtenerDAOInvolucradosMinuta();
bool success = false;
List <Parametro> parametros = new List <Parametro>();
Parametro elParametro = new Parametro(RecursosBDModulo8.ParametroFechaAcuerdo, SqlDbType.DateTime,
elAcuerdo.Fecha.ToString("yyyy-MM-dd HH':'mm':'ss"), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDModulo8.ParametroDesarrolloAcuerdo, SqlDbType.VarChar,
elAcuerdo.Compromiso, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosBDModulo8.ParametroIDMinuta, SqlDbType.Int,
idMinuta.ToString(), false);
parametros.Add(elParametro);
DataTable resultado = new DataTable();
try
{
resultado = EjecutarStoredProcedureTuplas(RecursosBDModulo8.ProcedimientoAgregarAcuerdo, parametros);
foreach (DataRow row in resultado.Rows)
{
if (elAcuerdo.ListaContacto != null)
{
foreach (Contacto contacto in elAcuerdo.ListaContacto)
{
bool contactoBool = DAOInvolucradosMinuta.AgregarContactoEnAcuerdo(contacto, row[RecursosBDModulo8.AtributoIDAcuerdo].ToString(), idProyecto);
}
}
if (elAcuerdo.ListaUsuario != null)
{
foreach (Usuario usuario in elAcuerdo.ListaUsuario)
{
bool usuarioBool = DAOInvolucradosMinuta.AgregarUsuarioEnAcuerdo(usuario, row[RecursosBDModulo8.AtributoIDAcuerdo].ToString(), idProyecto);
}
}
success = true;
}
}
catch (NullReferenceException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionNullReference,
RecursosBDModulo8.Mensaje_ExcepcionNullReference, ex);
}
catch (SqlException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionSql,
RecursosBDModulo8.Mensaje_ExcepcionSql, ex);
}
catch (ParametroIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new ParametroIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionParametro,
RecursosBDModulo8.Mensaje__ExcepcionParametro, ex);
}
catch (AtributoIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new AtributoIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionAtributo,
RecursosBDModulo8.Mensaje_ExcepcionAtributo, ex);
}
catch (Exception ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionGeneral,
RecursosBDModulo8.Mensaje_ExcepcionGeneral, ex);
}
return(success);
}
public void modificaParametro(Parametro _parametro)
{
ParametroDao dao = new ParametroDao();
dao.modificaParametro(_parametro);
}
public void eliminaParametro(Parametro _parametro)
{
ParametroDao dao = new ParametroDao();
dao.eliminaParametro(_parametro);
}
public int insertarParametro(Parametro _parametro)
{
ParametroDao dao = new ParametroDao();
return(dao.InsertaParametro(_parametro));
}
private static R ExecutaServico <R, S>(SoapHttpClientProtocol oServico, TService TipoServico, S xmlEnvio, Parametro oParam, VersaoXML versao, string stTipo)
{
var xmlRetorno = InternalExecutaServico(oServico, TipoServico, xmlEnvio, oParam);
try
{
return((R)XMLUtils.LoadXML(xmlRetorno, versao, stTipo));
}
catch (Exception ex)
{
throw new Exception($"Erro ao deserializar ({ex.Message}) o retorno do WebService ({xmlRetorno})");
}
}
public static TConfigUf GNREConfigUF(SoapHttpClientProtocol oServico, TConsultaConfigUf xmlEnvio, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <TConfigUf, TConsultaConfigUf>(oServico, TService.GNRE_ConsultaLote, xmlEnvio, oParam, oParam.versao, "TConfigUf"));
}
/// <summary>
/// Metodo para eliminar un acuerdo de la BD
/// </summary>
/// <param name="idAcuerdo">ID del Acuerdo que se desea eliminar</param>
/// <returns>Retorna un Boolean para saber si se realizo con exito o no la operacion</returns>
public bool Eliminar(Entidad parametro, String codigoProyecto)
{
bool success = false;
Acuerdo acuerdo = (Acuerdo)parametro;
Fabrica.FabricaDAOSqlServer laFabrica = new FabricaDAOSqlServer();
IntefazDAO.Modulo8.IDaoInvolucradosMinuta DAOInvolucradosMinuta = laFabrica.ObtenerDAOInvolucradosMinuta();
List <Parametro> parametros = new List <Parametro>();
Parametro elParametro = new Parametro(RecursosBDModulo8.ParametroIDAcuerdo, SqlDbType.Int,
acuerdo.Id.ToString(), false);
parametros.Add(elParametro);
try
{
List <Resultado> tmp = EjecutarStoredProcedure(RecursosBDModulo8.ProcedimientoEliminarAcuerdo, parametros);
if (tmp != null)
{
return(true);
}
else
{
return(false);
}
}
catch (NullReferenceException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionNullReference,
RecursosBDModulo8.Mensaje_ExcepcionNullReference, ex);
}
catch (SqlException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionSql,
RecursosBDModulo8.Mensaje_ExcepcionSql, ex);
}
catch (ParametroIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new ParametroIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionParametro,
RecursosBDModulo8.Mensaje__ExcepcionParametro, ex);
}
catch (AtributoIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new AtributoIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionAtributo,
RecursosBDModulo8.Mensaje_ExcepcionAtributo, ex);
}
catch (Exception ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionGeneral,
RecursosBDModulo8.Mensaje_ExcepcionGeneral, ex);
}
return(success);
}
public static Usuario UsuarioData(int IdUsuairo)
{
Parametro p = new Parametro("@IdUsuario", IdUsuairo);
return(DBHelper.InstanceCRM.ObtenerEntidad("security.spSca_ObtenerUsuario", p, ConstructorEntidad));
}
/// <summary>
/// Metodo para obtener los responsables Contactos de un Acuerdo de una Minuta
/// </summary>
/// <param name="IdAcuerdo">Id del acuerdo del que se desea consultar</param>
/// <returns>Retorna un DataTable de Contactos</returns>
public List <Entidad> ObtenerContactoAcuerdo(int IdAcuerdo)
{
FabricaEntidades laFabrica = new FabricaEntidades();
List <Entidad> laLista = new List <Entidad>();
List <Resultado> contacto = new List <Resultado>();
DataTable idContactos = new DataTable();
List <Parametro> parametros = new List <Parametro>();
Parametro elParametro = new Parametro(RecursosBDModulo8.ParametroIDAcuerdo, SqlDbType.Int,
IdAcuerdo.ToString(), false);
parametros.Add(elParametro);
try
{
idContactos = EjecutarStoredProcedureTuplas(RecursosBDModulo8.ProcedimientoContactoAcuerdo, parametros);
if (idContactos.Rows.Count > 0)
{
foreach (DataRow row in idContactos.Rows)
{
DaoInvolucradosMinuta daoInvolucradosMinuta;
FabricaDAOSqlServer fabricaDAO = new FabricaDAOSqlServer();
daoInvolucradosMinuta = (DaoInvolucradosMinuta)fabricaDAO.ObtenerDAOInvolucradosMinuta();
laLista.Add(daoInvolucradosMinuta.ConsultarContactoMinutas(int.Parse(row[RecursosBDModulo8.AtributoAcuerdoContacto].ToString())));
}
}
else
{
laLista = null;
}
}
catch (NullReferenceException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionNullReference,
RecursosBDModulo8.Mensaje_ExcepcionNullReference, ex);
}
catch (SqlException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionSql,
RecursosBDModulo8.Mensaje_ExcepcionSql, ex);
}
catch (ParametroIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new ParametroIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionParametro,
RecursosBDModulo8.Mensaje__ExcepcionParametro, ex);
}
catch (AtributoIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new AtributoIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionAtributo,
RecursosBDModulo8.Mensaje_ExcepcionAtributo, ex);
}
catch (Exception ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionGeneral,
RecursosBDModulo8.Mensaje_ExcepcionGeneral, ex);
}
return(laLista);
}
/// <summary>
/// Metodo que verifica el requerimiento en la base de datos
/// </summary>
/// <param name="requerimiento">Requerimiento a validar</param>
/// <returns>true si existe el requerimiento</returns>
public bool VerificarRequerimiento(Dominio.Entidad requerimiento)
{
bool existeRequerimiento = false;
Dominio.Entidades.Modulo5.Requerimiento requerimientoBD = (Dominio.Entidades.Modulo5.Requerimiento)requerimiento;
List <Parametro> parametros = new List <Parametro>();
Parametro parametro = new Parametro(RecursosDAOModulo5.
PARAMETRO_REQ_CODIGO, SqlDbType.VarChar, requerimientoBD.Codigo,
false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo5.
PARAMETRO_RESULTADO, SqlDbType.Int, true);
parametros.Add(parametro);
try
{
List <Resultado> resultados = base.EjecutarStoredProcedure(
RecursosDAOModulo5.PROCEDIMIENTO_RETORNAR_REQUERIMIENTO_POR_CODIGO,
parametros);
if (int.Parse(resultados[0].valor) == 1)
{
existeRequerimiento = true;
}
else
{
existeRequerimiento = false;
throw new RequerimientoNoExisteException();
}
}
#region Capturar Excepciones
catch (ExcepcionesTotem.Modulo5.RequerimientoInvalidoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw ex;
}
catch (SqlException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new ExcepcionesTotem.ExceptionTotemConexionBD(
RecursoGeneralDAO.Codigo_Error_BaseDatos,
RecursoGeneralDAO.Mensaje_Error_BaseDatos,
ex);
}
catch (ExcepcionesTotem.Modulo1.ParametroInvalidoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw ex;
}
catch (ExcepcionesTotem.ExceptionTotemConexionBD ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw ex;
}
#endregion
return(existeRequerimiento);
}
/// <summary>
/// Metodo para consultar los Acuerdos vinculados a una minuta es especifico
/// </summary>
/// <param name="idMinuta">id de la minuta </param>
/// <returns>Retorna un DataTable de Acuerdos vinculados a la Minuta</returns>
public List <Entidad> ConsultarTodos(int idMinuta)
{
FabricaEntidades laFabrica = new FabricaEntidades();
List <Entidad> laLista = new List <Entidad>();
DataTable resultado = new DataTable();
List <Parametro> parametros = new List <Parametro>();
Parametro elParametro = new Parametro(RecursosBDModulo8.ParametroIDMinuta, SqlDbType.Int,
idMinuta.ToString(), false);
parametros.Add(elParametro);
Acuerdo elAcuerdo;
try
{
resultado = EjecutarStoredProcedureTuplas(RecursosBDModulo8.ProcedimientoConsultarAcuerdo, parametros);
if (resultado.Rows.Count > 0)
{
foreach (DataRow row in resultado.Rows)
{
elAcuerdo = (Acuerdo)laFabrica.ObtenerAcuerdo();
elAcuerdo.Id = int.Parse(row[RecursosBDModulo8.AtributoIDAcuerdo].ToString());
elAcuerdo.Fecha = DateTime.Parse(row[RecursosBDModulo8.AtributoFechaAcuerdo].ToString());
elAcuerdo.Compromiso = row[RecursosBDModulo8.AtributoDesarrolloAcuerdo].ToString();
/* elAcuerdo.ListaContacto = ObtenerContactoAcuerdo(elAcuerdo.Id).Cast<Contacto>().ToList();
* elAcuerdo.ListaUsuario = ObtenerUsuarioAcuerdo(elAcuerdo.Id).Cast<Usuario>().ToList();*/
laLista.Add(elAcuerdo);
}
}
else
{
laLista = null;
}
}
catch (NullReferenceException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionNullReference,
RecursosBDModulo8.Mensaje_ExcepcionNullReference, ex);
}
catch (SqlException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionSql,
RecursosBDModulo8.Mensaje_ExcepcionSql, ex);
}
catch (ParametroIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new ParametroIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionParametro,
RecursosBDModulo8.Mensaje__ExcepcionParametro, ex);
}
catch (AtributoIncorrectoException ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new AtributoIncorrectoException(RecursosBDModulo8.Codigo_ExcepcionAtributo,
RecursosBDModulo8.Mensaje_ExcepcionAtributo, ex);
}
catch (Exception ex)
{
ExcepcionesTotem.Logger.EscribirError(this.GetType().Name,
ex);
throw new BDMinutaException(RecursosBDModulo8.Codigo_ExcepcionGeneral,
RecursosBDModulo8.Mensaje_ExcepcionGeneral, ex);
}
return(laLista);
}
public static ITRetDownloadNFe DownloadNF(SoapHttpClientProtocol oServico, ITDownloadNFe xmlEnvio, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetDownloadNFe, ITDownloadNFe>(oServico, TService.DownloadNF, xmlEnvio, oParam, versao, "TRetDownloadNFe"));
}
/*public static List<Usuario> ListarUsuarios()
* {
* return DBHelper.InstanceCRM.ObtenerColeccion("security.sp_SCA_ListarUsuarios", ConstructorEntidad);
* }*/
public static Usuario UsuarioData(string RutUsuario)
{
Parametro p = new Parametro("@RutUsuario", RutUsuario);
return(DBHelper.InstanceCRM.ObtenerEntidad("security.spSca_ObtenerUsuarioByRut", p, ConstructorEntidad));
}
public static ITRetInutNFe InutilizarNFe(SoapHttpClientProtocol oServico, ITInutNFe oInutNFe, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetInutNFe, ITInutNFe>(oServico, TService.Inutilizacao, oInutNFe, oParam, versao, "TRetInutNFe"));
}
public static ITRetConsReciNFe ConsultarProcessamentoEnvelope(SoapHttpClientProtocol oServico, ITConsReciNFe oConsReciNFe, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetConsReciNFe, ITConsReciNFe>(oServico, TService.RetAutorizacao, oConsReciNFe, oParam, versao, "TRetConsReciNFe"));
}
private static String InternalExecutaServico(SoapHttpClientProtocol oServico, TService TipoServico, Object DADOS, Parametro oParam)
{
try
{
string dados = XMLUtils.GetXML(DADOS, oParam.versao);
#region particularidades
if (oParam.UF == TCodUfIBGE.Parana && (DADOS.GetType() == typeof(SchemaXML.NFe_v200.TEnviNFe) ||
DADOS.GetType() == typeof(SchemaXML.NFe_v300.TEnviNFe) ||
DADOS.GetType() == typeof(SchemaXML.NFe_v310.TEnviNFe) ||
DADOS.GetType() == typeof(SchemaXML.NFe_v400.TEnviNFe)))
{
dados = dados.Replace("<NFe>", "<NFe xmlns=\"http://www.portalfiscal.inf.br/nfe\">");
}
#endregion
XmlNode node = null;
XmlDocument doc = new XmlDocument();
XmlReader reader = XmlReader.Create(new StringReader(dados));
reader.MoveToContent();
node = doc.ReadNode(reader);
InicializaServico(oServico, oParam);
if (oParam.versao == VersaoXML.NFe_v400 &&
(TipoServico == TService.Autorizacao || TipoServico == TService.RetAutorizacao || TipoServico == TService.ConsultaProtocolo ||
TipoServico == TService.Inutilizacao || TipoServico == TService.RecepcaoEvento || TipoServico == TService.Cadastro || TipoServico == TService.Status))
{
var wsMethod = Webservices.WSUtils.GetWSMethod(TipoServico);
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(wsMethod, System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else
{
//TODO : compatibilizar com a nova factory de webservices
if (DADOS.GetType() == typeof(TLote_GNRE))
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("processar",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType() == typeof(TConsLote_GNRE))
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("consultar",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType() == typeof(TConsultaConfigUf))
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("consultar",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITConsCad") != null)
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("consultaCadastro2",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITEnvEvento") != null)
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("nfeRecepcaoEvento",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITEnviNFe") != null)
{
if (((ITEnviNFe)DADOS).versao == "2.00")
{
//versao 2.00
#region particularidades
if (oParam.UF == TCodUfIBGE.Parana)
{
if (oParam.tipoAmbiente == TAmb.Homologacao)
{
oServico.Url = @"https://homologacao.nfe2.fazenda.pr.gov.br/nfe/NFeRecepcao2";
}
else
{
oServico.Url = @"https://nfe2.fazenda.pr.gov.br/nfe/NFeRecepcao2";
}
}
#endregion
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("nfeRecepcaoLote2",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else
{
//versao 3.00
//Somente meto Assincrono
//var test = (SchemaXML300.TEnviNFe)DADOS;
//test.indSinc = SchemaXML300.TEnviNFeIndSinc.Item0;//Não indica sincrono
//test.indSinc = SchemaXML300.TEnviNFeIndSinc.Item1; //indica sincrono, mas depende da SEFAZ autorizadora implementar servico.
//***.**.Autorizacao.NfeAutorizacao proxy = new ***.**.Autorizacao.NfeAutorizacao();
//var ret = proxy.nfeAutorizacaoLote(node);
//sincrono poderá ter o Nó : TProtNFe
//assincrono terá o Nó : TRetEnviNFeInfRec
var fnNome = "nfeAutorizacaoLote";
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(fnNome,
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
}
else if (DADOS.GetType().GetInterface("ITConsReciNFe") != null)
{
if (((ITConsReciNFe)DADOS).versao == "2.00")
{
//versao 2.00
#region particularidades
if (oParam.UF == TCodUfIBGE.Parana)
{
if (oParam.tipoAmbiente == TAmb.Homologacao)
{
oServico.Url = @"https://homologacao.nfe2.fazenda.pr.gov.br/nfe/NFeRetRecepcao2";
}
else
{
oServico.Url = @"https://nfe2.fazenda.pr.gov.br/nfe/NFeRetRecepcao2";
}
}
#endregion
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("nfeRetRecepcao2",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else
{
var fnNome = "nfeRetAutorizacaoLote";
if (oParam.UF == TCodUfIBGE.Parana && oParam.versao == VersaoXML.NFe_v310)
{
fnNome = "nfeRetAutorizacao";
}
//versao 3.00 ou 3.10
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(fnNome,
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
var temp = XMLUtils.GetXML(ret, oParam.versao);
if (oParam.UF == TCodUfIBGE.Pernambuco)
{
//SEFAZ PE está retornando retEnviNFe ao inves de retConsReciNFe quando lote ainda está em processamento
temp = temp.Replace("retEnviNFe", "retConsReciNFe");
}
return(temp);
}
}
else if (DADOS.GetType().GetInterface("ITConsStatServ") != null)
{
var fnNome = "nfeStatusServicoNF2";
if ((oParam.UF == TCodUfIBGE.Parana || oParam.UF == TCodUfIBGE.Bahia) &&
oParam.conexao == TipoConexao.NFe &&
oParam.tipoEmissao == TNFeInfNFeIdeTpEmis.Normal &&
oParam.versao == VersaoXML.NFe_v310)
{
fnNome = "nfeStatusServicoNF";
}
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(fnNome,
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITInutNFe") != null)
{
var fnNome = "nfeInutilizacaoNF2";
if ((oParam.UF == TCodUfIBGE.Parana || oParam.UF == TCodUfIBGE.Bahia) &&
oParam.conexao == TipoConexao.NFe &&
oParam.tipoEmissao == TNFeInfNFeIdeTpEmis.Normal &&
oParam.versao == VersaoXML.NFe_v310)
{
fnNome = "nfeInutilizacaoNF";
}
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(fnNome,
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITConsSitNFe") != null)
{
string fnNome = "nfeConsultaNF2";
if ((oParam.UF == TCodUfIBGE.Parana || oParam.UF == TCodUfIBGE.Bahia) &&
oParam.conexao == TipoConexao.NFe &&
oParam.tipoEmissao == TNFeInfNFeIdeTpEmis.Normal &&
oParam.versao == VersaoXML.NFe_v310)
{
fnNome = "nfeConsultaNF";
}
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember(fnNome,
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("IDistDFeInt") != null)
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("nfeDistDFeInteresse",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else if (DADOS.GetType().GetInterface("ITDownloadNFe") != null)
{
XmlNode ret = (XmlNode)oServico.GetType().InvokeMember("nfeDownloadNF",
System.Reflection.BindingFlags.InvokeMethod,
null, oServico, new object[] { node });
return(XMLUtils.GetXML(ret, oParam.versao));
}
else
{
throw new Exception("Tipo de objeto de envio não mapeado. Consulte o administrador do Sistema.");
}
}
}
catch (Exception ex)
{
String msg = ex.Message;
if (ex.InnerException != null)
{
msg += " inner : " + ex.InnerException.Message;
if (ex.InnerException.InnerException != null)
{
msg += " inner : " + ex.InnerException.InnerException.Message;
}
}
throw new Exception("Erro ao executar Serviço : typeof(" + DADOS.GetType().ToString() + "). Verifique sua conexão com a Internet, configurações de proxy e certificado. " + msg);
}
}
/// <summary>
/// Recupera una entidad <see cref="Asignacion"/> de la Base de Datos dado un ID de Asignacion
/// </summary>
/// <author>Carlos Pradenas</author>
/// <created>11-04-2017 17:27:28</created>
/// <param name="id_Asign">ID de Asignacion.</param>
/// <returns>Referencia a una clase <see cref="Asignacion"/>.</returns>
public static AsignacionEntity ObtenerPorID(int id_Asign)
{
Parametro parametro = new Parametro("@IdAsig", id_Asign);
return(DBHelper.InstanceCRM.ObtenerEntidad("dbo.spMotor_Asignacion_ObtenerByID", parametro, ConstructorEntidad));
}
public CatalogoRegistro getCatalogo()
{
CatalogoRegistro cat = new CatalogoRegistro();
// get bancos
string selectBancos = "select clv_banco as clave, descripcion as value from banco";
List <Parametro> parametros = new List <Parametro>();
Parametro paramIdEstado = new Parametro();
paramIdEstado.Nombre = "@estado";
paramIdEstado.Valor = "prueba";
parametros.Add(paramIdEstado);
SqlDataReader readerBancos = conexion.Consultar(selectBancos, parametros);
List <CatalogoRegistro.Banco> ldocSuc = new List <CatalogoRegistro.Banco>();
while (readerBancos.Read())
{
CatalogoRegistro.Banco docSuc = new CatalogoRegistro.Banco();
docSuc.value = readerBancos["value"].ToString();
docSuc.key = Convert.ToInt32(readerBancos["clave"].ToString());
ldocSuc.Add(docSuc);
}
cat.listaBancos = ldocSuc;
// get estado civil
string selectEstadoCivil = "select clv_edo_civil as clave, descripcion as value from estado_civil";
SqlDataReader readerEstadoCivil = conexion.Consultar(selectEstadoCivil, parametros);
List <CatalogoRegistro.EstadoCivil> ldocEdoCivil = new List <CatalogoRegistro.EstadoCivil>();
while (readerEstadoCivil.Read())
{
CatalogoRegistro.EstadoCivil docEdoCivil = new CatalogoRegistro.EstadoCivil();
docEdoCivil.value = readerEstadoCivil["value"].ToString();
docEdoCivil.key = Convert.ToInt32(readerEstadoCivil["clave"].ToString());
ldocEdoCivil.Add(docEdoCivil);
}
cat.listaEdoCivil = ldocEdoCivil;
// get grados de estudios
string selectGradosEstudios = "select clv_grado_estu as clave, descripcion as value from grado_estudios";
SqlDataReader readerGradosEstudios = conexion.Consultar(selectGradosEstudios, parametros);
List <CatalogoRegistro.GradoEstudios> ldocGradoEstudios = new List <CatalogoRegistro.GradoEstudios>();
while (readerGradosEstudios.Read())
{
CatalogoRegistro.GradoEstudios docGradoEstudio = new CatalogoRegistro.GradoEstudios();
docGradoEstudio.value = readerGradosEstudios["value"].ToString();
docGradoEstudio.key = Convert.ToInt32(readerGradosEstudios["clave"].ToString());
ldocGradoEstudios.Add(docGradoEstudio);
}
cat.listaGradoEstudios = ldocGradoEstudios;
// get estados
string selectEstados = " select clv_edo as clave, nombre as value from estado";
SqlDataReader readerEstados = conexion.Consultar(selectEstados, parametros);
List <CatalogoRegistro.Estados> ldocEstados = new List <CatalogoRegistro.Estados>();
while (readerEstados.Read())
{
CatalogoRegistro.Estados docEstado = new CatalogoRegistro.Estados();
docEstado.value = readerEstados["value"].ToString();
docEstado.key = Convert.ToInt32(readerEstados["clave"].ToString());
ldocEstados.Add(docEstado);
}
cat.listaEstados = ldocEstados;
// get regiones
string selectRegion = " select region as clave, nombre as value from region";
SqlDataReader readerRegion = conexion.Consultar(selectRegion, parametros);
List <CatalogoRegistro.Region> ldocregion = new List <CatalogoRegistro.Region>();
while (readerRegion.Read())
{
CatalogoRegistro.Region docRegion = new CatalogoRegistro.Region();
docRegion.value = readerRegion["value"].ToString();
docRegion.key = Convert.ToInt32(readerRegion["clave"].ToString());
ldocregion.Add(docRegion);
}
cat.listaRegiones = ldocregion;
// get puestos
string selectPuestos = "select clv_puesto as clave, puesto as value from cat_puesto where app_funcion=1";
SqlDataReader readerPuestos = conexion.Consultar(selectPuestos, parametros);
List <CatalogoRegistro.Puesto> ldocPuestos = new List <CatalogoRegistro.Puesto>();
while (readerPuestos.Read())
{
CatalogoRegistro.Puesto docPuesto = new CatalogoRegistro.Puesto();
docPuesto.value = readerPuestos["value"].ToString();
docPuesto.key = Convert.ToInt32(readerPuestos["clave"].ToString());
ldocPuestos.Add(docPuesto);
}
cat.listaPuestos = ldocPuestos;
conexion.Cerrar();
return(cat);
}
public Entidad ConsultarXId(Entidad parametro)
{
List <Parametro> parameters = new List <Parametro>();
Dominio.Entidades.Producto _LaVenta = (Dominio.Entidades.Producto)parametro;
Parametro theParam = new Parametro();
try
{
theParam = new Parametro(RecursoVenta.ParamId, SqlDbType.Int,
_LaVenta.Id.ToString(), false);
parameters.Add(theParam);
DataTable dt = EjecutarStoredProcedureTuplas(RecursoVenta.ConsultUsuarioXId, parameters);
//Guardar los datos
DataRow row = dt.Rows[0];
int _id = int.Parse(row[RecursoVenta.VentaId].ToString());
String _nombre = row[RecursoVenta.VentaNombre].ToString();
int _activo = int.Parse(row[RecursoVenta.VentaModelo].ToString());
String _modelo = row[RecursoVenta.VentaApellido].ToString();
String _descripcion = row[RecursoVenta.VentaPedido].ToString();
float _precio = float.Parse(row[RecursoVenta.ventaSub].ToString());
int _cantidad = int.Parse(row[RecursoVenta.VentaIva].ToString());
float _peso = float.Parse(row[RecursoVenta.VentaNPago].ToString());
float _alto = float.Parse(row[RecursoVenta.VentaProducto].ToString());
float _ancho = float.Parse(row[RecursoVenta.VentaOperador].ToString());
float _largo = float.Parse(row[RecursoVenta.VentaTracking].ToString());
DateTime _fechaCreacion = DateTime.Parse(row[RecursoVenta.ventaFecha].ToString());
DateTime _fechaModificacion = DateTime.Parse(row[RecursoVenta.VentaDirFact].ToString());
int _fkMarca = int.Parse(row[RecursoVenta.VentasPEnvio].ToString());
int _fkCategoria = int.Parse(row[RecursoVenta.VentaEstatus].ToString());
//Creo un objeto de tipo Compania con los datos de la fila y lo guardo.
_LaVenta = new Dominio.Entidades.Producto(_id, _nombre, _activo, _modelo, _descripcion, _precio, _cantidad, _peso,
_alto, _ancho, _largo, _fechaCreacion, _fechaModificacion, _fkMarca, _fkCategoria);
//_LaVenta.Id = _id;
}
catch (FormatException ex)
{
/*throw new ExcepcionesTangerine.M8.WrongFormatException(RecursoVenta.Codigo,
* RecursoVenta.MensajeFormato, ex);*/
}
catch (ArgumentNullException ex)
{
/*throw new ExcepcionesTangerine.M8.NullArgumentException(RecursoVenta.Codigo,
* RecursoVenta.MensajeNull, ex);*/
}
catch (ExceptionCcConBD ex)
{
/*throw new ExcepcionesTangerine.ExceptionsTangerine(RecursoVenta.Codigo,
* RecursoVenta.MensajeSQL, ex);*/
}
catch (Exception ex)
{
/*
* throw new ExcepcionesTangerine.ExceptionsTangerine(RecursoVenta.Codigo,
* RecursoVenta.MensajeOtro, ex);*/
}
return(_LaVenta);
}
public static ITRetConsCad ConsultarCadastro(SoapHttpClientProtocol oServico, ITConsCad oEnviNFe3, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <ITRetConsCad, ITConsCad>(oServico, TService.Cadastro, oEnviNFe3, oParam, versao, "TRetConsCad"));
}
/// <summary>
/// Método para agregar una Venta nueva en la base de datos.
/// </summary>
/// <param name="LaVenta">Objeto de tipo Venta para agregar en la base de datos.</param>
/// <returns>True si fue agregada exitosamente.</returns>
public bool Agregar(Entidad LaVenta)
{
Parametro theParam = new Parametro();
try
{
List <Parametro> parameters = new List <Parametro>();
//Las dos lineas siguientes tienen que repetirlas tantas veces como parametros reciba su stored procedure a llamar
//Parametro recibe (nombre del primer parametro en su stored procedure, el tipo de dato, el valor, false)
theParam = new Parametro(RecursoVenta.ParamNombre, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Nombre, false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamApellido, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Apellido,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamCedula, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Cedula.ToString(), false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamTelefono, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Telefono,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamCelular, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Celular,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamPassword, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Password,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamFechaNacimieto, SqlDbType.Date, ((Dominio.Entidades.Usuario)LaVenta).Fecha_Nacimiento.ToString(), false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamFechaIngreso, SqlDbType.Date, ((Dominio.Entidades.Usuario)LaVenta).Fecha_Ingreso.ToString(), false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamStatus, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Email, false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamGenero, SqlDbType.Int, ((Dominio.Entidades.Usuario)LaVenta).Fk_Genero.ToString(), false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamRol, SqlDbType.Int, ((Dominio.Entidades.Usuario)LaVenta).Fk_Rol.ToString(),
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamTipoDoc, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Tipo_Documento,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamOrigen, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Origen,
false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamValidacionDC, SqlDbType.Int, ((Dominio.Entidades.Usuario)LaVenta).Validacion_dc.ToString(), false);
parameters.Add(theParam);
theParam = new Parametro(RecursoVenta.ParamValidoDC, SqlDbType.VarChar, ((Dominio.Entidades.Usuario)LaVenta).Valido_dc.ToString(),
false);
parameters.Add(theParam);
List <Resultado> results = EjecutarStoredProcedure(RecursoVenta.AddNuevoUsuario, parameters);
}
catch (ArgumentNullException ex)
{
}
catch (FormatException ex)
{
}
catch (System.Data.SqlClient.SqlException ex)
{
}
catch (ExceptionCcConBD ex)
{
throw new ExceptionsCity(RecursoVenta.Codigo,
RecursoVenta.MensajeSQL, ex);
}
catch (Exception ex)
{
throw new ExceptionsCity(RecursoVenta.Codigo,
RecursoVenta.MensajeOtro, ex);
}
return(true);
}
/// <summary>
/// Funcion que permite buscar todas las facturas en la base de datos
/// </summary>
/// <returns>Retorna la lista con todas las facturas</returns>
public List <Entidad> ConsultarTodos()
{
List <Parametro> parameters = new List <Parametro>();
Parametro theParam = new Parametro();
List <Entidad> listVenta = new List <Entidad>();
try
{
//Guardo la tabla que me regresa el procedimiento de consultar contactos
DataTable dt = EjecutarStoredProcedureTuplas(RecursoVenta.ConsultVenta, parameters);
//Guardar los datos
foreach (DataRow row in dt.Rows)
{
string _producto = row[RecursoVenta.VentaProducto].ToString();
string _marca = row[RecursoVenta.VentaMarca].ToString();
int _id = int.Parse(row[RecursoVenta.VentaId].ToString());
string _nombre = row[RecursoVenta.VentaNombre].ToString();
string _apellido = row[RecursoVenta.VentaApellido].ToString();
string _tracking = row[RecursoVenta.VentaTracking].ToString();
DateTime _fechaCreacion = DateTime.Parse(row[RecursoVenta.ventaFecha].ToString());
string _subtotal = row[RecursoVenta.ventaSub].ToString();
string _pedido = row[RecursoVenta.VentaPedido].ToString();
string _iva = row[RecursoVenta.VentaIva].ToString();
string _precioEnvio = row[RecursoVenta.VentasPEnvio].ToString();
string _estatus = row[RecursoVenta.VentaEstatus].ToString();
//string _dirFact = row[RecursoVenta.VentaDirFact].ToString();
//string _dirEnv = row[RecursoVenta.VentaDirEnv].ToString();
string _numPago = row[RecursoVenta.VentaNPago].ToString();
//string _operador = row[RecursoVenta.VentaOperador].ToString();
string _modelo = row[RecursoVenta.VentaModelo].ToString();
string _mail = row[RecursoVenta.VentaCorreo].ToString();
string _notificacion = row["Notificacion"].ToString();
Dominio.Entidades.Venta _LaVenta = new Dominio.Entidades.Venta(_id, _nombre, _apellido, _tracking, _subtotal, _pedido,
_fechaCreacion, _iva, _precioEnvio, _estatus, _numPago, _producto, _modelo, _marca, _mail, _notificacion);
listVenta.Add(_LaVenta);
}
}
catch (FormatException ex)
{
/* throw new ExcepcionesTangerine.M8.WrongFormatException(RecursoVenta.Codigo,
* RecursoVenta.MensajeFormato, ex);*/
}
catch (ArgumentNullException ex)
{
/* throw new ExcepcionesTangerine.M8.NullArgumentException(RecursoVenta.Codigo,
* RecursoVenta.MensajeNull, ex);*/
}
catch (ExceptionCcConBD ex)
{
throw new ExceptionsCity(RecursoVenta.Codigo,
RecursoVenta.MensajeSQL, ex);
}
catch (Exception ex)
{
throw new ExceptionsCity(RecursoVenta.Codigo,
RecursoVenta.MensajeOtro, ex);
}
return(listVenta);
}
public static TResultLote_GNRE GNREConsultaLote(SoapHttpClientProtocol oServico, TConsLote_GNRE xmlEnvio, Parametro oParam, VersaoXML versao)
{
return(ExecutaServico <TResultLote_GNRE, TConsLote_GNRE>(oServico, TService.GNRE_ConsultaLote, xmlEnvio, oParam, oParam.versao, "TResultLote_GNRE"));
}
private static void InicializaServico(System.Web.Services.Protocols.SoapHttpClientProtocol oServico, Parametro oParam)
{
X509Certificate2 certificadoX509 = Certificado.Carregar(oParam.certificado, oParam.tipoBuscaCertificado);
oServico.ClientCertificates.Clear();
oServico.ClientCertificates.Add(certificadoX509);
if (oParam.prx)
{
oServico.Proxy = new WebProxy(oParam.prxUrl, true);
oServico.Proxy.Credentials = new NetworkCredential(oParam.prxUsr, oParam.prxPsw, oParam.prxDmn);
}
else
{
oServico.Credentials = System.Net.CredentialCache.DefaultCredentials;
}
oServico.Timeout = (int)oParam.timeout;
oServico.InitializeLifetimeService();
// forçar aceitação de todos os certificados dos servidores da SEFAZ
// independentemente de ter a cadeia de certificação instalada
System.Net.ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
if (oParam.versao == VersaoXML.NFe_v400)
{
//permitir somente o protocolo: TLS1.2
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
}
else
{
//permitir os protocolos: SSL3 TLS1.0 TLS1.1 TLS1.2
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
}
}
