private void ssMaquina_Search(object sender, EventArgs e)
 {
     try
     {
         String filtro = "";
         if (ItemSolicitudCotizacion.Operacion != null)
         {
             filtro = "IDOperacion='" + ItemSolicitudCotizacion.Operacion.ID + "'";
         }
         if (ItemSolicitudCotizacion == null)
         {
             return;
         }
         FrmSelectedEntity FrmSeleccionar = new FrmSelectedEntity();
         ItemSolicitudCotizacion.Maquina = (Maquina)FrmSeleccionar.GetSelectedEntity(typeof(Maquina), "Maquina Operacion", filtro);
         ssMaquina.Text = (ItemSolicitudCotizacion.Maquina != null) ? ItemSolicitudCotizacion.Maquina.Nombre : "";
     }
     catch (Exception ex)
     {
         SoftException.Control(ex);
     }
 }
 private void ssCliente_Search(object sender, EventArgs e)
 {
     try
     {
         String filtro = "Activo=1 ";
         if (FrmMain.Usuario.SuperAdministrador == false)
         {
             filtro = "UserID='" + FrmMain.Usuario.UserID + "'";
         }
         if (ssCliente.Text.Length > 0)
         {
             filtro = filtro + " and Nombre like '" + ssCliente.Text + "%'";
         }
         FrmSelectedEntity FrmSeleccionarProveedor = new FrmSelectedEntity();
         SolicitudCotizacion.Cliente = (SocioNegocio)FrmSeleccionarProveedor.GetSelectedEntity(typeof(SocioNegocio), "Cliente", filtro);
         ssCliente.Text = (SolicitudCotizacion.Cliente != null) ? SolicitudCotizacion.Cliente.Nombre : "";
     }
     catch (Exception ex)
     {
         SoftException.Control(ex);
     }
 }
Example #3
0
 public override void Start()
 {
     try
     {
         this.IniciarTransaccion();
         this.Modificar(base.m_ObjectFlow);
         this.Agregar(Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Modificación"));
         this.FinalizarTransaccion();
         this.m_ResultProcess = EnumResult.SUCESS;
     }
     catch (Exception ex)
     {
         this.FinalizarTransaccion(true);
         this.m_ResultProcess = EnumResult.ERROR;
         SoftException.Control(ex);
     }
     finally
     {
         this.CerrarSesion();
     }
     base.Start();
 }
Example #4
0
 public override void Start()
 {
     try
     {
         if (base.m_ItemsSelecteds.Count > 0)
         {
             using (ISession Sesion = m_SessionFactory.OpenSession())
             {
                 String ID = base.m_ItemsSelecteds[0];
                 base.m_ObjectFlow = Sesion.Get(base.m_EntidadSF.NombreClase, ID);
                 ((Parent)base.m_ObjectFlow).NewInstance = false;
                 base.m_ResultProcess = EnumResult.SUCESS;
             }
         }
     }
     catch (Exception ex)
     {
         base.m_ResultProcess = EnumResult.ERROR;
         SoftException.Control(ex);
     }
     base.Start();
 }
Example #5
0
        private void ugItems_CellChange(object sender, CellEventArgs e)
        {
            try
            {
                ItemNotaDebito Item = (ItemNotaDebito)e.Cell.Row.Tag;
                switch (e.Cell.Column.Key)
                {
                case colCodigo:
                    Item.Codigo = e.Cell.Text;
                    break;

                case colDescripcion:
                    Item.Descripcion = e.Cell.Text;
                    break;

                case colPrecio:
                    Item.Precio = Convert.ToDecimal(e.Cell.Text.Replace('_', ' '));
                    break;

                case colCantidad:
                    Item.Cantidad = Convert.ToDecimal(e.Cell.Text.Replace('_', ' '));
                    break;

                case colObservacion:
                    Item.Observacion = e.Cell.Text;
                    break;

                default:
                    break;
                }
                MostrarItem(e.Cell.Row);
                MostrarTotales();
            }
            catch (Exception ex)
            {
                SoftException.Control(ex);
            }
        }
Example #6
0
 private void rbNO_CheckedChanged(object sender, EventArgs e)
 {
     try
     {
         if (ActualizacionUI)
         {
             return;
         }
         SalidaCaja.RelacionItem = "NO";
         ugItems.DisplayLayout.Bands[0].Columns[colOT_OP].Hidden = true;
         foreach (ItemSalidaCaja item in SalidaCaja.Items)
         {
             item.IDOrdenProduccion                    = null;
             item.NumeracionOrdenProduccion            = null;
             item.IDConsolidadoOrdenProduccion         = null;
             item.NumeracionConsolidadoOrdenProduccion = null;
         }
     }
     catch (Exception ex)
     {
         SoftException.Control(ex);
     }
 }
Example #7
0
 private void rbOP_CheckedChanged(object sender, EventArgs e)
 {
     try
     {
         if (ActualizacionUI)
         {
             return;
         }
         SalidaCaja.RelacionItem = "OP";
         ugItems.DisplayLayout.Bands[0].Columns[colOT_OP].Hidden         = false;
         ugItems.DisplayLayout.Bands[0].Columns[colOT_OP].Header.Caption = "OP";
         foreach (ItemSalidaCaja item in SalidaCaja.Items)
         {
             item.IDOrdenProduccion         = null;
             item.NumeracionOrdenProduccion = null;
         }
         MostrarItems();
     }
     catch (Exception ex)
     {
         SoftException.Control(ex);
     }
 }
Example #8
0
 private void ubGenerarSolicitudCotizacion_Click(object sender, EventArgs e)
 {
     try
     {
         GenerarSolicitudDesdePlantilla Generacion = new GenerarSolicitudDesdePlantilla();
         Generacion.m_ObjectFlow = HelperNHibernate.GetEntityByID("Plantilla", InfoAsistente.Plantilla.ID);
         Generacion.Start();
         SolicitudCotizacion Solicitud = (SolicitudCotizacion)Generacion.m_ObjectFlow;
         Solicitud.Cliente       = InfoAsistente.Cliente;
         Solicitud.TipoDocumento = (TipoDocumento)HelperNHibernate.GetEntityByID("TipoSolicitudCotizacion", InfoAsistente.TipoDocumento.ID);
         Solicitud.Moneda        = InfoAsistente.Moneda;
         //Solicitud.FechaCreacion = InfoAsistente.FechaCreacion;
         Solicitud.CodigoGrupo      = InfoAsistente.CodigoGrupo;
         Solicitud.Contacto         = InfoAsistente.Contacto;
         Solicitud.ModalidadCredito = InfoAsistente.ModalidadCredito;
         Solicitud.Responsable      = InfoAsistente.Responsable;
         IniciarSolicitud(Solicitud);
     }
     catch (Exception ex)
     {
         SoftException.Control(ex);
     }
 }
Example #9
0
        private void ssChofer_Search(object sender, EventArgs e)
        {
            try
            {
                FrmSelectedEntity FrmSeleccionar = new FrmSelectedEntity();
                GuiaRemision.Chofer = (SocioNegocio)FrmSeleccionar.GetSelectedEntity(typeof(SocioNegocio), "Socio de Negocio", " Empleado = 1");
                if (GuiaRemision.Chofer != null)
                {
                    ssChofer.Text = GuiaRemision.Chofer.Nombre;

                    SocioNegocio sn = (SocioNegocio)HelperNHibernate.GetEntityByID("SocioNegocio", GuiaRemision.Chofer.ID);

                    SocioNegocioEmpleado sne = sn.Empleados.First();

                    GuiaRemision.LicenciaConducir = sne.LicenciaConducir;
                    txtLicenciaConducir.Text      = GuiaRemision.LicenciaConducir;
                }
            }
            catch (Exception ex)
            {
                SoftException.Control(ex);
            }
        }
Example #10
0
 public override void Start()
 {
     using (ISession Sesion = m_SessionFactory.OpenSession())
     {
         using (ITransaction Trans = Sesion.BeginTransaction())
         {
             try
             {
                 GuiaRemision GuiaRemision = (GuiaRemision)m_ObjectFlow;
                 SqlCommand   SqlCmd       = new SqlCommand();
                 SqlCmd.Connection  = (SqlConnection)Sesion.Connection;
                 SqlCmd.CommandText = "pSF_Actualizar_EstadoGuiaRemision_OrdenProduccion";
                 SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                 Trans.Enlist(SqlCmd);
                 foreach (ItemGuiaRemision ItemGuiaRemision in GuiaRemision.Items)
                 {
                     SqlCmd.Parameters.Clear();
                     SqlCmd.Parameters.AddWithValue("@IDOP", ItemGuiaRemision.IDOrdenProduccion);
                     SqlCmd.Parameters.AddWithValue("@Cantidad", ItemGuiaRemision.Cantidad * -1);
                     SqlCmd.ExecuteNonQuery();
                 }
                 Sesion.Delete(GuiaRemision);
                 Trans.Commit();
                 m_ResultProcess = EnumResult.SUCESS;
             }
             catch (Exception ex)
             {
                 Trans.Rollback();
                 m_ResultProcess = EnumResult.ERROR;
                 SoftException.Control(ex);
             }
             finally {
                 base.Start();
             }
         }
     }
 }
Example #11
0
        public void Mostrar()
        {
            try
            {
                ActualizandoUI = true;
                if (EntradaCaja.TipoDocumento != null)
                {
                    ssTipoDocumento.Text  = EntradaCaja.TipoDocumento.Descripcion;
                    txtNumeracion.Enabled = (EntradaCaja.TipoDocumento.NumeracionAutomatica) ? false : true;
                    lblSocioNegocio.Text  = EntradaCaja.TipoDocumento.TipoSocioDeNegocio;
                }
                if (EntradaCaja.Caja != null)
                {
                    ssCaja.Text          = EntradaCaja.Caja.Nombre;
                    uneSaldoActual.Value = EntradaCaja.Caja.SaldoActual;
                }
                ssSocioNegocio.Text    = (EntradaCaja.SocioNegocio != null) ? EntradaCaja.SocioNegocio.Nombre : "";
                ssResponsable.Text     = (EntradaCaja.Responsable != null) ? EntradaCaja.Responsable.Nombre : "";
                ssMoneda.Text          = (EntradaCaja.Moneda != null) ? EntradaCaja.Moneda.Simbolo : "";
                txtNumeracion.Text     = EntradaCaja.Numeracion;
                udtFechaCreacion.Value = EntradaCaja.FechaCreacion;
                txtObservacion.Text    = EntradaCaja.Observacion;
                MostrarItems();
                MostrarTotales();
                if (!EntradaCaja.NewInstance)
                {
                    DeshabilitarControles();
                }

                ActualizandoUI = false;
            }
            catch (Exception ex)
            {
                ActualizandoUI = false;
                SoftException.Control(ex);
            }
        }
 public override void Start()
 {
     using (ISession Sesion = m_SessionFactory.OpenSession())
     {
         using (ITransaction Trans = Sesion.BeginTransaction())
         {
             try
             {
                 SolicitudCotizacion SolicitudCotizacion = (SolicitudCotizacion)m_ObjectFlow;
                 SolicitudCotizacion.Numeracion       = "";
                 SolicitudCotizacion.EstadoAprobacion = "";
                 SolicitudCotizacion.EstadoCotizacion = "";
                 SolicitudCotizacion.FechaCreacion    = DateTime.Now;
                 m_ResultProcess = EnumResult.SUCESS;
             }
             catch (Exception ex)
             {
                 m_ResultProcess = EnumResult.ERROR;
                 SoftException.Control(ex);
             }
         }
     }
     base.Start();
 }
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria           Auditoria = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Creación");
                        RendicionCotizacion Rendicion = (RendicionCotizacion)m_ObjectFlow;

                        string sql = string.Format("UPDATE Cotizacion SET EstadoRendicion = 'TOTAL' WHERE ID = '{0}'", Rendicion.IDCotizacion);

                        var dbCommand = Sesion.Connection.CreateCommand();
                        Sesion.Transaction.Enlist(dbCommand);
                        dbCommand.CommandText = sql;
                        dbCommand.ExecuteNonQuery();

                        Sesion.Save(Rendicion);
                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                    finally
                    {
                        base.Start();
                    }
                }
            }
        }
Example #14
0
 private void ssSocioNegocio_Search(object sender, EventArgs e)
 {
     if (ActualizandoUI)
     {
         return;
     }
     try
     {
         try
         {
             FrmSelectedEntity FrmSeleccionar = new FrmSelectedEntity();
             EntradaCaja.SocioNegocio = (SocioNegocio)FrmSeleccionar.GetSelectedEntity(typeof(SocioNegocio), "Socio de Negocio", string.Format("{0} = 1", EntradaCaja.TipoDocumento.TipoSocioDeNegocio));
             Mostrar();
         }
         catch (Exception ex)
         {
             SoftException.Control(ex);
         }
     }
     catch (Exception ex)
     {
         SoftException.ShowException(ex);
     }
 }
Example #15
0
        protected override Variant OnCall(string method, List <Dom.ActionParameter> args)
        {
            object [] parameters = new object[args.Count];
            int       count      = 0;

            foreach (var arg in args)
            {
                try
                {
                    parameters[count] = GetVariantValue(arg.dataModel[0].InternalValue);
                }
                catch (Exception ex)
                {
                    logger.Debug("OnCall: Warning, unable to get value for parameter #" + count + ".  Setting parameter to null.  Exception: " + ex.ToString());
                    parameters[count] = null;
                }

                count++;
            }

            try
            {
                WebServiceInvoker invoker = new WebServiceInvoker(new Uri(this.Url));
                object            ret     = invoker.InvokeMethod <object>(this.Service, method, parameters);

                StatusCode = HttpStatusCode.OK.ToString();

                if (ret == null)
                {
                    return(null);
                }

                return(new Variant(ret.ToString()));
            }
            catch (Exception ex)
            {
                if (ex.InnerException is ArgumentException &&
                    ex.InnerException.Message.IndexOf("surrogate") != -1)
                {
                    throw new SoftException(ex.InnerException);
                }
                if (ex.InnerException is InvalidOperationException &&
                    ex.InnerException.Message.IndexOf("XML") != -1)
                {
                    throw new SoftException(ex.InnerException);
                }

                if (!(ex.InnerException is WebException))
                {
                    throw;
                }

                var webEx    = ex.InnerException as WebException;
                var response = webEx.Response as HttpWebResponse;
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    StatusCode = response.StatusCode.ToString();
                    logger.Debug("OnCall: Warning: Status code was: " + StatusCode);

                    if (ErrorOnStatusCode)
                    {
                        var sex = new SoftException(ex);                         // Soft or ignore?
                        throw sex;
                    }
                    else
                    {
                        return(null);
                    }
                }

                throw;
            }
        }
Example #16
0
        public override void Start()
        {
            FrmProgress frmProgreso = new FrmProgress();

            frmProgreso.Start(2, "Exportando ...");
            frmProgreso.Next();
            try
            {
                CReporte            reporte  = null;
                ExportFormatOptions opciones = null;
                ExportFormatType    formato;
                string nombreArchivo = string.Empty;
                string extension     = string.Empty;
                string sql           = string.Empty;
                if (base.m_ObjectFlow is DocumentoGenerico)
                {
                    DocumentoGenerico documento = (DocumentoGenerico)base.m_ObjectFlow;
                    reporte       = documento.TipoDocumento.Reporte;
                    nombreArchivo = string.Format("{0} - Nº {1} {2}", reporte.Nombre, documento.Numeracion, DateTime.Now.ToString("yyyy-MM-dd"));
                    sql           = reporte.SQL;
                    foreach (ParametroReporte Parametro in reporte.ParametrosSQL)
                    {
                        sql = sql.Replace(Parametro.Nombre, documento.ValueByProperty(Parametro.Propiedad).ToString());
                    }
                }
                else if (base.m_ObjectFlow is CReporte)
                {
                    reporte       = (CReporte)base.m_ObjectFlow;
                    nombreArchivo = string.Format("{0} {1}", reporte.Nombre, DateTime.Now.ToString("yyyy-MM-dd"));
                    sql           = reporte.SQL;
                    foreach (ParametroReporte Parametro in reporte.ParametrosSQL)
                    {
                        sql = sql.Replace(Parametro.Nombre, Parametro.Valor);
                    }
                }
                switch (base.m_Parameter)
                {
                case TypeEnum.CEnumExportFormat.PDF:
                    formato   = ExportFormatType.PortableDocFormat;
                    opciones  = new PdfRtfWordFormatOptions();
                    extension = ".pdf";
                    break;

                case TypeEnum.CEnumExportFormat.WORD:
                    formato   = ExportFormatType.WordForWindows;
                    opciones  = new PdfRtfWordFormatOptions();
                    extension = ".doc";
                    break;

                case TypeEnum.CEnumExportFormat.EXCEL:
                    formato   = ExportFormatType.Excel;
                    opciones  = new ExcelFormatOptions();
                    extension = ".xls";
                    break;

                default:
                    throw new Exception("El formato no es válido.");
                }
                if (reporte != null)
                {
                    ReportDocument CryRpt = new ReportDocument();
                    CryRpt.Load(String.Format("{0}{1}", FrmMain.CarpetaReportes, reporte.Ubicacion));
                    frmProgreso.Next();
                    // Si existe una consulta SQL se ejecuta.
                    if (sql.Trim().Length > 0)
                    {
                        CryRpt.SetDataSource(HelperNHibernate.GetDataSet(sql));
                    }
                    // Se reemplazan los parámetros Crystal.
                    foreach (ParametroReporte Parametro in reporte.ParametrosCrystal)
                    {
                        CryRpt.SetParameterValue(Parametro.Nombre, Parametro.Valor);
                    }
                    // Se exporta el reporte.
                    ExportOptions CrExportOptions;
                    DiskFileDestinationOptions CrDiskFileDestinationOptions = new DiskFileDestinationOptions();
                    CrDiskFileDestinationOptions.DiskFileName = string.Format("{0}{1}{2}", FrmMain.CarpetaExportacion, nombreArchivo, extension);
                    CrExportOptions = CryRpt.ExportOptions;
                    {
                        CrExportOptions.ExportDestinationType = ExportDestinationType.DiskFile;
                        CrExportOptions.ExportFormatType      = formato;
                        CrExportOptions.DestinationOptions    = CrDiskFileDestinationOptions;
                        CrExportOptions.FormatOptions         = opciones;
                    }
                    // Se exporta el archivo.
                    CryRpt.Export();
                    // Se inicia un proceso para abrir el archivo.
                    Process.Start(CrDiskFileDestinationOptions.DiskFileName);
                }
                else
                {
                    throw new Exception("Entidad no válida.");
                }
                base.m_ResultProcess = EnumResult.SUCESS;
            }
            catch (Exception ex)
            {
                SoftException.Control(ex);
            }
            finally
            {
                frmProgreso.Close();
                base.Start();
            }
        }
        public override void Start()
        {
            //try
            //{
            //    this.IniciarTransaccion();
            //    SolicitudCotizacion solicitudCotizacion = (SolicitudCotizacion)m_ObjectFlow;
            //    if (solicitudCotizacion.TipoDocumento.GeneraNumeracionAlFinal)
            //    {
            //        SqlCommand sqlCmd = new SqlCommand();
            //        sqlCmd.Connection = (SqlConnection)m_Sesion.Connection;
            //        m_Transaccion.Enlist(sqlCmd);
            //        {
            //            sqlCmd.CommandText = "pSF_Generar_Numeracion";
            //            sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
            //            sqlCmd.Parameters.Clear();
            //            sqlCmd.Parameters.AddWithValue("@Documento", "SolicitudCotizacion");
            //            sqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoSolicitudCotizacion");
            //            sqlCmd.Parameters.AddWithValue("@IDDocumento", solicitudCotizacion.ID);
            //            sqlCmd.Parameters.AddWithValue("@IDTipoDocumento", solicitudCotizacion.TipoDocumento.ID);
            //            sqlCmd.ExecuteNonQuery();
            //        }
            //    }
            //    this.Agregar(solicitudCotizacion);
            //    this.FinalizarTransaccion();

            //}
            //catch (Exception ex)
            //{
            //    this.FinalizarTransaccion(true);
            //    m_ResultProcess = EnumResult.ERROR;
            //    SoftException.Control(ex);
            //}
            //finally
            //{
            //    this.CerrarSesion();
            //}
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria           Auditoria = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Creación");
                        SolicitudCotizacion solicitud = (SolicitudCotizacion)m_ObjectFlow;

                        Sesion.Save(solicitud);
                        Sesion.Flush();

                        if (solicitud.TipoDocumento.GeneraNumeracionAlFinal)
                        {
                            SqlCommand SqlCmd = new SqlCommand();
                            SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                            Trans.Enlist(SqlCmd);
                            {
                                SqlCmd.CommandText = "pSF_Generar_Numeracion";
                                SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                                SqlCmd.Parameters.Clear();
                                SqlCmd.Parameters.AddWithValue("@Documento", "SolicitudCotizacion");
                                SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoSolicitudCotizacion");
                                SqlCmd.Parameters.AddWithValue("@IDDocumento", solicitud.ID);
                                SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", solicitud.TipoDocumento.ID);
                                SqlCmd.ExecuteNonQuery();
                            }
                        }
                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                }
            }
            base.Start();
        }
        public override void  Start()
        {
            try
            {
                SolicitudCotizacion SolicitudCotizacion = (SolicitudCotizacion)base.m_ObjectFlow;
                if (!SolicitudCotizacion.EstadoAprobacion.Equals("APROBADO"))
                {
                    throw new Exception(String.Format("La Solicitud de Cotización Nº : {0} no está APROBADO", SolicitudCotizacion.Numeracion));
                }
                if (!SolicitudCotizacion.EstadoCotizacion.Equals("PENDIENTE"))
                {
                    throw new Exception(String.Format("La Solicitud de Cotización Nº : {0} ya tiene una Cotizacion", SolicitudCotizacion.Numeracion));
                }

                Cotizacion Cotizacion = new Cotizacion();
                Cotizacion.Cantidad         = 1;
                Cotizacion.Descripcion      = SolicitudCotizacion.Descripcion;
                Cotizacion.Cantidad         = SolicitudCotizacion.Cantidad;
                Cotizacion.Cliente          = SolicitudCotizacion.Cliente;
                Cotizacion.ModalidadCredito = SolicitudCotizacion.ModalidadCredito;
                Cotizacion.TipoDocumento    = (TipoCotizacion)HelperNHibernate.GetEntityByID("TipoCotizacion", "B8AA5B25-9180-44A6-B750-F96D1EA17147");
                Cotizacion.Contacto         = SolicitudCotizacion.Contacto;
                Cotizacion.Vendedor         = SolicitudCotizacion.Responsable;
                Cotizacion.Observacion      = SolicitudCotizacion.Observacion;
                Cotizacion.Moneda           = SolicitudCotizacion.Moneda;

                if (Cotizacion.Moneda != null)
                {
                    if (Cotizacion.Moneda.Simbolo.Equals("US $"))
                    {
                        String      filtro = "IDMoneda='" + Cotizacion.Moneda.ID + "' and Fecha='" + Cotizacion.FechaCreacion.ToShortDateString() + "'";
                        XmlDocument XML    = HelperNHibernate.ExecuteSQL("SELECT TipoCambioVenta FROM vSF_TipoCambio", filtro);
                        if (XML.HasChildNodes && XML.DocumentElement.ChildNodes.Count > 0)
                        {
                            Cotizacion.TipoCambioFecha = Convert.ToDecimal(XML.DocumentElement.ChildNodes[0].SelectSingleNode("@TipoCambioVenta").Value);
                        }
                        else
                        {
                            throw new Exception("No hay tipo de cambio registrado a la fecha : " + Cotizacion.FechaCreacion.ToShortDateString());
                        }
                    }
                    else
                    {
                        Cotizacion.TipoCambioFecha = 1;
                    }
                }

                Cotizacion.IDSolicitudCotizacion = SolicitudCotizacion.ID;
                Cotizacion.LineaProduccion       = SolicitudCotizacion.LineaProduccion;

                foreach (ItemSolicitudCotizacion Item in SolicitudCotizacion.Items)
                {
                    ItemCotizacion ItemCotizacion = Cotizacion.AddItem();

                    ItemCotizacion.Nombre           = Item.Nombre;
                    ItemCotizacion.MedidaAnchoCaja  = Item.MedidaAnchoCaja;
                    ItemCotizacion.Cantidad         = 1;
                    ItemCotizacion.CantidadUnidad   = Item.Cantidad;
                    ItemCotizacion.CantidadElemento = Item.CantidadItem;
                    ItemCotizacion.Operacion        = Item.Operacion;
                    ItemCotizacion.Maquina          = Item.Maquina;

                    if (ItemCotizacion.Maquina != null)
                    {
                        ItemCotizacion.FormatoImpresionAlto  = ItemCotizacion.Maquina.PliegoAltoMaximo;
                        ItemCotizacion.FormatoImpresionLargo = ItemCotizacion.Maquina.PliegoAnchoMaximo;
                    }
                    ItemCotizacion.TieneFondo         = Item.TieneFondo;
                    ItemCotizacion.TipoUnidad         = Item.TipoUnidad;
                    ItemCotizacion.Material           = Item.Material;
                    ItemCotizacion.ImpresoRetiraColor = Item.ImpresoRetiraColor;
                    ItemCotizacion.ImpresoTiraColor   = Item.ImpresoTiraColor;
                    ItemCotizacion.MedidaAbiertaAlto  = Item.MedidaAbiertaAlto;
                    ItemCotizacion.MedidaAbiertaLargo = Item.MedidaAbiertaLargo;
                    ItemCotizacion.MedidaCerradaAlto  = Item.MedidaCerradaAlto;
                    ItemCotizacion.MedidaCerradaLargo = Item.MedidaCerradaLargo;
                    ItemCotizacion.TieneMedidaAbierta = Item.TieneMedidaAbierta;
                    ItemCotizacion.TieneMedidaCerrada = Item.TieneMedidaCerrada;
                    ItemCotizacion.TieneTiraRetira    = Item.TieneTiraRetira;
                    ItemCotizacion.TieneGraficos      = Item.TieneGraficos;
                    ItemCotizacion.TieneMaquina       = Item.TieneMaquina;
                    ItemCotizacion.TieneMaterial      = Item.TieneMaterial;

                    ItemCotizacion.TieneTipoUnidad     = Item.TieneTipoUnidad;
                    ItemCotizacion.UnidadMedidaAbierta = Item.UnidadMedidaAbierta;
                    ItemCotizacion.CantidadUnidad      = Item.CantidadUnidad;
                    foreach (ItemSolicitudCotizacionServicio ItemServicio in Item.Servicios)
                    {
                        ItemCotizacionServicio ItemCotizacionServicio = ItemCotizacion.AddServicio();
                        ItemCotizacionServicio.Servicio = ItemServicio.Servicio;
                    }
                    ItemCotizacion.Observacion = Item.Observacion;
                }
                base.m_ObjectFlow    = Cotizacion;
                base.m_EntidadSF     = (EntidadSF)HelperNHibernate.GetEntityByID("EntidadSF", "11D3E3C0-1639-49FF-8596-149E9D24F60A");
                base.m_ResultProcess = EnumResult.SUCESS;
            }
            catch (Exception ex)
            {
                base.m_ResultProcess = EnumResult.ERROR;
                SoftException.ShowException(ex);
            }
            base.Start();
        }
Example #19
0
		protected override void OnSetProperty(string property, Variant value)
		{
			if (property == "MTU")
			{
				uint mtu = 0;

				if (value.GetVariantType() == Variant.VariantType.BitStream)
				{
					var bs = (BitwiseStream)value;
					bs.SeekBits(0, SeekOrigin.Begin);
					ulong bits;
					int len = bs.ReadBits(out bits, 32);
					mtu = Endian.Little.GetUInt32(bits, len);
				}
				else if (value.GetVariantType() == Variant.VariantType.ByteString)
				{
					byte[] buf = (byte[])value;
					int len = Math.Min(buf.Length * 8, 32);
					mtu = Endian.Little.GetUInt32(buf, len);
				}
				else
				{
					throw new SoftException("Can't set MTU, 'value' is an unsupported type.");
				}

				if (MaxMTU >= mtu && mtu >= MinMTU)
				{
					try
					{
						using (var sock = OpenSocket(mtu))
						{
							Logger.Debug("Changed MTU of {0} to {1}.", Interface, mtu);
						}
					}
					catch (Exception ex)
					{
						string err = "Failed to change MTU of '{0}' to {1}. {2}".Fmt(Interface, mtu, ex.Message);
						Logger.Error(err);
						var se = new SoftException(err, ex);
						throw new SoftException(se);
					}
				}
			}
		}
        public override void Start()
        {
            try
            {
                Cotizacion Cotizacion = (Cotizacion)base.m_ObjectFlow;

                if (!Cotizacion.EstadoAprobacion.Equals("APROBADO"))
                {
                    throw new Exception(String.Format("La Cotización Nº : {0} aún no ha sido APROBADA.", Cotizacion.Numeracion));
                }

                if (Cotizacion.EstadoRendicion.Equals("TOTAL"))
                {
                    throw new Exception(String.Format("La Cotización Nº : {0} ya ha sido RENDIDA.", Cotizacion.Numeracion));
                }

                RendicionCotizacion Rendicion = new RendicionCotizacion();
                Rendicion.IDCotizacion     = Cotizacion.ID;
                Rendicion.NumeroCotizacion = Cotizacion.Numeracion;
                foreach (ItemCotizacion ItemCotizacion in Cotizacion.Items)
                {
                    if (ItemCotizacion.Maquina != null)
                    {
                        ItemRendicionCotizacion ItemRendicion = new ItemRendicionCotizacion();
                        ItemRendicion.Codigo             = ItemCotizacion.Maquina.Codigo;
                        ItemRendicion.Descripcion        = ItemCotizacion.Maquina.Descripcion;
                        ItemRendicion.CantidadCotizacion = 1;
                        ItemRendicion.PrecioCotizacion   = ItemCotizacion.CostoMaquina;
                        ItemRendicion.TotalCotizacion    = ItemCotizacion.CostoMaquina / 1;
                        ItemRendicion.CantidadReal       = 1;
                        ItemRendicion.PrecioReal         = ItemCotizacion.CostoMaquina;
                        ItemRendicion.TotalReal          = ItemCotizacion.CostoMaquina / 1;
                        Rendicion.Items.Add(ItemRendicion);
                    }
                    foreach (ItemCotizacionServicio ItemServicio in ItemCotizacion.Servicios)
                    {
                        if (ItemServicio.Servicio != null && ItemServicio.UnidadServicio != null)
                        {
                            ItemRendicionCotizacion ItemRendicion = new ItemRendicionCotizacion();
                            ItemRendicion.Codigo             = ItemServicio.Servicio.Codigo;
                            ItemRendicion.Descripcion        = ItemServicio.Servicio.Descripcion;
                            ItemRendicion.Unidad             = ItemServicio.UnidadServicio.Unidad.Codigo;
                            ItemRendicion.CantidadCotizacion = ItemServicio.CantidadServicio;
                            ItemRendicion.PrecioCotizacion   = ItemServicio.CostoServicio / ItemServicio.CantidadServicio;
                            ItemRendicion.TotalCotizacion    = ItemServicio.CostoServicio;
                            ItemRendicion.CantidadReal       = ItemServicio.CantidadServicio;
                            ItemRendicion.PrecioReal         = ItemServicio.CostoServicio / ItemServicio.CantidadServicio;
                            ItemRendicion.TotalReal          = ItemServicio.CostoServicio;
                            Rendicion.Items.Add(ItemRendicion);
                        }
                        if (ItemServicio.Maquina != null && ItemServicio.UnidadMaquina != null)
                        {
                            ItemRendicionCotizacion ItemRendicion = new ItemRendicionCotizacion();
                            ItemRendicion.Codigo             = ItemServicio.Maquina.Codigo;
                            ItemRendicion.Descripcion        = ItemServicio.Maquina.Descripcion;
                            ItemRendicion.Unidad             = ItemServicio.UnidadMaquina.Codigo;
                            ItemRendicion.CantidadCotizacion = ItemServicio.CantidadMaquina;
                            ItemRendicion.PrecioCotizacion   = ItemServicio.CostoMaquina / ItemServicio.CantidadMaquina;
                            ItemRendicion.TotalCotizacion    = ItemServicio.CostoMaquina;
                            ItemRendicion.CantidadReal       = ItemServicio.CantidadMaquina;
                            ItemRendicion.PrecioReal         = ItemServicio.CostoMaquina / ItemServicio.CantidadMaquina;
                            ItemRendicion.TotalReal          = ItemServicio.CostoMaquina;
                            Rendicion.Items.Add(ItemRendicion);
                        }
                    }
                }
                base.m_ObjectFlow    = Rendicion;
                base.m_EntidadSF     = (EntidadSF)HelperNHibernate.GetEntityByField("EntidadSF", "NombreClase", "RendicionCotizacion");
                base.m_ResultProcess = EnumResult.SUCESS;
            }
            catch (Exception ex)
            {
                base.m_ResultProcess = EnumResult.ERROR;
                SoftException.ShowException(ex);
            }
            base.Start();
        }
Example #21
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria  Auditoria = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Creación");
                        Cotizacion cp        = (Cotizacion)m_ObjectFlow;

                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;

                        SqlCmd.CommandText = "pSF_Actualizar_EstadoCotizacion_SolicitudCotizacion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        Trans.Enlist(SqlCmd);
                        SqlCmd.Parameters.Clear();
                        SqlCmd.Parameters.AddWithValue("@IDSolicitudCotizacion", cp.IDSolicitudCotizacion);
                        SqlCmd.ExecuteNonQuery();


                        foreach (ItemCotizacion item in cp.Items)
                        {
                            item.RequerimientosServicio.Clear();
                            item.RequerimientosMaterial.Clear();
                            foreach (ItemCotizacionServicio itemSer in item.Servicios)
                            {
                                if (itemSer.Material != null)
                                {
                                    RequerimientoMaterialItemCotizacion reqmaterial = new RequerimientoMaterialItemCotizacion();
                                    reqmaterial.Material = itemSer.Material;
                                    reqmaterial.Unidad   = itemSer.UnidadMaterial;
                                    reqmaterial.Cantidad = itemSer.CantidadMaterial;
                                    reqmaterial.Costo    = itemSer.CostoMaterial;

                                    item.RequerimientosMaterial.Add(reqmaterial);
                                }
                                if (itemSer.Servicio != null)
                                {
                                    RequerimientoServicioItemCotizacion reqservicio = new RequerimientoServicioItemCotizacion();
                                    reqservicio.Servicio = itemSer.Servicio;
                                    reqservicio.Unidad   = itemSer.UnidadServicio;
                                    reqservicio.Cantidad = itemSer.CantidadServicio;
                                    reqservicio.Costo    = itemSer.CostoServicio;

                                    item.RequerimientosServicio.Add(reqservicio);
                                }
                            }
                        }

                        Sesion.Save(cp);
                        Sesion.Flush();

                        if (cp.TipoDocumento.GeneraNumeracionAlFinal == true)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "Cotizacion");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoCotizacion");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", cp.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", cp.TipoDocumento.ID);
                            SqlCmd.ExecuteNonQuery();
                        }



                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                    finally
                    {
                        base.Start();
                    }
                }
            }
        }
Example #22
0
 public override void Start()
 {
     using (ISession Sesion = m_SessionFactory.OpenSession())
     {
         using (ITransaction Trans = Sesion.BeginTransaction())
         {
             try
             {
                 EntradaCaja EntradaCaja = (EntradaCaja)m_ObjectFlow;
                 SqlCommand  SqlCmd      = new SqlCommand();
                 // Actualizamos el saldo de la Caja
                 SqlCmd.Connection  = (SqlConnection)Sesion.Connection;
                 SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                 SqlCmd.CommandText = "pSF_Actualizar_Saldo_Caja";
                 Trans.Enlist(SqlCmd);
                 SqlCmd.Parameters.AddWithValue("@IDCaja", EntradaCaja.Caja.ID);
                 SqlCmd.Parameters.AddWithValue("@Monto", EntradaCaja.Total);
                 SqlCmd.ExecuteNonQuery();
                 // Creamos la Salida de Caja
                 Sesion.Save(EntradaCaja);
                 Sesion.Flush();
                 // Creamos una Deuda.
                 if (EntradaCaja.TipoCaja.GeneraDeuda)
                 {
                     Deuda Deuda = new Deuda();
                     Deuda.Tipo           = EntradaCaja.TipoCaja.TipoDeuda;
                     Deuda.TipoDocumento  = "Entrada de Caja";
                     Deuda.IDDocumento    = EntradaCaja.ID;
                     Deuda.Descripcion    = EntradaCaja.TipoDocumento.Nombre;
                     Deuda.IDSocioNegocio = (EntradaCaja.SocioNegocio != null) ? EntradaCaja.SocioNegocio.ID : null;
                     Deuda.Saldo          = EntradaCaja.Total;
                     Deuda.Total          = EntradaCaja.Total;
                     Sesion.Save(Deuda);
                 }
                 // Actualizamos la Numeración de la Salida de Caja
                 if (EntradaCaja.TipoDocumento.GeneraNumeracionAlFinal)
                 {
                     SqlCmd.CommandText = "pSF_Generar_Numeracion";
                     SqlCmd.Parameters.Clear();
                     SqlCmd.Parameters.AddWithValue("@Documento", "EntradaCaja");
                     SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoCaja");
                     SqlCmd.Parameters.AddWithValue("@IDDocumento", EntradaCaja.ID);
                     SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", EntradaCaja.TipoDocumento.ID);
                     SqlCmd.ExecuteNonQuery();
                 }
                 Trans.Commit();
                 m_ResultProcess = EnumResult.SUCESS;
             }
             catch (Exception ex)
             {
                 Trans.Rollback();
                 m_ResultProcess = EnumResult.ERROR;
                 SoftException.Control(ex);
             }
             finally
             {
                 base.Start();
             }
         }
     }
 }
Example #23
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Soft.Facturacion.Entidades.Facturacion Facturacion = (Soft.Facturacion.Entidades.Facturacion)m_ObjectFlow;
                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;

                        SqlCmd.CommandText = "pSF_Actualizar_EstadoFacturacion_OrdenProduccion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        Trans.Enlist(SqlCmd);
                        foreach (ItemFacturacion ItemFacturacion in Facturacion.Items)
                        {
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@IDOP", ItemFacturacion.IDOrdenProduccion);
                            SqlCmd.Parameters.AddWithValue("@Cantidad", ItemFacturacion.Cantidad);
                            SqlCmd.ExecuteNonQuery();
                        }


                        foreach (ItemFacturacion ItemFacturacion in Facturacion.Items)
                        {
                            if (ItemFacturacion.TieneGuia)
                            {
                                SqlCmd.CommandText = "pSF_Actualizar_EstadoFacturacion_ItemGuiaRemision";
                                SqlCmd.Parameters.Clear();
                                SqlCmd.Parameters.AddWithValue("@IDItemGuiaRemision", ItemFacturacion.IDItemGuiaRemision);
                                SqlCmd.Parameters.AddWithValue("@Cantidad", ItemFacturacion.Cantidad);
                                SqlCmd.ExecuteNonQuery();
                            }
                        }

                        // Creamos la Factura
                        Sesion.Save(Facturacion);
                        Sesion.Flush();
                        // Creamos una Deuda.
                        if (Facturacion.TipoFacturacion.GeneraDeuda)
                        {
                            Deuda Deuda = new Deuda();
                            Deuda.Tipo           = Facturacion.TipoFacturacion.TipoDeuda;
                            Deuda.TipoDocumento  = Facturacion.TipoFacturacion.Comprobante;
                            Deuda.IDDocumento    = Facturacion.ID;
                            Deuda.Descripcion    = Facturacion.TipoDocumento.Nombre;
                            Deuda.IDSocioNegocio = (Facturacion.Cliente != null) ? Facturacion.Cliente.ID : null;
                            Deuda.Saldo          = Facturacion.Total;
                            Deuda.Total          = Facturacion.Total;
                            Sesion.Save(Deuda);
                        }
                        // Actualizamos la Numeración de la Factura
                        if (Facturacion.TipoFacturacion.GeneraNumeracionAlFinal)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "Facturacion");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoFacturacion");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", Facturacion.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", Facturacion.TipoFacturacion.ID);
                            SqlCmd.ExecuteNonQuery();
                        }
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                    finally {
                        base.Start();
                    }
                }
            }
        }
        protected override void OnSetProperty(string property, Variant value)
        {
            if (property == "MTU")
            {
                uint mtu = 0;

                if (value.GetVariantType() == Variant.VariantType.BitStream)
                {
                    var bs = (BitwiseStream)value;
                    bs.SeekBits(0, SeekOrigin.Begin);
                    ulong bits;
                    int   len = bs.ReadBits(out bits, 32);
                    mtu = Endian.Little.GetUInt32(bits, len);
                }
                else if (value.GetVariantType() == Variant.VariantType.ByteString)
                {
                    byte[] buf = (byte[])value;
                    int    len = Math.Min(buf.Length * 8, 32);
                    mtu = Endian.Little.GetUInt32(buf, len);
                }
                else
                {
                    throw new SoftException("Can't set MTU, 'value' is an unsupported type.");
                }

                if (MaxMTU >= mtu && mtu >= MinMTU)
                {
                    using (var cfg = NetworkAdapter.CreateInstance(_iface))
                    {
                        try
                        {
                            cfg.MTU = mtu;
                        }
                        catch (Exception ex)
                        {
                            string msg = ex.Message;
                            if (ex is TypeInitializationException || ex is TargetInvocationException)
                            {
                                msg = ex.InnerException.Message;
                            }

                            string err = "Failed to change MTU of '{0}' to {1}. {2}".Fmt(_iface, mtu, msg);
                            Logger.Error(err);
                            var se = new SoftException(err, ex);
                            throw new SoftException(se);
                        }

                        _mtu = cfg.MTU;

                        if (!_mtu.HasValue || _mtu.Value != mtu)
                        {
                            string err = "Failed to change MTU of '{0}' to {1}. The change did not take effect.".Fmt(_iface, mtu);
                            Logger.Error(err);
                            throw new SoftException(err);
                        }
                        else
                        {
                            Logger.Debug("Changed MTU of '{0}' to {1}.", _iface, mtu);
                        }
                    }
                }
                else
                {
                    Logger.Debug("Not setting MTU of '{0}', value is out of range.", _iface);
                }
            }
        }
Example #25
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Soft.Facturacion.Entidades.Facturacion Facturacion = (Soft.Facturacion.Entidades.Facturacion)m_ObjectFlow;

                        if (Facturacion.Anulado)
                        {
                            throw new Exception(string.Format("La {0} N° {1} ya está anulada.", Facturacion.TipoFacturacion.Comprobante, Facturacion.Numeracion));
                        }

                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection  = (SqlConnection)Sesion.Connection;
                        SqlCmd.CommandText = "pSF_Actualizar_EstadoFacturacion_OrdenProduccion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        Trans.Enlist(SqlCmd);
                        foreach (ItemFacturacion ItemFacturacion in Facturacion.Items)
                        {
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@IDOP", ItemFacturacion.IDOrdenProduccion);
                            SqlCmd.Parameters.AddWithValue("@Cantidad", ItemFacturacion.Cantidad * -1);
                            SqlCmd.ExecuteNonQuery();
                        }

                        SqlCmd.CommandText = string.Format("UPDATE Facturacion SET Anulado = 1 WHERE ID = '{0}'", Facturacion.ID);
                        SqlCmd.CommandType = System.Data.CommandType.Text;
                        SqlCmd.Parameters.Clear();
                        SqlCmd.ExecuteNonQuery();

                        // Eliminamos la Deuda.
                        Deuda Deuda = (Deuda)HelperNHibernate.GetEntityByField("Deuda", "IDDocumento", Facturacion.ID);
                        if (Deuda != null)
                        {
                            if (Deuda.Total > Deuda.Saldo)
                            {
                                throw new Exception("Ya se realizaron pagos de este documento.");
                            }
                            else
                            {
                                Sesion.Delete(Deuda);
                            }
                        }
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                    finally
                    {
                        base.Start();
                    }
                }
            }
        }