//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
/// <summary>
/// Ejecuta el SP definido por el usuario: GetCodVend
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
public static string fGetCodVendAsString(StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Llamamos al metodo que nos da un vendedor.
EVendedor l_eVendedor = Bll.Vendedores.fGetVendedorFromUsu(p_smResult);
// Validamos que no haya errores.
if (p_smResult.NOk)
{
return("");
}
// Devolvemos el codigo de vendedor
return(l_eVendedor.Cod);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(null);
}
finally
{
// Si abrimos una conexion -> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Arma Tree de Moviles
/// </summary>
/// <param name="p_lentData">ListaEntidad de datos</param>
/// <param name="p_strDescripcion">Descripcion del Root</param>
/// <param name="p_iNroImagen">Indice de la imagen</param>
public static ListaEntidades fArmarTree(bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
ListaEntidades l_lentData;
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos los registros de la tabla
l_lentData = Bll.Moviles.GetMovilesTree(l_dbcAccess, p_smResult);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(null);
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
fAgregarRoot(l_lentData, "Moviles", 1);
return(l_lentData);
}
/// <summary>
/// Devuelve la próxima clave de la entidad
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Próxima clave</returns>
public static string NextKey(StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos la clave máxima
return(GetNK(l_dbcAccess,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion NextKey
p_smResult.BllError(l_expData);
return("");
}
finally {
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
public static int fGetKilometrajeActual(string p_strPatente, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
return(fGetKilometrajeActualWithConn(l_dbcAccess, p_strPatente, p_smResult));
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(0);
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Ejecuta el SP definido por el usuario: GetServiciosFull
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
internal static ListaEntidades GetServiciosFull(DBConn p_dbcAccess,
StatMsg p_smResult)
{
try {
// Llamamos al metodo definido por el usuario
DataSet l_dsTemp = new DataSet();
Dal.Servicios.GetServiciosFull(p_dbcAccess,
ref l_dsTemp,
"Temporal",
p_smResult);
if (p_smResult.NOk)
{
return(null);
}
// Creamos la LE y Captionamos
ListaEntidades l_lentRet = new ListaEntidades(l_dsTemp.Tables["Temporal"]);
BllRuts.FillStdCaptions(ref l_lentRet);
// Devolvemos la LE
l_dsTemp.Dispose();
return(l_lentRet);
}
catch (Exception l_expData) {
// Error en la operacion
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Terminamos
}
}
/// <summary>
/// Ejecuta el SP definido por el usuario: GetServiciosFull
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
public static ListaEntidades GetServiciosFull(StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Abrimos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Llamamos al metodo interno
return(GetServiciosFull(l_dbcAccess,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si abrimos una conexion -> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Ejecuta el SP definido por el usuario: GetPendientesFromMov
/// </summary>
/// <param name= p_strPatente>Patente</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
public static LEAlertas AleGetPendientesFromMov(string p_strPatente,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Abrimos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Llamamos al metodo interno
return(AleGetPendientesFromMov(l_dbcAccess,
p_strPatente,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si abrimos una conexion -> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
//**********************************************************
//
// Funciones para la Tabla: Servicios
// Usando ClaseDal : Servicios
//
//**********************************************************
//---------------------------------------------------------------
// Metodos públicos de la clase (visibles para la UIL)
//---------------------------------------------------------------
#region Metodos publicos de recupero
/// <summary>
/// Devuelve la grilla de la tabla: Servicios
/// </summary>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Lista-entidad: LEServicios</returns>
public static LEServicios UpFull(bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos los registros de la tabla
return(Upfl(l_dbcAccess, p_bOnlyActive, p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion UpFull
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Actualiza un registro a la tabla a partir de una entidad: EAlerta
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleUpdt(DBConn p_dbcAccess,
EAlerta p_entAlerta,
StatMsg p_smResult)
{
try {
// Validamos la integridad de la entidad
AleTInt(p_dbcAccess, p_entAlerta, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos un registro de la tabla: Alertas
Dal.Alertas.Update(p_dbcAccess,
p_entAlerta.Nroconfig,
p_entAlerta.Nroalerta,
p_entAlerta.Descripcion,
p_entAlerta.Detalle,
p_entAlerta.Importancia,
p_entAlerta.Fechadisparada,
p_entAlerta.Fechavista,
p_entAlerta.Usuariovista,
p_entAlerta.Repetirendias,
p_entAlerta.Finalizada,
p_entAlerta.Mailsenviados,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Updt
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Devuelve una Lista-entidad: LEServicios
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Lista-entidad: LEServicios</returns>
internal static LEServicios Upfl(DBConn p_dbcAccess,
bool p_bOnlyActive,
StatMsg p_smResult)
{
try {
// Pedimos los registros de la tabla: Servicios
DataSet l_dsTemp = new DataSet();
Dal.Servicios.Up(p_dbcAccess,
p_bOnlyActive,
ref l_dsTemp, "Temporal",
p_smResult);
if (p_smResult.NOk)
{
return(null);
}
// Fijamos los captions de la grilla
Dal.Servicios.MakeGridCaptions(ref l_dsTemp, "Temporal", p_smResult);
// Contruimos la lista-entidad y la devolvemos (si vino algun registro)
LEServicios l_lentRet = new LEServicios(l_dsTemp.Tables["Temporal"]);
l_dsTemp.Dispose();
return(l_lentRet);
}
catch (Exception l_expData) {
// Error en la operacion Upfl
p_smResult.BllError(l_expData);
return(null);
}
}
/// <summary>
/// Compacta una tabla borrando los registros deshabilitados
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Purge(StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Realizamos el borrado
Pack(l_dbcAccess,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Enabled
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Actualiza un registro a la tabla a partir de una entidad: ESupervisor
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entSupervisor">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void Updt(DBConn p_dbcAccess,
ESupervisor p_entSupervisor,
StatMsg p_smResult)
{
try {
// Validamos la integridad de la entidad
TInt(p_dbcAccess, p_entSupervisor, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos un registro de la tabla: Supervisores
Dal.Supervisores.Update(p_dbcAccess,
p_entSupervisor.Cod,
p_entSupervisor.Apellido,
p_entSupervisor.Nombre,
p_entSupervisor.Usuario,
p_entSupervisor.Tel,
p_entSupervisor.Cel,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Updt
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Devuelve una entidad: EAlerta
/// </summary>
/// <param name="p_iNroconfig">Nro Config Alerta</param>
/// <param name="p_iNroalerta">Nro Alerta</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad: EAlerta</returns>
public static EAlerta AleGet(int p_iNroconfig,
int p_iNroalerta,
bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos la entidad: EAlerta
return(AleSrch(l_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_bOnlyActive,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion Get
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Servicios
/// </summary>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Save(EServicio p_entServicio,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion y abrimos una transaccion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Grabamos la entidad: EServicio
SSav(l_dbcAccess, p_entServicio, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Save
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Devuelve los 5 ultimos estados de un movil
/// </summary>
/// <param name="p_strPatente"></param>
/// <param name="p_bOnlyActive"></param>
/// <param name="p_smResult"></param>
/// <returns></returns>
public static ListaEntidades fGetLastFiveMvlEstados(string p_strPatente,
bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
ListaEntidades l_lentData;
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos los registros de la tabla
l_lentData = Bll.Moviles.MvesgetLastFiveMvlEstads(l_dbcAccess, p_strPatente, p_smResult);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(null);
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
return(l_lentData);
}
/// <summary>
/// Ejecuta el SP definido por el usuario: getMovilEstadoActual
/// </summary>
/// <param name= p_strPatente>Patente</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
public static EMovilEstado fGetMovilEstadoActual(DBConn conexion,
string p_strPatente,
StatMsg p_smResult)
{
try
{
// Pedimos los registros de la tabla
ListaEntidades ultimos5Estados = Bll.Moviles.MvesgetLastFiveMvlEstads(conexion, p_strPatente, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
EMovilEstado estadoActual = Bll.Moviles.MvesSrch(conexion, p_strPatente, Convert.ToDateTime(ultimos5Estados.InternalData[0][Bel.EMovilEstado.FechaCmp]), true, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
return(estadoActual);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData);
return(null);
}
}
/// <summary>
/// Me devuelve un Array con las listas entidades de los ultimos 5 combustibles, estados, kms y eq
/// </summary>
/// <param name="p_strPatente">Patente</param>
/// <param name="p_bOnlyActive"></param>
/// <param name="p_smResult"></param>
/// <returns></returns>
public static List <ListaEntidades> fGetLastFiveTodos(string p_strPatente,
bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
List <ListaEntidades> l_lstLEListaListaEntidades = new List <ListaEntidades>();
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos los registros de la tabla
ListaEntidades ultimosCincoCombustibles = Moviles.MvcogetLastFiveMvlCombus(l_dbcAccess, p_strPatente, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
ListaEntidades ultimosCincoKilometrajes = Moviles.MvkmgetLastFiveMvlKm(l_dbcAccess, p_strPatente, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
ListaEntidades ultimosCincoEstados = Moviles.MvesgetLastFiveMvlEstads(l_dbcAccess, p_strPatente, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
ListaEntidades equipamientos = Moviles.MveqFSch(l_dbcAccess, p_strPatente, true, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
l_lstLEListaListaEntidades.Add(ultimosCincoCombustibles);
l_lstLEListaListaEntidades.Add(ultimosCincoKilometrajes);
l_lstLEListaListaEntidades.Add(ultimosCincoEstados);
l_lstLEListaListaEntidades.Add(equipamientos);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(null);
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
return(l_lstLEListaListaEntidades);
}
/// <summary>
/// Devuelve una entidad: EServicio
/// </summary>
/// <param name="p_strCod">Código</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad: EServicio</returns>
public static EServicio Get(string p_strCod,
bool p_bOnlyActive,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Pedimos la entidad: EServicio
return(Srch(l_dbcAccess,
p_strCod,
p_bOnlyActive,
p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion Get
p_smResult.BllError(l_expData);
return(null);
}
finally {
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
/// <summary>
/// Devuelve la lista entidades de ordenes de trabajo de un movil (buscando por patente)
/// </summary>
/// <param name="p_strPatente"></param>
/// <param name="p_smResult"></param>
/// <returns>ListaEOrdenes De Trabajo</returns>
public static LEOrdenesTrabajo ObtenerOTsPorPatente(string p_strPatente, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
LEOrdenesTrabajo l_LEOrdenesTrabajo = LEOrdenesTrabajo.NewEmpty();
try
{
// Obtenemos una conexion y abrimos una transaccion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Por cada equipamiento de la lista lo grabamos, con la misma coneccion todos
l_LEOrdenesTrabajo = Bll.OrdenesTrabajo.getPendByPatente(l_dbcAccess, p_strPatente, p_smResult);
}
catch (Exception l_expData)
{
// Error
p_smResult.BllError(l_expData.ToString());
}
finally
{
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
return(l_LEOrdenesTrabajo);
}
/// <summary>
/// Finaliza el proceso de los registros de un archivo de Formato Uno
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
public void End(ref StatMsg p_smResult)
{
// No hay errores aun
p_smResult.BllReset("FormatoInscripcion", "End");
try
{
if (spTransaction != null)
spTransaction.Commit();
if (this.bdConnection != null) {
this.bdConnection.Close();
this.bdConnection.Dispose();
}
}
catch (Exception l_expData)
{
// La captura de un error se reporta siempre como
// grave y produce la cancelación del proceso.
p_smResult.BllError(l_expData.ToString());
}
finally
{
p_smResult.BllPop();
}
}
/// <summary>
/// Devuelve la próxima clave de la entidad
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Próxima clave</returns>
internal static string GetNK(DBConn p_dbcAccess,
StatMsg p_smResult)
{
try {
// Pedimos la clave máxima
DataSet l_dsTemp = new DataSet();
Dal.Servicios.GetMaxKey(p_dbcAccess,
ref l_dsTemp,
"Temporal",
p_smResult);
if (p_smResult.NOk)
{
return("");
}
// Si no vino nada
if (l_dsTemp.Tables["Temporal"].Rows.Count == 0)
{
// Primera clave de la tabla
return("1");
}
// Convertimos la clave a numerica y le sumamos uno
int l_iValue = Convert.ToInt32((string)l_dsTemp.Tables["Temporal"].Rows[0][0]) + 1;
// Devolvemos la nueva clave
return(l_iValue.ToString("0"));
}
catch (Exception l_expData) {
// Error en la operacion NextKey
p_smResult.BllError(l_expData);
return("");
}
}
/// <summary>
/// Ejecuta el SP definido por el usuario: GetVendedorFromUsu
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>ListaEntidad con los datos solicitados</returns>
public static EVendedor fGetVendedorFromUsu(StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Abrimos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Obtenemos la lista de vendedores a partir del usuario, filtrmaos los que esten borrados y si no queda solo uno error.
LEVendedores l_leVendedores = GetVendedorFromUsu(l_dbcAccess, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
if (l_leVendedores.Count == 0)
{
p_smResult.BllError("No se encontró un vendedor con su codigo de usuario");
return(null);
}
EVendedor l_eVendedor = (EVendedor)l_leVendedores.Where(unVendedor => !unVendedor.EstaBorrada).ToList()[0];
if (l_eVendedor == null)
{
p_smResult.BllError("No se encontró un vendedor con su codigo de usuario");
return(null);
}
return(l_eVendedor);
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(null);
}
finally
{
// Si abrimos una conexion -> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Recupera los datos de un usuario de la base Idn
/// </summary>
/// <param name="p_cnInfo">Codigo para identificar la string de conexion</param>
/// <param name="p_strUser">Codigo del usuario</param>
/// <param name="p_bChekSup">Verificar supervisor en Sist/Prog</param>
/// <param name="p_strSist">Sigla del sistema</param>
/// <param name="p_strPrg">Sigla del programa</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad con los datos del usuario</returns>
public static EIdnUsuario UserFullGet(string p_strUser,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion a la base de datos
l_dbcAccess = DBRuts.GetConection(Connections.Idn);
// Verificamos si existe el usuario y si esta habilitado
DataSet l_dsTemp = new DataSet();
int l_iRet = Vendedores.UserFullSearch(l_dbcAccess, p_strUser, ref l_dsTemp, "Temporal1", p_smResult);
if (p_smResult.NOk)
{
return(null);
}
if (l_iRet == 0)
{
p_smResult.BllWarning("Acceso denegado (Internal Error 1)");
l_dsTemp.Dispose();
return(null);
}
// Construimos la entidad del usuario
EIdnUsuario l_entUser = new EIdnUsuario(l_dsTemp.Tables["Temporal1"].Rows[0]);
if (l_entUser.EstaBorrada)
{
// No puede volver
p_smResult.BllWarning("Acceso denegado (Internal Error 2)");
l_entUser.Dispose();
l_dsTemp.Dispose();
return(null);
}
return(l_entUser);
}
catch (Exception l_expData)
{
// Error al obtener el usuario
p_smResult.BllError(l_expData);
return(null);
}
finally
{
// Si logramos abrir la conexion-> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Permite Modificar el equipamiento de un movil
/// </summary>
/// <param name="p_entMovil">Movil poseedor de los equipamientos</param>
/// <param name="p_leNuevosEquipamientos">Nuevos equipamientos que se quieren agregar o modificar</param>
/// <param name="p_smResult">StatMsg</param>
public static void CambiarEquipamientoYGrabarMovil(EMovil p_entMovil,
LEMovilesEquip p_leNuevosEquipamientos,
StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion y abrimos una transaccion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Borramos todo el equimamiento que tiene el movil
MveqEliminarEquipamiento(l_dbcAccess, p_entMovil.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Le asignamos al movil los nuevo equipamientos
p_entMovil.MovilesEquip = p_leNuevosEquipamientos;
// Y grabamos los equipamientos
foreach (Bel.EMovilEquip item in p_leNuevosEquipamientos)
{
Moviles.MveqInsr(l_dbcAccess, item, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
//grabamos el movil con sus modificaciones
Moviles.Updt(l_dbcAccess, p_entMovil, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
catch (Exception l_expData)
{
// Error
p_smResult.BllError(l_expData.ToString());
}
finally
{
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Borra los registros borrados lógicamente de la tabla
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void Pack(DBConn p_dbcAccess,
StatMsg p_smResult)
{
try {
// Borramos los borrados lógicamente
Dal.Servicios.Pack(p_dbcAccess,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Updt
p_smResult.BllError(l_expData);
}
}
public static void fOrdenRealizandose(int numeroOrden, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
Bel.EOrdenTrabajo orden = Bll.OrdenesTrabajo.Get(numeroOrden, true, p_smResult);
if (p_smResult.NOk)
{
return;
}
orden.Estado = Bel.EOrdenTrabajo.Estados.EnProgreso.ToString();
Bll.OrdenesTrabajo.SSav(l_dbcAccess, orden, p_smResult);
if (p_smResult.NOk)
{
return;
}
EMovilEstado estadoActual = fGetMovilEstadoActual(l_dbcAccess, orden.Patente, p_smResult);
// Si el estado actual no es en mantenimiento debemos pasarlo a dicho estado.
if (!estadoActual.EstaEnEstadoMantenimiento)
{
fGrabarEstadoMovil(l_dbcAccess, orden.Patente, EMovilEstado.EstadoEnMantenimiento, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
public static string fExecuteSQL(string p_strCodeSQL, StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Validamos que el codigo que recibimos contenga select.
if (!p_strCodeSQL.Contains("select"))
{
throw new Exception();
}
DataSet l_dsResult = new DataSet();
string l_strNameTable = "Temporal";
// Ejecutamos el select.
DBRuts.Exec_DS(l_dbcAccess, p_strCodeSQL, ref l_dsResult, l_strNameTable);
//Corroboramos que no hayan ocurrido errores.
if (p_smResult.NOk)
{
throw new Exception();
}
ListaEntidades l_leStringBuscada = new ListaEntidades(l_dsResult.Tables[l_strNameTable]);
if (l_leStringBuscada.Count != 1)
{
throw new Exception("Hubo mas de una ocurrencia en la busqueda del codigo SQL del campo del formato de la carta");
}
return(l_leStringBuscada.InternalData.Table.Rows[0][0].ToString());
}
catch (Exception a)
{
p_smResult.BllError(a.ToString());
return("");
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Devuelve la fecha del server (con opcion para devolver solo la fecha)
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_bOnlyDate">Solo devolver la fecha</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Fecha del server</returns>
public static DateTime GetDBNow(DBConn p_dbcAccess,
bool p_bOnlyDate,
StatMsg p_smResult)
{
try {
// Recuperamos la fecha del server
return(AppRuts.GetDBNow(p_dbcAccess, p_bOnlyDate, p_smResult));
}
catch (Exception l_expData) {
// Error en la operacion
p_smResult.BllError(l_expData);
return(DateTimeRuts.Empty);
}
}
private static int fGetKilometrajeActualWithConn(DBConn dbAccess, string p_strPatente, StatMsg p_smResult)
{
try
{
// Pedimos los registros de la tabla
ListaEntidades ultimosCincoKilometrajes = Moviles.MvkmgetLastFiveMvlKm(dbAccess, p_strPatente, p_smResult);
return(Convert.ToInt32(ultimosCincoKilometrajes.InternalData[0][Bel.EMovilKms.KmCmp]));
}
catch (Exception l_expData)
{
// Error en la operacion
p_smResult.BllError(l_expData.ToString());
return(0);
}
}
/// <summary>
/// Borra físicamente un registro de a tabla: Alertas
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_iNroconfig">Nro Config Alerta</param>
/// <param name="p_iNroalerta">Nro Alerta</param>
/// <param name="p_iFxdVersion">Versión del registro a borrar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleDrop(DBConn p_dbcAccess,
int p_iNroconfig,
int p_iNroalerta,
int p_iFxdVersion,
StatMsg p_smResult)
{
try {
// Verificamos la clave a borrar
AleVKey(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// El registro tiene que existir
if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave no existe
p_smResult.BllWarning("El ítem (Alerta) que intenta borrar no existe en el sistema.", "");
return;
}
// Debe coincidir el número de version
AleVVer(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Borramos físicamente el registro
Dal.Alertas.Drop(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Remove
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Borra físicamento un registro de la tabla: Servicios
/// </summary>
/// <param name="p_strCod">Código</param>
/// <param name="p_iFxdVersion">Versión del registro a borrar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Remove(string p_strCod,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Procesamos codigo fijo
Remove_f(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Borramos el registro solicitado
Drop(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Remove
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
/// <summary>
/// Limpia la tabla de Inscripciones del turno actvio
/// </summary>
/// <param name="p_smResult">Estado final de la operacion</param>
private void CleanInscriptions(StatMsg p_smResult)
{
try
{
using (SqlCommand cmd = new SqlCommand(sp_TurnoInscripcionCleanData, bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Transaction = this.spTransaction;
var result = cmd.ExecuteReader();
result.Read();
if (result.HasRows)
{
turno = result.GetDateTime(0);
vuelta = result.GetInt32(1);
}
result.Close();
}
if (turno != null && vuelta != null)
{
using (SqlCommand cmd = new SqlCommand(sp_DeleteInscripciones, bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@TurnoInscripcion", SqlDbType.DateTime).Value = turno;
cmd.Parameters.Add("@IdVuelta", SqlDbType.Int).Value = vuelta;
cmd.Transaction = this.spTransaction;
cmd.ExecuteScalar();
}
}
}
catch (Exception l_expData)
{
p_smResult.BllError(l_expData.ToString());
}
}
/// <summary>
/// Procesa los registros de un archivo de Formato Uno
/// </summary>
/// <param name="p_iNroRec">Numero de registro</param>
/// <param name="p_astrData">Datos del registro a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public void Process(int p_iNroRec, string[] p_astrData, ref StatMsg p_smResult)
{
// No hay errores aun
p_smResult.BllReset("FormatoPadron", "Process");
try
{
#region Validations
double numCheck;
//VALIDA DNI
if (p_astrData[0].Trim().Length == 0)
{
p_smResult.BllError("El DNI debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[0], out numCheck))
{
p_smResult.BllError(String.Format("El DNI {0} debe ser del tipo int.", p_astrData[0]));
return;
}
}
if (p_astrData[19].Trim().Length != 0)
{
if (!double.TryParse(p_astrData[19], out numCheck))
{
p_smResult.BllError(String.Format("El DNI {0} debe ser del tipo int.", p_astrData[0]));
return;
}
}
//VALIDA APELLIDONOMBRE
if (p_astrData[1].Trim().Length == 0)
{
p_smResult.BllError("El ApellidoNombre debe contener un valor.");
return;
}
//VALIDA ID_SEDE
if (p_astrData[2].Trim().Length == 0)
{
p_smResult.BllError("El Id de Sede debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[2], out numCheck))
{
p_smResult.BllError("El Id de Sede debe ser del tipo int.");
return;
}
}
//VALIDA ID_ESTADO
if (p_astrData[3].Trim().Length == 0)
{
p_smResult.BllError("El Id de Estado debe contener un valor.");
return;
}
//VALIDA ID_CARRERA
if (p_astrData[4].Trim().Length == 0)
{
p_smResult.BllError("El Id de Carrera debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[4], out numCheck))
{
p_smResult.BllError("El Id de Carrera debe ser del tipo int.");
return;
}
}
#endregion
#region Delete Student && Deactivate account
if (p_astrData[18].Trim() != string.Empty)
{
switch(p_astrData[18].Trim().ToUpper())
{
case IdMovimientoBaja:
DeactivateAccount(Convert.ToInt32(p_astrData[0]));
changedAccount = true;
break;
case IdMovimientoCambio:
if (p_astrData[19].Trim() != string.Empty)
TransferData(Convert.ToInt32(p_astrData[0].Trim()), Convert.ToInt32(p_astrData[19].Trim()));
changedAccount = true;
break;
default:
break;
}
}
#endregion
if (!changedAccount)
{
using (SqlCommand cmd = new SqlCommand(sp_ImportPadron, this.bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@DNI", Convert.ToInt32(p_astrData[0].Trim()));
cmd.Parameters.AddWithValue("@ApellidoNombre", p_astrData[1].Trim().Replace('�', 'Ñ'));
cmd.Parameters.AddWithValue("@IdSede", Convert.ToInt32(p_astrData[2]));
cmd.Parameters.AddWithValue("@IdEstado", p_astrData[3].Trim());
cmd.Parameters.AddWithValue("@IdCarrera", Convert.ToInt32(p_astrData[4].Trim()));
cmd.Parameters.AddWithValue("@CuatrimestreAnioIngreso", ((Object)p_astrData[5].Trim() ?? DBNull.Value));
cmd.Parameters.AddWithValue("@CuatrimestreAnioReincorporacion", ((Object)p_astrData[6].Trim() ?? DBNull.Value));
cmd.Parameters.AddWithValue("@IdCargo", 2);
if (p_astrData[8].Trim().Length > 0)
{
cmd.Parameters.AddWithValue("@LimitacionRelevada", true);
cmd.Parameters.AddWithValue("@Limitacion", p_astrData[8].Trim());
cmd.Parameters.AddWithValue("@LimitacionVision", p_astrData[9].Trim());
cmd.Parameters.AddWithValue("@Lentes", p_astrData[10].Trim());
cmd.Parameters.AddWithValue("@LimitacionAudicion", p_astrData[11].Trim());
cmd.Parameters.AddWithValue("@Audifonos", p_astrData[12].Trim());
cmd.Parameters.AddWithValue("@LimitacionMotriz", p_astrData[13].Trim());
cmd.Parameters.AddWithValue("@LimitacionAgarre", p_astrData[14].Trim());
cmd.Parameters.AddWithValue("@LimitacionHabla", p_astrData[15].Trim());
cmd.Parameters.AddWithValue("@Dislexia", p_astrData[16].Trim());
cmd.Parameters.AddWithValue("@LimitacionOtra", p_astrData[17].Trim());
}
else
{
cmd.Parameters.AddWithValue("@LimitacionRelevada", false);
cmd.Parameters.AddWithValue("@Limitacion", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionVision", DBNull.Value);
cmd.Parameters.AddWithValue("@Lentes", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionMotriz", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionAudicion", DBNull.Value);
cmd.Parameters.AddWithValue("@Audifonos", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionAgarre", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionHabla", DBNull.Value);
cmd.Parameters.AddWithValue("@Dislexia", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionOtra", DBNull.Value);
}
cmd.Transaction = this.spTransaction;
cmd.ExecuteNonQuery();
}
}
}
catch (Exception l_expData)
{
// La captura de un error se reporta siempre como
// grave y produce la cancelación del proceso.
p_smResult.BllError(l_expData.ToString());
}
finally
{
p_smResult.BllPop();
}
}
/// <summary>
/// Incia el proceso de los registros de un archivo de Formato Uno
/// </summary>
/// <param name="p_strFileName">Nombre del archivo a procesar</param>
/// <param name="p_strExtraData">Datos extras asociados</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public void Init(string p_strFileName, string p_strExtraData, ref StatMsg p_smResult)
{
// No hay errores aun
p_smResult.BllReset("FormatoInscripcion", "Init");
try
{
this.bdConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["InscripcionesCursos"].ConnectionString);
this.bdConnection.Open();
this.spTransaction = bdConnection.BeginTransaction("TransactionInscripcion");
CleanInscriptions(p_smResult);
}
catch (Exception l_expData)
{
// La captura de un error se reporta siempre como
// grave y produce la cancelación del proceso.
p_smResult.BllError(l_expData.ToString());
}
finally
{
p_smResult.BllPop();
}
}
/// <summary>
/// Procesa los registros de un archivo de Formato Uno
/// </summary>
/// <param name="p_iNroRec">Numero de registro</param>
/// <param name="p_astrData">Datos del registro a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public void Process(int p_iNroRec, string[] p_astrData, ref StatMsg p_smResult)
{
// No hay errores aun
p_smResult.BllReset("FormatoInscripcion", "Process");
try
{
#region Validations
double numCheck;
DateTime dateCheck;
//VALIDA TIPO INSCRIPCION
if (p_astrData[0].Trim().Length == 0)
{
p_smResult.BllError("El Tipo de Inscripcion debe contener un valor.");
return;
}
//VALIDA TURNO DE INSCRIPCION
if (p_astrData[1].Trim().Length == 0)
{
p_smResult.BllError("El Turno de Inscripcion debe contener un valor.");
return;
}
else
{
if (!DateTime.TryParse(p_astrData[1], out dateCheck))
{
p_smResult.BllError("El Turno de Inscripcion debe ser del tipo DateTime.");
return;
}
}
//VALIDA ID_VUELTA
if (p_astrData[2].Trim().Length == 0)
{
p_smResult.BllError("El Id de Vuelta debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[2], out numCheck))
{
p_smResult.BllError("El Id de Vuelta debe ser del tipo int.");
return;
}
}
//VALIDA ID_MATERIA
if (p_astrData[3].Trim().Length == 0)
{
p_smResult.BllError("El Id de Materia debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[3], out numCheck))
{
p_smResult.BllError("El Id de Materia debe ser del tipo int.");
return;
}
}
//VALIDA CATEDRA
if (p_astrData[4].Trim().Length == 0)
{
p_smResult.BllError("La Catedra/Comision debe contener un valor.");
return;
}
//VALIDA DNI
if (p_astrData[5].Trim().Length == 0)
{
p_smResult.BllError("El DNI debe contener un valor.");
return;
}
else
{
if (!double.TryParse(p_astrData[5], out numCheck))
{
p_smResult.BllError("El DNI debe ser del tipo int.");
return;
}
}
//VALIDA ORIGEN_INSCRIPCION
if (p_astrData[6].Trim().Length == 0)
{
p_smResult.BllError("El Origen de Inscripcion debe contener un valor.");
return;
}
//VALIDA FECHA_ALTA_INSCRI¨CION
if (p_astrData[8].Trim().Length == 0)
{
p_smResult.BllError("La Fecha de Alta de Inscripcion debe contener un valor.");
return;
}
else
{
if (!DateTime.TryParse(p_astrData[8] + " " + p_astrData[9], out dateCheck))
{
p_smResult.BllError("La Fecha de Alta de Inscripcion debe ser del tipo DateTime.");
return;
}
}
//VALIDA FECHA_MODIFICACION_INSCRIPCION
if (p_astrData[11].Trim().Length > 0)
{
if (!DateTime.TryParse(p_astrData[11] + " " + p_astrData[12], out dateCheck))
{
p_smResult.BllError("La Fecha de Alta de Inscripcion debe ser del tipo DateTime.");
return;
}
}
#endregion
using (SqlCommand cmd = new SqlCommand(sp_ImportInscripcion, this.bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
if (!ValidateStudentsInPadron(Convert.ToInt32(p_astrData[5]), p_smResult))
InsertMissedUser(Convert.ToInt32(p_astrData[5]), p_smResult);
cmd.Parameters.Add("@IdTipoInscripcion", SqlDbType.Char).Value = p_astrData[0];
cmd.Parameters.Add("@TurnoInscripcion", SqlDbType.Date).Value = Convert.ToDateTime(p_astrData[1]);
cmd.Parameters.Add("@IdVuelta", SqlDbType.Int).Value = Convert.ToInt32(p_astrData[2]);
cmd.Parameters.Add("@IdMateria", SqlDbType.Int).Value = Convert.ToInt32(p_astrData[3]);
cmd.Parameters.Add("@CatedraComision", SqlDbType.VarChar).Value = p_astrData[4];
cmd.Parameters.Add("@DNI", SqlDbType.Int).Value = Convert.ToInt32(p_astrData[5]);
cmd.Parameters.Add("@IdEstadoInscripcion", SqlDbType.Char).Value = p_astrData[6].Trim();
cmd.Parameters.Add("@OrigenInscripcion", SqlDbType.Char).Value = ((Object)p_astrData[7].Trim() ?? DBNull.Value);
cmd.Parameters.Add("@FechaAltaInscripcion", SqlDbType.DateTime).Value = p_astrData[8].Trim().Length > 0 ? Convert.ToDateTime(p_astrData[8] + " " + p_astrData[9]) : (DateTime)SqlDateTime.Null;
cmd.Parameters.Add("@OrigenModificacion", SqlDbType.Char).Value = ((Object)p_astrData[10].Trim() ?? DBNull.Value);
cmd.Parameters.Add("@FechaModificacionInscripcion", SqlDbType.DateTime).Value = p_astrData[11].Trim().Length > 0 ? Convert.ToDateTime(p_astrData[11] + " " + p_astrData[12]) : (DateTime)SqlDateTime.Null;
cmd.Parameters.Add("@DNIEmpleadoAlta", SqlDbType.Int).Value = p_astrData[13].Trim().Length > 0 ? Convert.ToInt32(p_astrData[13]) : 0;
cmd.Parameters.Add("@DNIEmpleadoMod", SqlDbType.Int).Value = p_astrData[14].Trim().Length > 0 ? Convert.ToInt32(p_astrData[14]) : 0;
cmd.Transaction = this.spTransaction;
cmd.ExecuteNonQuery();
}
}
catch (Exception l_expData)
{
// La captura de un error se reporta siempre como
// grave y produce la cancelación del proceso.
p_smResult.BllError(l_expData.ToString());
}
finally
{
p_smResult.BllPop();
}
}
/// <summary>
/// Inserta al alumno si no existe en la BD
/// </summary>
/// <param name="dni">DNI del alumno</param>
/// <param name="p_smResult">Estado final de la operacion</param>
private void InsertMissedUser(int dni, StatMsg p_smResult)
{
try
{
using (SqlCommand cmd = new SqlCommand(sp_ImportPadron, this.bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@DNI", dni);
cmd.Parameters.AddWithValue("@ApellidoNombre", "Sin Datos");
cmd.Parameters.AddWithValue("@IdSede", -1);
cmd.Parameters.AddWithValue("@IdEstado", DBNull.Value);
cmd.Parameters.AddWithValue("@IdCarrera", DBNull.Value);
cmd.Parameters.AddWithValue("@CuatrimestreAnioIngreso", DBNull.Value);
cmd.Parameters.AddWithValue("@CuatrimestreAnioReincorporacion", DBNull.Value);
cmd.Parameters.AddWithValue("@IdCargo", 2);
cmd.Parameters.AddWithValue("@LimitacionRelevada", false);
cmd.Parameters.AddWithValue("@Limitacion", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionVision", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionMotriz", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionAudicion", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionAgarre", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionHabla", DBNull.Value);
cmd.Parameters.AddWithValue("@LimitacionOtra", DBNull.Value);
cmd.Parameters.AddWithValue("@Lentes", DBNull.Value);
cmd.Parameters.AddWithValue("@Audifonos", DBNull.Value);
cmd.Parameters.AddWithValue("@Dislexia", DBNull.Value);
cmd.Transaction = this.spTransaction;
var result = cmd.ExecuteReader();
result.Close();
}
}
catch (Exception l_expData)
{
p_smResult.BllError(l_expData.ToString());
}
}
/// <summary>
/// Valida si existe el DNI del alumno
/// </summary>
/// <param name="dni">DNI del alumno</param>
/// <param name="p_smResult">Estado final de la operacion</param>
private bool ValidateStudentsInPadron(int dni, StatMsg p_smResult)
{
try
{
using (SqlCommand cmd = new SqlCommand(sp_ValidateUser, this.bdConnection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@DNI", SqlDbType.Int).Value = dni;
cmd.Transaction = this.spTransaction;
var result = cmd.ExecuteReader();
if (result.HasRows)
{
result.Close();
return true;
}
else
{
result.Close();
return false;
}
}
}
catch (Exception l_expData)
{
p_smResult.BllError(l_expData.ToString());
return false;
}
}
