/// <summary>
/// Deshabilita todos los documentos relacionados a una asociación egreso-ingreso-cfdi de pago
/// </summary>
/// <param name="id_egreso_ingreso_comprobante">Id de Egreso-Ingreso-Pago</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public static RetornoOperacion DeshabilitarDocumentosRelacionadosIngresoEgresoComprobantePago(int id_egreso_ingreso_comprobante, int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Creando arreglo de parámetros para deshabilitación
object[] param = { 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, id_egreso_ingreso_comprobante, id_usuario, 0, "", "" };
//Realizando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Realizando actualización de los registros
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
//Validando resultados
resultado = RetornoOperacion.ValidaResultadoOperacionMultiple(ds);
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Confirmando cambios realizados
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Edita una Sucursal
/// </summary>
/// <param name="id_compania_emisor"></param>
/// <param name="nombre"></param>
/// <param name="id_direccion"></param>
/// <param name="id_usuario"></param>
/// <param name="habilitar"></param>
/// <returns></returns>
private RetornoOperacion editaSucursal(int id_compania_emisor, string nombre, int id_direccion, int id_usuario, bool habilitar)
{
//Declaramos Objeto resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validamo existencia de ubicación
if (!Validacion.ValidaOrigenDatos(Comprobante.RecuperaComprobantesPorSucursal(this._id_sucursal)))
{
//Inicializando arreglo de parámetros
object[] param = { 2, this._id_sucursal, id_compania_emisor, nombre, id_direccion, id_usuario, habilitar, "", "" };
//Realizando actualizacion
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nombre_stored_procedure, param);
}
else
{
resultado = new RetornoOperacion("No puede ser editado el registro debido a que está ligado a un CFD.");
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Finalizamos Transacción
scope.Complete();
}
}
//Devolvemos Resultado
return(resultado);
}
protected void wucSoporteTecnico_ClickAceptarSoporte(object sender, EventArgs e)
{
//Realizando el guardado
RetornoOperacion resultado = new RetornoOperacion();
//Inicializando Bloque Transaccional
using (TransactionScope trans = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
resultado = EliminaVale();
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Actualizando lista de vales de diesel
resultado = ucSoporte.GuardaSoporte();
}
if (resultado.OperacionExitosa)
{
trans.Complete();
}
}
//Cerrando ventana modal
ScriptServer.AlternarVentana(this, "Soporte", "soporteTecnicoModal", "soporteTecnico");
buscaValeDiesel();
ScriptServer.MuestraNotificacion(this.Page, resultado.Mensaje, ScriptServer.NaturalezaNotificacion.Exito, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Evento Producido al dar click en boton Aceptar
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void wucSoporteTecnico_ClickAceptarSoporte(object sender, EventArgs e)
{
//Realizando el guardado
RetornoOperacion result = new RetornoOperacion();
//Inicializando Bloque Transaccional
using (TransactionScope trans = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Realizando el guardado
result = CambiaOperador();
//Si no hay errores
if (result.OperacionExitosa)
{
ucSoporte.GuardaSoporte();
}
if (result.OperacionExitosa)
{
trans.Complete();
}
}
//Cerrando ventana modal
ScriptServer.AlternarVentana(this, "Soporte", "soporteTecnicoModal", "soporteTecnico");
ScriptServer.MuestraNotificacion(this.Page, result.Mensaje, ScriptServer.NaturalezaNotificacion.Exito, ScriptServer.PosicionNotificacion.AbajoDerecha);
buscaMovimiento();
Controles.InicializaIndices(gvMovimientos);
}
/// <summary>
/// Deshabilita la relación Egreso/Ingreso - CFDI de Pagos, así como los Documentos Relacionados
/// </summary>
/// <param name="id_egreso_ingreso_comprobante">Id de Realción Egreso/Ingreso CFDI de Pago</param>
/// <param name="id_usuario">Id de Usuario que realiza la operación</param>
/// <returns></returns>
public static RetornoOperacion DeshabilitaEgresoIngresoComprobante(int id_egreso_ingreso_comprobante, int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion(string.Format("Error al Deshabilitar relación Egreso/Ingreso - CFDI. Id: '{0}'", id_egreso_ingreso_comprobante));
//Realizando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando Registro
using (EgresoIngresoComprobante eic = new EgresoIngresoComprobante(id_egreso_ingreso_comprobante))
{
//Si el registro existe
if (eic.habilitar)
{
//Deshabilitando
resultado = eic.DeshabilitaEgresoIngresoComprobante(id_usuario);
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Deshabilitando relaciones de CFDI (documentos relacionados)
resultado = ComprobantePagoDocumentoRelacionado.DeshabilitarDocumentosRelacionadosIngresoEgresoComprobantePago(eic.id_egreso_ingreso_comprobante, id_usuario);
}
}
}
//Si no hay errores
if (resultado.OperacionExitosa)
{
//Confirmando cambios realizados
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
/*
* /// <summary>
* /// Método Público encargado de la Insercción de Registros
* /// </summary>
* /// <param name="idContacto">Id Contacto</param>
* /// <param name="fechaGeneracion">Fecha de Generación</param>
* /// <param name="fechaCaducidad">Fecha de Caducidad</param>
* /// <param name="descargasRestantes">Descargas Restantes</param>
* /// <param name="requierePDF">Requiere PDF</param>
* /// <param name="idUsuario">Id de Usuario</param>
* /// <returns></returns>
* public static int InsertaLinkDescarga(int idContacto,
* DateTime fechaGeneracion, DateTime fechaCaducidad,
* int descargasRestantes, bool requierePDF,
* int idUsuario)
* { //Inicialziando parrámetros
* object[] param = { 1, 0, idContacto, fechaGeneracion, fechaCaducidad,
* descargasRestantes, requierePDF, idUsuario, true, "", "" };
* //Declarando e inicializando variable de retorno
* int idLink = 0;
* //Insertando registro en BD
* try
* { //Insertando el nuevo registro
* idLink = Convert.ToInt32(CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nom_sp, param));
* }
* //En caso de error
* catch (Exception ex)
* { //Registrando error
* //clExcepciones.RegistraExcepcionXML("~/Errores/ReporteErrores.xml", ex);
* }
* //Devolviendo id de registro insertado
* return idLink;
* }
* /// <summary>
* /// Método Público encargado de la Insercción de Registros
* /// </summary>
* /// <param name="idContacto">Id Contacto</param>
* /// <param name="fechaGeneracion">Fecha de Generación</param>
* /// <param name="fechaCaducidad">Fecha de Caducidad</param>
* /// <param name="descargasRestantes">Descargas Restantes</param>
* /// <param name="requierePDF">Requiere PDF</param>
* /// <param name="idUsuario">Id de Usuario</param>
* /// <param name="transaccion">Transacción</param>
* /// <returns></returns>
* public static int InsertaLinkDescarga(int idContacto,
* DateTime fechaGeneracion, DateTime fechaCaducidad,
* int descargasRestantes, bool requierePDF,
* int idUsuario, SqlTransaction transaccion)
* { //Inicialziando parrámetros
* object[] param = { 1, 0, idContacto, fechaGeneracion, fechaCaducidad,
* descargasRestantes, requierePDF, idUsuario, true, "", "" };
* //Declarando e inicializando variable de retorno
* int idLink = 0;
* //Insertando registro en BD
* try
* { //Insertando el nuevo registro
* idLink = Convert.ToInt32(CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nom_sp, param, transaccion));
* }
* //En caso de error
* catch (Exception ex)
* { //Registrando error
* //clExcepciones.RegistraExcepcionXML("~/Errores/ReporteErrores.xml", ex);
* }
* //Devolviendo id de registro insertado
* return idLink;
* }
* /// <summary>
* /// Obtiene un arreglo con los Id de comprobantes involucrados en la descarga de archivos de la instancia
* /// </summary>
* /// <returns></returns>
* public int[] ObtieneRutasDescarga()
* { //Inicialziando parámetros para consulta a la BD
* object[] param = {4, this._idLinkDescarga, 0, TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro(), TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro(), 0, false, 0, false, "", ""};
* //Obteniendo los datos desde la BD
* using (DataSet DS = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
* { //Validando el origen de datos
* if (Validacion.ValidaOrigenDatos(DS, "Table"))
* { //Inicializnado variable de retorno
* int[] comprobantesDescarga = new int[DS.Tables["Table"].Rows.Count];
* //Declarando variable indexadora de rutas
* int indice = 0;
* //Recorriendo todos los elementos devueltos
* foreach (DataRow fila in DS.Tables["Table"].Rows)
* { //Añadiendo la ruta de descarga
* comprobantesDescarga[indice] = Convert.ToInt32(fila["IdComprobante"]);
* //Incrementando el indice
* indice++;
* }//Devolvinedo el arreglo de rutas resultante
* return comprobantesDescarga;
* }
* }
*
* //Devolviendo arreglo vacio
* return null;
* }*/
/// <summary>
/// Genera un link automaticamente con los parametros almacenados en la base de datos
/// </summary>
/// <param name="idContacto">Id de contacto</param>
/// <param name="idComprobantes">Comprobantes que tendra el link</param>
/// <param name="fechaCaducidad">Parámetro de salida para almacenar la fecha de caducidad del link de descarga</param>
/// <param name="descargasRestantes">Parámetro de salida para almacenar el máximo de descargas configurado para cada link</param>
/// /// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion GeneraLinkDescarga(int idContacto, string[] idComprobantes, out DateTime fechaCaducidad, out int descargasRestantes, int id_compania, int id_usuario)
{
//Declaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion(0);
//Declaramos Variable para Almacenear el Encabezado del Link Descarga
int id_descarga = 0;
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Definiendo los dias de caducidad (Obtenidos desde catálogo de variables en BD)
int diasCaducidad = Convert.ToInt32(Cadena.VerificaCadenaVacia(CapaNegocio.m_capaNegocio.RegresaVariableCatalogoBD("Dias caducidad por Link", id_compania), "1"));
//Calculando la fecha de caducidad
fechaCaducidad = TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro().AddDays(diasCaducidad);
//Definiendo las descargas restantes (Obtenidos desde catálogo de variables en BD)
descargasRestantes = Convert.ToInt32(Cadena.VerificaCadenaVacia(CapaNegocio.m_capaNegocio.RegresaVariableCatalogoBD("Máximo descargas por Link", id_compania), "1"));
//Insertando el registro padre (link descarga)
resultado = LinkDescarga.InsertaLinkDescarga(idContacto, TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro(), fechaCaducidad, descargasRestantes, true, id_usuario);
//Asignamos Variable de Encabezado de Descarga
id_descarga = resultado.IdRegistro;
//Si se Registro Corectamente
if (resultado.OperacionExitosa)
{
//Insertando los detalles de descarga
foreach (string comprobante in idComprobantes)
{
//Validamos Insercción del Link Detalle Descarga
if (resultado.OperacionExitosa)
{
//Validamos qu exista id_comprobante
if (comprobante != "")
{
resultado = DetalleLinkDescarga.InsertarDetalleLinkDescarga(id_descarga, Convert.ToInt32(comprobante), id_usuario);
}
}
else
{
//Salimos del Ciclo
break;
}
}
//Validamo Resultados Exitosos
if (resultado.OperacionExitosa)
{
//Asignamos Id Descarga
resultado = new RetornoOperacion(id_descarga);
//Completamos transacción
scope.Complete();
}
}
}
//Devolvinedo resultado de transacción
return(resultado);
}
/// <summary>
/// Método encargado de deshabilitar el registro y sus dependencias
/// </summary>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaPaqueteEnvioCascada(int id_usuario)
{
//Definiendo objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validando el estatus del paquete, sólo Registrado puede ser eliminado
if (this.id_estatus == EstatusPaqueteEnvio.Registrado)
{
//Deshabilitando los detalles
resultado = PaqueteEnvioDocumento.DeshabilitaPaqueteEnvioDocumentos(this._id_paquete_envio, id_usuario);
//Si se deshabilitaron los detalles
if (resultado.OperacionExitosa)
{
//Realizando deshabilitación de este registros
resultado = DeshabilitaPaqueteEnvio(id_usuario);
}
}
else
{
resultado = new RetornoOperacion("Un paquete sólo puede ser eliminado cuando su estatus es 'Registrado'.");
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos Transacción
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Método encargado de insertar un concepto
/// </summary>
/// <param name="id_comprobante"></param>
/// <param name="cantidad"></param>
/// <param name="id_unidad"></param>
/// <param name="id_descripcion"></param>
/// <param name="no_identificacion"></param>
/// <param name="valor_unitario"></param>
/// <param name="importe_moneda_captura"></param>
/// <param name="importe_moneda_nacional"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion InsertaConcepto(int id_comprobante,
decimal cantidad, int id_unidad, int id_descripcion,
string no_identificacion, decimal valor_unitario, decimal importe_moneda_captura,
decimal importe_moneda_nacional, int id_usuario)
{
int id_concepto = 0;
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciamos comprobante
using (Comprobante objComprobante = new Comprobante(id_comprobante))
{
//validamos Existencia de comprobante
if (objComprobante.id_comprobante > 0)
{
//Validamos existencia de Descuento
if (objComprobante.descuento_moneda_captura == 0 || objComprobante.descuento_moneda_nacional == 0)
{
//Inicializando arreglo de parámetros
object[] param = { 1, 0, id_comprobante, 0, 1, cantidad, id_unidad,
id_descripcion, "", no_identificacion, valor_unitario, importe_moneda_captura,
importe_moneda_nacional, id_usuario, true, "", "" };
//Realziando inserción del concepto
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(nombre_stored_procedure, param);
//Asignamos Id de Concopeto
id_concepto = resultado.IdRegistro;
//Recalucular Impuestos
if (resultado.OperacionExitosa)
{
resultado = Impuesto.RecalcularImpuestos(id_comprobante, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Declaramos Objeto Retorno
resultado = new RetornoOperacion(id_concepto);
//Finalizamos transacción
scope.Complete();
}
}
}
else
{
resultado = new RetornoOperacion("No se puede agregar un concepto, ya que existe el decuento");
}
}
else
{
resultado = new RetornoOperacion("No se encontró datos complementarios Comprobante");
}
}
}
return(resultado);
}
/// <summary>
/// Deshabilitamos Certificado
/// </summary>
private void deshabilitarCertificado()
{
//Establecemos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando registro actual
using (SAT_CL.Global.CertificadoDigital objCertificado = new SAT_CL.Global.CertificadoDigital(Convert.ToInt32(Session["id_registro"])))
{
resultado = objCertificado.DeshabilitaCertificado(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
if (resultado.OperacionExitosa)
{
//Deshabilitamos Registros Archivo
using (ArchivoRegistro objArchivoCer = new
ArchivoRegistro(objCertificado.idCer))
//Deshabilitamos Registro
resultado = objArchivoCer.DeshabilitaArchivoRegistro(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Deshabilitamos Registros Archivo
using (ArchivoRegistro objArchivoKey = new
ArchivoRegistro(objCertificado.idKey))
//Deshabilitamos Registro
resultado = objArchivoKey.DeshabilitaArchivoRegistro(((SAT_CL.Seguridad.Usuario)Session["usuario"]).id_usuario);
//Si se deshabilitó Correctamente
if (resultado.OperacionExitosa)
{
//Establecemos el id del registro
Session["id_registro"] = 0;
//Establecemos el estatus de la forma
Session["estatus"] = Pagina.Estatus.Nuevo;
//Inicializamos la forma
inicializaPagina();
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Mostrando error
lblError.Text = resultado.Mensaje;
}
/// <summary>
/// Método encargado de Insertar los Detalles de la Devolución
/// </summary>
/// <param name="id_devolucion_faltante">Devolución Faltante</param>
/// <param name="cantidad">Cantidad</param>
/// <param name="estatus">Estatus del Detalle</param>
/// <param name="id_producto_devolucion">Producto de la Devolución</param>
/// <param name="id_unidad">Unidad</param>
/// <param name="codigo_producto">Código del Producto</param>
/// <param name="descripcion_producto">Descripción del Producto</param>
/// <param name="razon_detalle">Razon del Detalle</param>
/// <param name="id_usuario">Usuario que Actualiza el Registro</param>
/// <returns></returns>
public RetornoOperacion EditaDevolucionFaltanteDetalle(int id_devolucion_faltante, EstatusDevolucionDetalle estatus, int id_producto_devolucion,
decimal cantidad, byte id_unidad, string codigo_producto, string descripcion_producto, RazonDetalle razon_detalle, int id_usuario)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Declarando Variable Auxliar
int id_detalle = 0;
//Inicializando Bloque Transaccional
using (TransactionScope trans = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Invocando Método de Actualización
result = this.actualizaRegistrosBD(id_devolucion_faltante, (byte)estatus, id_producto_devolucion, cantidad, id_unidad, codigo_producto,
descripcion_producto, (byte)razon_detalle, id_usuario, this._habilitar);
//Validando Operación Exitosa
if (result.OperacionExitosa)
{
//Obteniendo Detalle
id_detalle = result.IdRegistro;
//Validando que el Estatus sea Distinto
if ((EstatusDevolucionDetalle)this._id_estatus != estatus)
{
//Instanciando Devolución
using (DevolucionFaltante devolucion = new DevolucionFaltante(id_devolucion_faltante))
{
//Validando existencia
if (devolucion.habilitar)
{
//Actualizando Estatus
result = devolucion.ActualizaEstatusDevolucionFaltante(ObtieneEstatusDevolucion(id_devolucion_faltante), id_usuario);
}
else
{
//Instanciando Excepción
result = new RetornoOperacion("No existe la Devolución");
}
}
}
}
//Validando Operación Exitosa
if (result.OperacionExitosa)
{
//Instanciando Registro
result = new RetornoOperacion(id_detalle);
//Completando transacción
trans.Complete();
}
}
//Devolviendo Resultado Obtenido
return(result);
}
/// <summary>
/// Metodo encargado de terminar el periodo ligado a la actividad
/// </summary>
/// <param name="fecha"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion TerminaActividadPeriodo(DateTime fecha, int id_usuario)
{
//Declarando variable de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Instanciamos la actividad
using (ActividadAsignacion actividad = new ActividadAsignacion(_id_actividad_asignacion))
{
//Validando que la actividad no se encuentre terminada aún
if (actividad.Estatus != ActividadAsignacion.EstatusAsignacionActividad.Terminada)
{
//Validamos Resultado
if (this._inicio_periodo > this._fin_periodo)
{
//Instanciamos al tipo de periodo
using (TipoPeriodoAsignacion tipo = new TipoPeriodoAsignacion(this._id_tipo_periodo))
{
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Terminamos el periodo
resultado = this.editaActividadPeriodo(this.id_actividad_asignacion, this.id_tipo_periodo, this.inicio_periodo, fecha, 0, id_usuario, this.habilitar);
//Si el resultado de la actualizacion es correcto
if (resultado.OperacionExitosa)
{
//Si el tipo de periodo es negativo
if (tipo.signo == -1)
{
//Realizamos la activacion de la actividad
resultado = actividad.CambiaEstatusActividadAsignacion(ActividadAsignacion.EstatusAsignacionActividad.Iniciada, id_usuario);
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Terminamos transacción
scope.Complete();
}
}
}
}
}
else //Establecemos Mesaje Error
{
resultado = new RetornoOperacion("La fecha de inicio del periodo " + this._inicio_periodo.ToString("dd/MM/yyyy HH:mm") + " debe ser mayor a la fecha de fin del periodo " + this._fin_periodo.ToString("dd/MM/yyyy HH:mm") + ".");
}
}
else
{
resultado = new RetornoOperacion("Imposible actualizar, la asignación ya se encuentra terminada.");
}
}
//Devolvinedo resultado
return(resultado);
}
/// <summary>
/// Método Público encargado de Insertar nuevos Registros
/// </summary>
/// <param name="id_servicio">Id de servicio</param>
/// <param name="fecha_inicio">Fecha Inicio</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public static RetornoOperacion InsertaServicioControlEvidencia(int id_servicio, DateTime fecha_inicio, int id_usuario)
{
//Declarando Objeto de Retorno
RetornoOperacion resultado = new RetornoOperacion();
int idServicioControlEvidencia = 0;
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Insertamos Servicio Control Evidencia
//Declarando Arreglo de Parametros del SP
object[] param = { 1, 0, id_servicio, (byte)EstatusServicioControlEvidencias.No_Recibidos, fecha_inicio, null,
id_usuario, true, "", "" };
//Obteniendo Resultado del SP
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nom_sp, param);
//Asignamos IdServicioControlEvidencia
idServicioControlEvidencia = resultado.IdRegistro;
//Si se realizo la Insercción correctamente
if (resultado.OperacionExitosa)
{
//Cargamos Segmentos Obteniendo HI
using (DataTable mit = SegmentoCarga.CargaSegmentosObteniendoHI(id_servicio, id_usuario))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Obtenemos cada uno de los Registros
foreach (DataRow r in mit.Rows)
{
//Si el resultado es exitoso
if (resultado.OperacionExitosa)
{
//Insertamos Segmento Control Evidencia
resultado = SegmentoControlEvidencia.InsertaSegmentoControlEvidencia(idServicioControlEvidencia, r.Field <int>("IdSegmento"), r.Field <int>("HI"), id_usuario);
}
else
{
//Salimos del ciclo
break;
}
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos Transacción
scope.Complete();
}
}
return(resultado);
}
/// <summary>
/// Terminamos Movimiento
/// </summary>
private void terminarMovimiento()
{
//Declarando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion();
//inicializando transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando movimiento vacío
using (SAT_CL.Despacho.Movimiento mov = new Movimiento(Convert.ToInt32(gvMovimientos.SelectedDataKey["IdMovimiento"])))
{
//Si el movimiento se recuperó
if (mov.id_movimiento > 0)
{
//Instanciando parada de origen
using (SAT_CL.Despacho.Parada origen = new Parada(mov.id_parada_origen))
{
//Validamos fecha de salida de origen vs fecha llegada a destino
if (Convert.ToDateTime(txtFechaTerminar.Text).CompareTo(origen.fecha_salida) > 0)
{
//Terminamos Movimiento
resultado = mov.TerminaMovimientoVacio(chkFechaActual.Checked ? TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro() : Convert.ToDateTime(txtFechaTerminar.Text), EstanciaUnidad.TipoActualizacionInicio.Manual, ((Usuario)Session["usuario"]).id_usuario);
}
else
{
resultado = new RetornoOperacion(string.Format("La Llegada al Destino '{0:dd/MM/yyyy HH:mm}' debe ser Mayor a la Salida del Origen '{1:dd/MM/yyyy HH:mm}'", Convert.ToDateTime(txtFechaTerminar.Text), origen.fecha_salida));
}
}
}
//Si no hay movimiento
else
{
resultado = new RetornoOperacion(string.Format("Movimiento '{0}' no encontrado.", gvMovimientos.SelectedDataKey["IdMovimiento"]));
}
}
//Finalizando transacción
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Validamos Resultado final
if (resultado.OperacionExitosa)
{
//Cargamos Movimientos
cargaMovimientosVacio();
//Registrando el script sólo para los paneles que producirán actualización del mismo
ScriptServer.AlternarVentana(btnAceptarTerminarMovimiento, btnAceptarTerminarMovimiento.GetType(), "CierreVentanaModal", "contenidoFechaTerminarMovimiento", "confirmacionFechaTerminarMovimiento");
}
//Mostrando resultado
ScriptServer.MuestraNotificacion(btnAceptarTerminarMovimiento, resultado, ScriptServer.PosicionNotificacion.AbajoDerecha);
}
/// <summary>
/// Actualiza Total Impuesto
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion ActualizaTotalImpuesto(int id_usuario)
{
//Inicializamos Variables
decimal total_retenido_moneda_captura = 0,
total_retenido_moneda_nacional = 0,
total_trasladado_moneda_captura = 0,
total_trasladado_moneda_nacional = 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 = DetalleImpuesto.CargaDetallesImpuesto(this.id_impuesto))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Obtenemos Importe Captura Impuestos Retenidos
total_retenido_moneda_captura = (from DataRow r in mit.Rows
where r.Field <int>("IdTipo") == 1
select Convert.ToDecimal(r["ImporteMonedaCaptura"])
).Sum();
//Obtenemos Importe Nacional Impuesto Retenidos
total_retenido_moneda_nacional = (from DataRow r in mit.Rows
where r.Field <int>("IdTipo") == 1
select Convert.ToDecimal(r["ImporteMonedaNacional"])).Sum();
//Obtenemos Importe Captura Impuestos Retenidos
total_trasladado_moneda_captura = (from DataRow r in mit.Rows
where r.Field <int>("IdTipo") == 2
select Convert.ToDecimal(r["ImporteMonedaCaptura"])
).Sum();
//Obtenemos Importe Nacional Impuesto Trasladado
total_trasladado_moneda_nacional = (from DataRow r in mit.Rows
where r.Field <int>("IdTipo") == 2
select Convert.ToDecimal(r["ImporteMonedaNacional"])).Sum();
}
}
//Editamos Combrobante
resultado = this.editaImpuesto(this._id_comprobante, total_retenido_moneda_captura, total_retenido_moneda_nacional,
total_trasladado_moneda_captura, total_trasladado_moneda_nacional, id_usuario, this._habilitar
);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Finalizamos Transacción
scope.Complete();
}
}
//Obtenemos Resultado
return(resultado);
}
/// <summary>
/// Método encargado de Actualizar los Atributos en BD
/// </summary>
/// <param name="id_compania_emisora">Compania Emisora</param>
/// <param name="no_consecutivo">No. Consecutivo por Compania</param>
/// <param name="id_nomina_origen">Nomina de Origen</param>
/// <param name="version">Versión de la Nómina</param>
/// <param name="id_tipo_nomina">Tipo de Nómina (Oridnaria, Extraordinaria)</param>
/// <param name="fecha_pago">Fecha de Pago</param>
/// <param name="fecha_inicial_pago">Fecha de Inicio del Pago</param>
/// <param name="fecha_final_pago">Fecha de de Fin del Pago</param>
/// <param name="fecha_nomina">Fecha de Nomina</param>
/// <param name="dias_pago">Dias de Pago</param>
/// <param name="id_sucursal">Sucursal</param>
/// <param name="id_periodicidad_pago">Periodicidad de Pago(Quincenal, Semanal, Mensual, etc...)</param>
/// <param name="id_metodo_pago">Método de Pago(Efectivo, Transferencia, Cheque, etc...)</param>
/// <param name="id_usuario">Usuario que actualiza el Registro</param>
/// <returns></returns>
public RetornoOperacion EditaNomina(int id_compania_emisor, int no_consecutivo, int id_nomina_origen, string version, byte id_tipo_nomina, DateTime fecha_pago, DateTime fecha_inicial_pago, DateTime fecha_final_pago, DateTime fecha_nomina, decimal dias_pago, int id_sucursal, byte id_periodicidad_pago, byte id_metodo_pago, int id_usuario)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Obtenemos Valores
string RegistroPatronal = Global.Referencia.CargaReferencia("0", 25, id_compania_emisor, "Recibo Nómina", "Registro Patronal");
string Curp = Global.Referencia.CargaReferencia("0", 25, id_compania_emisor, "Recibo Nómina", "Curp");
string RfcPatron = "";
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validando Nomina Timbrada
result = this.validaNominaTimbrada(this._id_nomina);
//Operación Exitosa?
if (!result.OperacionExitosa)
{
//Devolviendo Resultado Obtenido
result = this.actualizaAtributosBD(id_compania_emisor, no_consecutivo, id_nomina_origen, version, id_tipo_nomina, fecha_pago, fecha_inicial_pago, fecha_final_pago, fecha_nomina, dias_pago, id_sucursal, id_periodicidad_pago, id_metodo_pago, RegistroPatronal, Curp, RfcPatron, id_usuario, true);
//Validamos Resultado
if (result.OperacionExitosa)
{
//Cargamos Empleado ligado a la Nómina
using (DataTable mit = NomEmpleado.ObtieneNominasEmpleadoRegistrados(this._id_nomina))
{
//Validamos Orifen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Recorremos Empleados
foreach (DataRow r in mit.Rows)
{
//Actualizamos Tipo de Nómina
result = NomEmpleado.ActualizaEncabezadoNominaEsquema(this._id_nomina, r.Field <int>("Id"), id_usuario);
}
}
}
}
}
else
{
//Instanciando Excepción
result = new RetornoOperacion(result.Mensaje);
}
//Validamos Resultado
if (result.OperacionExitosa)
{
//Asignamos Valor de Resultado
result = new RetornoOperacion(this._id_nomina, result.Mensaje, result.OperacionExitosa);
//Terminamos Transacción
scope.Complete();
}
}
//Devolviendo Resultado Obtenido
return(result);
}
/// <summary>
/// Inserta un Descuento
/// </summary>
/// <param name="id_motivo_descuento"></param>
/// <param name="id_comprobante"></param>
/// <param name="porcentaje"></param>
/// <param name="cantidad_moneda_captura"></param>
/// <param name="cantidad_moneda_nacional"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public static RetornoOperacion InsertaDescuento(int id_motivo_descuento, int id_comprobante,
decimal porcentaje, decimal cantidad_moneda_captura, decimal cantidad_moneda_nacional,
int id_usuario)
{
//Declarando objeto de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validamos Existencia de Coonceptos
if (Validacion.ValidaOrigenDatos(Concepto.RecuperaConceptosComprobantes(id_comprobante)))
{
//Inicializando arreglo de parámetros
object[] param = { 1, 0, id_motivo_descuento, id_comprobante, porcentaje, cantidad_moneda_captura,
cantidad_moneda_nacional, id_usuario, true, "", "" };
//Realziando inserción del concepto
resultado = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nombre_stored_procedure, param);
//Editamos encabezado del Comprobante
if (resultado.OperacionExitosa)
{
//Guardando Id de Descuento afectado
int id_descuento = resultado.IdRegistro;
//Intsnaciamos Comprobante
using (Comprobante objcomprobante = new Comprobante(id_comprobante))
{
resultado = objcomprobante.ActualizaDescuento(cantidad_moneda_captura, cantidad_moneda_nacional, id_usuario);
}
//Actualizamos Impuestos
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();
}
}
}
else
{
resultado = new RetornoOperacion("No existen conceptos");
}
}
return(resultado);
}
/// <summary>
/// Deshabilita todos los documentos ligados a la HI indicada
/// </summary>
/// <param name="id_paquete_envio">Id de Paquete envío</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public static RetornoOperacion DeshabilitaPaqueteEnvioDocumentos(int id_paquete_envio, int id_usuario)
{
//Definiendo objeto de resultado
RetornoOperacion resultado = new RetornoOperacion(id_paquete_envio);
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Cargando documentos
using (DataTable mitDoc = CargaDocumentoDelPaquete(id_paquete_envio))
{
//Si existen resultados
if (Validacion.ValidaOrigenDatos(mitDoc))
{
//Para cada uno de los registros
foreach (DataRow d in mitDoc.Rows)
{
//instanciando registro
using (PaqueteEnvioDocumento dp = new PaqueteEnvioDocumento(Convert.ToInt32(d["Id"])))
{
//Si el registro existe
if (dp.id_paquete_envio_documento > 0)
{
//Deshabilitando Documento
resultado = dp.DeshabilitaPaqueteEnvioDocumento(id_usuario);
}
else
{
resultado = new RetornoOperacion(string.Format("Detalle 'ID: {0}' no encontrado.", Convert.ToInt32(d["Id"])));
}
}
//Si existe error
if (!resultado.OperacionExitosa)
{
//Saliendo de ciclo
break;
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos Transacción
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Actualiza Estatus del Paquete Envio Documento
/// </summary>
/// <param name="estatus"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion ActualizaEstatusPaqueteEnvioDocumento(EstatusPaqueteEnvioDocumento estatus, int id_usuario)
{
//Declaramos Variable resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Declaramos Id del Documento
int idDocumento = 0;
//Declaramos Variable para fecha de recepción del Documento
DateTime fecha_recepcion = this._fecha_recepcion;
//Validamos que el estatus sea Recibido o en Aclaración para la asignación de la fecha de recepción
if (estatus == EstatusPaqueteEnvioDocumento.Recibido || estatus == EstatusPaqueteEnvioDocumento.En_Aclaracion)
{
fecha_recepcion = TSDK.Base.Fecha.ObtieneFechaEstandarMexicoCentro();
}
//Actualiza Estatus del Paquete Envío documento
resultado = this.actualizaRegistros(this._id_control_evidencia_documento, this._id_paquete_envio, estatus,
fecha_recepcion, id_usuario, this._habilitar);
//Establecemos Id del Documento
idDocumento = resultado.IdRegistro;
//Validamos Actalizacion del Paquete Documento
if (resultado.OperacionExitosa)
{
//Instanciamos Paquete
using (PaqueteEnvio objPaqueteEnvio = new PaqueteEnvio(this._id_paquete_envio))
{
//Actualizamos Estatus del Paquete
resultado = objPaqueteEnvio.ActualizaEstatusGeneralPaquete(id_usuario);
//Si se realizo correctamente las actualizaciones
if (resultado.OperacionExitosa)
{
resultado = new RetornoOperacion(idDocumento);
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Validamos Transacción
scope.Complete();
}
}
return(resultado);
}
/// <summary>
/// Autorización sobre el control indicado para el perfil
/// </summary>
/// <param name="id_accion">Id Acción</param>
/// <param name="id_usuario">Id Usuario</param>
/// <param name="valor">-1 Niega Control / 1 Autoriza Control</param>
/// <param name="id_usuario_actualiza">Usuario que realiza las actualizaciones del registro</param>
/// <returns></returns>
public static RetornoOperacion AutorizaControlUsuario(byte id_accion, int id_usuario, decimal valor, int id_usuario_actualiza)
{
//DFeclaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion(0);
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Cargamos Controles ligados a la Acción
using (DataTable mit = SAT_CL.Seguridad.Control.CargaControles(id_accion))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Recorremos cada uno de los Controles
foreach (DataRow r in mit.Rows)
{
//Instanciamos Control Perfil Usuario
using (ControlPerfilUsuario objControlPerfilUsuario = new ControlPerfilUsuario(Tipo.Usuario, r.Field <int>("Id"), 0, id_usuario))
{
//Validamos Existencia del Objeto
if (objControlPerfilUsuario.id_control_perfil_usuario > 0)
{
//Negamos Control Perfil Usuario
resultado = objControlPerfilUsuario.editaControlPerfilUsuario((Tipo)objControlPerfilUsuario.id_tipo, objControlPerfilUsuario.id_control,
objControlPerfilUsuario.id_perfil, objControlPerfilUsuario.id_usuario, valor, id_usuario_actualiza, objControlPerfilUsuario.habilitar);
}
else
{
//Insertamos Nuevo Registro
resultado = InsertaControlPerfilUsuario(Tipo.Usuario, r.Field <int>("Id"), 0, id_usuario, valor, id_usuario_actualiza);
}
//Validamos Resultado
if (!resultado.OperacionExitosa)
{
//Salimos del Ciclo
break;
}
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Finalizamos Transacción
scope.Complete();
}
}
//Devolvemos Resultado
return(resultado);
}
/// <summary>
/// Metodo encargado de deshabilitar el periodo ligado a la actividad
/// </summary>
/// <param name="id_usuario">Id de usuario</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaActividadPeriodo(int id_usuario)
{
//Declarando variable de retorno
RetornoOperacion resultado = new RetornoOperacion();
//Instanciamos al tipo de periodo
using (TipoPeriodoAsignacion t = new TipoPeriodoAsignacion(this._id_tipo_periodo))
{
//Instanciamos la actividad
using (ActividadAsignacion actividad = new ActividadAsignacion(id_actividad_asignacion))
{
//Si la actividad no se ha cerrado aún y el periodo es negativo (pausa)
//O si el periodo no implica actualización sobre la asignación y la actividad
if ((actividad.Estatus != ActividadAsignacion.EstatusAsignacionActividad.Terminada && t.signo < 0) ||
t.signo > 0)
{
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Deshabilitando el periodo
resultado = this.editaActividadPeriodo(this.id_actividad_asignacion, this.id_tipo_periodo, this.inicio_periodo, this.fin_periodo, 0, id_usuario, false);
//Si el resultado de la actualizacion es correcto
if (resultado.OperacionExitosa)
{
//Si el tipo de periodo es negativo
if (t.signo == -1 && this._fin_periodo.CompareTo(DateTime.MinValue) == 0)
{
//Realizamos la activacion de la actividad
resultado = actividad.CambiaEstatusActividadAsignacion(ActividadAsignacion.EstatusAsignacionActividad.Iniciada, id_usuario);
//Validamos Resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
}
}
}
//De lo contrario
else
{
resultado = new RetornoOperacion("El estatus de la asignación de actividad no permite esta actualización.");
}
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Método que cambia el estado de uso de un registro (Habilitado-Disponible, Deshabilitado-No Disponible)
/// </summary>
/// <param name="id_usuario">Permite identificar al usuario que realizo la acción</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaRutaTipoUnidad(int id_usuario)
{
//Declaramos Objeto resultado
RetornoOperacion resultado = new RetornoOperacion(0);
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Cargamos Vales de Diesel
using (DataTable mit = SAT_CL.Ruta.RutaUnidadDiesel.CargaVales(this._id_ruta_tipo_unidad))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Recorremos Vales
foreach (DataRow r in mit.Rows)
{
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Vale
using (RutaUnidadDiesel objVale = new RutaUnidadDiesel(r.Field <int>("Id")))
{
//Deshabilitamos Vale
resultado = objVale.DeshabilitaRutaUnidadDiesel(id_usuario);
}
}
else
{
//Salimos del Ciclo
break;
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Retorna al método el resultado del método que actualiza los registro RutaTipoUnidad
resultado = editarRutaTipoUnidad(this._id_ruta, this._id_tipo_unidad, this._id_configuracion, this._rendimiento, id_usuario, false);
}
//Validamos resultado
if (resultado.OperacionExitosa)
{
//Finaizamos Transaccion
scope.Complete();
}
}
//Devolvemos Valor
return(resultado);
}
/// <summary>
/// Metodo encargado de Deshabilitar una Addenda ligado a una transaccion
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabilitaAddenda(int id_usuario)
{
//Inicializamos objeto Retorno
RetornoOperacion resultado = new RetornoOperacion(0);
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Cargamos Addenda Emisores
using (DataTable mit = AddendaEmisor.CargaAddendaEmisor(this._id_addenda))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Obtenemos cada uno de los Registros
foreach (DataRow r in mit.Rows)
{
//Si se actualizo correctamente
if (resultado.OperacionExitosa)
{
//Instanciamos cada uno de las Addendas Emisores
using (AddendaEmisor objAddendaEmisor = new AddendaEmisor(r.Field<int>("Id")))
{
//Deshabilitamos Registros
resultado = objAddendaEmisor.DeshabilitaAddendaEmisor(id_usuario);
}
}
else
{
//Salimos del ciclo
break;
}
}
}
}
//Si las Actualizaciones fueron Correctas
if (resultado.OperacionExitosa)
{
//Deshabilitamos Addenda
resultado = this.actualizaAddenda(this._id_elemento_comprobante, this._descripcion, this._xsd_validation, id_usuario,
false);
}
//Validamos Resultado
if(resultado.OperacionExitosa)
{
scope.Complete();
}
}
return resultado;
}
/// <summary>
/// Deshabilita todos los periodos asociados a una asignación de actividad
/// </summary>
/// <param name="idAsignacionActividad">Id de </param>
/// <param name="id_usuario">Id de usuario</param>
/// <returns></returns>
public static RetornoOperacion DeshabilitaPeriodosAsignacionActividad(int idAsignacionActividad, int id_usuario)
{
//Declarando variable de retorno
RetornoOperacion resultado = new RetornoOperacion(1);
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Cargando los periodos ligados a la asignación
using (DataTable mit = AsignacionPeriodo.CargaPeriodosAsignacionActividad(idAsignacionActividad))
{
//Validando que el origen de datos exista
if (Validacion.ValidaOrigenDatos(mit))
{
//Para cada registro devuelto
foreach (DataRow f in mit.Rows)
{
//Instanciando registro
using (AsignacionPeriodo p = new AsignacionPeriodo(f.Field <int>("IdActividadAsignacionPeriodo")))
{
//Si el periodo existe
if (p.id_actividad_asignacion_periodo > 0)
{
//Deshabilitando el registro
resultado = p.DeshabilitaActividadPeriodo(id_usuario);
}
else
{
resultado = new RetornoOperacion("Error al leer registro del periodo.");
}
//En caso de error, saliendo del ciclo
if (!resultado.OperacionExitosa)
{
break;
}
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Método Público encargado de la Insercion de los Registros
/// </summary>
/// <param name="id_servicio_control_evidencia">Id Sevicio Control de Evidencia</param>
/// <param name="id_servicio">Id de Servcio</param>
/// <param name="id_segmento_control_evidencia">Id Segmento Control Evidencia</param>
/// <param name="id_segmento">Id Segmento</param>
/// <param name="id_tipo_documento">Id de Tipo de Documento</param>
/// <param name="id_estatus_documento">Estatus del Documento</param>
/// <param name="id_hoja_instruccion_documento">Hoja de Instrucción</param>
/// <param name="terminal_recepcion">Terminal de Recepción</param>
/// <param name="fecha_recepcion">Fecha de Recepción</param>
/// <param name="terminal_cobro">Terminal de Cobro</param>
/// <param name="bit_original">Origina</param>
/// <param name="bit_copia">Copia</param>
/// <param name="bit_sello">Sello</param>
/// <param name="id_imagen">Id de Imagen</param>
/// <param name="referencia_imagen">Referencia de Imagen</param>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public static RetornoOperacion InsertaControlEvidenciaDocumento(int id_servicio_control_evidencia, int id_servicio, int id_segmento_control_evidencia, int id_segmento, byte id_tipo_documento,
EstatusDocumento id_estatus_documento, int id_hoja_instruccion_documento, int terminal_recepcion,
DateTime fecha_recepcion, int terminal_cobro, bool bit_original,
bool bit_copia, bool bit_sello, int id_imagen, string referencia_imagen,
int id_usuario)
{ //Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion();
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Declarando Arreglo de Parametros
object[] param = { 1, 0, id_servicio_control_evidencia, id_servicio, id_segmento_control_evidencia, id_segmento, id_tipo_documento,
(byte)id_estatus_documento, id_hoja_instruccion_documento, terminal_recepcion,
Fecha.ConvierteDateTimeObjeto(fecha_recepcion),
terminal_cobro, bit_original, bit_copia, bit_sello, id_imagen, referencia_imagen,
id_usuario, true, "", "" };
//Declarando Variable Auxiliar
int id_control_evidencia = 0;
//Obteniendo Resultado del SP
result = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoObjeto(_nom_sp, param);
//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();
}
}
//Devolviendo Resultado
return(result);
}
/// <summary>
/// Método encargado de Deshabilitar un Movimiento Vacio Iniciado
/// </summary>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion DeshabilitaMovimientoVacioIniciado(int id_usuario)
{
//Declaramos objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Iniciando transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Validamos que el estatus actual del movimiento sea Iniciado
if (this.EstatusMovimiento == Estatus.Iniciado)
{
//Validamos que no existan pagos ligados al movimeinto
resultado = validaPagos();
//Validamos que no existan Pagos
if (resultado.OperacionExitosa)
{
//Cargamos Estancias ligadas a un Id Movimiento en Estatus Iniciado
using (DataTable mitEstanciasOrigen = EstanciaUnidad.CargaEstanciasTerminadasParada(this._id_parada_origen))
{
//Reversa Inicio de Moimiento
resultado = ReversaInicioMovimietoVacio(mitEstanciasOrigen, MovimientoAsignacionRecurso.Estatus.Iniciado, id_usuario);
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Parada Destino
using (Parada objParadaDestino = new Parada(this._id_parada_destino))
{
//Deshabilitamos Parada Destino
resultado = objParadaDestino.DeshabilitaParada(id_usuario);
}
}
}
}
else
{
//Establecemos Mensaje
resultado = new RetornoOperacion("El estatus del movimiento no permite su edición.");
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Devolvemos Valor Retorno
return(resultado);
}
/// <summary>
/// Método Público encargado de Deshabilitar una Notificación
/// </summary>
/// <param name="id_usuario">Id de Usuario</param>
/// <returns></returns>
public RetornoOperacion DeshabilitaNotificacion(int id_usuario)
{
//Declaramos Resultado
RetornoOperacion resultado = new RetornoOperacion(0);
//Creamos la transacción
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Obtenemos Detalles
using (DataTable mitDetalles = DetalleNotificacion.CargaDetalleNotificacion(this._id_notificacion))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mitDetalles))
{
//Recorremos cada uno de los Detalles
foreach (DataRow r in mitDetalles.Rows)
{
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Instanciamos Detalle
using (DetalleNotificacion objDetalle = new DetalleNotificacion(r.Field <int>("Id")))
{
//Deshabilitamos Detalle
resultado = objDetalle.DeshabilitarDetallleNotificacion(id_usuario);
}
}
else
{
break;
}
}
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Invocando Método de Actualización
resultado = this.actualizaRegistros(this._id_contacto, this._id_compania_emisor, this._id_compania_cliente, this._id_tabla, this._id_registro, id_usuario, false);
}
//Validamos resultado
if (resultado.OperacionExitosa)
{
scope.Complete();
}
}
//Devolvemos Resultado
return(resultado);
}
/// <summary>
/// Editamos un Concepto
/// </summary>
/// <param name="id_comprobante"></param>
/// <param name="cantidad"></param>
/// <param name="id_unidad"></param>
/// <param name="id_descripcion"></param>
/// <param name="descripcion_parte"></param>
/// <param name="no_identificacion"></param>
/// <param name="valor_unitario"></param>
/// <param name="importe_moneda_captura"></param>
/// <param name="importe_moneda_nacional"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion EditaConcepto(int id_comprobante, decimal cantidad, int id_unidad, int id_descripcion,
int descripcion_parte, string no_identificacion, decimal valor_unitario,
decimal importe_moneda_captura, decimal importe_moneda_nacional, int id_usuario)
{
//Declaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion();
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciamos comprobante
using (Comprobante objComprobante = new Comprobante(id_comprobante))
{
//validamos Existencia de comprobante
if (objComprobante.id_comprobante > 0)
{
//Validamos existencia de Descuento
if (objComprobante.descuento_moneda_captura == 0 || objComprobante.descuento_moneda_nacional == 0)
{
//Realizando actualizacion
resultado = editaConcepto(id_comprobante, 0, 1, cantidad, id_unidad, id_descripcion, "",
no_identificacion, valor_unitario, importe_moneda_captura, importe_moneda_nacional, id_usuario,
this._habilitar);
//Validamos Resultado
//Recalucular Impuestos
if (resultado.OperacionExitosa)
{
resultado = Impuesto.RecalcularImpuestos(id_comprobante, id_usuario);
//Finalizamos transacción
scope.Complete();
}
}
else
{
resultado = new RetornoOperacion("No se puede editar un concepto, ya que existe el descuento");
}
}
else
{
resultado = new RetornoOperacion("No se encontró datos complementarios Comprobante");
}
}
}
return(resultado);
}
/// <summary>
/// Añade un conjunto de Pagos (FI) a un CFDI de Recepción de Pagos
/// </summary>
/// <param name="lista_egreso_ingreso_comprobante">Lista de Pagos</param>
/// <param name="id_usuario">Id de Usuario que realiza la operación</param>
/// <param name="id_comprobante_pago">Id de CFDI de Recepción de Pagos</param>
/// <returns></returns>
public static RetornoOperacion EliminarIngresosDeCFDIPagos(List <int> lista_egreso_ingreso_comprobante, int id_usuario, int id_comprobante_pago)
{
//Declarando objeto de Retorno
RetornoOperacion resultado = new RetornoOperacion(id_comprobante_pago);
//Inicializando bloque transaccional
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Instanciando CFDI de Pagos
using (Comprobante cfdi = new Comprobante(id_comprobante_pago))
{
//SI no se ha generado
if (cfdi.habilitar && !cfdi.bit_generado)
{
//Si la lista contiene elementos válidos
if (lista_egreso_ingreso_comprobante.Count(fi => fi == 0) == 0)
{
//Se realiza la inserción de la(s) relacion(es) entre el Ingreso y el CFDI registrado
foreach (int fi in lista_egreso_ingreso_comprobante)
{
//Deshabilitando relación
resultado = DeshabilitaEgresoIngresoComprobante(fi, id_usuario);
//Si hay algún error
if (!resultado.OperacionExitosa)
{
break;
}
}
}
else
{
resultado = new RetornoOperacion("Uno o más Pagos tienen un identificador '0' (o no hay elementos especificados), es imposible agregar al CFDI.");
}
}
else
{
resultado = new RetornoOperacion("El Comprobante ya fue Timbrado. No es posible agregar o quitar Pagos.");
}
//Si no hay errores, se confirman cambios realizados
if (resultado.OperacionExitosa)
{
resultado = new RetornoOperacion(id_comprobante_pago);
scope.Complete();
}
}
}
return(resultado);
}
/// <summary>
/// Validamos Total Conceptos y Partes
/// </summary>
/// <returns></returns>
public RetornoOperacion ValidaTotalConceptosHijos()
{
//Declaramos Objeto Resultado
RetornoOperacion resultado = new RetornoOperacion(0);
//Creamos la transacción
using (System.Transactions.TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Obtiene Total Conceptos
using (DataTable mit = Concepto.CargaConceptosPartes(this.id_concepto))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(mit))
{
//Obtenemos Total Conceptos
double ImporteCaptura = (from DataRow r in mit.Rows
select r.Field <double>("ImporteCaptura")).Sum();
double ImportelNacional = (from DataRow r in mit.Rows
select r.Field <double>("ImporteNacional")).Sum();
//Validamos Totale del Concepto y Conceptos Hijos
if (ImporteCaptura == Convert.ToDouble(this._importe_moneda_captura) && ImportelNacional == Convert.ToDouble(this._importe_moneda_nacional))
{
}
else
{
resultado = new RetornoOperacion("Lo detalles no coincide con el Total del Concepto.");
}
}
else
{
resultado = new RetornoOperacion("Lo detalles no coincide con el Total del Concepto.");
}
}
//Validamos Resultado
if (resultado.OperacionExitosa)
{
//Finalizamos transacción
scope.Complete();
}
}
//Obtenemos Resultado
return(resultado);
}
/// <summary>
/// Método encargado de Actualizar la Cancelación en la Nota de Credito e Insertar la Nueva relación a los CFDI's de Ingreso
/// </summary>
/// <param name="id_facturado_egreso"></param>
/// <param name="id_usuario"></param>
/// <returns></returns>
public RetornoOperacion ActualizaSustitucionRelacion(int id_facturado_egreso, int id_usuario)
{
//Declarando Objeto de retorno
RetornoOperacion retorno = new RetornoOperacion();
//Validando Estatus
switch ((Estatus)this._id_estatus)
{
case Estatus.Vigente:
case Estatus.Cancelado:
{
//Inicializando Bloque Transaccional
using (TransactionScope scope = Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
{
//Actualizando a Cancelado el Registro Anterior
retorno = this.actualizaEstatus(Estatus.Sustituido, id_usuario);
//Validando Operación
if (retorno.OperacionExitosa)
{
//Insertando Registro Nuevo
retorno = InsertaFacturadoEgresoRelacion(id_facturado_egreso, this._id_cfdi_ingreso, this._id_aplicacion, id_usuario);
//Validando Operación
if (retorno.OperacionExitosa)
{
//Completando Operación
scope.Complete();
}
}
}
break;
}
case Estatus.Sustituido:
{
//Instanciando Excepción
retorno = new RetornoOperacion("El CFDI de la Nota de Credito fue Sustituido previamente");
break;
}
}
//Devolviendo Resultado Obtenido
return(retorno);
}
