/// <summary>
/// Ediitamos Control Evidencia Documento
/// </summary>
/// <param name="fecha_recepcion">Fecha de Recepción</param>
/// <param name="id_usuario">Id Usuario</param>
/// <returns></returns>
public RetornoOperacion EditaControlEvidenciaDocumentoRecibido(DateTime fecha_recepcion, int id_terminal_recepcion, int id_terminal_cobro, EstatusDocumento estatus, int id_usuario)
{
//Declaramos Objeto Resultado
RetornoOperacion result = new RetornoOperacion();
int id_control_evidencia = 0;
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Invocando Método de Actualización
result = this.actualizaRegistros(this._id_servicio_control_evidencia, this._id_servicio, this._id_segmento_control_evidencia, this._id_segmento, this._id_tipo_documento,
estatus, this._id_hoja_instruccion_documento, id_terminal_recepcion,
fecha_recepcion, id_terminal_cobro, this._bit_original, this._bit_copia, this._bit_sello,
this._id_imagen, this._referencia_imagen, id_usuario, this._habilitar);
//Si se Inserto Correctamente Control Evidencia Documento
if (result.OperacionExitosa)
{
//Asignando Control Evidencia
id_control_evidencia = result.IdRegistro;
//Instanciamos SegmentoControlEvidencia
using (SegmentoControlEvidencia sce = new SegmentoControlEvidencia(SegmentoControlEvidencia.TipoConsulta.IdSegmentoControlEvidencia, id_segmento_control_evidencia))
{
//Actualizamos Estatus
result = sce.ActualizaEstatusSegmentoControlEvidenciaSegmento(id_usuario);
}
}
//Validamos Resultado
if (result.OperacionExitosa)
{
//Actualizamos Estatus
result = new RetornoOperacion(id_control_evidencia);
//Validamos Transacción
scope.Complete();
}
}
//Declaramos Objeto resultado
return(result);
}
/// <summary>
/// Evento Producido al Guardar la Dirección
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ucDireccion_ClickGuardarDireccion(object sender, EventArgs e)
{ //Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Obteniendo resultado de la Operación
result = ucDireccion.GuardaDireccion();
//Instanciando Direccion
using (SAT_CL.Global.Direccion dir = new SAT_CL.Global.Direccion(result.IdRegistro))
{ //Validando que exista
if (dir.id_direccion != 0)
{ //Mostrando Descripcion
txtDireccion.Text = dir.calle + " ID:" + dir.id_direccion.ToString();
//Deshabilitando el Control
ucDireccion.Enable = false;
}
else//Limpiando Control
{
txtDireccion.Text = "";
}
}
}
/// <summary>
/// Método que actualiza el promedio calculado a partir de los conceptos evaluados
/// </summary>
public RetornoOperacion GuardarCalificacionGeneral()
{
//Creación del objeto retorno
RetornoOperacion retorno = new RetornoOperacion();
//Instancia a la clase calificación
using (SAT_CL.Calificacion.Calificacion cal = new SAT_CL.Calificacion.Calificacion(this._id_calificacion))
{
//Realiza la actualización de la calificación en general con los datos del contacto
retorno = cal.ActualizaComentario(txtComenatrio.Text, this._id_contacto, this._id_usuario);
}
//Valida la operación (que se realizo correctamente)
if (retorno.OperacionExitosa)
{
//Inicializa el CU
inicializaValores(this._id_tabla, this._id_registro, this._id_contacto, this._id_usuario, this._id_calificacion, false);
}
//Muestra el mensaje de error
TSDK.ASP.ScriptServer.MuestraNotificacion(this.btnGuardar, retorno, ScriptServer.PosicionNotificacion.AbajoDerecha);
return(retorno);
}
/// <summary>
/// Realiza la confirmación de la autorización, actualizando el valor de esta, así como la fecha
/// </summary>
/// <param name="confirmacion"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion ConfirmaAutorizacion(bool confirmacion, int id_usuario)
{
//Definiendo objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//Validando que no se encuentre confirmada previamnete
if (this._bit_confirmacion == null)
{
//Actualizando autorización, indicando la fecha actual como fecha de confirmación
resultado = editaAutorizacionRealizada(this._id_tabla, this._id_registro, this._id_autorizacion_detalle_bloque_responsable,
confirmacion, TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro(), id_usuario, this._habilitar);
}
//De lo contrario
else
{
resultado = new RetornoOperacion("La autorización ya ha sido confirmada previamente.");
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Evento Producido al Guardar el Kilometraje
/// </summary>
protected void ucKilometraje_ClickGuardar(object sender, EventArgs e)
{
//Invocando Método de Guardado
RetornoOperacion resultado = ucKilometraje.GuardaKilometraje();
//Validando Operación Exitosa
if (resultado.OperacionExitosa)
{
//Mostrando Ventana Modal
TSDK.ASP.ScriptServer.AlternarVentana(ucKilometraje.Page, "VentanaKilometraje", "ventanaKilometraje", "contenedorVentanaKilometraje");
//Cargando movimientos
cargaMovimientosPendiente();
//Mostrar venta modal de movimientos pendientes
TSDK.ASP.ScriptServer.AlternarVentana(ucKilometraje.Page, "MovimientosPendientes", "ventanaMovimientosPendientesModal", "ventanaMovimientosPendientes");
}
//Mostrando resultado
TSDK.ASP.ScriptServer.MuestraNotificacion(this, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Evento generado al timbrar la Factura
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnAceptarTimbrarFacturacionElectronica_Click(object sender, EventArgs e)
{
//Declaramos objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Instanciando registro comprobante
using (SAT_CL.FacturacionElectronica33.Comprobante c = new SAT_CL.FacturacionElectronica33.Comprobante(Convert.ToInt32(Session["id_registro"])))
{
/*/Registramos Factura
* resultado = c.TimbraComprobanteFacturadoFacturaGlobal(txtSerieTimbrar.Text, chkOmitirAddenda.Checked, HostingEnvironment.MapPath("~/XSLT/FacturacionElectronica/cadenaoriginal_3_3.xslt"),
* HostingEnvironment.MapPath("~/XSLT/FacturacionElectronica33/cadenaoriginal_3_3_desconectado.xslt"), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);//*/
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Inicializamos Valores
inicializaValoresRegistro();
}
//Mostrando resultado
lblTimbrarFacturacionElectronica.Text = resultado.Mensaje;
}
/// <summary>
/// Método encargado de Terminar los Vencimientos Provenientes de una Orden de Trabajo
/// </summary>
/// <param name="fecha_fin"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion TerminaVencimientoOrdenTrabajo(DateTime fecha_fin, int id_usuario)
{
//Creación del objeto retorno
RetornoOperacion retorno = new RetornoOperacion();
//Validando que no sea el Tipo de Taller
if (id_tipo_vencimiento == 17)
{
//Devolviendo Resultado Obtenido
retorno = this.actualizaRegistros((byte)Estatus.Completado, this._id_tabla, this._id_registro, this._id_prioridad, this._id_tipo_vencimiento, this._descripcion,
this._fecha_inicio, fecha_fin, this._valor_km, id_usuario, this._habilitar);
}
else
{
//Instanciando Excepción
retorno = new RetornoOperacion("El Vencimiento debe de ser de Tipo 'Taller'.");
}
//Retorno del resultado al método
return(retorno);
}
/// <summary>
/// Click en botón eliminar evento
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void wucParadaEvento_OnlkbEliminarClick(object sender, EventArgs e)
{
//Realizando actualización de evento
RetornoOperacion resultado = wucParadaEvento.EliminaEvento();
//Si se actualizó correctamente
if (resultado.OperacionExitosa)
{
//Obteniendo Evento Seleccionado
int idEvento = Convert.ToInt32(gvEventos.SelectedDataKey["Id"]);
//Actualizando lista de eventos
cargaEventos();
//Macando Fila
Controles.MarcaFila(gvEventos, idEvento.ToString(), "Id", "Id-IdParada", OrigenDatos.RecuperaDataTableDataSet((DataSet)Session["DS"], "Table"), lblCriterioGridViewEventos.Text, Convert.ToInt32(ddlTamañoGridViewEventos.SelectedValue), true, 3);
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(this, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Método Público encargado de Insertar los Eventos de los Detalles de Acceso
/// </summary>
/// <param name="id_detalle_acceso_patio">Detalle del Acceso de Patio</param>
/// <param name="id_tipo_evento">Tipo de Evento</param>
/// <param name="id_entidad_patio">Entidad de Patio</param>
/// <param name="id_zona_patio">Zona de Patio</param>
/// <param name="fecha_inicio">Fecha de Inicio</param>
/// <param name="fecha_fin">Fecha de Fin</param>
/// <param name="referencia">Referencia</param>
/// <param name="id_tipo_actualizacion_inicio">Tipo de Actualización de Inicio</param>
/// <param name="id_tipo_actualizacion_fin">Tipo de Actualización de Fin</param>
/// <param name="bit_confirmacion_asignacion_ini">Indicador de Confirmación de Inicio de la Asignación</param>
/// <param name="bit_confirmacion_asignacion_fin">Indicador de Confirmación de Fin de la Asignación</param>
/// <param name="id_operador_asignado">Operador asignado</param>
/// <param name="fecha_asignacion">Fecha de asignación</param>
/// <param name="fecha_confirmacion">Fecha de confirmación</param>
/// <param name="bit_inicio_anden">Indicador de Inicio en Andén</param>
/// <param name="bit_fin_anden">Indicador de Fin en Andén</param>
/// <param name="fecha_inicio_anden">Fecha de Inicio en Andén</param>
/// <param name="fecha_fin_anden">Fecha de Fin en Andén</param>
/// <param name="id_operador_fin">Operador Fin</param>
/// <param name="id_usuario">Usuario que Actualiza el Registro</param>
/// <returns></returns>
public static RetornoOperacion InsertaEventoDetalleAcceso(int id_detalle_acceso_patio, int id_tipo_evento, int id_entidad_patio, int id_zona_patio,
DateTime fecha_inicio, DateTime fecha_fin, string referencia, byte id_tipo_actualizacion_inicio, byte id_tipo_actualizacion_fin,
bool bit_confirmacion_asignacion_ini, bool bit_confirmacion_asignacion_fin, int id_operador_asignado, DateTime fecha_asignacion,
DateTime fecha_confirmacion, bool bit_inicio_anden, bool bit_fin_anden, DateTime fecha_inicio_anden, DateTime fecha_fin_anden,
int id_operador_fin, int id_usuario)
{ //Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Armando Arreglo de Parametros
object[] param = { 1, 0, id_detalle_acceso_patio, id_tipo_evento, id_entidad_patio, id_zona_patio,
TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_inicio), TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_fin),
referencia, id_tipo_actualizacion_inicio, id_tipo_actualizacion_fin, bit_confirmacion_asignacion_ini,
bit_confirmacion_asignacion_fin, id_operador_asignado, TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_asignacion),
TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_confirmacion), bit_inicio_anden, bit_fin_anden,
TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_inicio_anden), TSDK.Base.Fecha.ConvierteDateTimeObjeto(fecha_fin_anden),
id_operador_fin, id_usuario, true, null, "", "" };
//Obteniendo Resultado Obtenido
result = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nom_sp, param);
//Devolviendo Resultado Obtenido
return(result);
}
/// <summary>
/// Inserta una nueva opcion en de un tipo de catalogo, la consecutividad (idValor) del lado de base de datos
/// </summary>
/// <param name="idTipoCatalogo"></param>
/// <param name="valorCadena"></param>
/// <param name="idValorSuperior"></param>
/// <param name="descripcion"></param>
/// <returns></returns>
public static RetornoOperacion InsertaCatalogoConsecutivo(int idTipoCatalogo, string valorCadena, string descripcion, int idUsuario)
{
//Declarando objeto retorno
RetornoOperacion retorno = new RetornoOperacion();
//Armar arreglo de parámetros
object[] parametros = { 12, //Tipo
0, //PK
idTipoCatalogo, //TipoCatalogo
valorCadena, //ValorCadena
0, //IdValor - Se obtiene en base de datos
0, //IdValorSuperior - Se obtiene en base de datos
descripcion, //Descripcion
idUsuario, //IdUsuario
true, //Habilitar
"", "" };
//Ejecutar SP
retorno = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_stored_procedure, parametros);
//Devolver retorno
return(retorno);
}
/// <summary>
/// Determina si la compañía especificada tiene habilitado el uso de aplicación móvil
/// </summary>
/// <param name="id_compania">Id de Compañía</param>
/// <returns></returns>
public static RetornoOperacion ValidaConfiguracionUsoAplicacionMovil(int id_compania)
{
//Declarando variable de retorno
RetornoOperacion resultado = new RetornoOperacion("La compañía no tiene habilitado el uso de aplicación móvil.");
//Cargando referencia de configuración
using (DataTable mit = Referencia.CargaReferencias(id_compania, 25, ReferenciaTipo.ObtieneIdReferenciaTipo(id_compania, 25, "Uso Aplicación Móvil", 0, "Configuración")))
{
//Si hay resultados
if (mit != null)
{
if (Convert.ToBoolean(mit.Rows[0]["Valor"]))
{
resultado = new RetornoOperacion("Configuración válida.", true);
}
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Deshabilitar Bitacora Monitoreo
/// </summary>
/// <returns></returns>
public RetornoOperacion DeshabilitaBitacoraMonitoreo()
{
//Declaramos Mensaje
RetornoOperacion resultado = new RetornoOperacion();
//Validamos Existencia de Bitácora Monitoreo
if (this._id_bitacora_monitoreo > 0)
{
//Instanciamos Bitácora Monitoreo
using (SAT_CL.Monitoreo.BitacoraMonitoreo objBitacoraMonitoreo = new SAT_CL.Monitoreo.BitacoraMonitoreo(this._id_bitacora_monitoreo))
{
//Solicitamos Depósito
resultado = objBitacoraMonitoreo.DeshabilitaBitacoraMonitoreo(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
}
}
//Mostramos Mensaje Error
lblError.Text = resultado.Mensaje;
//Devolvemos Valor
return(resultado);
}
/// <summary>
/// Realiza el firmado del usuario sobre una compañía en particular
/// </summary>
/// <param name="id_usuario">Id de Usuario Autenticado</param>
/// <param name="id_compania">Id de Compañía donde se firmará el usuario</param>
/// <param name="tipo_dispositivo">Tipo de dispositivo desde donde se accesa (Consultar TipoDispositivo en contrato de servicio)</param>
/// <param name="nombre_dispositivo">Nombre o alias del dispositivo</param>
/// <param name="direccion_ip_mac">Dirección ipV6 o MAC del dispositivo</param>
/// <returns>TSDK.Base.RetornoOperacion en formato xml</returns>
public string IniciaSesion(int id_usuario, int id_compania, string tipo_dispositivo, string nombre_dispositivo, string direccion_ip_mac)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion("No fueron proporcionados todos los valores de parámetros requeridos.");
//Validando conjunto de datos requeridos
if (id_usuario > 0 && id_compania > 0 && !string.IsNullOrEmpty(tipo_dispositivo) && !string.IsNullOrEmpty(nombre_dispositivo) && !string.IsNullOrEmpty(direccion_ip_mac))
{
//Insertamos Sesión del Usuario
resultado = SAT_CL.Seguridad.UsuarioSesion.IniciaSesion(id_usuario, id_compania, (SAT_CL.Seguridad.UsuarioSesion.TipoDispositivo)((byte)convierteCadenaTipoDispositivo(tipo_dispositivo)), direccion_ip_mac, nombre_dispositivo, id_usuario);
}
else
{
resultado = new RetornoOperacion(string.Format("{0} {1} {2} {3} {4}.", id_usuario < 1 ? "Falta id_usuario." : "", id_compania < 1 ? "Falta id_compania." : "",
string.IsNullOrEmpty(tipo_dispositivo) ? "Falta tipo_dispositivo." : "", string.IsNullOrEmpty(nombre_dispositivo) ? "Falta nombre_dispositivo." : "",
string.IsNullOrEmpty(direccion_ip_mac) ? "Falta direccion_ip_mac." : ""));
}
//Devolviendo resultado
return(resultado.ToXMLString());
}
/// <summary>
/// Clic en Botón Terminar Vencimiento (Ventana de actualización de vencimientos)
/// </summary>
protected void wucVencimiento_ClickTerminarVencimiento(object sender, EventArgs e)
{
//Realizando guardado de vencimiento
RetornoOperacion resultado = wucVencimiento.TerminaVencimiento();
//Sino hay error
if (resultado.OperacionExitosa)
{
//Instanciando vencimiento almacenado
using (Vencimiento v = new Vencimiento(resultado.IdRegistro))
//Se actualizará sobre la unidad involucrada en la inserción de vencimiento
wucVencimientosHistorial.InicializaControl(TipoVencimiento.TipoAplicacion.Servicio, v.id_registro);
//Cerrando ventana de edición de vencimiento
alternaVentanaModal("actualizacionVencimiento", this);
//Abriendo ventana de historial de vencimientos
alternaVentanaModal("historialVencimientos", this);
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(this, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Realiza la deshabilitación del certificado
/// </summary>
/// <param name="id_usuario">Id de usuario</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaCertificado(int id_usuario)
{
//Definiendo objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Validando que no existan comprobnates sellados con el certificado indicado
if (!Validacion.ValidaOrigenDatos(Comprobante.RecuperaComprobantesSellados(this._id_certificado_digital)))
{
//Ejecutando el SP
resultado = editaCertificado(this._id_emisor, this._id_sucursal, this.tipo_certificado, this.estatus_certificado,
this._contrasena, this._iv_contrasena, this._key_contrasena,
this._contrasena_revocacion, this._iv_contrasena_revocacion, this._key_contrasena_revocacion, id_usuario, false);
}
else
{
resultado = new RetornoOperacion("No es posible deshabilitar el certificado, ya tiene comprobantes sellados.");
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
///
/// </summary>
/// <param name="id_usuario_registro"></param>
/// <param name="id_compania"></param>
/// <param name="id_usuario"></param>
/// <param name="vigencia"></param>
/// <param name="token_nvo"></param>
/// <returns></returns>
public static RetornoOperacion GeneraNuevoTokenUUID(int id_usuario_registro, int id_compania, int id_usuario, int vigencia, out string token_nvo)
{
RetornoOperacion retorno = new RetornoOperacion();
token_nvo = "";
//Obteniendo Clave de Encriptación (Aleatorio)
string llave_encriptacion = Cadena.CadenaAleatoria(1, 5, 4);
if (!llave_encriptacion.Equals(""))
{
//Generando TOKEN
retorno = generaTokenUUID(id_usuario_registro, llave_encriptacion, id_compania, id_usuario, vigencia, out token_nvo);
}
else
{
retorno = new RetornoOperacion("El token no se genero correctamente");
}
return(retorno);
}
/// <summary>
/// Métoo que realiza la actualización de los campos de la tabla Lectura
/// </summary>
/// <param name="fecha_lectura">Permite la actualizar la fecha de lectura de unidad de transporte</param>
/// <param name="id_unidad">Permite actualizar el identficador de una unidad de transporte</param>
/// <param name="id_operador">Permite actualizar el identificador del operador</param>
/// <param name="identificador_operador_unidad">Permite actualizar un identificador cuando no existen registro sobre una unidad u operador</param>
/// <param name="kms_sistema">Permite actualizar los kms registrados en el sistema</param>
/// <param name="kms_lectura">Permite actualizar los kms registrados por un odometro</param>
/// <param name="horas_lectura">Permite actualizar las horas registradas por un odometro</param>
/// <param name="litros_lectura">Permite actualizar los litros registrados por un odometro</param>
/// <param name="referencia">Permite actualizar descripciones sobre una lectura de unidad de transporte</param>
/// <param name="id_usuario">Permite actualizar el identificador del usuario que realizo acciones sobre el registro </param>
public RetornoOperacion EditarLectura(DateTime fecha_lectura, int id_unidad, int id_operador, string identificador_operador_unidad, decimal kms_sistema,
decimal kms_lectura, int horas_lectura, decimal litros_lectura, string referencia, int id_usuario)
{
//Creación del objeto retorno
RetornoOperacion retorno = new RetornoOperacion();
//Validando Importación del Archivo
if (!this._referencia.Contains("Importado desde Archivo"))
{
//Invoca y retorna el resultado al método editarLectura
retorno = this.editarLectura(fecha_lectura, id_unidad, id_operador, identificador_operador_unidad, kms_sistema, kms_lectura, horas_lectura, litros_lectura, referencia, id_usuario, this._habilitar);
}
else
{
//Instanciando Excepción
retorno = new RetornoOperacion("La Lectura viene de un archivo de importación, imposible su modificación");
}
//Devolviendo Resultado
return(retorno);
}
/// <summary>
/// Metodo encargado de regresar la descripcion en razon a un ID proporcionado
/// </summary>
/// <param name="id_producto"></param>
/// <returns></returns>
public static string ObtenDescripcionProducto(int id_producto)
{
//Instanciamos el objeto resultado
RetornoOperacion resultado = new RetornoOperacion();
//Inicializamos el arreglo de parametros
object[] param = { 4, id_producto, 0, "", "", 0, 0, "", 0, 0, 0, 0.0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 0.0, false, 0, false, "", "" };
//Ejecutamos el store procedure
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_procedimiento_almacenado, param);
//Validamos el resultado
if (resultado.Retorno != null)
{
return(resultado.Retorno.ToString());
}
else
{
return("");
}
}
/// <summary>
/// Método encargado de Deshabilitar la Relación
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabilitaFacturadoEgresoRelacion(int id_usuario)
{
//Declarando Objeto de retorno
RetornoOperacion retorno = new RetornoOperacion();
//Validando Estatus
switch ((Estatus)this._id_estatus)
{
case Estatus.Registrado:
{
//Ejecutando SP
retorno = this.actualizaAtributosBD(this._id_facturado_egreso, this._id_cfdi_ingreso, this._id_aplicacion, (Estatus)this._id_estatus, id_usuario, false);
break;
}
case Estatus.Vigente:
{
//Instanciando Excepción
retorno = new RetornoOperacion("El CFDI esta Vigente");
break;
}
case Estatus.Cancelado:
{
//Instanciando Excepción
retorno = new RetornoOperacion("El CFDI fue cancelado previamente");
break;
}
case Estatus.Sustituido:
{
//Instanciando Excepción
retorno = new RetornoOperacion("El CFDI fue Sustituido previamente");
break;
}
}
//Devolviendo Resultado Obtenido
return(retorno);
}
/// <summary>
///
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabilitaServicioImportacionDetalle(int id_usuario)
{
RetornoOperacion retorno = new RetornoOperacion();
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
retorno = this.actualizandoRegistrosBD(this._id_servicio_importacion, this._id_servicio, this._no_viaje, this._secuencia, this._cita_carga, this._cita_descarga, this._operador, this._unidad, id_usuario, false);
if (retorno.OperacionExitosa)
{
using (DataTable dtDetalles = ServicioImportacionDetalle.ObtieneImportaciones(this._id_servicio_importacion))
{
if (Validacion.ValidaOrigenDatos(dtDetalles))
{
retorno = ActualizaEstatusImportacionGeneral(this._id_servicio_importacion, id_usuario);
}
else
{
using (ServicioImportacion si = new ServicioImportacion(this._id_servicio_importacion))
{
if (si.habilitar)
{
retorno = si.DeshabilitaServicioImportacion(id_usuario);
}
else
{
retorno = new RetornoOperacion("No se puede recuperar la Importación del Servicio");
}
}
}
if (retorno.OperacionExitosa)
{
retorno = new RetornoOperacion(this._id_servicio_importacion);
scope.Complete();
}
}
}
}
return(retorno);
}
/// <summary>
/// Metodo que se encarga de guardar un cliente casignandole un proceso
/// </summary>
private void guardaClienteProceso()
{
RetornoOperacion retorno = new RetornoOperacion();
//Obtenemos el estado de la pagina
switch ((Pagina.Estatus)Session["estatus"])
{
//Si el estado es de nuevo
case Pagina.Estatus.Nuevo:
{
//Insertamos un registro
retorno = SAT_CL.Facturacion.ClienteProceso.InsertaClienteProceso(Convert.ToInt32(TSDK.Base.Cadena.RegresaCadenaSeparada(txtCliente.Text, "ID:", 1)), Convert.ToInt32(ddlTipoProceso.SelectedValue), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario, Convert.ToByte(txtSecuencia.Text), txtDescripcion.Text, txtContacto.Text);
break;
}
//Si el estado es de edicion
case Pagina.Estatus.Edicion:
{
//Instanciamos clase con el id de registro que se va a editar
using (SAT_CL.Facturacion.ClienteProceso cp = new SAT_CL.Facturacion.ClienteProceso((int)Session["id_registro"]))
{
//Editamos registro
retorno = cp.ActualizaRegistroBD(Convert.ToInt32(TSDK.Base.Cadena.RegresaCadenaSeparada(txtCliente.Text, "ID:", 1)), Convert.ToInt32(ddlTipoProceso.SelectedValue), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario, Convert.ToByte(txtSecuencia.Text), txtDescripcion.Text, txtContacto.Text);
}
break;
}
}
if (retorno.OperacionExitosa)
{
//Asigna a la variable estatus el estado de lectura
Session["estatus"] = Pagina.Estatus.Lectura;
//La variable id_registro se le asigna el id generado en la base de datos
Session["id_registro"] = retorno.IdRegistro;
//Invoca al método inicializaForma
inicializaForma();
}
TSDK.ASP.ScriptServer.MuestraNotificacion(this, retorno, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Evento Producido al Guardar la Lectura
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void wucLectura_ClickGuardarLectura(object sender, EventArgs e)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Inicializando Bloque Transaccional
using (TransactionScope trans = TSDK.Datos.Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando Vale de Diesel
using (SAT_CL.EgresoServicio.AsignacionDiesel diesel = new SAT_CL.EgresoServicio.AsignacionDiesel(Convert.ToInt32(gvValesDiesel.SelectedDataKey["Id"])))
{
//Validando que exista el Vale
if (diesel.habilitar)
{
//Guardando Lectura
result = wucLectura.GuardarLectura();
//Validando que se Haya Guardado el Registro
if (result.OperacionExitosa)
{
//Obteniendo Lectura de Diesel
int idLectura = result.IdRegistro;
//Actualizando Lectura
result = diesel.ActualizaLecturaDiesel(idLectura, ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
//Validando que se Haya Actualizado el Registro
if (result.OperacionExitosa)
{
//Completando Transacción
trans.Complete();
}
}
}
}
}
//Mostrando Notificación
ScriptServer.MuestraNotificacion(this, result, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Guarda los cambios realizados en la clasificación del Servicio
/// </summary>
/// <returns></returns>
public RetornoOperacion GuardaCambiosClasificacionServicio()
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Validando que exista un Registro
if (objClasificacion.id_clasificacion == 0)
{
//Insertando Clasificacion
result = SAT_CL.Global.Clasificacion.InsertaClasificacion(this._id_tabla, this._id_registro, 0, Convert.ToInt32(ddlFlota.SelectedValue),
Convert.ToInt32(ddlRegion.SelectedValue), Convert.ToInt32(ddlUbicacionTerminal.SelectedValue),
Convert.ToInt32(ddlTipoServicio.SelectedValue), Convert.ToInt32(ddlAlcanceServicio.SelectedValue),
Convert.ToInt32(ddlDetalleNegocio.SelectedValue), Convert.ToInt32(ddlClasificacion1.SelectedValue),
Convert.ToInt32(ddlClasificacion2.SelectedValue), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
}
else
{
//Instanciamos Servicio
using (Servicio objServicio = new Servicio(this._id_registro))
{
//Actualizando los Datos
result = objClasificacion.EditaClasificacion(this._id_tabla, this._id_registro, objClasificacion.id_tipo, Convert.ToInt32(ddlFlota.SelectedValue),
Convert.ToInt32(ddlRegion.SelectedValue), Convert.ToInt32(ddlUbicacionTerminal.SelectedValue),
Convert.ToInt32(ddlTipoServicio.SelectedValue), Convert.ToInt32(ddlAlcanceServicio.SelectedValue),
Convert.ToInt32(ddlDetalleNegocio.SelectedValue), Convert.ToInt32(ddlClasificacion1.SelectedValue),
Convert.ToInt32(ddlClasificacion2.SelectedValue), ((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
}
}
//Validando que la operacion fuera exitosa
if (result.OperacionExitosa)
{ //Creando Objeto
objClasificacion = new SAT_CL.Global.Clasificacion(result.IdRegistro);
//Inicializando Controles
InicializaControl(this.objClasificacion.id_tabla, this.objClasificacion.id_registro, this._id_compania);
}
//Mostrando Mensaje de Operacion
lblError.Text = result.Mensaje;
//Devolviendo Objeto de Retorno
return(result);
}
/// <summary>
/// Deshabilita un Descuento
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabiltaDescuento(int id_usuario)
{
//Declaramos Objeto Retorno
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Realizando actualizacion
resultado = editaDescuento(this._id_motivo_descuento, this._id_comprobante, this._porcentaje, this._cantidad_moneda_captura, this._cantidad_moneda_nacional,
id_usuario, false);
//Editamos Descuento del Comprobante
if (resultado.OperacionExitosa)
{
//Guardando Id de Descuento afectado
int id_descuento = resultado.IdRegistro;
//Instanciamos Comprobante
using (Comprobante objcomprobante = new Comprobante(id_comprobante))
{
resultado = objcomprobante.ActualizaDescuento(0, 0, id_usuario);
}
//Validamos edición del comprobante
if (resultado.OperacionExitosa)
{
resultado = Impuesto.RecalcularImpuestos(id_comprobante, id_usuario);
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
resultado = new RetornoOperacion(id_descuento);
//Finalizamos transacción
scope.Complete();
}
}
}
return(resultado);
}
/// <summary>
/// Método encargado de validar si el Producto tiene transacciones en el Inventario
/// </summary>
/// <param name="id_producto">Producto por Verificar</param>
/// <returns></returns>
public static RetornoOperacion ValidaTransaccionProductoInventario(int id_producto)
{
//Declarando Objeto de retorno
RetornoOperacion retorno = new RetornoOperacion();
//Creación del arreglo param, que almacena los datos necesarios para realizar la inserción de registro.
object[] param = { 5, 0, 0, id_producto, 0, 0.00M, null, 0, false, "", "" };
//Invoca al método EjecutaProcAlmacenadoDataSet y asigna el resultado en el dataset DS
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Valida los datos del DS (que existan y no sean nulos)
if (TSDK.Datos.Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Recorre las filas y almacena el resultado en los atributos
foreach (DataRow r in ds.Tables["Table"].Rows)
{
//Validando Registro
if (Convert.ToInt32(r["Id"]) > 0)
{
//Instanciando Retorno
retorno = new RetornoOperacion(id_producto, "El Producto tiene Transacciones en el Inventario.", true);
}
else
{
//Instanciando Retorno
retorno = new RetornoOperacion("El Producto no tiene Transacciones en el Inventario.");
}
}
}
else
{
//Instanciando Retorno
retorno = new RetornoOperacion("El Producto no tiene Transacciones en el Inventario.");
}
}
//Devolviendo Resultado Obtenido
return(retorno);
}
/// <summary>
/// Método encargado de Obtener el Mapa de la Ubicación (Dando un Origen y un Destino).
/// </summary>
/// <param name="tipoMapa">Tipo de Mapa</param>
/// <param name="ancho">Ancho del Mapa</param>
/// <param name="alto">Alto del Mapa</param>
/// <param name="marcador">Marcador Origen (Etiqueta, Color, Latitud, Longitud) del Mapa</param>
/// <param name="ubicacion_destino">Poligono Destino (Color, Color Relleno, Tamano, Ubicación y Etiqueta) del Mapa</param>
/// <param name="imagen">Parametro de Imagen de Salida</param>
/// <returns></returns>
public RetornoOperacion ObtieneMapaUbicacion(TipoMapa tipoMapa, int ancho, int alto, MarcadorMapa marcador_origen,
PoligonoMapa ubicacion_destino, out Bitmap imagen)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
string url_parametros = "";
imagen = null;
//Validando que existan Alto y Ancho
if (ancho > 0 && alto > 0)
{
//Validando que exista la Ubicación de Destino
if (ubicacion_destino.ubicacion != SqlGeography.Null)
{
//Creando URL de Petición
url_parametros = string.Format("{0}?size={1}x{2}&maptype={3}&{4}&{5}&key={6}",
this._url, ancho, alto, traduceTipoMapa(tipoMapa),
convierteMarcadorCadena(marcador_origen),
conviertePoligonoCadena(ubicacion_destino),
this._key);
//Ejecutando Petición Web
result = obtieneRespuestaPeticion(url_parametros, out imagen);
}
else
{
//Instanciando Excepción
result = new RetornoOperacion("Debe especificar un Destino");
}
}
else
{
//Instanciando Excepción
result = new RetornoOperacion("Valores de Ancho y Alto Invalidos");
}
//Devolviendo Resultado Obtenido
return(result);
}
/// <summary>
/// Actualiza Subtotal de Comprobante
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion ActualizaTotalDetalleImpuesto(int id_usuario)
{
//Inicializamos Vaariables
decimal ImporteMonedaCaptura = 0, ImporteMonedaNacional = 0;
//Declaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Obtiene Total Conceptos
using (DataTable mit = ConceptoDetalleImpuesto.RecuperaConceptosDetalles(this.id_detalle_impuesto))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Obtenemos Total Conceptos
ImporteMonedaCaptura = (from DataRow r in mit.Rows
select Convert.ToDecimal(r["ImporteMonedaCaptura"])).Sum();
ImporteMonedaNacional = (from DataRow r in mit.Rows
select Convert.ToDecimal(r["ImporteMonedaNacional"])).Sum();
}
}
//Editamos Combrobante
resultado = editaDetalleImpuesto(this.id_impuesto, this._id_tipo_detalle, this._id_impuesto_retenido,
this._id_impuesto_trasladado, this.tasa, ImporteMonedaCaptura, ImporteMonedaNacional,
id_usuario, this._habilitar);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Finalizamos transacción
scope.Complete();
}
}
//Obtenemos Resultado
return(resultado);
}
/// <summary>
/// Evento provocado al presionar el botón Agregar dentro de la ventana modal
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnAgregarClave_Click(object sender, EventArgs e)
{
//Declarar objeto retorno
RetornoOperacion retorno = new RetornoOperacion();
if (gvClaveSP.SelectedIndex == -1) //Si el índice seleccionado es -1 significa que no hay ningun registro seleccionado y se inserta uno nuevo
{
//Insertar Catalogo
retorno = SAT_CL.Global.Catalogo.InsertaCatalogoConsecutivo(
3196,
Cadena.RegresaCadenaSeparada(txtClave.Text, "-", 0),
Cadena.RegresaCadenaSeparada(txtClave.Text, "-", 1),
((SAT_CL.Seguridad.UsuarioSesion)Session["usuario_sesion"]).id_usuario);
//Valida que se insertó
if (retorno.OperacionExitosa)
{
//Vuelve a cargar el GV
cargaClavesSP();
//Mostrar mensaje
TSDK.ASP.ScriptServer.MuestraNotificacion(btnAgregarClave, "La clave se agregó correctamente.", TSDK.ASP.ScriptServer.NaturalezaNotificacion.Exito, TSDK.ASP.ScriptServer.PosicionNotificacion.AbajoDerecha);
}
}
else //Si es diferente, es porque hay uno seleccionado
{
//Editar registro
using (SAT_CL.Global.Catalogo catalogo = new Catalogo(Convert.ToInt32(gvClaveSP.SelectedDataKey["Id"])))
{
catalogo.editaVCadenaDescripcionCatalogo(
Cadena.RegresaCadenaSeparada(txtClave.Text, "-", 0),
Cadena.RegresaCadenaSeparada(txtClave.Text, "-", 1),
((SAT_CL.Seguridad.UsuarioSesion)Session["usuario_sesion"]).id_usuario
);
}
}
//Reiniciar indices
Controles.InicializaIndices(gvClaveSP);;
//Recargar gridview
cargaClavesSP();
txtClave.Text = "";
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void wucDevolucionFaltante_ClickEliminarDevolucionDetalle(object sender, EventArgs e)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Guardando Devolución
result = wucDevolucionFaltante.EliminaDetalleDevolucion();
//Validando que la Operación fuese Exitosa
if (result.OperacionExitosa)
{
//Buscando Devoluciones y Detalles
buscarDevolucionesDetalles();
//Inicializando Indices
Controles.InicializaIndices(gvDevoluciones);
Controles.InicializaIndices(gvDetalles);
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(this.Page, result, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Determina si es posible eliminar una aplicación de pago de Cliente, en base a su relación con un CFDI de Recepción de Pagos Activo
/// </summary>
/// <param name="id_tabla_origen_aplicacion"></param>
/// <param name="id_aplicacion_pago"></param>
/// <returns></returns>
public static RetornoOperacion ValidarAplicacionEnCFDIRecepcionPagoActivo(int id_tabla_origen_aplicacion, int id_aplicacion_pago)
{
//Declarando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion(id_aplicacion_pago);
//Creando arreglo de parámetros para deshabilitación
object[] param = { 6, 0, Convert.ToByte(id_tabla_origen_aplicacion == 9 ? TipoOperacion.Ingreso : TipoOperacion.Egreso), 0, 0, 0, 0, id_aplicacion_pago, 0, 0, 0, 0, 0, 0, 0, "", "" };
//Realizando búsqueda de los registros que impidan elimiar Aplicación de Pago
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando resultados
if (Validacion.ValidaOrigenDatos(ds, true, true))
{
//Si hay resultados
resultado = new RetornoOperacion("Existe una Relación Activa a un CFDI de Recepción de Pagos Vigente.");
}
}
//Devolviendo resultado
return(resultado);
}
