Exemple #1
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria           Auditoria = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Modificación");
                        SolicitudCotizacion cp        = (SolicitudCotizacion)m_ObjectFlow;

                        SolicitudCotizacion cpactual = (SolicitudCotizacion)HelperNHibernate.GetEntityByID("SolicitudCotizacion", cp.ID);

                        if (cpactual.EstadoAprobacion.Equals("PENDIENTE"))
                        {
                            Sesion.Update(cp);
                            Sesion.Save(Auditoria);
                            Trans.Commit();
                            m_ResultProcess = EnumResult.SUCESS;
                        }
                        else
                        {
                            throw new Exception("Estado " + cpactual.EstadoAprobacion + " del documento no permite modificaciones");
                        }
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                }
            }
            base.Start();
        }
Exemple #2
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria       Auditoria       = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Modificar");
                        OrdenProduccion OrdenProduccion = (OrdenProduccion)m_ObjectFlow;

                        if (!OrdenProduccion.EstadoAprobacion.Equals("PENDIENTE"))
                        {
                            throw new Exception("El Orden Produccion numero " + OrdenProduccion.Numeracion + " se encuentra " + OrdenProduccion.EstadoAprobacion);
                        }



                        Sesion.Update(OrdenProduccion);
                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                }
            }
            base.Start();
        }
Exemple #3
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");
                        Presupuesto Presupuesto = (Presupuesto)m_ObjectFlow;
                        SqlCommand  SqlCmd      = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        SqlCmd.CommandText = "pSF_Actualizar_IDPresupuesto_Cotizacion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        SqlCmd.Parameters.AddWithValue("@IDPresupuesto", Presupuesto.ID);
                        SqlCmd.Parameters.AddWithValue("@Items", ContruirXML(Presupuesto));
                        SqlCmd.ExecuteNonQuery();

                        if (EstaModificado(Presupuesto))
                        {
                            Presupuesto.EstadoAprobacion = "MODIFICADO";
                        }

                        Sesion.Save(Presupuesto);
                        Sesion.Flush();

                        // Actualizamos la Numeración de la Factura
                        if (Presupuesto.TipoDocumento.GeneraNumeracionAlFinal)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "Presupuesto");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoPresupuesto");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", Presupuesto.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", Presupuesto.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();
        }
Exemple #4
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");

                        SalidaInventario SalidaInventario = (SalidaInventario)m_ObjectFlow;
                        SqlCommand       SqlCmd           = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        // Creamos la Salida de Inventario.
                        Sesion.Save(SalidaInventario);
                        Sesion.Flush();
                        // Actualizamos los Stocks.
                        foreach (ItemSalidaInventario Item in SalidaInventario.Items)
                        {
                            SqlCmd.CommandText = "pSF_ActualizarStocks";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                            SqlCmd.Parameters.AddWithValue("@IDAlmacen", SalidaInventario.Almacen.ID);
                            SqlCmd.Parameters.AddWithValue("@IDProducto", Item.Producto.ID);
                            SqlCmd.Parameters.AddWithValue("@Cantidad", Item.Cantidad * Item.Factor);
                            SqlCmd.Parameters.AddWithValue("@Operacion", "Decrementar");
                            SqlCmd.ExecuteNonQuery();
                        }
                        // Actualizamos la Numeración de la Salida de Inventario
                        if (SalidaInventario.TipoDocumento.GeneraNumeracionAlFinal)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "SalidaInventario");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoDocumentoInventario");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", SalidaInventario.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", SalidaInventario.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()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    FrmProgress Progreso = new FrmProgress();
                    try
                    {
                        Collection Presupuestos = (Collection)m_ObjectFlow;
                        Progreso.Start(Presupuestos.Count, "Aprobando Presupuestos ...");
                        foreach (Presupuesto Presupuesto in Presupuestos)
                        {
                            Auditoria Auditoria = Auditoria.ConstruirAuditoria(Presupuesto, "Enviar Cliente");

                            if (!Presupuesto.EstadoAprobacion.Equals("APROBADO"))
                            {
                                throw new Exception(String.Format("El presupuesto número {0} no esta aprobado", Presupuesto.Numeracion));
                            }


                            if (!Presupuesto.EstadoAceptacion.Equals("PENDIENTE"))
                            {
                                throw new Exception(String.Format("El presupuesto número {0} ya fue enviado", Presupuesto.Numeracion));
                            }


                            SqlCommand SqlCmd = new SqlCommand();
                            SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                            Trans.Enlist(SqlCmd);
                            SqlCmd.CommandText = "pSF_Enviar_Cliente_Presupuesto";
                            SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                            SqlCmd.Parameters.AddWithValue("@ID", Presupuesto.ID);
                            SqlCmd.Parameters.AddWithValue("@EstadoAceptacion", "ENVIADO");
                            SqlCmd.ExecuteNonQuery();
                            Sesion.Save(Auditoria);
                            Progreso.Next();
                        }
                        Trans.Commit();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control((ex.InnerException != null) ? ex.InnerException : ex);
                    }
                }
            }
            base.Start();
        }
Exemple #6
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    FrmProgress Progreso = new FrmProgress();
                    try
                    {
                        Collection Cps = (Collection)m_ObjectFlow;


                        Progreso.Start(Cps.Count, "Aprobando Cotizaciones ...");
                        foreach (ConsolidadoOp Cp in Cps)
                        {
                            Auditoria     Auditoria     = Auditoria.ConstruirAuditoria(Cp, "Aprobacion");
                            ConsolidadoOp ConsolidadoOp = (ConsolidadoOp)HelperNHibernate.GetEntityByID("ConsolidadoOp", Cp.ID);


                            if (ConsolidadoOp.EstadoAprobacion.Equals("APROBADO"))
                            {
                                throw new Exception(String.Format("El consolidado número {0} ya se encuentra APROBADA.", Cp.Numeracion));
                            }
                            SqlCommand SqlCmd = new SqlCommand();
                            SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                            Trans.Enlist(SqlCmd);
                            SqlCmd.CommandText = "pSF_Aprobar_ConsolidadoOp";
                            SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                            SqlCmd.Parameters.AddWithValue("@ID", ConsolidadoOp.ID);
                            SqlCmd.Parameters.AddWithValue("@EstadoAprobacion", "APROBADO");
                            SqlCmd.ExecuteNonQuery();
                            Sesion.Save(Auditoria);
                            Progreso.Next();
                        }
                        Trans.Commit();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control((ex.InnerException != null) ? ex.InnerException : 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");
                        ConsolidadoOp ConsolidadoOp = (ConsolidadoOp)m_ObjectFlow;

                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        SqlCmd.CommandText = "pSF_Actualizar_IDConsolidadoOP_OrdenProduccion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        SqlCmd.Parameters.AddWithValue("@IDConsolidadoOp", ConsolidadoOp.ID);
                        SqlCmd.Parameters.AddWithValue("@Items", ContruirXML(ConsolidadoOp));
                        SqlCmd.ExecuteNonQuery();

                        Sesion.Save(ConsolidadoOp);
                        Sesion.Flush();

                        // Actualizamos la Numeración
                        if (ConsolidadoOp.TipoDocumento.GeneraNumeracionAlFinal)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "ConsolidadoOp");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoDocumentoConsolidadoOp");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", ConsolidadoOp.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", ConsolidadoOp.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();
        }
Exemple #8
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");

                        OrdenProduccion OrdenProduccion = (OrdenProduccion)m_ObjectFlow;
                        SqlCommand      SqlCmd          = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        // Valida la OP.
                        SqlCmd.CommandText = "pSF_Validar_Orden_Producion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        SqlCmd.Parameters.AddWithValue("@IDItemPresupuesto", OrdenProduccion.IDItemPresupuesto);
                        SqlCmd.ExecuteNonQuery();
                        // Creamos la OP.
                        Sesion.Save(OrdenProduccion);
                        Sesion.Flush();
                        // Actualizamos la Numeración de la Salida de Inventario
                        if (OrdenProduccion.TipoDocumento.GeneraNumeracionAlFinal)
                        {
                            SqlCmd.CommandText = "pSF_Generar_Numeracion";
                            SqlCmd.Parameters.Clear();
                            SqlCmd.Parameters.AddWithValue("@Documento", "OrdenProduccion");
                            SqlCmd.Parameters.AddWithValue("@TipoDocumento", "TipoOrdenProduccion");
                            SqlCmd.Parameters.AddWithValue("@IDDocumento", OrdenProduccion.ID);
                            SqlCmd.Parameters.AddWithValue("@IDTipoDocumento", OrdenProduccion.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()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    try
                    {
                        Auditoria Auditoria = Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Modificación");

                        Presupuesto Presupuesto = (Presupuesto)m_ObjectFlow;

                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        SqlCmd.CommandText = "pSF_Actualizar_IDPresupuesto_Cotizacion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        SqlCmd.Parameters.AddWithValue("@IDPresupuesto", Presupuesto.ID);
                        SqlCmd.Parameters.AddWithValue("@Items", ContruirXML(Presupuesto));
                        SqlCmd.ExecuteNonQuery();

                        if (Presupuesto.EstadoAceptacion.Equals("ENVIADO"))
                        {
                            throw new Exception(String.Format("El presupuesto número {0} ya fue enviado al cliente", Presupuesto.Numeracion));
                        }
                        if (EstaModificado(Presupuesto))
                        {
                            Presupuesto.EstadoAprobacion = "MODIFICADO";
                        }

                        Sesion.Update(Presupuesto);
                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                }
            }
            base.Start();
        }
Exemple #10
0
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    FrmProgress Progreso = new FrmProgress();
                    try
                    {
                        Collection Cotizaciones = (Collection)m_ObjectFlow;
                        Progreso.Start(Cotizaciones.Count, "Desaprobando Cotizaciones ...");
                        foreach (Cotizacion Cotizacion in Cotizaciones)
                        {
                            Auditoria Auditoria = Auditoria.ConstruirAuditoria(Cotizacion, "Desaprobar");
                            if (Cotizacion.EstadoAprobacion.Equals("PENDIENTE"))
                            {
                                throw new Exception(String.Format("La cotización número {0} aún no ha sido APROBADA.", Cotizacion.Numeracion));
                            }

                            SqlCommand SqlCmd = new SqlCommand();
                            SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                            Trans.Enlist(SqlCmd);
                            SqlCmd.CommandText = "pSF_Aprobar_Desaprobar_Cotizacion";
                            SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                            SqlCmd.Parameters.AddWithValue("@ID", Cotizacion.ID);
                            SqlCmd.Parameters.AddWithValue("@EstadoAprobacion", "PENDIENTE");
                            SqlCmd.ExecuteNonQuery();
                            Sesion.Save(Auditoria);
                            Progreso.Next();
                        }
                        Trans.Commit();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control((ex.InnerException != null) ? ex.InnerException : ex);
                    }
                }
            }
            base.Start();
        }
        public override void Start()
        {
            using (ISession Sesion = m_SessionFactory.OpenSession())
            {
                using (ITransaction Trans = Sesion.BeginTransaction())
                {
                    FrmProgress Progreso = new FrmProgress();
                    try
                    {
                        Collection Cps = (Collection)m_ObjectFlow;


                        Progreso.Start(Cps.Count, "Cambiando a Despacho a Ordenes de Produccion ...");
                        foreach (OrdenProduccion Cp in Cps)
                        {
                            Auditoria Auditoria = Auditoria.ConstruirAuditoria(Cp, "En Acabados");

                            SqlCommand SqlCmd = new SqlCommand();
                            SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                            Trans.Enlist(SqlCmd);
                            SqlCmd.CommandText = "pSF_Estados_Produccion_OrdenProduccion";
                            SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                            SqlCmd.Parameters.AddWithValue("@ID", Cp.ID);
                            SqlCmd.Parameters.AddWithValue("@EstadoAprobacion", "EN DESPACHO");
                            SqlCmd.ExecuteNonQuery();
                            Sesion.Save(Auditoria);
                            Progreso.Next();
                        }
                        Trans.Commit();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        Progreso.Close();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control((ex.InnerException != null) ? ex.InnerException : 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, "Modificar");
                        ConsolidadoOp ConsolidadoOp = (ConsolidadoOp)m_ObjectFlow;

                        if (!ConsolidadoOp.EstadoAprobacion.Equals("PENDIENTE"))
                        {
                            throw new Exception("El consolidado numero " + ConsolidadoOp.Numeracion + " se encuentra " + ConsolidadoOp.EstadoAprobacion);
                        }


                        SqlCommand SqlCmd = new SqlCommand();
                        SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                        Trans.Enlist(SqlCmd);
                        SqlCmd.CommandText = "pSF_Actualizar_IDConsolidadoOP_OrdenProduccion";
                        SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                        SqlCmd.Parameters.AddWithValue("@IDConsolidadoOp", ConsolidadoOp.ID);
                        SqlCmd.Parameters.AddWithValue("@Items", ContruirXML(ConsolidadoOp));
                        SqlCmd.ExecuteNonQuery();


                        Sesion.Update(ConsolidadoOp);
                        Sesion.Save(Auditoria);
                        Trans.Commit();
                        m_ResultProcess = EnumResult.SUCESS;
                    }
                    catch (Exception ex)
                    {
                        Trans.Rollback();
                        m_ResultProcess = EnumResult.ERROR;
                        SoftException.Control(ex);
                    }
                }
            }
            base.Start();
        }
Exemple #13
0
 public override void Start()
 {
     try
     {
         this.IniciarTransaccion();
         this.Agregar(base.m_ObjectFlow);
         this.Agregar(Auditoria.ConstruirAuditoria(base.m_ObjectFlow, "Creació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();
 }
        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();
                    }
                }
            }
        }
        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()
        {
            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();
                    }
                }
            }
        }