public ResultadoKumite(int puntaje1, int puntaje2, DominioSKD.Entidades.Modulo10.Inscripcion inscripcion1, DominioSKD.Entidades.Modulo10.Inscripcion inscripcion2)
{
this.puntaje1 = puntaje1;
this.puntaje2 = puntaje2;
this.inscripcion1 = inscripcion1;
this.inscripcion2 = inscripcion2;
}
public ResultadoKata(int jurado1, int jurado2, int jurado3, DominioSKD.Entidades.Modulo10.Inscripcion inscripcion)
{
this.jurado1 = jurado1;
this.jurado2 = jurado2;
this.jurado3 = jurado3;
this.inscripcion = inscripcion;
}
public bool agregarCompetencia(DominioSKD.Competencia laCompetencia)
{
Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosLogicaModulo12.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
try
{
Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosLogicaModulo12.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return BDCompetencia.AgregarCompetencia(laCompetencia);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw ex;
}
catch (ExcepcionesSKD.Modulo12.CompetenciaExistenteException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw ex;
}
catch (ExcepcionesSKD.Modulo12.FormatoIncorrectoException ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw ex;
}
catch (ExcepcionesSKD.ExceptionSKD ex)
{
Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
throw ex;
}
}
/// <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;
}
public DominioSKD.Entidades.Modulo8.RestriccionCinta meterParametrosVistaEnObjeto(DominioSKD.Entidades.Modulo8.RestriccionCinta laRestriccion)
{
DominioSKD.Entidades.Modulo8.RestriccionCinta retriccionCinta = laRestriccion;
retriccionCinta.IdRestriccionCinta = int.Parse(vista.id_restriccion);
retriccionCinta.PuntosMinimos = int.Parse(vista.puntaje_min);
retriccionCinta.TiempoDocente = int.Parse(vista.horas_docen);
retriccionCinta.TiempoMinimo = int.Parse(vista.tiempo_Min);
//generarDescripcion();
return retriccionCinta;
}
public Cinta(String elColor, String elRango, String laClasificacion, int elOrden, String elSignificado, DominioSKD.Entidades.Modulo3.Organizacion organizacion,Boolean status)
: base()
{
color_nombre = elColor;
rango = elRango;
clasificacion = laClasificacion;
orden = elOrden;
significado = elSignificado;
this.organizacion = organizacion;
this.status = status;
}
public Inscripcion(DateTime fecha, Persona persona, DominioSKD.Entidades.Modulo12.Competencia competencia)
{
this.fecha = fecha;
this.persona = persona;
this.competencia = competencia;
this.evento = new Evento();
this.asistencias = new List<Asistencia>();
this.resAscenso = new List<Entidad>();
this.resKata = new List<Entidad>();
this.resKumite = new List<ResultadoKumite>();
}
/// <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 Inscripcion(DateTime fecha, Persona persona, Evento evento, DominioSKD.Entidades.Modulo14.SolicitudPlanilla solicitud)
{
this.fecha = fecha;
this.persona = persona;
this.evento = evento;
this.solicitud = solicitud;
this.competencia = new Modulo12.Competencia();
this.asistencias = new List<Asistencia>();
this.resAscenso = new List<Entidad>();
this.resKata = new List<Entidad>();
this.resKumite = new List<ResultadoKumite>();
}
public DominioSKD.Entidades.Modulo8.RestriccionEvento meterParametrosVistaEnObjeto1(DominioSKD.Entidades.Modulo8.RestriccionEvento laRestriccion)
{
DominioSKD.Entidades.Modulo8.RestriccionEvento retriccionEvento = laRestriccion;
retriccionEvento.EdadMinima = int.Parse(vista.edadMinima.SelectedValue);
retriccionEvento.EdadMaxima = int.Parse(vista.edadMaxima.SelectedValue);
retriccionEvento.Sexo = vista.sexo.ToString();
//generarDescripcion();
return retriccionEvento;
}
public Boolean Eliminar(DominioSKD.Entidad parametro)
{
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro;
try
{
if (ExisteRestriccionCompetenciaSimilar(laRestriccionCompetencia))
{
List<Parametro> parametros = new List<Parametro>(); //declaras lista de parametros
laRestriccionCompetencia.IdRestriccionComp = traerIdRestriccionCompetencia(laRestriccionCompetencia);
Parametro elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdRestriccionCompetencia, SqlDbType.Int,
laRestriccionCompetencia.IdRestriccionComp.ToString(), false);
parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamDescripcion, SqlDbType.VarChar,
// laRestriccionCompetencia.Descripcion, false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamEdadMin, SqlDbType.Int,
// laRestriccionCompetencia.EdadMinima.ToString(), false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamEdadMax, SqlDbType.Int,
// laRestriccionCompetencia.EdadMaxima.ToString(), false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamRangoMin, SqlDbType.Int,
// laRestriccionCompetencia.RangoMinimo.ToString(), false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamRangoMax, SqlDbType.Int,
// laRestriccionCompetencia.RangoMaximo.ToString(), false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamSexo, SqlDbType.VarChar,
// laRestriccionCompetencia.Sexo, false);
//parametros.Add(elParametro);
//elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamModalidad, SqlDbType.VarChar,
// laRestriccionCompetencia.Modalidad, false);
//parametros.Add(elParametro);
EjecutarStoredProcedure(RecursosDAORestriccionCompetencia.EliminarRestriccionCompetencia, parametros);
}
else
throw new ExcepcionesSKD.Modulo8.RestriccionExistenteException(RecursosDAORestriccionCompetencia.Codigo_Restriccion_Competencia_No_Existente,
RecursosDAORestriccionCompetencia.Mensaje_Restriccion_Competencia_No_Existente, new Exception());
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD 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>
/// Metodo que permite obtener de base de datos todos los atletas que participaran a una competencia por id de especialidad, competencia y categoria
/// </summary>
/// <param name="entidad">id de la categoria</param>
/// <returns>lista de inscripciones</returns>
public List<DominioSKD.Entidad> ListaAtletasParticipanCompetenciaKata(DominioSKD.Entidad entidad)
{
List<Entidad> inscripciones = new List<Entidad>();
try
{
List<Parametro> parametros = new List<Parametro>();
Parametro parametro = new Parametro(RecursosDAOModulo11.ParametroIdEspecialidad, SqlDbType.Int, ((DominioSKD.Entidades.Modulo12.Competencia)entidad).TipoCompetencia, false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo11.ParametroIdCompetencia, SqlDbType.Int, ((DominioSKD.Entidades.Modulo12.Competencia)entidad).Id.ToString(), false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo11.ParametroIdCategoria, SqlDbType.Int, ((DominioSKD.Entidades.Modulo12.Competencia)entidad).Categoria.Id.ToString(), false);
parametros.Add(parametro);
DataTable dt = EjecutarStoredProcedureTuplas(RecursosDAOModulo11.ProcedimientoPersonasCompitenCompetencia, parametros);
foreach (DataRow row in dt.Rows)
{
Entidad inscripcion = DominioSKD.Fabrica.FabricaEntidades.ObtenerInscripcion();
((DominioSKD.Entidades.Modulo10.Inscripcion)inscripcion).Id = int.Parse(row[RecursosDAOModulo11.aliasIdInscripcion].ToString());
Entidad persona = DominioSKD.Fabrica.FabricaEntidades.ObtenerPersonaM10();
((DominioSKD.Entidades.Modulo10.Persona)persona).Id = int.Parse(row[RecursosDAOModulo11.aliasIdPersona].ToString());
((DominioSKD.Entidades.Modulo10.Persona)persona).Nombre = row[RecursosDAOModulo11.aliasNombrePersona].ToString();
((DominioSKD.Entidades.Modulo10.Persona)persona).Apellido = row[RecursosDAOModulo11.aliasApellidoPersona].ToString();
((DominioSKD.Entidades.Modulo10.Inscripcion)inscripcion).Persona = persona as DominioSKD.Entidades.Modulo10.Persona;
Entidad resultadoKata = DominioSKD.Fabrica.FabricaEntidades.ObtenerResultadoKata();
((DominioSKD.Entidades.Modulo11.ResultadoKata)resultadoKata).Id = int.Parse(row[RecursosDAOModulo11.aliasIdResultadoKata].ToString());
((DominioSKD.Entidades.Modulo11.ResultadoKata)resultadoKata).Jurado1 = int.Parse(row[RecursosDAOModulo11.aliasJurado1].ToString());
((DominioSKD.Entidades.Modulo11.ResultadoKata)resultadoKata).Jurado2 = int.Parse(row[RecursosDAOModulo11.aliasJurado2].ToString());
((DominioSKD.Entidades.Modulo11.ResultadoKata)resultadoKata).Jurado3 = int.Parse(row[RecursosDAOModulo11.aliasJurado3].ToString());
List<Entidad> resultadosKata = new List<Entidad>();
resultadosKata.Add(resultadoKata);
((DominioSKD.Entidades.Modulo10.Inscripcion)inscripcion).ResKata = resultadosKata;
inscripciones.Add(inscripcion);
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
//throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosBDModulo10.CodigoErrorFormato,
// RecursosBDModulo10.MensajeErrorFormato, ex);
throw ex;
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return inscripciones;
}
/// <summary>
/// Metodo que permite obtener de base de datos todas las categorias que participan en una competencia
/// </summary>
/// <param name="entidad">id de la competencia</param>
/// <returns>lista de categorias</returns>
public List<DominioSKD.Entidad> ListaCategoriaCompetencia(DominioSKD.Entidad entidad)
{
List<Entidad> categorias = new List<Entidad>();
DominioSKD.Fabrica.FabricaEntidades fabrica = new DominioSKD.Fabrica.FabricaEntidades();
try
{
List<Parametro> parametros = new List<Parametro>();
Parametro parametro = new Parametro(RecursosDAOModulo11.ParametroIdCompetencia, SqlDbType.Int, ((DominioSKD.Entidades.Modulo12.Competencia)entidad).Id.ToString(), false);
parametros.Add(parametro);
parametro = new Parametro(RecursosDAOModulo11.ParametroIdEspecialidad, SqlDbType.Int, ((DominioSKD.Entidades.Modulo12.Competencia)entidad).TipoCompetencia, false);
parametros.Add(parametro);
DataTable dt = EjecutarStoredProcedureTuplas(RecursosDAOModulo11.ProcedimientoCategoriasCompetenciaEspecialidad, parametros);
foreach (DataRow row in dt.Rows)
{
Entidad categoria = FabricaEntidades.ObtenerCategoria();
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Id = int.Parse(row[RecursosDAOModulo11.aliasIdCategoria].ToString());
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Edad_inicial = int.Parse(row[RecursosDAOModulo11.aliasEdadInicial].ToString());
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Edad_final = int.Parse(row[RecursosDAOModulo11.aliasEdadFinal].ToString());
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Cinta_inicial = row[RecursosDAOModulo11.aliasCintaInicial].ToString();
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Cinta_final = row[RecursosDAOModulo11.aliasCintaFinal].ToString();
((DominioSKD.Entidades.Modulo12.Categoria)categoria).Sexo = row[RecursosDAOModulo11.aliasSexoCategoria].ToString();
categorias.Add(categoria);
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
//throw new ExcepcionesSKD.Modulo12.FormatoIncorrectoException(RecursosBDModulo10.CodigoErrorFormato,
// RecursosBDModulo10.MensajeErrorFormato, ex);
throw ex;
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return categorias;
}
/// <summary>
/// Metodo para eliminar relaciones entre Restricciones y Competencias.
/// </summary>
/// <param name="parametro1">Tipo: objeto RestriccionCompetencia</param>
/// <param name="parametro2">Tipo: objeto Competencia</param>
/// <returns>True si se elimina la relacion exitosamente, False si no existe o falla la eliminacion</returns>
public Boolean EliminarCompetenciaRestriccionCompetencia(DominioSKD.Entidad parametro1, DominioSKD.Entidad parametro2)
{
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro1;
DominioSKD.Entidades.Modulo12.Competencia laCompetencia =
(DominioSKD.Entidades.Modulo12.Competencia)parametro2;
if (ExisteCompetenciaRestriccionCompetencia(laRestriccionCompetencia, laCompetencia))
{
try
{
laRestriccionCompetencia.Id = traerIdRestriccionCompetencia(parametro1);
List<Parametro> parametros;
parametros = new List<Parametro>();
Parametro elParametro;
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdRestriccionCompetencia, SqlDbType.Int,
laRestriccionCompetencia.IdRestriccionComp.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdCompetencia, SqlDbType.Int,
laCompetencia.Id.ToString(), false);
parametros.Add(elParametro);
EjecutarStoredProcedure(RecursosDAORestriccionCompetencia.EliminarCompetenciaRestriccionCompetencia, parametros);
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo, RecursoGeneralBD.Mensaje, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
}
else
{
return false;
}
return true;
}
/// <summary>
/// Método para validar la informacion de la cinta antes de agregarla
/// </summary>
public void ValidarExpresionesReg(DominioSKD.Entidades.Modulo5.Cinta laCinta, string ordenString)
{
//Validar las expresionnes regulares
Regex rex = new Regex(RecursoPresentadorM5.expresionNombre);
Regex rex2 = new Regex(RecursoPresentadorM5.expresionNumero);
Regex rex3 = new Regex(RecursoPresentadorM5.expresionNombreNumero);
if (!rex.IsMatch(laCinta.Color_nombre))
throw new ExcepcionesSKD.Modulo5.ExpresionesRegularesException(RecursoPresentadorM5.Codigo_Error_Expresion_Regular,
RecursoPresentadorM5.Mensaje_Error_Expresion_Regular_Color, new Exception());
else if (!rex3.IsMatch(laCinta.Rango))
throw new ExcepcionesSKD.Modulo5.ExpresionesRegularesException(RecursoPresentadorM5.Codigo_Error_Expresion_Regular,
RecursoPresentadorM5.Mensaje_Error_Expresion_Regular_Rango, new Exception());
else if (!rex.IsMatch(laCinta.Clasificacion))
throw new ExcepcionesSKD.Modulo5.ExpresionesRegularesException(RecursoPresentadorM5.Codigo_Error_Expresion_Regular,
RecursoPresentadorM5.Mensaje_Error_Expresion_Regular_Clasificacion, new Exception());
else if (!rex.IsMatch(laCinta.Significado))
throw new ExcepcionesSKD.Modulo5.ExpresionesRegularesException(RecursoPresentadorM5.Codigo_Error_Expresion_Regular,
RecursoPresentadorM5.Mensaje_Error_Expresion_Regular_Significado, new Exception());
else if (!rex2.IsMatch(ordenString))
throw new ExcepcionesSKD.Modulo5.ExpresionesRegularesException(RecursoPresentadorM5.Codigo_Error_Expresion_Regular,
RecursoPresentadorM5.Mensaje_Error_Expresion_Regular_Orden, new Exception());
}
/// <summary>
/// Metodo que permite corroborar dado un objeto tipo RestriccionCompetencia
/// si existe una restriccion de competencia con los mismos parametros en la
/// base de datos
/// </summary>
/// <param name="parametro"> Objeto de tipo generico que sera interpretado
/// como un objeto del tipo RestriccionCompetencia</param>
/// <returns>Retorna True si encuentra una restriccion similar en la base
/// de datos, o False si no existe tal restriccion de competencia.</returns>
public Boolean ExisteRestriccionCompetenciaSimilar(DominioSKD.Entidad parametro)
{
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro;
Boolean retorno = false;
List<Parametro> parametros;
try
{
parametros = new List<Parametro>();
Parametro elParametro;
elParametro = new Parametro(DatosSKD.DAO.Modulo8.RecursosDAORestriccionCompetencia.ParamDescripcion, SqlDbType.VarChar,
laRestriccionCompetencia.Descripcion, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamEdadMin, SqlDbType.Int,
laRestriccionCompetencia.EdadMinima.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamEdadMax, SqlDbType.Int,
laRestriccionCompetencia.EdadMaxima.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamRangoMin, SqlDbType.Int,
laRestriccionCompetencia.RangoMinimo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamRangoMax, SqlDbType.Int,
laRestriccionCompetencia.RangoMaximo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamSexo, SqlDbType.VarChar,
laRestriccionCompetencia.Sexo, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamModalidad, SqlDbType.VarChar,
laRestriccionCompetencia.Modalidad, false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamSalidaNumRestriccion, SqlDbType.Int, true);
parametros.Add(elParametro);
List<Resultado> resultados = EjecutarStoredProcedure(RecursosDAORestriccionCompetencia.ExisteRestriccionCompetencia
, parametros);
foreach (Resultado elResultado in resultados)
{
if (elResultado.etiqueta == RecursosDAORestriccionCompetencia.ParamSalidaNumRestriccion)
if (int.Parse(elResultado.valor) != 0)
retorno = true;
else
retorno = false;
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return retorno;
}
public static Entidad ObtenerSolicitudPlanilla(DateTime fechaRetiro, DateTime fechaReincorporacion, string motivo, DominioSKD.Entidades.Modulo14.Planilla planilla)
{
return new DominioSKD.Entidades.Modulo14.SolicitudPlanilla(fechaRetiro, fechaReincorporacion, motivo, planilla);
}
public DominioSKD.Entidad ConsultarXId(DominioSKD.Entidad parametro)
{
throw new NotImplementedException();
}
/// <summary>
/// Metodo para Modificar una restriccion de cinta existente en la base de datos.
/// </summary>
/// <param name="parametro"></param>
/// <returns></returns>
public Boolean ModificarRestriccionCinta(DominioSKD.Entidad parametro)
{
DominioSKD.Entidades.Modulo8.RestriccionCinta laRestriccionCinta =
(DominioSKD.Entidades.Modulo8.RestriccionCinta)parametro;
try
{
List<Parametro> parametros = new List<Parametro>();
Parametro elParametro = new Parametro(RecursosDAORestriccionCinta.ParamIdRestriccion, SqlDbType.Int,
laRestriccionCinta.IdRestriccionCinta.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamTiempoMinimo, SqlDbType.Int,
laRestriccionCinta.TiempoMinimo.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamPuntosMinimos, SqlDbType.Int,
laRestriccionCinta.PuntosMinimos.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamHorasDocentes, SqlDbType.Int,
laRestriccionCinta.TiempoDocente.ToString(), false);
parametros.Add(elParametro);
//BDConexion laConexion = new BDConexion();
this.EjecutarStoredProcedure(RecursosDAORestriccionCinta.ModificarRestriccionCinta, parametros);
}
catch (SqlException ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionCompetencia.Codigo_Error_Formato,
RecursosDAORestriccionCompetencia.Mensaje_Error_Formato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw ex;
}
catch (Exception ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return true;
}
public static Entidad ObtenerCinta_M5(String elColor, String elRango, String laClasificacion, int elOrden, String elSignificado, DominioSKD.Entidades.Modulo3.Organizacion organizacion, Boolean status)
{
return new DominioSKD.Entidades.Modulo5.Cinta(elColor, elRango, laClasificacion, elOrden, elSignificado, organizacion, status);
}
/// <summary>
/// Metodo para eliminar las relaciones entre una lista de competencias y una restriccion de competencia
/// </summary>
/// <param name="parametro1">objeto tipo: RestriccionCompetencia</param>
/// <param name="parametro2">lista de objetos tipo : Competencia</param>
/// <returns></returns>
public Boolean EliminarListaCompetenciaRestriccionCompetencia(DominioSKD.Entidad parametro1, List<DominioSKD.Entidad> parametro2)
{
DominioSKD.Entidad restriccion = parametro1;
Boolean resultado = false;
try
{
foreach (DominioSKD.Entidad competencia in parametro2)
{
try
{
resultado = EliminarCompetenciaRestriccionCompetencia(restriccion, competencia);
resultado = true;
}
catch (Exception ex)
{
throw ex;
}
}
}
catch (Exception ex1)
{
throw ex1;
}
return resultado;
}
public Boolean EliminarLogicoRestriccionCompetencia(DominioSKD.Entidad parametro)
{
//Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDRestriccionCompetencia.MensajeInicioInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
Boolean resultado = false;
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro;
try
{
List<Parametro> parametros;
parametros = new List<Parametro>();
Parametro elParametro;
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdRestriccionCompetencia, SqlDbType.Int,
laRestriccionCompetencia.IdRestriccionComp.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamStatus, SqlDbType.Int,
laRestriccionCompetencia.Status.ToString(), false);
parametros.Add(elParametro);
this.EjecutarStoredProcedure(RecursosDAORestriccionCompetencia.EiminarLogicoRestriccionCompetencia, parametros);
resultado = true;
}
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(RecursosDAORestriccionCompetencia.Codigo_Error_Formato,
RecursosDAORestriccionCompetencia.Mensaje_Error_Formato, 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);
}
//Logger.EscribirInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, RecursosBDRestriccionCompetencia.MensajeFinInfoLogger, System.Reflection.MethodBase.GetCurrentMethod().Name);
return resultado;
}
/// <summary>
/// Metodo que dado un objeto RestriccionCompetencia, retorna una lista
/// de objetos Competencia los cuales no estan relacionados con la RestriccionCompetencia provista
/// </summary>
/// <param name="parametro">Tipo: Objeto RestriccionCompetencia</param>
/// <returns>Lista de objetos: Competencia</returns>
public List<DominioSKD.Entidad> ConsultarTodasLasCompetenciasNoAsociadas(DominioSKD.Entidad parametro)
{
List<DominioSKD.Entidad> listaDeCompetencias = new List<DominioSKD.Entidad>();
List<Parametro> parametros;
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro;
try
{
parametros = new List<Parametro>();
Parametro elParametro;
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdRestriccionCompetencia, SqlDbType.Int,
laRestriccionCompetencia.IdRestriccionComp.ToString(), false);
parametros.Add(elParametro);
DataTable dt;
dt = EjecutarStoredProcedureTuplas(RecursosDAORestriccionCompetencia.ConsultarTodasLasCompetenciasNoAsociadas, parametros);
foreach (DataRow row in dt.Rows)
{
Competencia laCompetencia;
laCompetencia = new Competencia();
laCompetencia.Id_competencia = int.Parse(row[RecursosDAORestriccionCompetencia.AliasIdCompetencia].ToString());
laCompetencia.Nombre = row[RecursosDAORestriccionCompetencia.AliasNombreCompetencia].ToString();
laCompetencia.TipoCompetencia = row[RecursosDAORestriccionCompetencia.AliasTipoCompetencia].ToString();
if (laCompetencia.TipoCompetencia == "1")
{
laCompetencia.TipoCompetencia = RecursosDAORestriccionCompetencia.TipoCompetenciaKata;
}
else
{
laCompetencia.TipoCompetencia = RecursosDAORestriccionCompetencia.TipoCompetenciaKumite;
}
laCompetencia.Status = row[RecursosDAORestriccionCompetencia.AliasStatusCompetencia].ToString();
laCompetencia.OrganizacionTodas = Convert.ToBoolean(row[RecursosDAORestriccionCompetencia.AliasTodasOrganizaciones].ToString());
if (laCompetencia.OrganizacionTodas == false)
{
laCompetencia.Organizacion = new Organizacion(int.Parse(row[RecursosDAORestriccionCompetencia.AliasIdOrganizacion].ToString())
, row[RecursosDAORestriccionCompetencia.AliasNombreOrganizacion].ToString());
}
else
{
laCompetencia.Organizacion = new Organizacion(RecursosDAORestriccionCompetencia.TodasLasOrganizaciones);
}
laCompetencia.Ubicacion = new Ubicacion(int.Parse(row[RecursosDAORestriccionCompetencia.AliasIdUbicacion].ToString()),
row[RecursosDAORestriccionCompetencia.AliasNombreCiudad].ToString(), row[RecursosDAORestriccionCompetencia.AliasNombreEstado].ToString());
listaDeCompetencias.Add(laCompetencia);
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return listaDeCompetencias;
}
/// <summary>
/// Método para validar la informacion de la organizacion antes de agregarla
/// </summary>
public void ValidarExpresionesReg(DominioSKD.Entidades.Modulo3.Organizacion laOrganizacion, string telefono)
{
//Validar las expresionnes regulares
Regex rexNombre = new Regex(RecursosPresentadorM3.expresionNombre);
Regex resNumero = new Regex(RecursosPresentadorM3.expresionNumero);
Regex rexNombreNumero = new Regex(RecursosPresentadorM3.expresionNombreNumero);
Regex rexCorreo = new Regex(RecursosPresentadorM3.expresionesCorreo);
Regex rexDireccion = new Regex(RecursosPresentadorM3.expresionDireccion);
if (!rexNombre.IsMatch(laOrganizacion.Nombre))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Nombre, new Exception());
else if (!rexCorreo.IsMatch(laOrganizacion.Email) || !laOrganizacion.Email.Contains(RecursosPresentadorM3.arroba))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Email, new Exception());
else if (!resNumero.IsMatch(telefono))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Telefono, new Exception());
else if (!rexDireccion.IsMatch(laOrganizacion.Direccion))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Direccion, new Exception());
else if (!rexNombre.IsMatch(laOrganizacion.Estado))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Estado, new Exception());
else if (!rexNombre.IsMatch(laOrganizacion.Estilo))
throw new ExcepcionesSKD.Modulo3.ExpresionesRegularesException(RecursosPresentadorM3.Codigo_Error_Expresion_Regular,
RecursosPresentadorM3.Mensaje_Error_Expresion_Regular_Estilo, new Exception());
}
public static Entidad ObtenerSolicitudP(int id, String fechaRetiro, String fechaReincorporacion, String motivo, DominioSKD.Entidades.Modulo14.Planilla planilla, int idInscripcion)
{
return new DominioSKD.Entidades.Modulo14.SolicitudP(id, fechaRetiro, fechaReincorporacion, motivo, planilla, idInscripcion);
}
/// <summary>
/// Metodo que retorna si existe una relacion entre una RestriccionCompetencia y una Competencia dadas
/// </summary>
/// <param name="parametro1">objeto tipo: RestriccionCompetencia</param>
/// <param name="parametro2">objeto tipo: Competencia</param>
/// <returns>retorna true si existe false si no existe</returns>
public Boolean ExisteCompetenciaRestriccionCompetencia(DominioSKD.Entidad parametro1, DominioSKD.Entidad parametro2)
{
DominioSKD.Entidades.Modulo8.RestriccionCompetencia laRestriccionCompetencia =
(DominioSKD.Entidades.Modulo8.RestriccionCompetencia)parametro1;
DominioSKD.Entidades.Modulo12.Competencia laCompetencia =
(DominioSKD.Entidades.Modulo12.Competencia)parametro2;
Boolean retorno = false;
List<Parametro> parametros;
try
{
parametros = new List<Parametro>();
Parametro elParametro;
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdRestriccionCompetencia, SqlDbType.Int,
laRestriccionCompetencia.IdRestriccionComp.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCompetencia.ParamIdCompetencia, SqlDbType.Int,
laCompetencia.Id.ToString(), false);
parametros.Add(elParametro);
List<Resultado> resultados;
resultados = EjecutarStoredProcedure(RecursosDAORestriccionCompetencia.ExisteRestriccionCompetencia
, parametros);
foreach (Resultado elResultado in resultados)
{
if (elResultado.etiqueta == RecursosDAORestriccionCompetencia.ParamSalidaNumRestriccion)
{
if (int.Parse(elResultado.valor) != 0)
retorno = true;
else
retorno = false;
}
}
}
catch (SqlException ex)
{
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return retorno;
}
public Boolean Modificar(DominioSKD.Entidad parametro)
{
throw new NotImplementedException();
}
public static Entidad ObtenerSolicitudPlanilla(int id, DateTime fechaCreacion, DateTime fechaRetiro, DateTime fechaReincorporacion,
string motivo, DominioSKD.Entidades.Modulo14.Planilla planilla, int idInscripcion, int idPersona)
{
return new DominioSKD.Entidades.Modulo14.SolicitudPlanilla(id, fechaCreacion, fechaRetiro, fechaReincorporacion,
motivo, planilla, idInscripcion, idPersona);
}
/// <summary>
/// Metodo para Eliminar una restriccion de cinta a la base de datos.
/// </summary>
/// <param name="parametro"></param>
/// <returns></returns>
public Boolean StatusRestriccionCinta(DominioSKD.Entidad parametro)
{
try
{
DominioSKD.Entidades.Modulo8.RestriccionCinta laRestriccionCinta =
(DominioSKD.Entidades.Modulo8.RestriccionCinta)parametro;
List<Parametro> parametros = new List<Parametro>(); //declaras lista de parametros
Parametro elParametro = new Parametro(RecursosDAORestriccionCinta.ParamIdRestriccion, SqlDbType.Int,
laRestriccionCinta.IdRestriccionCinta.ToString(), false);
parametros.Add(elParametro);
elParametro = new Parametro(RecursosDAORestriccionCinta.ParamStatus, SqlDbType.Int,
laRestriccionCinta.Status.ToString(), false);
parametros.Add(elParametro);
List<Resultado> resultados = this.EjecutarStoredProcedure(RecursosDAORestriccionCinta.EliminarRestriccionCinta
, parametros);
}
catch (SqlException ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.ExceptionSKDConexionBD(RecursoGeneralBD.Codigo,
RecursoGeneralBD.Mensaje, ex);
}
catch (FormatException ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.Modulo8.FormatoIncorrectoException(RecursosDAORestriccionCompetencia.Codigo_Error_Formato,
RecursosDAORestriccionCompetencia.Mensaje_Error_Formato, ex);
}
catch (ExcepcionesSKD.ExceptionSKDConexionBD ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw ex;
}
catch (Exception ex)
{
Console.Out.WriteLine("1" + " " + ex.Message);
throw new ExcepcionesSKD.ExceptionSKD(RecursoGeneralBD.Mensaje_Generico_Error, ex);
}
return true;
}
public static Entidad ObtenerSolicitudPlanilla(int id, DateTime fechaCreacion, DominioSKD.Entidades.Modulo14.Planilla planilla, int idInscripcion, int idPersona)
{
return new DominioSKD.Entidades.Modulo14.SolicitudPlanilla(id, fechaCreacion, planilla, idInscripcion, idPersona);
}
