/// <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 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();
}
}
}
/// <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();
}
}
}
/// <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();
}
}
}
/// <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>
/// 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>
/// 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>
/// 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>
/// 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>
/// 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();
}
}
}
//---------------------------------------------------------------
// 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);
}
//**********************************************************
//
// 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();
}
}
}
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>
/// 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();
}
}
}
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>
/// 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>
/// 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>
/// Borra físicamento un registro de la tabla: Alertas
/// </summary>
/// <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>
public static void AleRemove(int p_iNroconfig,
int p_iNroalerta,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Procesamos codigo fijo
AleRemove_f(l_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Borramos el registro solicitado
AleDrop(l_dbcAccess,
p_iNroconfig,
p_iNroalerta,
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();
}
}
}
public static ListaEntidades fGetTiposMovilesCEDI(StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Obtenemos conexion a CEDI.
EParametro conexionCEDI = AppRuts.ParaGet("connCEDI", true, p_smResult);
if (p_smResult.NOk)
{
return(null);
}
if (conexionCEDI.VStr.Trim() == "")
{
return(null);
}
DBConn.AltDatConn = conexionCEDI.VStr;
l_dbcAccess = DBRuts.GetConection(Connections.AltDat, "tngsqbe", CriptoRuts.DESHide("qbe"));
DataSet l_dsResult = new DataSet();
DBRuts.Exec_DS(l_dbcAccess, "select * from TNGS_Cedi..MerlinTiposMovilesV1", ref l_dsResult, "TiposMoviles");
return(new ListaEntidades(l_dsResult.Tables["TiposMoviles"]));
}
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();
}
}
}
/// <summary>
/// Graba todos los OTItems que se encuentran en una lista entidad.
/// </summary>
/// <param name="p_lentOTItems"> Lista Entidad con los items a grabar </param>
/// <param name="p_smResult">StatMsg</param>
public static void GrabarOTItems(LEOTItems p_lentOTItems, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
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
foreach (Bel.EOTItem item in p_lentOTItems)
{
// insertamos todas las entidades
OtitInsr(l_dbcAccess, item, 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();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
/// <summary>
/// Retorna la fecha y hora del momento (pero sacada del server).
/// </summary>
/// <param name="p_smResult">Resultado de las operaciones</param>
/// <returns></returns>
public static DateTime fGetDate(StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
// Conseguimos la fecha de hoy
DateTime l_dtToday = BllRuts.GetDBNow(l_dbcAccess, false, p_smResult);
//Corroboramos que no hayan ocurrido errores.
if (p_smResult.NOk)
{
return(DateTimeRuts.Empty);
}
else
{
return(l_dtToday);
}
}
catch (Exception a)
{
p_smResult.BllError(a.ToString());
return(DateTimeRuts.Empty);
}
finally
{
// Si pude abrir la conexion -> la cierro
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
// Metodo que devuelve la descripcion del codigo de parametro que recibe por parametro
public static string fParametros(string p_strParametro, StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
DataSet l_dsResult = new DataSet();
EParametro l_eParametro = AppRuts.ParaGet(p_strParametro, false, p_smResult);
//Corroboramos que no hayan ocurrido errores.
if (p_smResult.NOk)
{
throw new Exception();
}
return(l_eParametro.Descripcion);
}
catch (Exception a)
{
p_smResult.BllError(a.ToString());
return("");
}
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
public static void fCheckCreacionAlertas(EMovil p_entMovil, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
Bel.LEMovilesAlertas configAlertas = Moviles.MvalFSch(l_dbcAccess, p_entMovil.Patente, true, p_smResult);
if (p_smResult.NOk)
{
return;
}
if (configAlertas.Count == 0)
{
return;
}
p_entMovil.MovilesKms = Moviles.MvkmFSch(l_dbcAccess, p_entMovil.Patente, true, p_smResult);
if (p_smResult.NOk)
{
return;
}
LEAlertas alertasDelMovil = Alertas.AleGetAlertasFromMovil(p_entMovil.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
LEOTItems reparacionesDelMovil = OrdenesTrabajo.OtitGetRealizadosMvl(p_entMovil.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
DateTime fechaActual = BllRuts.GetDBNow(l_dbcAccess, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Iteramos por todas las config alertas y si alguna cumple condicion creamos la nueva alerta.
foreach (EMovilAlerta configAlerta in configAlertas)
{
if (configAlerta.CumpleCondicion(p_entMovil, alertasDelMovil, reparacionesDelMovil, fechaActual))
{
ETalonario nroAlerta = AppRuts.TaloGet(l_dbcAccess, "ConfAlerta", p_smResult);
if (p_smResult.NOk)
{
return;
}
Bel.EAlerta nuevaAlerta = configAlerta.crearAlerta(nroAlerta.Valor, fechaActual);
Alertas.AleSave(nuevaAlerta, 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.Close();
}
}
}
/// <summary>
/// Habilita/Deshabilita un registro de la tabla: Servicios
/// </summary>
/// <param name="p_bEnable">Tipo de operacion</param>
/// <param name="p_strCod">Código</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Enabled(bool p_bEnable,
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
Enabled_f(l_dbcAccess,
p_bEnable,
p_strCod,
ref p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a modificar
VKey(l_dbcAccess,
p_strCod,
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 (Servicio) que intenta modificar no existe en el sistema.", "");
return;
}
// Debe coincidir el número de version
VVer(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Segun el modo
if (p_bEnable)
{
// Hay que habilitar el registro
Dal.Servicios.Recall(l_dbcAccess,
p_strCod,
p_smResult);
}
else
{
// Hay que deshabilitar el registro
Dal.Servicios.Delete(l_dbcAccess,
p_strCod,
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();
}
}
}
public static void fCerrarOrden(EOrdenTrabajo p_eOrdenACerrar, StatMsg p_smResult)
{
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
int kilometrajeActualMovil = Bll.Moviles.fGetKilometrajeActualWithConn(l_dbcAccess, p_eOrdenACerrar.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Conseguimos la fecha de hoy
DateTime l_dtToday = BllRuts.GetDBNow(l_dbcAccess, false, p_smResult);
if (p_smResult.NOk)
{
return;
}
p_eOrdenACerrar.Kmsactuales = kilometrajeActualMovil;
p_eOrdenACerrar.Feccierre = l_dtToday;
p_eOrdenACerrar.Finalizada();
Bll.OrdenesTrabajo.SSav(l_dbcAccess, p_eOrdenACerrar, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Pedimos los registros de la tabla
EMovilEstado estadoActual = Bll.Moviles.fGetMovilEstadoActual(l_dbcAccess, p_eOrdenACerrar.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
LEOrdenesTrabajo ordenesPendientes = OrdenesTrabajo.getPendByPatente(l_dbcAccess, p_eOrdenACerrar.Patente, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Si el movil esta en mantenimiento y acabamos de cerrar la ultima orden en progreso, pasamos el movil a disponible.
if (estadoActual.EstaEnEstadoMantenimiento && !ordenesPendientes.ToList().Exists(ordenPend => ordenPend.EstaEnProgreso))
{
fGrabarEstadoMovil(l_dbcAccess, p_eOrdenACerrar.Patente, EMovilEstado.EstadoDisponible, 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();
}
}
}
