コード例 #1
0
        public void PersonalizarTienda(string colorPrimario, string colorSecundario, int estilo, byte[] img, string idTienda)
        {
            IDALTienda it = new DALTiendaEF();

            //Obtener Template
            Personalizacion p;

            if (estilo == 1)
            {
                p = it.ObtenerPersonalizacionTienda("template1");

                //Modificar Template
                string newcss = p.css;
                newcss = newcss.Replace("#colorPrimario", colorPrimario);
                newcss = newcss.Replace("#colorSecundario", colorSecundario);
                p.css  = newcss;
            }
            else // if (estilo == 2)
            {
                p = it.ObtenerPersonalizacionTienda(idTienda);
                p.backgroud_image = img;
            }


            //Guardar CSS en la base
            p.template = estilo;
            it.PersonalizarTienda(p, idTienda);
        }
コード例 #2
0
ファイル: Global.asax.cs プロジェクト: AleAnonMallo/Chebay-1
        public void cargarPersonalizacion(string url)
        {
            try {
                 //Personalizacion
                IDALTienda it = new DALTiendaEF();

                String fileName = "_ViewStart.cshtml";
                var filePath = Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Views"), fileName);

                Personalizacion p = it.ObtenerPersonalizacionTienda(url);
                String layout = "@{Layout = \"~/Views/Shared/_Layout.cshtml\";}";
                if (p.template != null && p.template == 1)
                {
                    layout = "@{Layout = \"~/Views/Shared/_Layout.cshtml\";}";
                    String cssFileName = "orangeStyle.css";
                    var cssFilePath = Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Content/personalizacion/EstiloUno"), cssFileName);
                    if (p.css != null)
                    {
                        //Escribir css
                        System.IO.File.WriteAllText(cssFilePath, p.css);
                    }
                    else
                    {
                        var orangePath = Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Content/personalizacion/EstiloUno"), "orangeStyle_backup.css");
                        String orangeStyle = System.IO.File.ReadAllText(orangePath);
                        System.IO.File.WriteAllText(cssFilePath, orangeStyle);
                    }
                }
                else if (p.template != null && p.template == 2)
                {
                    layout = "@{Layout = \"~/Views/Shared/_Layout2.cshtml\";}";

                    String cssFile = "fixes.css";
                    String cssFileBackup = "fixes_backup.css";
                    var cssPathBackup = Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Content/personalizacion/EstiloDos"), cssFileBackup);
                    //Original css
                    String cssText = System.IO.File.ReadAllText(cssPathBackup);
                    var imgUrl = "";
                    if (p.backgroud_image != null)
                    {
                        imgUrl = Request.Url.Scheme + "://" + Request.Url.Authority + "/" + url + "/Product/getTiendaImg";
                    }
                    else
                    {
                        //Por default
                        imgUrl = "images/bg01.png";
                    }
                    cssText = cssText.Replace("body {}", "body {background-image: url("+ imgUrl +")}");
                    //Escribimos el css editado
                    var cssPath = Path.Combine(System.Web.HttpContext.Current.Server.MapPath("~/Content/personalizacion/EstiloDos"), cssFile);
                    System.IO.File.WriteAllText(cssPath, cssText);
                }
                Session["Tienda_Desc"] = p.tienda.descripcion;
                //Escribimos el layout a usar que carga todos los css para esa pers.
                System.IO.File.WriteAllText(filePath, layout);
            }
            catch (Exception ex){

            }
        }
コード例 #3
0
 public String[] Get()
 {
     IDALTienda it = new DALTiendaEF();
     List<Tienda> lt = it.ObtenerTodasTiendas();
     String[] ret = new String[lt.Count];
     int i = 0;
     foreach (Tienda t in lt)
     {
         ret[i] = t.TiendaID;
         i++;
     }
     return ret;
 }
コード例 #4
0
ファイル: Program.cs プロジェクト: AleAnonMallo/Chebay-1
        // Please set the following connection strings in app.config for this WebJob to run:
        // AzureWebJobsDashboard and AzureWebJobsStorage
        //Hace broadcast a topic, para todas las instancias del worker role.
        static void Main()
        {
            string QueueName = "recomendacion";
            string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");

            QueueClient Client;
            Client = QueueClient.CreateFromConnectionString(connectionString, QueueName);

            IDALTienda tdal = new DALTiendaEF();
            var tiendas = tdal.ObtenerTodasTiendas();
            foreach (var t in tiendas)
            {
                Console.WriteLine(t.TiendaID);
                var message = new BrokeredMessage(t.TiendaID);
                Client.Send(message);
            }
        }
コード例 #5
0
        public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // No cuenta los errores de inicio de sesión para el bloqueo de la cuenta
            // Para permitir que los errores de contraseña desencadenen el bloqueo de la cuenta, cambie a shouldLockout: true
            
            // Valido en nuestra bd, posteriormente con Identity
            IDALTienda idal = new DALTiendaEF();
            try
            {
                bool aut = idal.AutenticarAdministrador(model.Email, model.Password);

            } catch(Exception e){

                ModelState.AddModelError("", "Intento de inicio de sesión no válido.");
                return View(model);
            }
            
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                case SignInStatus.Failure:
                default:
                    ModelState.AddModelError("", "Intento de inicio de sesión no válido.");
                    return View(model);
            }
        }
コード例 #6
0
ファイル: Algorithms.cs プロジェクト: AleAnonMallo/Chebay-1
        public void Run(string tiendaID)
        {
            IDALUsuario udal = new DALUsuarioEF();
            IDALTienda tdal = new DALTiendaEF();
            IDALSubasta sdat = new DALSubastaEF();

            Tienda tienda = tdal.ObtenerTienda(tiendaID);
            List<Producto> productos = sdat.ObtenerTodosProductos(tienda.TiendaID);
            //obtengo algoritmo
            Personalizacion pers = tdal.ObtenerPersonalizacionTienda(tienda.TiendaID);
            List<Usuario> usuarios = udal.ObtenerTodosUsuariosFull(tienda.TiendaID);
            bool defaultalgorithm = false;

            if (pers.algoritmo == null || pers.algoritmo.Length == 0)
            {
                defaultalgorithm = true;
            }

            //creo indice
            Task index = udal.InicializarColeccionRecomendaciones(tienda.TiendaID);
            index.Wait();

            foreach (var user in usuarios)
            {
                if (defaultalgorithm)
                {
                    Algorithms def = new Algorithms();
                    def.default_recomendation_algorithm(productos, user, tienda.TiendaID);
                }
                else
                {
                    Algorithms a = new Algorithms();
                    a.custom_algorithm(pers, productos, user, tienda.TiendaID);
                }
            }//IF tienda es de instancia...
        }
コード例 #7
0
        public void SessionAtributesTest()
        {
            using (var schema = ChebayDBPublic.CreatePublic())
            {
                IDALTienda handler = new DALTiendaEF();
                AtributoSesion[] atr = {
                                                    new AtributoSesion { AdministradorID="Admin1", AtributoSesionID="Cache", Datos="algo" },
                                                    new AtributoSesion { AdministradorID = "Admin1", AtributoSesionID = "Cache2", Datos = "algo2" },
                                                    new AtributoSesion { AdministradorID = "Admin1", AtributoSesionID = "Cache2", Datos = "distinto" }
                                                };
                foreach (var a in atr)
                {
                    handler.AgregarAtributoSesion(a);
                }

                Console.WriteLine("Atributos del usuario admin.");
                foreach (var a in handler.ObtenerAtributosSesion("Admin1"))
                {
                    Console.WriteLine(a.AtributoSesionID + " " + a.Datos);
                }
            }
        }
コード例 #8
0
        public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
        {
            var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
            if (loginInfo == null)
            {
                return RedirectToAction("Login");
            }

            // Si el usuario ya tiene un inicio de sesión, iniciar sesión del usuario con este proveedor de inicio de sesión externo
            var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
            switch (result)
            {
                case SignInStatus.Success:
                    IDALTienda dalT = new DALTiendaEF();
                    Administrador admin;

                    try 
                    {
                        admin = dalT.ObtenerAdministrador(loginInfo.Email);
                    } 
                    catch (Exception e) {
                        admin = new Administrador {AdministradorID=loginInfo.Email, password="" };
                        try
                        {
                            dalT.AgregarAdministrador(admin);
                        }
                        catch (Exception e2)
                        {
                            Debug.WriteLine(e2.Message);
                        }
                    }
          


                    return RedirectToLocal(returnUrl);
                case SignInStatus.LockedOut:
                    return View("Lockout");
                case SignInStatus.RequiresVerification:
                    return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = false });
                case SignInStatus.Failure:
                default:
                    // Si el usuario no tiene ninguna cuenta, solicitar que cree una
                    ViewBag.ReturnUrl = returnUrl;
                    ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
                    return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
            }
        }
コード例 #9
0
        public async Task<ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                IDALTienda idalt = new DALTiendaEF();
                Administrador admin = new Administrador { AdministradorID= model.Email, password=model.Password};
                idalt.AgregarAdministrador(admin);
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await UserManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
                    
                    // Para obtener más información sobre cómo habilitar la confirmación de cuenta y el restablecimiento de contraseña, visite http://go.microsoft.com/fwlink/?LinkID=320771
                    // Enviar correo electrónico con este vínculo
                    // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                    // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    // await UserManager.SendEmailAsync(user.Id, "Confirmar cuenta", "Para confirmar la cuenta, haga clic <a href=\"" + callbackUrl + "\">aquí</a>");

                    return RedirectToAction("Index", "Home");
                }
                AddErrors(result);
            }

            // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
            return View(model);
        }
コード例 #10
0
ファイル: DALTiendaEF.cs プロジェクト: AleAnonMallo/Chebay-1
        public void PersonalizarTienda(string colorPrimario, string colorSecundario, int estilo, byte[] img, string idTienda)
        {
            IDALTienda it = new DALTiendaEF();

            //Obtener Template
            Personalizacion p;
            if (estilo == 1)
            {
                p = it.ObtenerPersonalizacionTienda("template1");

                //Modificar Template
                string newcss = p.css;
                newcss = newcss.Replace("#colorPrimario", colorPrimario);
                newcss = newcss.Replace("#colorSecundario", colorSecundario);
                p.css = newcss;
            }
            else // if (estilo == 2)
            {
                p = it.ObtenerPersonalizacionTienda(idTienda);
                p.backgroud_image = img;
            }

            //Guardar CSS en la base
            p.template = estilo;
            it.PersonalizarTienda(p, idTienda);
        }
コード例 #11
0
ファイル: DALSubastaEF.cs プロジェクト: AleAnonMallo/Chebay-1
        public List<DataProducto> ObtenerProductosCategoria(long idCategoria, string idTienda)
        {
            IDALTienda idalt = new DALTiendaEF();
            List<DataProducto> listadp = new List<DataProducto>();

            //obtengo todas las categorias simples de idCategoria
            using(var db = ChebayDBContext.CreateTenant(idTienda))
            {
                //valido
                var query = from cat in db.categorias
                            where cat.CategoriaID == idCategoria
                            select cat;
                if(query.Count()==0){
                    throw new Exception("DALSubastaEF::ObtenerProductosCategoria: No existe categoria");
                }

                //backtracking
                List<Categoria> stack = new List<Categoria>();
                stack.Add(query.First());

                while (stack.Count() != 0)
                {
                    var first = stack.First();
                    System.Console.WriteLine(first.CategoriaID);

                    if (first is CategoriaSimple)
                    {
                        CategoriaSimple cs = (CategoriaSimple)first;
                        db.Entry(cs).Collection(c => c.productos).Load();

                        foreach (var p in cs.productos)
                        {
                            //Para agregar solo los productos que no vencieron.
                            if (p.fecha_cierre > DateTime.UtcNow)
                            {
                                DataProducto dp = new DataProducto
                                {
                                    nombre = p.nombre,
                                    descripcion = p.descripcion,
                                    precio_actual = p.precio_base_subasta,
                                    precio_base_subasta = p.precio_base_subasta,
                                    precio_compra = p.precio_compra,
                                    ProductoID = p.ProductoID,
                                    fecha_cierre = p.fecha_cierre
                                };
                                //Para agregar idOfertante y mayor oferta recibida
                                Oferta of = ObtenerMayorOferta(p.ProductoID, idTienda);
                                if (of != null)
                                {
                                    dp.precio_actual = of.monto;
                                    dp.idOfertante = of.UsuarioID;
                                }
                                listadp.Add(dp);
                            }
                        }
                    }
                    else
                    {
                        CategoriaCompuesta cc = (CategoriaCompuesta)first;
                        db.Entry(cc).Collection(p => p.hijas).Load();

                        foreach (var c in cc.hijas)
                        {
                            stack.Add(c);
                        }
                    }
                    //quito el primero
                    stack.RemoveAt(0);
                }

            }//using

            return listadp;
        }