Example #1
0
 public PaperlessUsuario1()
 {
     Paso1HousesBL = new List<PaperlessUsuario1HousesBL>();
     Paso1HousesBLInfo = new PaperlessUsuario1HouseBLInfo();
     Excepciones = new List<PaperlessExcepcion>();
     Disputas = new List<PaperlessUsuario1Disputas>();
 }
Example #2
0
 public PaperlessUsuario1()
 {
     Paso1HousesBL     = new List <PaperlessUsuario1HousesBL>();
     Paso1HousesBLInfo = new PaperlessUsuario1HouseBLInfo();
     Excepciones       = new List <PaperlessExcepcion>();
     Disputas          = new List <PaperlessUsuario1Disputas>();
 }
Example #3
0
        private void GuardarPaso1()
        {
            if (!ValidarPaso1())
            {
                return;
            }
            VistaADominioPaso1();

            ResultadoTransaccion resultado = new ResultadoTransaccion();

            var Nuevo = PaperlessAsignacionActual.IsNew;
            resultado = LogicaNegocios.Paperless.Paperless.GuardaPaso1(PaperlessAsignacionActual);
            if (resultado.Estado == Enums.EstadoTransaccion.Aceptada)
            {
                if  (ConPrealerta.Equals(true)) //(!txtNumMaster.Enabled)
                {
                    ResultadoTransaccion res = new ResultadoTransaccion();
                    res = LogicaNegocios.Paperless.Paperless.CambiaEstadoVinculadoPreAlerta(txtNumConsolidada.Text.Trim());

                    if (resultado.Estado != Enums.EstadoTransaccion.Aceptada)
                        MessageBox.Show(resultado.Descripcion, "Paperless", MessageBoxButtons.OK, MessageBoxIcon.Error);

                    ResultadoTransaccion res1 = new ResultadoTransaccion();
                    res1 = LogicaNegocios.Paperless.Paperless.ActualizarPreAlertaNumMaster(txtNumConsolidada.Text.Trim(), PaperlessAsignacionActual);

                    if (resultado.Estado != Enums.EstadoTransaccion.Aceptada)
                        MessageBox.Show(resultado.Descripcion, "Paperless", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                if (IsBrasil)
                {
                   PaperlessUsuario1HouseBLInfo HouseBLInfo = new PaperlessUsuario1HouseBLInfo();
                   HouseBLInfo.IdAsignacion = Convert.ToInt64(resultado.ObjetoTransaccion);
                   HouseBLInfo.NumConsolidado = txtNumConsolidada.Text;
                   HouseBLInfo.CantHouses = Convert.ToInt64(txtNumHousesBL.Text);

                   var resultado1 = LogicaNegocios.Paperless.Paperless.AsignacionGuardaHousesBLInfo(HouseBLInfo, Nuevo);

                    if (resultado1.Estado != Enums.EstadoTransaccion.Aceptada)
                        MessageBox.Show(resultado1.Descripcion, "Paperless", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                ValidarEstados();
                PaperlessAsignacionActual.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
                tabAsignacion.SelectedTabPage = tabFechas;
                if (PaperlessAsignacionActual.IdResultado.Equals(1))
                    MessageBox.Show(PaperlessAsignacionActual.GlosaResultado, "Paperless", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                MessageBox.Show(resultado.Descripcion, "Paperless", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Example #4
0
        private static ResultadoTransaccion Usuario1GuardaHouseBLInfo(PaperlessUsuario1HouseBLInfo infohousesbl, SqlConnection connparam, SqlTransaction tranparam)
        {
            resTransaccion = new ResultadoTransaccion();
            Int64 IdHouseInfo = 0;
            try {
                objParams = SqlHelperParameterCache.GetSpParameterSet(connparam, "SP_N_PAPERLESS_USUARIO1_HOUSESBL_INFO");
                objParams[0].Value = infohousesbl.IdAsignacion;
                objParams[1].Value = infohousesbl.NumConsolidado;
                objParams[2].Value = infohousesbl.CantHouses;
                //objParams[3].Value = infohousesbl.NumHouse;

                SqlCommand command = new SqlCommand("SP_N_PAPERLESS_USUARIO1_HOUSESBL_INFO", connparam);
                command.Parameters.AddRange(objParams);
                command.Transaction = tranparam;
                command.CommandType = CommandType.StoredProcedure;
                IdHouseInfo = Convert.ToInt64(command.ExecuteScalar());

                resTransaccion.Estado = Enums.EstadoTransaccion.Aceptada;
                resTransaccion.ObjetoTransaccion = IdHouseInfo;
            } catch (Exception ex) {
                resTransaccion.Estado = Enums.EstadoTransaccion.Rechazada;
                resTransaccion.Descripcion = ex.Message;
                Log.EscribirLog(ex.Message);
            }
            return resTransaccion;
        }
Example #5
0
        private static ResultadoTransaccion Usuario1ActualizaPaso1Info(PaperlessUsuario1HouseBLInfo house, SqlConnection connparam, SqlTransaction tranparam)
        {
            resTransaccion = new ResultadoTransaccion();
            try {
                objParams = SqlHelperParameterCache.GetSpParameterSet(connparam, "SP_U_PAPERLESS_USUARIO1_HOUSESBL_INFO");
                objParams[0].Value = house.IdAsignacion;
                objParams[1].Value = house.NumConsolidado;
                objParams[2].Value = house.CantHouses;

                SqlCommand command = new SqlCommand("SP_U_PAPERLESS_USUARIO1_HOUSESBL_INFO", connparam);
                command.Parameters.AddRange(objParams);
                command.CommandType = CommandType.StoredProcedure;
                command.Transaction = tranparam;
                command.ExecuteNonQuery();

                resTransaccion.Estado = Enums.EstadoTransaccion.Aceptada;
            } catch (Exception ex) {
                resTransaccion.Estado = Enums.EstadoTransaccion.Rechazada;
                resTransaccion.Descripcion = ex.Message;
                Log.EscribirLog(ex.Message);
            }
            return resTransaccion;
        }
Example #6
0
        public static PaperlessUsuario1HouseBLInfo Usuario1ObtenerHousesBLInfo(Int64 IdAsignacion)
        {
            PaperlessUsuario1HouseBLInfo info = null;

            try {
                //Abrir Conexion
                conn = BaseDatos.NuevaConexion();
                objParams = SqlHelperParameterCache.GetSpParameterSet(conn, "SP_C_PAPERLESS_USUARIO1_HOUSESBL_INFO");
                objParams[0].Value = IdAsignacion;

                SqlCommand command = new SqlCommand("SP_C_PAPERLESS_USUARIO1_HOUSESBL_INFO", conn);
                command.Parameters.AddRange(objParams);
                command.CommandType = CommandType.StoredProcedure;
                dreader = command.ExecuteReader();

                while (dreader.Read()) {
                    info = new PaperlessUsuario1HouseBLInfo();
                    info.Id = Convert.ToInt64(dreader["Id"]);
                    info.IdAsignacion = Convert.ToInt64(dreader["IdAsignacion"]);
                    info.NumConsolidado = dreader["NumConsolidado"].ToString();
                    info.CantHouses = Convert.ToInt16(dreader["CantHouses"]);
                    //info.NumHouse = Convert.ToInt16(dreader["NumHouse"]);

                    //info.Cliente = Clientes.clsClienteMasterADO.ObtenerClienteMasterPorId(Convert.ToInt64(dreader["IdCliente"]));
                    //info.Cliente = new clsClienteMaster(true) { NombreCompañia = dreader["NombreCompania"].ToString() };

                }
            } catch (Exception ex) {
                Base.Log.Log.EscribirLog(ex.Message);
            } finally {
                conn.Close();
            }

            return info;
        }
Example #7
0
        public static ResultadoTransaccion Usuario1GuardaHousesBLDesdeExcepcion(PaperlessUsuario1HousesBL h,
            PaperlessUsuario1HouseBLInfo info,
            PaperlessPasosEstado paso)
        {
            ResultadoTransaccion resultado = new ResultadoTransaccion();
            conn = Base.BaseDatos.BaseDatos.NuevaConexion();
            SqlTransaction transaction = conn.BeginTransaction();
            bool esupdate = false;
            IList<PaperlessUsuario1HousesBL> houses = new List<PaperlessUsuario1HousesBL>();
            houses.Add(h);

            try {
                //Eliminar Info anterior
                //resultado = Usuario1EliminarHousesBLFull(houses[0].IdAsignacion, conn, transaction);
                //if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                //    throw new Exception(resultado.Descripcion);

                //Registrar houses
                foreach (var house in houses) {
                    if (house.IsNew) {
                        if (house.Cliente != null && house.Cliente.IsNew) {
                            resultado = Clientes.clsClienteMasterADO.GuardarClienteMaster(house.Cliente, conn, transaction);
                            if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                                throw new Exception(resultado.Descripcion);
                            else {
                                house.Cliente.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
                            }
                        }

                        resultado = Usuario1AgregarHouseBL(house, conn, transaction);
                        if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                            throw new Exception(resultado.Descripcion);
                        else {
                            house.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
                        }

                        //verificar si tiene recargo collect

                        if (house.ExcepcionRecargoCollect != null) {
                            house.ExcepcionRecargoCollect.IdAsignacion = house.IdAsignacion;
                            house.ExcepcionRecargoCollect.HouseBL.Id = house.Id;

                            resultado = Usuario1MarcaIngresoExcepcion(house.ExcepcionRecargoCollect, conn, transaction);
                        }
                        if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                            throw new Exception(resultado.Descripcion);

                    } else {
                        if (house.Cliente != null && house.Cliente.IsNew) {
                            resultado = Clientes.clsClienteMasterADO.GuardarClienteMaster(house.Cliente, conn, transaction);
                            if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                                throw new Exception(resultado.Descripcion);
                            else {
                                house.Cliente.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
                            }
                        }

                        resultado = Usuario1ActualizaPaso1(house, conn, transaction);
                        if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                            throw new Exception(resultado.Descripcion);
                        esupdate = true;

                        if (house.ExcepcionRecargoCollect != null)
                            resultado = Usuario1ActualizaExcepcion(house.ExcepcionRecargoCollect, conn, transaction);
                        if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                            throw new Exception(resultado.Descripcion);
                    }

                }

                //cambiar estado paso
                resultado = Usuario1CambiarEstadoPaso(paso, conn, transaction);
                if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                    throw new Exception(resultado.Descripcion);

                transaction.Commit();
                resultado.Estado = Enums.EstadoTransaccion.Aceptada;

            } catch (Exception ex) {
                transaction.Rollback();
                resultado.Estado = Enums.EstadoTransaccion.Rechazada;
                resultado.Descripcion = ex.Message;
            } finally {
                conn.Close();
            }

            return resultado;
        }
Example #8
0
        public static ResultadoTransaccion AsignacionGuardaHousesBLInfo1(PaperlessUsuario1HouseBLInfo info, Boolean IsNew)
        {
            ResultadoTransaccion resultado = new ResultadoTransaccion();
            conn = Base.BaseDatos.BaseDatos.NuevaConexion();
            SqlTransaction transaction = conn.BeginTransaction();

            try
            {
                if (IsNew)
                {
                    resultado = Usuario1GuardaHouseBLInfo(info, conn, transaction);
                    if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                        throw new Exception(resultado.Descripcion);
                    else
                        info.Id = Convert.ToInt64(resultado.ObjetoTransaccion);
                }
                else
                {
                    resultado = Usuario1ActualizaPaso1Info(info, conn, transaction);
                    if (resultado.Estado == Enums.EstadoTransaccion.Rechazada)
                        throw new Exception(resultado.Descripcion);
                }
                transaction.Commit();
                resultado.Estado = Enums.EstadoTransaccion.Aceptada;

            }
            catch (Exception ex)
            {
                transaction.Rollback();
                resultado.Estado = Enums.EstadoTransaccion.Rechazada;
                resultado.Descripcion = ex.Message;
            }
            finally
            {
                conn.Close();
            }

            return resultado;
        }
Example #9
0
 public static ResultadoTransaccion Usuario1GuardaHousesBLDesdeExcepcion(PaperlessUsuario1HousesBL houses, PaperlessUsuario1HouseBLInfo info, PaperlessPasosEstado paso)
 {
     return AccesoDatos.Paperless.clsPaperlessADO.Usuario1GuardaHousesBLDesdeExcepcion(houses, info, paso);
 }
Example #10
0
 public static ResultadoTransaccion Usuario1GuardaHousesBL(IList<PaperlessUsuario1HousesBL> houses, PaperlessUsuario1HouseBLInfo info, PaperlessPasosEstado paso, Boolean existeConsolidada)
 {
     return AccesoDatos.Paperless.clsPaperlessADO.Usuario1GuardaHousesBL(houses, info, paso,existeConsolidada);
 }
Example #11
0
 public static ResultadoTransaccion AsignacionGuardaHousesBLInfo(PaperlessUsuario1HouseBLInfo info, Boolean IsNew)
 {
     return AccesoDatos.Paperless.clsPaperlessADO.AsignacionGuardaHousesBLInfo1(info, IsNew);
 }
Example #12
0
        private PaperlessUsuario1HouseBLInfo Usuario1ObtenerHousesBLInfo()
        {
            PaperlessUsuario1HouseBLInfo info = new PaperlessUsuario1HouseBLInfo();

            info.CantHouses = Convert.ToInt16(txtP1CantHouses.Text);
            info.IdAsignacion = PaperlessAsignacionActual.Id;
            info.NumConsolidado = txtP1NumConsolidado.Text;
            //info.NumHouse = Convert.ToInt16(txtP1NumHouse.Text);

            //if (txtP1Cliente.Text.Trim() == "")
            //{
            //    info.Cliente = null;
            //}
            //else
            //{
            //    for (int i = 0; i < ddlP1Cliente.Properties.Items.Count; i++)
            //    {
            //        if (ddlP1Cliente.Properties.Items[i].ToString() == txtP1Cliente.Text)
            //            ddlP1Cliente.SelectedIndex = i;
            //    }

            //    if (ddlP1Cliente.SelectedIndex == 0)
            //    {
            //        info.Cliente = new clsClienteMaster(true);
            //    }
            //    else
            //        info.Cliente = (clsClienteMaster)this.ddlP1Cliente.SelectedItem;
            //}

            return info;
        }
Example #13
0
        private PaperlessUsuario1HouseBLInfo Usuario1ObtenerHousesBLInfo()
        {
            PaperlessUsuario1HouseBLInfo info = new PaperlessUsuario1HouseBLInfo();

            info.CantHouses = Convert.ToInt16(txtP1CantHouses.Text);
            info.IdAsignacion = PaperlessAsignacionActual.Id;
            info.NumConsolidado = txtP1NumConsolidado.Text;
            return info;
        }