public ActionResult ExternalLoginConfirmation(RegisterExternalLoginModel model, string returnUrl)
        {
            string provider = null;
            string providerUserId = null;

            if (User.Identity.IsAuthenticated || !OAuthWebSecurity.TryDeserializeProviderUserId(model.ExternalLoginData, out provider, out providerUserId))
            {
                return RedirectToAction("Manage");
            }

            if (ModelState.IsValid)
            {
                // Insertar un nuevo usuario en la base de datos
                using (SigeretContext db = new SigeretContext())
                {
                    UserProfile user = db.UserProfiles.FirstOrDefault(u => u.UserName.ToLower() == model.UserName.ToLower());
                    // Comprobar si el usuario ya existe
                    if (user == null)
                    {
                        // Insertar el nombre en la tabla de perfiles
                        db.UserProfiles.Add(new UserProfile { UserName = model.UserName });
                        db.SaveChanges();

                        OAuthWebSecurity.CreateOrUpdateAccount(provider, providerUserId, model.UserName);
                        OAuthWebSecurity.Login(provider, providerUserId, createPersistentCookie: false);

                        return RedirectToLocal(returnUrl);
                    }
                    else
                    {
                        ModelState.AddModelError("UserName", "El nombre de usuario ya existe. Escriba un nombre de usuario diferente.");
                    }
                }
            }

            ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(provider).DisplayName;
            ViewBag.ReturnUrl = returnUrl;
            return View(model);
        }
        /// <summary>
        /// Saúl H. Sánchez.
        /// 
        /// Metodo utilizado para inicializar la configuración del
        /// plugin WebSecurity, y la inicialización de la conexión
        /// de la base de datos, tomando en cuenta la tabla de la 
        /// base de datos que almacenará los datos de los usuarios
        /// de la aplicación. También en este método se insertan los
        /// datos por defecto requeridos para el mínimo funcionamiento
        /// de la aplicación, tales como roles y un usuario por defecto.
        /// </summary>
        public static void Register()
        {
            try
            {
                WebSecurity.InitializeDatabaseConnection
                    (
                     "SigeretContext",
                     "UserProfile",
                     "UserId",
                     "username",
                     autoCreateTables: true
                    );

                //verificacion y creacion de roles de la aplicacion
                var roles = (SimpleRoleProvider)Roles.Provider;
                if (roles.GetAllRoles().Count() == 0)
                {
                    roles.CreateRole("Administrador");
                    roles.CreateRole("Profesor");
                    roles.CreateRole("Estudiante");
                }

                //Creacion y gestion de parametros para cuenta administrador
                if (!WebSecurity.UserExists("SigeretAdmin"))
                {
                    WebSecurity.CreateUserAndAccount(
                        "SigeretAdmin", "000000",
                        propertyValues: new { Nombre = "Administrador", Apellido = "Sigeret", Cedula = "00000000000", Matricula = "7777777777" });
                }

                if (!roles.GetRolesForUser("SigeretAdmin").Contains("Administrador"))
                {
                    roles.AddUsersToRoles(new[] { "SigeretAdmin" }, new[] { "Administrador" });
                }

                using (SigeretContext db = new SigeretContext())
                {
                    //Almacenando datos de los controladores y la acciones en la bd, para el modulo de permisos.
                    var types =
                        from a in AppDomain.CurrentDomain.GetAssemblies()
                        from t in a.GetTypes()
                        where typeof(IController).IsAssignableFrom(t)
                        select t;

                    foreach (var ctrlType in types)
                    {
                        ReflectedControllerDescriptor ctrlDescriptor = new ReflectedControllerDescriptor(ctrlType);
                        if (ctrlDescriptor.GetCustomAttributes(typeof(EsControllerAttribute), false).Any())
                        {
                            var attribute = ctrlDescriptor.GetCustomAttributes(typeof(EsControllerAttribute), false).FirstOrDefault() as EsControllerAttribute;
                            Controlador ctrl = db.Controladors.FirstOrDefault(c => c.Descriptor == attribute.Descriptor);

                            if (ctrl == null)
                            {
                                ctrl = new Controlador();
                                ctrl.Name = attribute.ControllerName;
                                ctrl.Descriptor = attribute.Descriptor;
                                db.Controladors.Add(ctrl);
                            }
                            else
                            {
                                if (ctrl.Name != attribute.ControllerName)
                                {
                                    ctrl.Name = attribute.ControllerName;
                                }
                                db.Entry(ctrl).State = System.Data.EntityState.Modified;
                            }

                            foreach (ActionDescriptor ad in ctrlDescriptor.GetCanonicalActions())
                            {
                                if (ad.GetCustomAttributes(typeof(VistaAttribute), false).Any())
                                {
                                    var ActionAttribute = ad.GetCustomAttributes(typeof(VistaAttribute), false).FirstOrDefault() as VistaAttribute;
                                    Accion acc = db.Accions.FirstOrDefault(a => a.Descriptor == ActionAttribute.Descriptor);

                                    if (acc == null)
                                    {
                                        acc = new Accion();
                                        acc.Name = ActionAttribute.ViewName;
                                        acc.Descriptor = ActionAttribute.Descriptor;
                                        ctrl.Accions.Add(acc);
                                        db.Accions.Add(acc);
                                    }
                                    else
                                    {
                                        if (acc.Name != ActionAttribute.ViewName)
                                        {
                                            acc.Name = ActionAttribute.ViewName;
                                        }
                                        db.Entry(acc).State = System.Data.EntityState.Modified;
                                    }
                                }
                            }
                            db.SaveChanges();
                        }
                    }

                    //Asignando permisos sobre todas las acciones a la cuenta de Administrador por defecto.
                    var adminRole = db.webpages_Roles.FirstOrDefault(r => r.RoleName == "Administrador");
                    foreach (Accion a in db.Accions)
                    {
                        if (!adminRole.Accions.Contains(a))
                            adminRole.Accions.Add(a);
                    }
                    db.Entry(adminRole).State = System.Data.EntityState.Modified;
                    db.SaveChanges();
                }

            }
            catch (Exception ex)
            {
                throw new InvalidOperationException("No se pudo inicializar la conexión con la base de datos.", ex);
            }
        }