Ejemplo n.º 1
0
        public ActionResult Accesorio_Borrar(int codAccesorioModelo, int codModelo)
        {
            try
            {
                ServicioSistema <Modelo> .BeginTransaction();

                Modelo modelo = ServicioSistema <Modelo> .GetById(m => m.CodModelo == codModelo);

                AccesorioModelo accesorioModelo = modelo.Accesorios.FirstOrDefault <AccesorioModelo>(am => am.CodAccesorioModelo == codAccesorioModelo);

                if (accesorioModelo != null)
                {
                    modelo.Accesorios.Remove(accesorioModelo);

                    ServicioSistema <AccesorioModelo> .Delete(am => am.CodAccesorioModelo == codAccesorioModelo);

                    ServicioSistema <Modelo> .SaveOrUpdate(modelo);
                }

                ServicioSistema <Modelo> .CommitTransaction();

                ModelState.Clear();

                return(RedirectToAction("Accesorio_Lista", new { codModelo = codModelo }));
                //return Url.Action("Accesorios", new { codModelo = codModelo });
                //return Accesorios(codModelo);
            }
            catch (Exception ex)
            {
                ServicioSistema <Modelo> .RollbackTransaction();

                //ServicioSistema<AccesorioModelo>.RollbackTransaction();
                throw ex;
            }
        }
Ejemplo n.º 2
0
        public ActionResult Imagen_Editar(int codImagenModelo, int codModelo, ImagenModelo imagenModeloPost)
        {
            try
            {
                ServicioSistema <ImagenModelo> .BeginTransaction();

                ImagenModelo imagenModelo = ServicioSistema <ImagenModelo> .GetById(im => im.CodImagenModelo == codImagenModelo);

                if (imagenModelo != null)
                {
                    imagenModelo.Nombre              = imagenModeloPost.Nombre;
                    imagenModelo.ClaseCSSTitulo      = imagenModeloPost.ClaseCSSTitulo;
                    imagenModelo.Bajada              = imagenModeloPost.Bajada;
                    imagenModelo.MostrarEnHome       = imagenModeloPost.MostrarEnHome;
                    imagenModelo.MostrarEnAccesoHome = imagenModeloPost.MostrarEnAccesoHome;
                    imagenModelo.Vigente             = imagenModeloPost.Vigente;
                    imagenModelo = ServicioSistema <ImagenModelo> .SaveOrUpdate(imagenModelo);
                }

                ServicioSistema <ImagenModelo> .CommitTransaction();

                return(RedirectToAction("Imagen_Lista", new { codModelo = codModelo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <ImagenModelo> .RollbackTransaction();

                throw ex;
            }
        }
Ejemplo n.º 3
0
        public ActionResult Caracteristica_Crear(CaracteristicaModelo caracteristicaModeloPost)
        {
            try
            {
                ServicioSistema <CaracteristicaModelo> .BeginTransaction();

                CaracteristicaModelo caracteristicaModelo = new CaracteristicaModelo();
                dynamic caracteristicasModelo             = new ExpandoObject();

                //Esta es la versión del modelo a la que se agregará la caractrística
                VersionModelo versionModelo = ServicioSistema <VersionModelo> .GetById(v => v.CodVersionModelo == caracteristicaModeloPost.Versiones[0].CodVersionModelo);

                //1º busco si existe la carcterística
                CaracteristicaModelo caracteristicaExistente = ServicioSistema <CaracteristicaModelo> .Get(cm => cm.DesCaracteristicaModelo.ToLower() == caracteristicaModeloPost.DesCaracteristicaModelo.ToLower()).FirstOrDefault();

                //Si existe
                if (caracteristicaExistente != null)
                {
                    //Si el modelo actual no contiene esa característica, la asigno
                    if (!versionModelo.Caracteristicas.Contains <CaracteristicaModelo>(caracteristicaExistente))
                    {
                        versionModelo.Caracteristicas.Add(caracteristicaExistente);
                        versionModelo = ServicioSistema <VersionModelo> .SaveOrUpdate(versionModelo);
                    }
                }
                //Si no existe la característica, la asigno
                else
                {
                    CaracteristicaModelo caracteristicaNueva = new CaracteristicaModelo();
                    caracteristicaNueva.DesCaracteristicaModelo = caracteristicaModeloPost.DesCaracteristicaModelo;
                    caracteristicaNueva = ServicioSistema <CaracteristicaModelo> .SaveOrUpdate(caracteristicaNueva);

                    versionModelo.Caracteristicas.Add(caracteristicaNueva);
                    versionModelo = ServicioSistema <VersionModelo> .SaveOrUpdate(versionModelo);
                }

                caracteristicasModelo.Caracteristicas = versionModelo.Caracteristicas;
                caracteristicasModelo.VersionModelo   = versionModelo;

                ModelState.Clear();

                ServicioSistema <CaracteristicaModelo> .CommitTransaction();

                //return View("Caracteristica-Lista", caracteristicasModelo);
                return(RedirectToAction("Caracteristica_Lista", new { codVersion = versionModelo.CodVersionModelo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <CaracteristicaModelo> .RollbackTransaction();

                throw ex;
            }
        }
Ejemplo n.º 4
0
        public ActionResult Caracteristica_Crear_Muchas(CaracteristicaModelo caracteristicaModeloPost)
        {
            try
            {
                ServicioSistema <VersionModelo> .BeginTransaction();

                //string caracteristicas = Request.Form["txtCaractristicas"];
                //int codVersionModelo = int.Parse(Request.Form["CodVersionModelo"]);

                VersionModelo vm = ServicioSistema <VersionModelo> .GetById(v => v.CodVersionModelo == caracteristicaModeloPost.Versiones[0].CodVersionModelo);

                CaracteristicaModelo cm;

                caracteristicaModeloPost.MuchasCarcteristicas.Split('\n').ToList().ForEach(caracteristica =>
                {
                    caracteristica = caracteristica.Trim();

                    if (caracteristica != string.Empty)
                    {
                        cm = ServicioSistema <CaracteristicaModelo> .Get(c => c.DesCaracteristicaModelo.ToLower() == caracteristica.ToLower()).FirstOrDefault();

                        if (cm == null)
                        {
                            cm = new CaracteristicaModelo()
                            {
                                DesCaracteristicaModelo = caracteristica
                            };
                            cm = ServicioSistema <CaracteristicaModelo> .SaveOrUpdate(cm);
                        }

                        if (!vm.Caracteristicas.Contains <CaracteristicaModelo>(cm))
                        {
                            vm.Caracteristicas.Add(cm);
                            vm = ServicioSistema <VersionModelo> .SaveOrUpdate(vm);
                        }
                    }
                });

                ServicioSistema <VersionModelo> .CommitTransaction();

                return(RedirectToAction("Caracteristica_Lista", new { codVersion = vm.CodVersionModelo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <VersionModelo> .RollbackTransaction();
            }

            return(null);
        }
Ejemplo n.º 5
0
        public ActionResult EliminarArchivo(int CodArchivo)
        {
            try
            {
                ServicioSistema <ArchivoAutoahorro> .BeginTransaction();

                ServicioSistema <ArchivoAutoahorro> .Delete(aa => aa.CodArchivoAutoahorro == CodArchivo);

                ServicioSistema <ArchivoAutoahorro> .CommitTransaction();
            }
            catch (Exception ex)
            {
                ServicioSistema <ArchivoAutoahorro> .RollbackTransaction();
            }
            finally
            {
                ObtenerArchivosCargados();
            }

            return(RedirectToAction("CargaArchivos"));
        }
Ejemplo n.º 6
0
        public ActionResult Caracteristica_Eliminar(int codCaracteristicaModelo, int codVersionModelo)
        {
            try
            {
                ServicioSistema <CaracteristicaVersion> .BeginTransaction();

                ServicioSistema <CaracteristicaVersion> .Delete(cv => cv.CaracteristicaModelo.CodCaracteristicaModelo == codCaracteristicaModelo && cv.VersionModelo.CodVersionModelo == codVersionModelo);

                ServicioSistema <CaracteristicaVersion> .CommitTransaction();

                ModelState.Clear();

                return(RedirectToAction("Caracteristica_Lista", new { codVersion = codVersionModelo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <CaracteristicaVersion> .RollbackTransaction();

                throw ex;
            }
        }
Ejemplo n.º 7
0
        public ActionResult Accesorio_Crear(AccesorioModelo am)
        {
            try
            {
                ServicioSistema <AccesorioModelo> .BeginTransaction();

                AccesorioModelo accesorio = new AccesorioModelo();

                if (am.ImagenPosteada != null)
                {
                    using (var binaryReader = new BinaryReader(am.ImagenPosteada.InputStream))
                    {
                        accesorio.Imagen = binaryReader.ReadBytes(am.ImagenPosteada.ContentLength);
                    }
                }

                accesorio.Titulo              = am.Titulo;
                accesorio.Descripcion         = am.Descripcion;
                accesorio.MostrarEnAccesoHome = am.MostrarEnAccesoHome;
                accesorio.Vigente             = am.Vigente;
                accesorio.Modelo              = new Modelo()
                {
                    CodModelo = am.Modelo.CodModelo
                };

                accesorio = ServicioSistema <AccesorioModelo> .SaveOrUpdate(accesorio);

                ModelState.Clear();

                ServicioSistema <AccesorioModelo> .CommitTransaction();

                return(RedirectToAction("Accesorio_Lista", new { codModelo = accesorio.Modelo.CodModelo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <AccesorioModelo> .RollbackTransaction();

                throw ex;
            }
        }
Ejemplo n.º 8
0
        public ActionResult Archivo_Borrar(int codArchivoAutoahorro, int Tipo)
        {
            try
            {
                ServicioSistema <ArchivoAutoahorro> .BeginTransaction();

                string sql = string.Format("exec EliminarArchivo @CodArchivoAutoahorro = {0}", codArchivoAutoahorro);
                ServicioSistema <ArchivoAutoahorro> .ExecuteSQLQueryUniqueResult(sql);

                ServicioSistema <ArchivoAutoahorro> .CommitTransaction();

                ModelState.Clear();

                return(RedirectToAction("ListarArchivos", new { Tipo = Tipo }));
            }
            catch (Exception ex)
            {
                ServicioSistema <ArchivoAutoahorro> .RollbackTransaction();

                throw ex;
            }
        }
Ejemplo n.º 9
0
        public ActionResult Archivo_Crear(HttpPostedFileBase[] ArchivosPosteados, int Tipo)
        {
            if (Tipo == 1)
            {
                if (ArchivosPosteados.Length > 0 &&
                    ArchivosPosteados[0].ContentLength > 0)
                {
                    ArchivoAutoahorro archivoAutoahorro = new ArchivoAutoahorro();

                    archivoAutoahorro.NombreArchivo = ArchivosPosteados[0].FileName;
                    archivoAutoahorro.FechaAlta     = DateTime.Now;
                    archivoAutoahorro.Activo        = true;
                    int i = 0;

                    //string sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                    //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);

                    IList <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                    listaAutoahorro = HelperWeb.Parseo.ParseoOfertas(ArchivosPosteados[0].InputStream, ref archivoAutoahorro);

                    DateTime inicio, fin;

                    inicio = DateTime.Now;

                    try
                    {
                        if (listaAutoahorro != null)
                        {
                            ServicioSistema <AutoahorroDato> .BeginTransaction();

                            archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                            //foreach (AutoahorroDato dato in listaAutoahorro.Where(aad => ((AutoahorroOferta)aad).Concesionario == "01411").ToList())
                            foreach (AutoahorroDato dato in listaAutoahorro)
                            {
                                dato.ArchivoAutoahorro = archivoAutoahorro;
                                ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                                if (++i % 500 == 0)
                                {
                                    ServicioSistema <AutoahorroDato> .Flush();
                                }
                            }

                            archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                            ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                            ServicioSistema <AutoahorroDato> .CommitTransaction();
                        }
                        else
                        {
                            throw new ApplicationException("Error en el archivo de ofertas.");
                        }
                    }
                    catch (Exception ex)
                    {
                        ServicioSistema <AutoahorroDato> .RollbackTransaction();

                        throw ex;
                    }

                    fin = DateTime.Now;
                }
            }
            else if (Tipo == 2)
            {
                if (ArchivosPosteados.Length > 0 &&
                    ArchivosPosteados[0].ContentLength > 0)
                {
                    ArchivoAutoahorro archivoAutoahorro = new ArchivoAutoahorro();

                    archivoAutoahorro.NombreArchivo = ArchivosPosteados[0].FileName;
                    archivoAutoahorro.FechaAlta     = DateTime.Now;
                    archivoAutoahorro.Activo        = true;
                    int i = 0;

                    //string sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                    //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);

                    List <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                    listaAutoahorro = HelperWeb.Parseo.ParseoEmisiones(ArchivosPosteados[0].InputStream, ref archivoAutoahorro);

                    try
                    {
                        if (listaAutoahorro != null)
                        {
                            ServicioSistema <AutoahorroDato> .BeginTransaction();

                            foreach (AutoahorroDato dato in listaAutoahorro)
                            {
                                dato.ArchivoAutoahorro = archivoAutoahorro;
                                ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                                if (++i % 500 == 0)
                                {
                                    ServicioSistema <AutoahorroDato> .Flush();
                                }
                            }

                            archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                            ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                            ServicioSistema <AutoahorroDato> .CommitTransaction();
                        }
                        else
                        {
                            throw new ApplicationException("Error en el archivo de emisiones.");
                        }
                    }
                    catch (Exception ex)
                    {
                        ServicioSistema <AutoahorroDato> .RollbackTransaction();

                        throw ex;
                    }
                }
            }
            else if (Tipo == 3)
            {
                if (ArchivosPosteados.Length > 0 &&
                    ArchivosPosteados[0].ContentLength > 0)
                {
                    ArchivoAutoahorro archivoAutoahorro = new ArchivoAutoahorro();

                    archivoAutoahorro.NombreArchivo = ArchivosPosteados[0].FileName;
                    archivoAutoahorro.FechaAlta     = DateTime.Now;
                    archivoAutoahorro.Activo        = true;
                    int i = 0;

                    //string sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                    //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);


                    IList <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                    listaAutoahorro = HelperWeb.Parseo.ParseoGanadores(ArchivosPosteados[0].InputStream, ref archivoAutoahorro);

                    try
                    {
                        ServicioSistema <AutoahorroDato> .BeginTransaction();

                        foreach (AutoahorroDato dato in listaAutoahorro.Where(aad => ((AutoahorroGanador)aad).Concesionario == "01411").ToList())
                        {
                            dato.ArchivoAutoahorro = archivoAutoahorro;
                            ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                            if (++i % 500 == 0)
                            {
                                ServicioSistema <AutoahorroDato> .Flush();
                            }
                        }

                        archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                        ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                        ServicioSistema <AutoahorroDato> .CommitTransaction();

                        //litCantidadGanadores.Text = string.Format("{0} ganadores cargados", listaAutoahorro.Count);
                    }
                    catch (Exception ex)
                    {
                        ServicioSistema <AutoahorroDato> .RollbackTransaction();

                        throw ex;
                    }
                }
            }

            return(RedirectToAction("ListarArchivos", new { Tipo = Tipo }));
        }
Ejemplo n.º 10
0
        public ActionResult CargaArchivos(Matassi.Web.Areas.Admin.Models.ArchivosAutoahorro archivosAutoahorro)
        {
            //Proceso Ofertas de Autoahorro
            ArchivoAutoahorro archivoAutoahorro;
            string            sql;

            if (archivosAutoahorro.ArchivoOfertas != null && archivosAutoahorro.ArchivoOfertas.ContentLength > 0)
            {
                archivoAutoahorro = new ArchivoAutoahorro();

                archivoAutoahorro.NombreArchivo = archivosAutoahorro.ArchivoOfertas.FileName;
                archivoAutoahorro.FechaAlta     = DateTime.Now;
                archivoAutoahorro.Activo        = true;
                int i = 0;

                //sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);

                IList <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                listaAutoahorro = HelperWeb.Parseo.ParseoOfertas(archivosAutoahorro.ArchivoOfertas.InputStream, ref archivoAutoahorro);

                try
                {
                    if (listaAutoahorro != null)
                    {
                        ServicioSistema <AutoahorroDato> .BeginTransaction();

                        archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                        foreach (AutoahorroDato dato in listaAutoahorro)
                        {
                            dato.ArchivoAutoahorro = archivoAutoahorro;
                            ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                            if (++i % 20 == 0)
                            {
                                ServicioSistema <AutoahorroDato> .Flush();
                            }
                        }

                        archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                        ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                        ServicioSistema <AutoahorroDato> .CommitTransaction();
                    }
                    else
                    {
                        throw new ApplicationException("Error en el archivo de ofertas.");
                    }
                }
                catch (Exception ex)
                {
                    ServicioSistema <AutoahorroDato> .RollbackTransaction();

                    throw ex;
                }
            }

            if (archivosAutoahorro.ArchivoEmisiones != null && archivosAutoahorro.ArchivoEmisiones.ContentLength > 0)
            {
                archivoAutoahorro = new ArchivoAutoahorro();

                archivoAutoahorro.NombreArchivo = archivosAutoahorro.ArchivoEmisiones.FileName;
                archivoAutoahorro.FechaAlta     = DateTime.Now;
                archivoAutoahorro.Activo        = true;
                int i = 0;

                //sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);

                List <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                listaAutoahorro = HelperWeb.Parseo.ParseoEmisiones(archivosAutoahorro.ArchivoEmisiones.InputStream, ref archivoAutoahorro);

                try
                {
                    ServicioSistema <AutoahorroDato> .BeginTransaction();

                    foreach (AutoahorroDato dato in listaAutoahorro)
                    {
                        dato.ArchivoAutoahorro = archivoAutoahorro;
                        ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                        if (++i % 20 == 0)
                        {
                            ServicioSistema <AutoahorroDato> .Flush();
                        }
                    }

                    archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                    ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                    ServicioSistema <AutoahorroDato> .CommitTransaction();

                    //litCantidadEmisiones.Text = string.Format("{0} emisiones cargadas", listaAutoahorro.Count);
                }
                catch (Exception ex)
                {
                    ServicioSistema <AutoahorroDato> .RollbackTransaction();

                    throw ex;
                }
            }

            if (archivosAutoahorro.ArchivoGanadores != null && archivosAutoahorro.ArchivoGanadores.ContentLength > 0)
            {
                archivoAutoahorro = new ArchivoAutoahorro();

                archivoAutoahorro.NombreArchivo = archivosAutoahorro.ArchivoGanadores.FileName;
                archivoAutoahorro.FechaAlta     = DateTime.Now;
                archivoAutoahorro.Activo        = true;
                int i = 0;

                //sql = string.Format("exec BuscarArchivoYBorrarlo @archivo = '{0}'", archivoAutoahorro.NombreArchivo);
                //ServicioSistema<ArchivoAutoahorro>.ExecuteSQLQueryUniqueResult(sql);


                IList <AutoahorroDato> listaAutoahorro = new List <AutoahorroDato>();
                listaAutoahorro = HelperWeb.Parseo.ParseoGanadores(archivosAutoahorro.ArchivoGanadores.InputStream, ref archivoAutoahorro);

                try
                {
                    ServicioSistema <AutoahorroDato> .BeginTransaction();

                    foreach (AutoahorroDato dato in listaAutoahorro)
                    {
                        dato.ArchivoAutoahorro = archivoAutoahorro;
                        ServicioSistema <AutoahorroDato> .SaveOrUpdateWithoutFlush(dato);

                        if (++i % 20 == 0)
                        {
                            ServicioSistema <AutoahorroDato> .Flush();
                        }
                    }

                    archivoAutoahorro.CantidadRegistros = listaAutoahorro.Count;
                    ServicioSistema <ArchivoAutoahorro> .SaveOrUpdate(archivoAutoahorro);

                    ServicioSistema <AutoahorroDato> .CommitTransaction();

                    //litCantidadGanadores.Text = string.Format("{0} ganadores cargados", listaAutoahorro.Count);
                }
                catch (Exception ex)
                {
                    ServicioSistema <AutoahorroDato> .RollbackTransaction();

                    throw ex;
                }
            }

            ObtenerArchivosCargados();


            return(View());
        }