public ActionResult Crear([Bind(Include = "TipoMovimientoID,Nombre,Status")] TipoMovimiento tipoMovimiento)
        {
            //validar el nombre
            var tmov = db.TipoMovimientos.Select(a => new { a.Nombre, a.TipoMovimientoID }).FirstOrDefault(a => a.Nombre == tipoMovimiento.Nombre);

            if (tmov != null)
            {
                ModelState.AddModelError("Nombre", "Nombre ya existe.");
            }


            if (ModelState.IsValid)
            {
                tipoMovimiento.TipoMovimientoID = Guid.NewGuid();
                db.TipoMovimientos.Add(tipoMovimiento);
                db.SaveChanges();

                AlertaSuccess(string.Format("Tipo de Movimiento: <b>{0}</b> creado.", tipoMovimiento.Nombre), true);

                string url = Url.Action("Lista", "TipoMovimiento");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Crear", tipoMovimiento));
        }
示例#2
0
        //obtener datos para los combobox del tipo de movimiento
        public List <TipoMovimiento> llenarComboTipoMovimiento()
        {
            tipoMovimientoList = new List <TipoMovimiento>();

            try
            {
                string sComando = string.Format("SELECT id_tipo_movimiento, nombre_tipo_movimiento, signo " +
                                                "FROM tipos_movimientos;");

                OdbcDataReader reader = transaccion.ConsultarDatos(sComando);

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        TipoMovimiento tipoMovimientottmp = new TipoMovimiento();
                        tipoMovimientottmp.ID_TIPO_MOVIMIENTO     = reader.GetInt32(0);
                        tipoMovimientottmp.NOMBRE_TIPO_MOVIMIENTO = reader.GetString(1);
                        tipoMovimientottmp.SIGNO = reader.GetChar(2);
                        tipoMovimientoList.Add(tipoMovimientottmp);
                    }
                }
                return(tipoMovimientoList);
            }
            catch (OdbcException ex)
            {
                mensaje = new Mensaje("Error en la operacion con la Base de Datos: \n" + ex.Message);
                mensaje.Show();
                return(null);
            }

            return(null);
        }
示例#3
0
        public ActionResult Create(TipoMovimiento tipoMovimiento)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    db.Add(tipoMovimiento);
                    TempData["MessageViewBagName"] = new GenericMessageViewModel
                    {
                        Message     = "Registro agregado a la base de datos.",
                        MessageType = GenericMessages.success
                    };
                    return(RedirectToAction("Index"));
                }
                catch (Exception ex)
                {
                    TempData["MessageViewBagName"] = new GenericMessageViewModel
                    {
                        Message         = ex.Message,
                        MessageType     = GenericMessages.danger,
                        ConstantMessage = true
                    };
                }
            }

            return(View(tipoMovimiento));
        }
示例#4
0
        public ActionResult Create(TipoMovimiento TipoMovimiento)
        {
            try
            {
                // TODO: Add insert logic here
                var result = process.Agregar(TipoMovimiento);
                TempData["MessageViewBagName"] = new GenericMessageViewModel
                {
                    Message     = "Registro agregado a la base de datos.", // orivle
                    MessageType = GenericMessages.success
                };

                return(RedirectToAction("Index"));
            }
            catch (Exception ex)
            {
                TempData["MessageViewBagName"] = new GenericMessageViewModel
                {
                    Message         = ex.Message,
                    MessageType     = GenericMessages.danger,
                    ConstantMessage = true
                };

                return(View(TipoMovimiento));
            }
        }
示例#5
0
        //obtener datos para los combobox de cotizaciones segun proveedor
        public List <TipoMovimiento> llenarComboTipoMovimiento(int id_proveedor)
        {
            List <TipoMovimiento> tipoMovimientoList = new List <TipoMovimiento>();

            try
            {
                string sComando = string.Format("SELECT id_cotizacion_encabezado, nombre_cotizacion " +
                                                "FROM cotizaciones_encabezado " +
                                                "WHERE id_proveedor = {0}" +
                                                "AND fecha_caducidad > NOW();");

                OdbcDataReader reader = transaccion.ConsultarDatos(sComando);

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        TipoMovimiento tipoMovimientottmp = new TipoMovimiento();
                        tipoMovimientottmp.ID_TIPO_MOVIMIENTO     = reader.GetInt32(0);
                        tipoMovimientottmp.NOMBRE_TIPO_MOVIMIENTO = reader.GetString(1);
                        tipoMovimientottmp.SIGNO = reader.GetChar(2);
                        tipoMovimientoList.Add(tipoMovimientottmp);
                    }
                }
                return(tipoMovimientoList);
            }
            catch (OdbcException ex)
            {
                mensaje = new Mensaje("Error en la operacion con la Base de Datos: \n" + ex.Message);
                mensaje.Show();
                return(null);
            }
        }
示例#6
0
        public ActionResult DeleteConfirmed(int id)
        {
            TipoMovimiento tipoMovimiento = db.Find(id);

            db.Remove(tipoMovimiento);
            return(RedirectToAction("Index"));
        }
示例#7
0
        public async Task <IActionResult> PutTipoMovimiento(int id, TipoMovimiento tipoMovimiento)
        {
            if (id != tipoMovimiento.Id)
            {
                return(BadRequest());
            }

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

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

            return(NoContent());
        }
示例#8
0
        public async Task <ActionResult <TipoMovimiento> > PostTipoMovimiento(TipoMovimiento tipoMovimiento)
        {
            _context.TipoMovimientos.Add(tipoMovimiento);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetTipoMovimiento", new { id = tipoMovimiento.Id }, tipoMovimiento));
        }
示例#9
0
 /// <summary>
 /// Metodo Para Obtener lo el animal de reimplante
 /// </summary>
 internal ReimplanteInfo ObtenerAreteIndividual(AnimalInfo animalInfo, TipoMovimiento corte)
 {
     try
     {
         Logger.Info();
         var            parameters = AuxReimplante.ObtenerParametrosObtenerAreteIndividual(animalInfo, corte);
         var            ds         = Retrieve("ReimplanteGanado_ObtenerArete", parameters);
         ReimplanteInfo result     = null;
         if (ValidateDataSet(ds))
         {
             result = MapReimplanteDAL.ObtenerAreteIndividual(ds);
         }
         return(result);
     }
     catch (SqlException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (DataException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
 public Boolean Post(ref string error, UsuarioDto usuario, TipoMovimiento tipoMovimiento)
 {
     if (tipoMovimiento == null)
     {
         error = "El tipo de movimiento no puede ser vacio.";
         return(false);
     }
     if (tipoMovimiento.Codigo.ToString().Length == 0)
     {
         error = "El codigo de tipo de movimiento  no puede ser vacio.";
         return(false);
     }
     this._contexto.TiposMovimiento.Add(tipoMovimiento);
     try
     {
         this._contexto.SaveChanges();
         return(true);
     }
     catch (Exception e)
     {
         this._logger.EscribirError(e.ToString());
         error = "Ocurrio un error al guardar tipo de movimiento.";
         return(false);
     }
 }
        protected void bt_Buscar_Click(object sender, EventArgs e)
        {
            conque  = ddl_tipoMov.SelectedValue;
            tipoMov = iTM.getPorCriterio <TipoMovimiento>(conque).First <TipoMovimiento>();

            llenar(tipoMov.codigoTipoMov);
        }
        public ActionResult EliminarConfirmado(Guid id)
        {
            string btnValue = Request.Form["accionx"];
            string Nombre   = "";

            TipoMovimiento tipoMovimiento = db.TipoMovimientos.Find(id);

            Nombre = tipoMovimiento.Nombre;

            switch (btnValue)
            {
            case "deshabilitar":
                tipoMovimiento.Status          = false;
                db.Entry(tipoMovimiento).State = EntityState.Modified;
                db.SaveChanges();
                AlertaDefault(string.Format("Se deshabilito <b>{0}</b>", Nombre), true);
                break;

            case "eliminar":
                db.TipoMovimientos.Remove(tipoMovimiento);
                db.SaveChanges();
                AlertaDanger(string.Format("Se elimino <b>{0}</b>", Nombre), true);
                break;

            default:
                AlertaDanger(string.Format("Ocurrio un error."), true);
                break;
            }

            string url = Url.Action("Lista", "TipoMovimiento");

            return(Json(new { success = true, url = url }));
        }
 public TipoMovimientoViewModel(TipoMovimiento model)
 {
     _TipoMovimientoId = model.TipoMovimientoId;
     _Codigo           = model.Codigo;
     _Nombre           = model.Nombre;
     _Descripcion      = model.Descripcion;
 }
 public Boolean Put(ref string error, TipoMovimiento tipoMovimiento)
 {
     if (tipoMovimiento == null)
     {
         error = "El tipo de movimiento no puede ser vacio.";
         return(false);
     }
     if (tipoMovimiento.Codigo.ToString().Length == 0)
     {
         error = "El codigo de tipo de movimiento  no puede ser vacio.";
         return(false);
     }
     this._contexto.Entry(tipoMovimiento).State = EntityState.Modified;
     try
     {
         this._contexto.SaveChanges();
         return(true);
     }
     catch (Exception e)
     {
         this._logger.EscribirError(e.ToString());
         error = "Ocurrio un error al guardar tipo de movimiento.";
         return(false);
     }
 }
        public ActionResult Editar([Bind(Include = "TipoMovimientoID,Nombre,Status")] TipoMovimiento tipoMovimiento)
        {
            //validar el nombre
            var tmov = db.TipoMovimientos.Select(a => new { a.Nombre, a.TipoMovimientoID }).FirstOrDefault(a => a.Nombre == tipoMovimiento.Nombre);

            if (tmov != null)
            {
                if (tmov.TipoMovimientoID != tipoMovimiento.TipoMovimientoID)
                {
                    ModelState.AddModelError("Nombre", "Nombre ya existe.");
                }
            }



            if (ModelState.IsValid)
            {
                db.Entry(tipoMovimiento).State = EntityState.Modified;
                db.SaveChanges();

                AlertaInfo(string.Format("Tipo de Movimiento: <b>{0}</b> se editó.", tipoMovimiento.Nombre), true);
                string url = Url.Action("Lista", "TipoMovimiento");
                return(Json(new { success = true, url = url }));
            }

            return(PartialView("_Editar", tipoMovimiento));
        }
示例#16
0
 public LineaAsientoContable(
     Cuenta cuenta, int importe, TipoMovimiento columna)
 {
     this._cuenta  = cuenta;
     this._importe = importe;
     this._columna = columna;
 }
示例#17
0
        public async Task <IHttpActionResult> Create(TipoMovimiento tipoMovimiento)
        {
            try
            {
                var result = new AjaxResult();

                var tipoMovTemp = await db.TipoActividades.Where(u => u.TipoActividadID == tipoMovimiento.TipoMovimientoID).FirstOrDefaultAsync();

                if (tipoMovTemp == null)
                {
                    db.TipoMovimientos.Add(tipoMovimiento);
                    await db.SaveChangesAsync();

                    AddLog("", tipoMovimiento.TipoMovimientoID, tipoMovimiento);
                }
                else
                {
                    return(Ok(result.False("Type of movements already exists")));
                }


                return(Ok(result.True()));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
示例#18
0
        //obtener el tipo de movimiento para el ingreso de movimiento
        public TipoMovimiento obtenerTipoMovimiento(int id_tipo_movimiento)
        {
            tipoMovimiento = new TipoMovimiento();

            try
            {
                string sComando = string.Format("SELECT id_tipo_movimiento, nombre_tipo_movimiento, signo " +
                                                "FROM tipos_movimientos " +
                                                "WHERE id_tipo_movimiento = {0} ;",
                                                id_tipo_movimiento);

                OdbcDataReader reader = transaccion.ConsultarDatos(sComando);

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        tipoMovimiento.ID_TIPO_MOVIMIENTO     = reader.GetInt32(0);
                        tipoMovimiento.NOMBRE_TIPO_MOVIMIENTO = reader.GetString(1);
                        tipoMovimiento.SIGNO = reader.GetChar(2);
                    }
                }
                return(tipoMovimiento);
            }
            catch (OdbcException ex)
            {
                mensaje = new Mensaje("Error en la operacion con la Base de Datos: \n" + ex.Message);
                mensaje.Show();
                return(null);
            }
        }
示例#19
0
        public TipoMovimiento BuscarPorId(int id)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            tipoMovimientoDAC = new TipoMovimientoDAC();

            result = tipoMovimientoDAC.ReadBy(id);
            return(result);
        }
示例#20
0
        /// <summary>
        /// Constructor movimiento
        /// </summary>
        /// <param name="pId"></param>
        /// <param name="pFecha"></param>
        /// <param name="pTipoMovimiento"></param>
        public Movimiento(int pId, DateTime pFecha, TipoMovimiento pTipoMovimiento)
        {
            Id             = pId;
            Fecha          = DateTime.Today.Date;
            TipoMovimiento = pTipoMovimiento;

            this.LineaMovimientos = new List <LineaMovimiento>();
        }
示例#21
0
        public TipoMovimiento Agregar(TipoMovimiento tipoMovimiento)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            tipoMovimientoDAC = new TipoMovimientoDAC();

            result = tipoMovimientoDAC.Create(tipoMovimiento);
            return(result);
        }
        public TipoMovimiento Create(TipoMovimiento TipoMovimiento)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            TipoMovimientoDAC = new TipoMovimientoDAC();

            result = TipoMovimientoDAC.Create(TipoMovimiento);
            return(result);
        }
        public TipoMovimiento GetByID(int ID)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            TipoMovimientoDAC = new TipoMovimientoDAC();

            result = TipoMovimientoDAC.ReadBy(ID);
            return(result);
        }
示例#24
0
        public TipoMovimiento Eliminar(int id)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            tipoMovimientoDAC = new TipoMovimientoDAC();

            result = tipoMovimientoDAC.ReadBy(id);
            tipoMovimientoDAC.Delete(id);
            return(result);
        }
示例#25
0
 public ActionResult Edit(TipoMovimiento tipoMovimiento)
 {
     if (ModelState.IsValid)
     {
         db.Edit(tipoMovimiento);
         return(RedirectToAction("Index"));
     }
     return(View(tipoMovimiento));
 }
        public ActionResult DeleteConfirmed(int id)
        {
            var p = new TipoMovimientoApiProcess();

            TipoMovimiento tipoMovimiento = p.ReadBy(id);

            p.Delete(tipoMovimiento);
            return(RedirectToAction("Index"));
        }
示例#27
0
        public TipoMovimiento Editar(TipoMovimiento tipoMovimiento)
        {
            TipoMovimiento result            = default(TipoMovimiento);
            var            tipoMovimientoDAC = new TipoMovimientoDAC();

            tipoMovimientoDAC.Update(tipoMovimiento);
            result = tipoMovimiento;
            return(result);
        }
        public ActionResult Crear()
        {
            var tmov = new TipoMovimiento()
            {
                Status = true
            };

            return(PartialView("_Crear", tmov));
        }
示例#29
0
        public TipoMovimiento Agregar(TipoMovimiento tipoMovimiento)
        {
            // TODO: Completar *************esto toque GABY
            var bc = new TipoMovimientoComponent();

            return(bc.Agregar(tipoMovimiento));

            throw new NotImplementedException();
        }
 public ActionResult Edit(TipoMovimiento tipoMovimiento)
 {
     if (ModelState.IsValid)
     {
         var p = new TipoMovimientoApiProcess();
         p.Update(tipoMovimiento);
         return(RedirectToAction("Index"));
     }
     return(View(tipoMovimiento));
 }
        public void crearTipoMov(object sender, EventArgs e)
        {
            try
            {
                numerogenerado = generarCodigo();
                tipoM = new TipoMovimiento();
                tipoM.codigoTipoMov = numerogenerado;
                tipoM.descripcionTipoMov = txt_descripcionTM.Text;
                tipoM.tipo = ddl_tipoMov.SelectedValue;

                iTM.save<TipoMovimiento>(tipoM);

                txt_descripcionTM.Text = "";

                String msj = "El tipo de movimiento ha sido creado correctamente";
                Intermediario.confirmarCambios();
                this.Page.Response.Write("<script language='JavaScript'>window.alert('" + msj + "');</script>");

            }
            catch (Exception) { }
        }
        //Busca los stockMovimientos asociados a ese lote
        //Si existen stockMedicamentos-->Actualizar ese stock existente
        //Si no existe stockMedicamento-->Crear un nuevo stockMedicamento e indicarle el stock
        //Guarda el movimiento generado con todos sus detalles
        protected void bt_guardar_Click(object sender, EventArgs e)
        {
            try
            {
                numerogenerado = generarCodigo();
                String tipoM = ddl_tipoMovE.SelectedValue;
                //Busca el tipo de movimiento seleccionado
                tipoMov = iTM.getPorCriterio<TipoMovimiento>(tipoM).First<TipoMovimiento>();
                //Crea el movimiento
                DetalleMovimientoStock f;
                MovimientoStock movimiento = new MovimientoStock();
                IList<StockMedicamento> stockM;

                //Generaciòn del movimiento
                movimiento.fechaMovimiento = DateTime.Now.Date;
                movimiento.nroMovimiento = numerogenerado; // generarCodigo();
                //Este tipo=1 indica que son movimienots de tipo entrada
                movimiento.tipoMovimiento = tipoMov.codigoTipoMov;
                movimiento.nroComprobante = int.Parse(txt_comprobante.Text);

                //Guarda el movimiento de stock
                iMovStk.save<MovimientoStock>(movimiento);
                Intermediario.confirmarCambios();

                DataTable dt = Session["DataTableMovimientosE"] as DataTable;

                //Guarda los elementos de la grilla--crea un detalle para cada uno

                foreach (DataRow row in dt.Rows)
                {

                    f = new DetalleMovimientoStock();
                    f.codigoMedicamento = Convert.ToInt32(row["codigo"]);
                    f.cantidad = Convert.ToInt32(row["cantidad"]);
                    f.nroLote = Convert.ToInt32(row["lote"]);
                    f.codDetalle = generarCodigoDetalles();
                    f.nroMovimiento = movimiento.nroMovimiento;
                    iDetMovStk.save<DetalleMovimientoStock>(f);
                    Intermediario.confirmarCambios();

                    //Busca el stock actual para el codigo seleccionado

                    stockM = iStockM.getCriterioById<StockMedicamento>("", "", Convert.ToInt32(Convert.ToInt32(row["codigo"])));
                    //Verifica si tiene creado stock para ese lote
                    if (stockM.Count == 0)
                    {
                        stockNuevo = new StockMedicamento();
                        stockNuevo.codigoMedicamento = Convert.ToInt32(row["codigo"]);
                        stockNuevo.codigoStock = generarCodigoStock();
                        stockNuevo.stockActual = Convert.ToInt32(row["cantidad"]);
                        stockNuevo.lote = Convert.ToInt32(row["lote"]);

                        iStockM.save<StockMedicamento>(stockNuevo);

                    }
                    else
                    {

                        StockMedicamento stockMed = stockM.First<StockMedicamento>();   // = iStockM.getCriterioById<StockMedicamento>("", "", Convert.ToInt32(Convert.ToInt32(row["codigo"]))).First<StockMedicamento>();
                        stockMed.stockActual = stockMed.stockActual + Convert.ToInt32(row["cantidad"]);
                        iStockM.Update<StockMedicamento>(stockMed);

                    }

                    Intermediario.confirmarCambios();
                }


                msj = "El Movimiento ha sido creado correctamente, con el nro: " + numerogenerado;

                Session["DataTableMovimientosE"] = null;

                txt_comprobante.Text = "";
                txt_cantidad.Text = "";
                txt_descripcionMed.Text = "";
                txt_codigoMed.Text = "";
                txt_lote1.Text = "";
                panelMedicamento.Visible = false;
                panel_grilla.Visible = false;
                gv_Movimientos.Visible = false;
                bt_Nuevo.Visible = false;
                bt_cancel.Visible = false;
                bt_guardar.Visible = false;
                bt_cancelar.Visible = false;
                ddl_lotes.Items.Clear();
                ddl_medicamentos.Items.Clear();
                //ddl_tipoMovE.Items.Clear();

                mostrarMensaje(msj);
            }

            catch (Exception) { }
        }
示例#33
0
        protected void Page_Load(object sender, EventArgs e)
        {
            listaMedicamentos = iStockMed.getAll<StockMedicamento>();
            tipito=iTipo.getPorCriterio<TipoMovimiento>("Vencimiento").First<TipoMovimiento>();
            vencidos.nroMovimiento = generarCodigo();
            vencidos.fechaMovimiento = DateTime.Today;
            vencidos.nroComprobante = 0;
            vencidos.tipoMovimiento = tipito.codigoTipoMov;

            iMovStk.save<MovimientoStock>(vencidos);

            mensajes.Columns.Add("codigo");
            mensajes.Columns.Add("descripcion");
            mensajes.Columns.Add("mensaje");
            mensajes.Columns.Add("fecha");
            mensajes.Columns.Add("lote");

            //            int det = generarCodigoDetalles();

            foreach (StockMedicamento m in listaMedicamentos)
            {
                Lote lote = iLote.getCriterioById<Lote>("", "", Convert.ToInt32(m.lote)).First<Lote>();
                Medicamento remedio = iMedicamento.getCriterioById<Medicamento>("", "", Convert.ToInt32(m.codigoMedicamento)).First<Medicamento>();
                DataRow fila = mensajes.NewRow();
                dif = DateTime.Today.Subtract(Convert.ToDateTime(lote.fechaVto));

                if (m.fechaBaja == null)
                {
                    //VERIFICAR CUANDO EL MEDICAMENTO YA ESTÉ VENCIDO
                    if (-(dif.Days) <= remedio.diasAlertas)
                    {
                        //Agregar el mensaje a un dto mensaje
                        //msj=new DtoMensaje();

                        //Si la fecha es igual o menor a la fecha de hoy le doy de baja
                        if (lote.fechaVto <= DateTime.Today)
                        {
                            m.fechaBaja = DateTime.Today;
                            iStockMed.Update<StockMedicamento>(m);

                            fila["codigo"] = m.codigoMedicamento;
                            fila["descripcion"] = remedio.descripcion;
                            fila["fecha"] = lote.fechaVto.ToString();
                            fila["mensaje"] = "El medicamento con cód: " + m.codigoMedicamento + " está vencido. Fue dado de baja.";
                            fila["lote"] = "Pertenece al lote: " + lote.nroLote;

                            detalle = new DetalleMovimientoStock();
                            detalle.codDetalle = generarCodigoDetalles();
                            detalle.cantidad = Convert.ToInt32(m.stockActual);
                            detalle.codigoMedicamento = m.codigoMedicamento;
                            detalle.nroMovimiento = vencidos.nroMovimiento;
                            detalle.nroLote = m.lote;

                            iDetMovStk.save<DetalleMovimientoStock>(detalle);

                        }
                        else
                        {
                            fila["codigo"] = m.codigoMedicamento;
                            fila["descripcion"] = remedio.descripcion;
                            fila["fecha"] = lote.fechaVto.ToString();
                            fila["mensaje"] = "Faltan " + Convert.ToInt32(-dif.Days) + " días para que el medicamento se venza";
                            fila["lote"] = "Pertenece al lote: " + lote.nroLote;
                        }
                        mensajes.Rows.Add(fila);

                    }

                }

            }

            Intermediario.confirmarCambios();

            if (mensajes.Rows.Count > 0)
            {
                panelMensajes.Visible = true;
                grillaMsjs.DataSource = mensajes;
                grillaMsjs.DataBind();
                grillaMsjs.Visible = true;
            }
        }
示例#34
0
        //Guarda el movimiento generado con todos sus detalles. Actualiza el stock
        protected void bt_guardar_Click(object sender, EventArgs e)
        {
            try
            {
                    numerogenerado = generarCodigo();

                    String tipoM = ddl_tipMov.SelectedValue;
                    tipoMov = iTM.getPorCriterio<TipoMovimiento>(tipoM).First<TipoMovimiento>();

                    DetalleMovimientoStock f;
                    MovimientoStock movimiento = new MovimientoStock();

                    StockMedicamento stockM;
                    stockM = new StockMedicamento();

                    //guarda la cabecera el movimiento
                    movimiento.fechaMovimiento = DateTime.Now.Date;
                    movimiento.nroMovimiento = numerogenerado;
                    movimiento.tipoMovimiento = tipoMov.codigoTipoMov;
                    movimiento.nroComprobante = int.Parse(txt_comprobante.Text);

                    iMovStk.save<MovimientoStock>(movimiento);
                    Intermediario.confirmarCambios();

                    // guarda los detalles del movimiento
                    DataTable dt = Session["DataTableMovimientos"] as DataTable;
                    foreach (DataRow row in dt.Rows) {

                        f= new DetalleMovimientoStock();
                        f.codigoMedicamento = Convert.ToInt32(row["codigo"]);
                        f.cantidad = Convert.ToInt32(row["cantidad"]);
                        f.nroLote = Convert.ToInt32(row["lote"]);
                        f.codDetalle = generarCodigoDetalles();
                        f.nroMovimiento = movimiento.nroMovimiento;
                        iDetMovStk.save<DetalleMovimientoStock>(f);
                        Intermediario.confirmarCambios();

                        stockM = iStockM.getCriterioById<StockMedicamento>("", "", Convert.ToInt32(Convert.ToInt32(row["codigo"]))).First<StockMedicamento>();
                        listaStkM1 = iStockM.getCriterioById<StockMedicamento>("", "", Convert.ToInt32(Convert.ToInt32(row["codigo"])));

                        //actualiza el stock del medicamento
                        foreach (StockMedicamento stk in listaStkM1)
                        {
                            if (stk.lote == Convert.ToInt32(Convert.ToInt32(row["lote"])))
                            {
                                stk.stockActual = stk.stockActual - Convert.ToInt32(row["cantidad"]);

                                if (stk.stockActual == 0) msj = "Algunos Medicamentos quedaron con stock en cero. ";

                                iStockM.Update<StockMedicamento>(stk);
                                Intermediario.confirmarCambios();
                                mostrarMensaje(msj);
                            }

                        }
                }

                msj = "El Movimiento ha sido creado correctamente, con el nro: " + numerogenerado ;
                mostrarMensaje(msj);

                //limpia variables y pantalla
                txt_comprobante.Text = "";
                txt_cantidad.Text = "";
                txt_descripcionMed.Text = "";
                txt_codigoMed.Text = "";
                txt_lote1.Text = "";
                panelMedicamento.Visible = false;
                panel_grilla.Visible = false;
                gv_Movimientos.Visible = false;
                bt_guardar.Visible = false;
                bt_cancelar.Visible = false;

            }

            catch (Exception) { }
        }