public static List <Cotizacion> listarEntreFechas(DateTime fecha1, DateTime fecha2)
    {
        SqlConnection cnn      = new SqlConnection(Conexion.STR);
        string        consulta = "listarCotizacionEntreFechas";
        SqlCommand    comando  = new SqlCommand(consulta, cnn);

        comando.CommandType = CommandType.StoredProcedure;
        comando.Parameters.AddWithValue("@fechaIni", fecha1);
        comando.Parameters.AddWithValue("@fechaFin", fecha2);
        try
        {
            cnn.Open();
            SqlDataReader     lector = comando.ExecuteReader();
            List <Cotizacion> lista  = new List <Cotizacion>();
            while (lector.Read())
            {
                DateTime   fecha = (DateTime)lector["fecha"];
                double     dolar = (double)lector["dolar"];
                double     euro  = (double)lector["euro"];
                Cotizacion c     = new Cotizacion(fecha, dolar, euro);
                lista.Add(c);
            }
            return(lista);
        }
        catch (Exception es)
        {
            throw new Exception("Problemas con la base de datos !!!!! " + es.Message);
        }
        finally
        {
            cnn.Close();
        }
    }
 public IHttpActionResult Post(Cotizacion cotizacion)
 {
     try
     {
         var _sucursal = Request.Headers.GetValues("sucursal").FirstOrDefault();
         if (_sucursal == null)
         {
             return(BadRequest("No existe sucursal."));
         }
         cotizacion.SucursalId = int.Parse(_sucursal);
         cotizacion.UsuarioId  = Util.USUARIO.Id;
         if (_servicio.Post(ref _error, cotizacion))
         {
             return(Ok("Cotizacion guardada correctamente"));
         }
         else
         {
             return(BadRequest(_error));
         }
     }
     catch (Exception e)
     {
         return(BadRequest(e.ToString()));
     }
 }
        public FileStream GetFile(ref string error, ref string nombre, ref Cotizacion cotizacion, int archivoId, HttpContext contexto)
        {
            cotizacion = GetId(cotizacion.Id);
            Ruta _ruta    = new Ruta(contexto, cotizacion);
            var  _archivo = cotizacion.Archivos.Where(ca => ca.Id == archivoId).FirstOrDefault();

            if (_archivo == null)
            {
                error = "No existe archivo.";
                return(null);
            }
            FileStream _archivoRespuesta = null;
            var        _rutaArchivo      = Path.Combine(_ruta.RutaCarpetaCotizacionesArchivosClientes, _archivo.NombreFisico);

            if (File.Exists(_rutaArchivo))
            {
                nombre            = _archivo.NombreFisico;
                _archivoRespuesta = new FileStream(_rutaArchivo, FileMode.Open, FileAccess.Read);
                return(_archivoRespuesta);
            }
            else
            {
                error = "No existe archivo.";
                return(null);
            }
        }
        public ActionResult AsociarMecanico(int?id)
        {
            if (id == null)
            {
                return(RedirectToAction("IniciarSesion", "Login"));
            }

            if (Session["TiendaId"] == null)
            {
                return(RedirectToAction("IniciarSesion", "Login"));
            }

            Tienda tienda = ObtenerTienda();

            Cotizacion           cotizacion     = tienda.Cotizaciones.Where(c => c.Id == id).FirstOrDefault();
            List <UsuarioTienda> usuariosTienda = tienda.UsuariosTienda.Where(ust => ust.UsuariosTiendaMecanicos.Count > 0).ToList();

            List <Usuario> usuariosMecanicos = new List <Usuario>();
            List <UsuarioTiendaMecanico> usuarioTiendaMecanicos = new List <UsuarioTiendaMecanico>();

            foreach (UsuarioTienda ust in usuariosTienda)
            {
                usuariosMecanicos.Add(ust.Usuario);
                usuarioTiendaMecanicos.Add(ust.UsuariosTiendaMecanicos.First());
            }

            ViewBag.Cotizacion = cotizacion;
            ViewBag.MecanicoId = new SelectList(usuariosMecanicos, "Id", "NombreCompleto");

            return(View(usuarioTiendaMecanicos.AsEnumerable()));
        }
Example #5
0
 public override void Start()
 {
     using (ISession Sesion = m_SessionFactory.OpenSession())
     {
         using (ITransaction Trans = Sesion.BeginTransaction())
         {
             try
             {
                 Cotizacion Cotizacion = (Cotizacion)m_ObjectFlow;
                 SqlCommand SqlCmd     = new SqlCommand();
                 SqlCmd.Connection = (SqlConnection)Sesion.Connection;
                 Trans.Enlist(SqlCmd);
                 SqlCmd.CommandText = "pSF_EliminarCotizacion";
                 SqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
                 SqlCmd.Parameters.AddWithValue("@IDSolicitudCotizacion", Cotizacion.IDSolicitudCotizacion);
                 SqlCmd.ExecuteNonQuery();
                 Sesion.Delete(Cotizacion);
                 Trans.Commit();
                 m_ResultProcess = EnumResult.SUCESS;
             }
             catch (Exception ex)
             {
                 Trans.Rollback();
                 m_ResultProcess = EnumResult.ERROR;
                 SoftException.Control(ex.InnerException);
             }
         }
     }
     base.Start();
 }
Example #6
0
        public bool AprobarCotizacion(Cotizacion cotizacion)
        {
            bool bol_resultado_operacion = false;
            int  int_numero_registro     = 0;

            conexion.Open();

            string query = "Sp_Aprobar_Cotizacion_Venta";

            SqlCommand comando = new SqlCommand(query, conexion);

            comando.CommandType = CommandType.StoredProcedure;
            comando.Parameters.AddWithValue("@ID_Ordenes", cotizacion.ID_Ordenes);

            int_numero_registro = int.Parse(comando.ExecuteScalar().ToString());

            if (int_numero_registro > 0)
            {
                bol_resultado_operacion = true;
            }
            else
            {
                bol_resultado_operacion = false;
            }

            conexion.Close();
            return(bol_resultado_operacion);
        }
        public async Task <IActionResult> PutCotizacion([FromRoute] int id, [FromBody] Cotizacion cotizacion)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != cotizacion.IdCotizacion)
            {
                return(BadRequest());
            }

            _context.Entry(cotizacion).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CotizacionExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #8
0
        public ActionResult CreateCot(CotizacionViewModel cot)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var usuario = User.Identity.GetUserName();
                    var cliente = cot.Cotizacion.Clientes.ClienteId;
                    var fecha   = cot.GetDate();

                    Cotizacion file = new Cotizacion();

                    file.ClienteId = cliente;
                    file.Fecha     = fecha;

                    DB.Cotizacion.Add(file);
                    DB.SaveChanges();

                    TempData["Status"] = "Upload successful";
                    return(RedirectToAction("ProductoFac", new { cotId = file.CotizacionId }));
                }
            }
            catch (RetryLimitExceededException /* dex */)
            {
                //Log the error (uncomment dex variable name and add a line here to write a log.
                ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
            }

            return(View(cot));
        }
Example #9
0
        public ActionResult DeleteProConfirmed(DetalleCot det)
        {
            try
            {
                var        MId        = det.DetalleCotId;
                DetalleCot detallecot = DB.DetalleCot.Find(MId);
                DB.DetalleCot.Remove(detallecot);
                DB.SaveChanges();

                Decimal monto = DB.DetalleCot
                                .Where(d => d.CotizacionId == MId)
                                .Sum(m => m.Cantidad * m.Valor);
                Decimal itbis = monto * 0.18m;

                Cotizacion cotm = DB.Cotizacion.Find(MId);
                cotm.TotalFactura = monto;
                cotm.Itbis        = itbis;
                DB.SaveChanges();

                return(RedirectToAction("ProductoFac", new { cotId = detallecot.CotizacionId }));
            }
            catch (RetryLimitExceededException /* dex */)
            {
                //Log the error (uncomment dex variable name and add a line here to write a log.
                return(RedirectToAction("ProDelete", new { id = det.DetalleCotId, saveChangesError = true }));
            }
        }
        /// <summary>
        /// Permite Buscar una entidad en la base de datos
        /// </summary>
        ///<param name="id">El Id de la Cotizacion que se desea encontrar </param>
        /// <returns>Retorna la visita encontrada </returns>
        public static Cotizacion Buscar(int id)
        {
            Contexto   contexto   = new Contexto();
            Cotizacion cotizacion = new Cotizacion();

            try
            {
                cotizacion = contexto.Cotizacion.Find(id);
                //Cargar la lista en este punto porque
                //luego de hacer Dispose() el Contexto
                //no sera posible leer la lista
                cotizacion.Detalle.Count();

                //Cargar los nombres de las ciudades
                foreach (var item in cotizacion.Detalle)
                {
                    //forzando la ciudad a cargarse
                    string a = item.Articulos.Descripcion;
                    string p = item.Personas.Nombres;
                }

                contexto.Dispose();
            }
            catch (Exception)
            {
                throw;
            }
            return(cotizacion);
        }
        /// <summary>
        /// Permite guardar una entidad en la base de datos
        /// </summary>
        /// <param name="cotizaciones">Una instancia de cotizaciones</param>
        /// <returns>Retorna True si guardo o Falso si falló </returns>
        public static bool Guardar(Cotizacion cotizacion)
        {
            bool paso = false;

            try
            {
                Contexto contexto = new Contexto();
                contexto.Cotizacion.Add(cotizacion);
                foreach (CotizaDetalle detalle in cotizacion.Detalle)
                {
                    contexto.CotizaDetalle.Add(detalle);
                    Articulos articulo = ArticulosBLL.Buscar(detalle.ArticuloId);
                    articulo.Cantidad += detalle.Cantidad;
                    ArticulosBLL.Modificar(articulo);
                }

                contexto.SaveChanges();
                contexto.Dispose();
                paso = true;
            }
            catch (Exception)
            {
                throw;
            }
            return(paso);
        }
        public IHttpActionResult GetServicio(string id)
        {
            if (id == "Pesos")
            {
                TipoMoneda = new Cotizacion(new Pesos());

                return(Ok(TipoMoneda.obtenerRespuesta()));
            }
            else if (id == "Real")
            {
                TipoMoneda = new Cotizacion(new Real());

                return(Ok(TipoMoneda.obtenerRespuesta()));
            }
            else if (id == "Dolar")
            {
                TipoMoneda = new Cotizacion(new Dolar());

                return(Ok(TipoMoneda.obtenerRespuesta()));
            }
            else
            {
                return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Pagina no encontrada")));
            }
        }
Example #13
0
        public ActionResult Index()
        {
            try
            {
                List <Cotizacion> listaCotizacion = new List <Cotizacion>();
                clsCotizacion     cliente         = new clsCotizacion();
                var data = cliente.ConsultarCotizacion().ToList();

                foreach (var item in data)
                {
                    Cotizacion modelo = new Cotizacion();
                    modelo.idCotizacion               = item.idCotizacion;
                    modelo.idColaborador              = item.idColaborador;
                    modelo.nombreProductoCotizacion   = item.nombreProductoCotizacion;
                    modelo.cantidadProductoCotizacion = item.cantidadProductoCotizacion;
                    modelo.detalleCotizacion          = item.detalleCotizacion;
                    modelo.estadoCotizacion           = item.estadoCotizacion;

                    listaCotizacion.Add(modelo);
                }
                return(View(listaCotizacion));
            }
            catch
            {
                string descMsg = "Error consultando la informacion del CLiente.";
                //Bitacora
                return(RedirectToAction("Error", "Error"));
            }
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Necesidad,Tipo,Lugar,Cuando,NDeInvitados,Descripcion")] Cotizacion cotizacion)
        {
            if (id != cotizacion.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(cotizacion);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CotizacionExists(cotizacion.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(cotizacion));
        }
Example #15
0
        private async void SaveCotizacion()
        {
            Cotizacion cotizacion = new Cotizacion {
                ProveedorId = int.Parse(IDProveedor[(int)spinnerProveedor.SelectedItemId]),
                Fecha       = DateTime.Now,
                EstatusId   = 1
            };

            try {
                cotizacion = await NetworkService.GetCotizacionService().SaveTodoItemAsync(cotizacion, true);
            } catch (Exception) {
                throw;
            }
            foreach (SolicitudCotizacion solicitud in articulos)
            {
                solicitud.CotizacionId = cotizacion.CotizacionId;
                await NetworkService.GetSolicitudCotizacionService().SaveSolicitud(solicitud);
            }
            Cotizacion newCot = await NetworkService.GetCotizacionService().GetCotizacion(cotizacion.CotizacionId);

            await NetworkService.GetNotificationService().EnviarCorreo(newCot.CotizacionId, newCot.Proveedor.Correo);

            Intent myIntent           = new Intent(this, typeof(MainActivity));
            var    MySerializedObject = JsonConvert.SerializeObject(newCot);

            myIntent.PutExtra("Detalle", MySerializedObject);
            SetResult(Result.Ok, myIntent);
            Finish();
        }
        //
        // GET: /Cotizaciones/Edit/5

        public ActionResult Edit(int id)
        {
            Cotizacion cotizacion = db.Cotizaciones.Find(id);

            ViewBag.IdRequerimiento = new SelectList(db.Requerimientos, "IdRequerimiento", "NumReq", cotizacion.IdRequerimiento);
            return(View(cotizacion));
        }
    public static Cotizacion Buscar(DateTime fecha)
    {
        Cotizacion c     = null;
        double     dolar = 0;
        double     euro  = 0;

        SqlConnection cnn      = new SqlConnection(Conexion.STR);
        string        consulta = "BuscarCotizacion";
        SqlCommand    comando  = new SqlCommand(consulta, cnn);

        comando.CommandType = CommandType.StoredProcedure;
        comando.Parameters.AddWithValue("@fecha", fecha);
        SqlDataReader lector;

        try
        {
            cnn.Open();
            lector = comando.ExecuteReader();
            if (lector.Read())
            {
                dolar = (double)lector["dolar"];
                euro  = (double)lector["euro"];
                c     = new Cotizacion(fecha, dolar, euro);
            }
            return(c);
        }
        catch (Exception es)
        {
            throw new Exception("Problemas !!!!! " + es.Message);
        }
        finally
        {
            cnn.Close();
        }
    }
        /// <summary>
        /// Permite Modificar una entidad en la base de datos
        /// </summary>
        /// <param name="visita">Una instancia de Cotizacion</param>
        /// <returns>Retorna True si Modifico o Falso si falló </returns>
        public static bool Modificar(Cotizacion cotizacion)
        {
            bool     paso     = false;
            Contexto contexto = new Contexto();

            try
            {
                //todo: buscar las entidades que no estan para removerlas

                //recorrer el detalle
                foreach (var item in cotizacion.Detalle)
                {
                    //Muy importante indicar que pasara con la entidad del detalle
                    var estado = item.Id > 0 ? EntityState.Modified : EntityState.Added;
                    contexto.Entry(item).State = estado;
                }

                //Indicar que se esta modificando el encabezado
                contexto.Entry(cotizacion).State = EntityState.Modified;

                if (contexto.SaveChanges() > 0)
                {
                    paso = true;
                }
                contexto.Dispose();
            }
            catch (Exception)
            {
                throw;
            }
            return(paso);
        }
    public static List <Cotizacion> listar()
    {
        SqlConnection cnn     = new SqlConnection(Conexion.STR);
        SqlCommand    comando = new SqlCommand("ListarCotizacion", cnn);

        comando.CommandType = CommandType.StoredProcedure;
        try
        {
            cnn.Open();
            SqlDataReader     lector = comando.ExecuteReader();
            List <Cotizacion> lista  = new List <Cotizacion>();
            while (lector.Read())
            {
                DateTime   fecha = (DateTime)lector["fecha"];
                double     dolar = (double)lector["dolar"];
                double     euro  = (double)lector["euro"];
                Cotizacion c     = new Cotizacion(fecha, dolar, euro);
                lista.Add(c);
            }
            return(lista);
        }
        catch (Exception es)
        {
            throw new Exception("Problemas con la base de datos !!!!! " + es.Message);
        }
        finally
        {
            cnn.Close();
        }
    }
        /// <summary>
        /// Procedimiento que realiza el alta, modificación o baja de los datos de la tabla mst_Cotizacion
        /// </summary>
        /// <param name="cotizacion"></param>
        /// <param name="rack"></param>
        /// <param name="tinOpcion"></param>
        /// <returns></returns>
        public Resultado setMstCotizacion(Cotizacion cotizacion, RackSelectivo rack, short tinOpcion)
        {
            Resultado result = new Resultado();

            try
            {
                using (CotizacionDataContext dc = new CotizacionDataContext(Helper.ConnectionString()))
                {
                    var query = from item in dc.stp_setMstCotizacion(cotizacion.intCotizacionID, cotizacion.intEstatusID, cotizacion.sintPrioridadID, cotizacion.intEmpresaID,
                                                                     cotizacion.vchFolio, cotizacion.datFechaAceptacion, cotizacion.datFechaRechazo,
                                                                                     // Datos que son almacenados en tbl_RackSelectivo
                                                                     rack.intRackID, //rack.bitMontacarga, rack.intNumeroTarimaPorNivel,
                                                                                     //rack.decFrente, rack.decFondo, rack.decAltura, rack.decPeso,
                                                                     /*rack.vchDimensionMontacarga, rack.intNumeroNivelSobreViga, rack.intPosicion,*/ rack.sintVisitas,
                                                                     rack.intRelCotizaProductoID, rack.intProductoGralID, rack.intSubProductoID, cotizacion.intUsuarioID, cotizacion.bitActivo, (byte)tinOpcion)
                                select new Resultado
                    {
                        vchDescripcion = item.vchDescripcion,
                        vchResultado   = item.vchResultado
                    };
                    result = query.First();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(result);
        }
Example #21
0
        public ActionResult EditPost(int?id, CotizacionViewModel mod)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            try
            {
                if (ModelState.IsValid)
                {
                    var cliente = mod.Cotizacion.Clientes.ClienteId;
                    var fecha   = mod.GetDate();

                    Cotizacion file = DB.Cotizacion.Find(id);
                    file.ClienteId = cliente;
                    file.Fecha     = fecha;
                    DB.SaveChanges();
                    return(RedirectToAction("ProductoFac", new { cotId = file.CotizacionId }));
                }
            }
            catch (RetryLimitExceededException /* dex */)
            {
                //Log the error (uncomment dex variable name and add a line here to write a log.
                ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
            }
            return(View(mod));
        }
        /// <summary>
        /// Procedimiento que realiza el alta, modificación o baja de los datos de la tabla det_Cotizacion
        /// </summary>
        /// <param name="cotizacion"></param>
        /// <param name="tinOpcion"></param>
        /// <returns></returns>
        public Resultado setDetCotizacion(Cotizacion cotizacion, short tinOpcion)
        {
            Resultado result = new Resultado();

            try
            {
                using (CotizacionDataContext dc = new CotizacionDataContext(Helper.ConnectionString()))
                {
                    var query = from item in dc.stp_setDetCotizacion(cotizacion.intDetCotizaID, cotizacion.intCotizacionID, cotizacion.intSeleccionVigaID, cotizacion.intElementoID, cotizacion.intPartida, cotizacion.intCantidad,
                                                                     cotizacion.decDolar, cotizacion.decMonto, cotizacion.decSubtotal, cotizacion.decDescuento,
                                                                     cotizacion.decDescuentoFin, cotizacion.decIEMPS, cotizacion.decRetISR, cotizacion.decRetIVA, cotizacion.decIVA, cotizacion.decTotal,
                                                                     cotizacion.bitActivo, (byte)tinOpcion)
                                select new Resultado
                    {
                        vchDescripcion = item.vchDescripcion,
                        vchResultado   = item.vchResultado
                    };
                    result = query.First();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(result);
        }
Example #23
0
        public async Task <IActionResult> Edit(int id, [Bind("correlativoID,tipoServicio,descripcion,montoTotal,valorAgregado,fecha,estado,version")] Cotizacion cotizacion)
        {
            if (id != cotizacion.correlativoID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(cotizacion);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CotizacionExists(cotizacion.correlativoID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(cotizacion));
        }
Example #24
0
        public void CargarDetallePago(Cotizacion cotizacion)
        {
            CotizacionActual    = cotizacion;
            CotizacionActual.Id = cotizacion.Id;

            var format = new NumberFormatInfo {
                NumberDecimalSeparator = ",", NumberGroupSeparator = "."
            };

            txtNumCotizacion.Text = cotizacion.Id.ToString();
            txtPrecioSinIva.Text  = $"$ {cotizacion.TotalSinIva.ToString("#,##0", format)}";
            txtIva.Text           = $"$ {cotizacion.Iva.ToString("#,##0", format)}";
            txtPrecioFinal.Text   = $"$ {cotizacion.TotalFinal.ToString("#,##0", format)}";
            txtCuotas.Text        = cotizacion.CantidadCuotas.ToString();
            txtValorCuotas.Text   = $"$ {cotizacion.ValorCuota.ToString("#,##0", format)}";

            if (cotizacion.IdTipoPago == 1)
            {
                CargarBancos();
                gridPac.Visibility = Visibility.Visible;
                gridPat.Visibility = Visibility.Hidden;
            }
            else
            {
                CargarTarjetasDeCredito();
                gridPat.Visibility = Visibility.Visible;
                gridPac.Visibility = Visibility.Hidden;
            }
        }
        public ActionResult LogSISE()
        {
            if (Session["cotizacionID"] != null)
            {
                int cotizacionID = (int)Session["cotizacionID"];
                ViewBag.UbicacionList        = _AseguradoService.FindCatalogoUbicaciones(cotizacionID);
                ViewBag.TipoBeneficiarioList = _CatalogoService.AllTableData((int)enumTable.TipoBeneficiario);
                ViewBag.BeneficiariosNumber  = _AseguradoService.GetNumberBenefbyCotizacion(cotizacionID);
                ViewBag.RFC = _CotizacionService.FindRFCCotizacionbyID(cotizacionID);

                Cotizacion cot = _CotizacionService.FindCotizacionLogbyID(cotizacionID);
                if (cot.bk_te_CotizacionLog.ToList().Exists(x => x.isOK.Value))
                {
                    ViewBag.isEnable = false;
                }
                else
                {
                    ViewBag.isEnable = true;
                }


                ViewBag.ListaAseguradoDiferencias = _AseguradoService.GetDiferenciaAsegurado(cot.AseguradoID);
                ViewBag.ErrorNroBeneficiarios     = MessagesValidation.Error(cot.ErrorMaxBeneficiario());
                return(View(cot));
            }
            return(View());
        }
        public async Task <IActionResult> Edit(int id, [Bind("ID,nombreCliente,nombreProductor,fechaCreacion,fechaValidez,descripcion,costo,total,estado,PersonaRut")] Cotizacion cotizacion)
        {
            if (id != cotizacion.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(cotizacion);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CotizacionExists(cotizacion.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["PersonaRut"] = new SelectList(_context.Personas, "Rut", "Rut", cotizacion.PersonaRut);
            return(View(cotizacion));
        }
Example #27
0
 public void add(Cotizacion cotizacion)
 {
     // Guardo cotizaciones en el contexto
     CotizacionesContext.Cotizaciones.Add(cotizacion);
     // Guardo los cambios
     CotizacionesContext.SaveChanges();
 }
Example #28
0
        public async Task <IActionResult> Edit(int id, [Bind("ID,fechaModificacion,fechaCreacion,requisitos")] Cotizacion cotizacion)
        {
            if (id != cotizacion.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(cotizacion);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CotizacionExists(cotizacion.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(cotizacion));
        }
        public ActionResult CrearCotizacion(bool manual, int solicitudId = 0)
        {
            if (Session["Rol"] == null)
            {
                return(RedirectToAction("IniciarSesion", "Login"));
            }

            if (Session["TiendaId"] == null)
            {
                return(RedirectToAction("IniciarSesion", "Login"));
            }

            Tienda tienda = ObtenerTienda();

            Cotizacion cotizacion = new Cotizacion();

            cotizacion.Manual = manual;

            if (!manual)
            {
                cotizacion = CompletarCotizacionConSolicitud(solicitudId, cotizacion);
            }

            List <Categoria> categorias = db.Categorias.Where(c => c.TipoCategoria == Categoria.CategoriaTipo.Servicio).ToList();

            ViewBag.CategoriaId = new SelectList(categorias, "Id", "NombreCategoria");

            List <LogoRemitente> logosRemitentes = tienda.LogosRemitente.ToList();

            ViewBag.LogoRemitenteId = new SelectList(logosRemitentes, "Id", "Nombre");

            return(View(cotizacion));
        }
    public static int AltaCotizacion(Cotizacion c)
    {
        SqlConnection cnn      = new SqlConnection(Conexion.STR);
        string        consulta = "AltaCotizacion";
        SqlCommand    cmd      = new SqlCommand(consulta, cnn);

        cmd.CommandType = CommandType.StoredProcedure;
        int          afectados = -1;
        SqlParameter retorno   = new SqlParameter("retorno", SqlDbType.Int);

        retorno.Direction = ParameterDirection.ReturnValue;
        cmd.Parameters.Add(retorno);
        cmd.Parameters.AddWithValue("@fecha", c.Fecha);
        cmd.Parameters.AddWithValue("@dolar", c.Dolar);
        cmd.Parameters.AddWithValue("@euro", c.Euro);
        try
        {
            cnn.Open();
            cmd.ExecuteNonQuery();
            afectados = (int)cmd.Parameters["retorno"].Value;
            return(afectados);
        }
        catch (Exception err)
        {
            throw new Exception("!!Problemas " + err.Message);
        }
        finally
        {
            cnn.Close();
        }
    }
        private void rptArticulosApartados_ItemClick(object sender, ItemClickEventArgs e)
        {
            Cotizacion dsCotizacion=new Cotizacion();
            var art = new EmpeñosDC(new clsConeccionDB().StringConn()).DetalleVentas.Where(
                                    v => v.Venta.Estado == "Apartado")
                .Select(
                    vta =>
                        new
                        {
                            vta.CveArticulo,
                            vta.Articulo.Descripcion,
                            vta.Articulo.Kilates,
                            vta.Articulo.Peso,
                            vta.PrecioCompra,
                            Abonos = vta.Venta.PagosVentas.Sum(pg => (decimal?)pg.Abono)??0,
                            SaldoActual = vta.Venta.Saldo - (vta.Venta.PagosVentas.Where(pg=>pg.Estado).Sum(pg => (decimal?)pg.Abono) ?? 0),
                            registro=vta.Venta.Usuario.Nombre,
                        });//.Select(vta => vta.Saldo - (vta.PagosVentas.Where(pv => pv.Estado).Sum(pv => pv.Abono))).Sum();

            foreach (var dt in art)
            {
                dsCotizacion.Tables["ArticulosApartados"].Rows.Add(new object[]
                {dt.CveArticulo, dt.Descripcion, dt.Peso, dt.Kilates, dt.PrecioCompra, dt.SaldoActual, dt.registro});
            }
            if (art.Any())
            {
                XrptArticulosApartados articulos = new XrptArticulosApartados { DataSource = dsCotizacion.Tables["ArticulosApartados"], SaldoArticulosPartados = { Value = art.Sum(s => s.SaldoActual) } };
                articulos.ShowPreviewDialog();
            }
            else
                XtraMessageBox.Show("No hay suficientes datos para mostrar el reporte", "Registros 0");
        }
        public List<Cotizacion> CotizacionPorEjecutivo(int IdEjecutivo, string FechaInicio, string FechaFin)
        {
            InicializaConexion();
            List<Cotizacion> listaCotizaciones = new List<Cotizacion>();

            sqlDataAdapter.SelectCommand = new SqlCommand("ReporteCotizaciones", sqlConnection);
            sqlDataAdapter.SelectCommand.CommandType = CommandType.StoredProcedure;

            sqlDataAdapter.SelectCommand.Parameters.Add("@ID", SqlDbType.Int).Value = IdEjecutivo;
            sqlDataAdapter.SelectCommand.Parameters["@ID"].Direction = ParameterDirection.Input;
            
            sqlDataAdapter.SelectCommand.Parameters.Add("@Oper", SqlDbType.Int).Value = 1;
            sqlDataAdapter.SelectCommand.Parameters["@Oper"].Direction = ParameterDirection.Input;

            if (FechaInicio == "")
            {
                sqlDataAdapter.SelectCommand.Parameters.Add("@Fecha_Ini", SqlDbType.DateTime).Value = DBNull.Value;
                sqlDataAdapter.SelectCommand.Parameters["@Fecha_Ini"].Direction = ParameterDirection.Input;
            }
            else
            {
                
                sqlDataAdapter.SelectCommand.Parameters.Add("@Fecha_Ini", SqlDbType.DateTime).Value = Convert.ToDateTime(FechaInicio+" 00:00");
                sqlDataAdapter.SelectCommand.Parameters["@Fecha_Ini"].Direction = ParameterDirection.Input;
            }

            if (FechaFin == "")
            {
                
                sqlDataAdapter.SelectCommand.Parameters.Add("@Fecha_Fin", SqlDbType.DateTime).Value = DBNull.Value;
                sqlDataAdapter.SelectCommand.Parameters["@Fecha_Fin"].Direction = ParameterDirection.Input;
            }
            else
            {
                sqlDataAdapter.SelectCommand.Parameters.Add("@Fecha_Fin", SqlDbType.DateTime).Value = Convert.ToDateTime(FechaFin+" 23:59");
                sqlDataAdapter.SelectCommand.Parameters["@Fecha_Fin"].Direction = ParameterDirection.Input;
            }

            sqlDataAdapter.Fill(ds, "ReporteCotizaciones");

            foreach (DataRow dr in ds.Tables["ReporteCotizaciones"].Rows)
            {

                Cotizacion tmp = new Cotizacion();
                
                tmp.IdCotizacion = Convert.ToString(dr["Id_Cotiza"]);
                tmp.NoSocio= Convert.ToString(dr["No_Socio"]);
                tmp.NombreSocio = Convert.ToString(dr["Socio"]);
                tmp.Marca = Convert.ToString(dr["Marca"]);
                tmp.Modelo = Convert.ToString(dr["Modelo"]);
                tmp.Ano = Convert.ToString(dr["Ano"]);
                tmp.Fecha = Convert.ToString(dr["Fecha_Cot"]);
                tmp.Status = Convert.ToString(dr["Estado"]);

                listaCotizaciones.Add(tmp);
            }

            FinalizaConexion();
            return listaCotizaciones;
        }