def login(request, matricular):
# Creamos el formulario de autenticación vacío
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Recuperamos las credenciales validadas
username = form.cleaned_data['username']
password = form.cleaned_data['password']
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
print(matricular)
if matricular == 1:
return redirect("/GestionPortafolios")
else:
return redirect("/GestionPortafolios/matriculaEst/%s" %
matricular)
else:
messages.warning(request, "Credenciales no validas")
# Si llegamos al final renderizamos el formulario
return render(request, "principal.html", {'form': form})
def login(request):
if request.user.is_authenticated:
return redirect('/')
else :
if request.method == "POST":
username=request.POST['user']
contraseña=request.POST['pass']
user = authenticate(username=username, password=contraseña)
if user is not None:
do_login(request, user)
usuario = User.objects.get(email=user.email)
usuario.codigoSeguridad = None
usuario.save()
#Obtiene las listas y las crea en caso de no estar creadas
listas = Lista.objects.filter(usuario=user)
if listas:
return redirect('../')
else :
listaFav = Lista(descripcion='Lista de Favoritos', tipo=0, usuario=user)
listaVerDespues = Lista(descripcion='Lista de Escuchar Mas Tarde', tipo=1, usuario=user)
listaFav.save()
listaVerDespues.save()
return redirect('../')
else :
messages.error(request, "Usuario no encontrado")
return redirect('../login')
return render(request, "SistemaAudios/login.html")
def login(request):
if request.method == "GET":
return render_to_response('login.html',{'next':request.REQUEST.get('next')},context_instance=RequestContext(request))
if request.method == "POST":
username = request.REQUEST.get('username', None)
password = request.REQUEST.get('password', None)
next = request.REQUEST.get('next', LOGIN_REDIRECT_URL)
register = request.REQUEST.get('register', None)
submit = request.REQUEST.get('submit', None)
email = request.REQUEST.get('email', None)
c_password = request.REQUEST.get('c_password', None)
if register:
if email and password == c_password:
u = User.objects.create_user(username, email, password)
u.save()
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
do_login(request, user)
return HttpResponseRedirect(next)
else:
return render_to_response('login.html', {'error': 'passwords not matching'}, context_instance=RequestContext(request))
elif submit:
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
do_login(request, user)
return HttpResponseRedirect(next)
return HttpResponseRedirect('/')
def LoginUsers(request):
"""
API endpoint that allows users to be viewed or edited.
"""
if request.is_ajax() and request.method == "POST":
print(request.POST)
form = AuthenticationForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
do_login(request, user)
response = {"status": True, "msg": "paso todo OK"}
else:
response = {
"status": False,
"msg": "El usuario o contrasena invalida"
}
else:
response = {"status": False, "msg": "el formulario no es valido"}
else:
response = {"status": False, "msg": "Ups a ocurrido un error"}
return HttpResponse(json.dumps(response), content_type='application/json')
def login(request):
next = request.GET.get('next')
if request.method == 'POST':
form = forms.LoginForm(request.POST)
if form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password')
remember_me = request.POST.get('remember_me')
user = authenticate(username=username, password=password)
if user is not None:
if not user.is_active: return render(request, 'thunderchild/login.html', {'form':form, 'next':next, 'errors':['Account is inactive']})
if not user.is_staff: return render(request, 'thunderchild/login.html', {'form':form, 'next':next, 'errors':['Your account is not authorized to access this area']})
# If remember me is False, set session expiry to 0 so the login will remain active for the current session only.
if not remember_me:
request.session.set_expiry(0)
do_login(request, user)
if next:
return redirect(next)
else:
return redirect('thunderchild.views.dashboard')
else:
return render(request, 'thunderchild/login.html', {'form':form, 'next':next, 'errors':['Invalid login']})
else:
return render(request, 'thunderchild/login.html', {'form':form, 'next':next, 'errors':['Invalid login']})
else:
form = forms.LoginForm()
return render(request, 'thunderchild/login.html', {'form':form, 'next':next})
def login(request):
form = UserForm()
form2 = UserAdminForm()
if 'usuarios' in request.POST:
form = UserForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
do_login(request, user)
return redirect('usuario')
elif 'admins' in request.POST:
form2 = UserAdminForm(data=request.POST)
if form2.is_valid():
username = form2.cleaned_data['username']
password = form2.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
do_login(request, user)
return redirect('usuario')
return render(request, "login.html", {'form': form, 'form2': form2})
def login(request):
context = {}
user = request.user
if user.is_authenticated:
return redirect('dashboard')
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AccountAuthenticationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Recuperamos las credenciales validadas
email = request.POST['email']
password = request.POST['password']
# Verificamos las credenciales del usuario
user = authenticate(email=email, password=password)
# Si existe un usuario con ese nombre y contraseña
if user:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('dashboard')
else:
form = AccountAuthenticationForm()
context = {'form': form}
# Si llegamos al final renderizamos el formulario
return render(request, "login.html", context)
def register(request):
#Creamos el formulario de autentificación vacio
form = SignUpForm()
if request.method == "POST":
#añadimos los datos recibidos al formulario
form = SignUpForm(data=request.POST)
#si el formulario es valido..
if form.is_valid():
#creamos la nueva cuenta de usuario
fundaciones = form.save()
#Guardar usuario en grupo fundaciones
g = Group.objects.get(name='fundaciones')
g.user_set.add(fundaciones)
#si el usuario se crea correctamnte
if fundaciones is not None:
#hacemos el login manualmente
do_login(request, fundaciones)
#y le redireccionamos a la portada
return redirect('/')
# Si queremos borramos los campos de ayuda
form.fields['username'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
#si llegamos al final renderizamos el formulario
return render(request, "register.html", {'form': form})
def login(request):
form = AuthenticationForm()
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
do_login(request, user)
if request.GET.get('next'):
return redirect(request.GET.get('next'))
return redirect('/')
#return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
return render(
request,
'registration/login.html',
{
'form': form,
'div_clase': 'test'
},
)
def register(request):
context = {}
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = RegistrationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
do_login(request, account)
return redirect('dashboard')
else:
context = {'form': form}
else:
form = RegistrationForm()
context = {'form': form}
# Si queremos borramos los campos de ayuda
#form.fields['username'].help_text = None
form.fields['email'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "register.html", context)
def post(self, request, *args, **kwargs):
username = request.POST.get("u")
password = request.POST.get("p")
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
try:
client = Client.objects.get(user=user)
do_login(request, user)
return redirect('/profile')
except:
print("is not a client")
try:
restaurant = Restaurant.objects.get(user=user)
do_login(request, user)
return redirect('/restaurant_profile')
except:
print("is not a restaurant")
return render(request, "login.html",{'message':'Datos erroneos, vuelve a intentarlo.'})
def login(request):
form = AuthenticationForm()
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
url = "http://localhost:8000/auth/"
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"username\"\r\n\r\n{username}\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"password\"\r\n\r\n{password}\r\n-----011000010111000001101001--\r\n".format(
username=username, password=password)
headers = {
'Content-Type':
"multipart/form-data",
'content-type':
"multipart/form-data; boundary=---011000010111000001101001"
}
response = requests.request("POST",
url,
data=payload,
headers=headers)
global token
global auth_user
token = json.loads(response.text)['token']
auth_user = username
do_login(request, user)
return redirect('/room/default')
return render(request, "login.html", {'login_form': form})
def signup(request):
if request.method == 'POST':
form = PUserForm(request.POST)
if form.is_valid():
user = form.save()
group, created = Group.objects.get_or_create(name='PUsuario')
group.user_set.add(user)
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
user = authenticate(username=username, password=password)
do_login(request, user)
return redirect('ingresar_datos')
else:
form = PUserForm()
return render(request, 'registration/signup.html', {'form': form})
def register(request):
if request.user.is_authenticated:
return redirect('survey')
form = SignUpForm()
if request.method == 'POST':
form = SignUpForm(request.POST)
if (form.is_valid()):
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password1')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
try:
form.check_mail(email)
user = User.objects.create_user(username=email,
email=email,
password=password,
first_name=first_name,
last_name=last_name)
send_mail(
'Nuevo usuario',
f'Se ha registrado {user.first_name} {user.last_name}, {user.email} en Finplans',
'*****@*****.**',
['*****@*****.**'],
fail_silently=False,
)
if user is not None:
do_login(request, user)
return redirect('survey')
#return redirect("https://docs.google.com/forms/d/e/1FAIpQLSfTVN6PxiaZkTKmPmZdFL86Hb_Tril-_pEBtM2gV5SePkKRMg/viewform?usp=sf_link")
return redirect('index')
except Exception as e:
print(e)
return render(request, 'register.html', {'form': form})
def login(request):
if request.method == 'GET':
return render(request,
'common_page.html',
context={
'user': request.user,
'sub_title': "Login",
'scripts': ['/static/js-bundle/login.js'],
'nav_item_role': 'login',
})
if request.method == 'POST':
if request.user.is_authenticated:
return HttpResponseForbidden()
username = request.POST['username']
password = request.POST['password']
user = do_authenticate(username=username, password=password)
if user is not None:
do_login(request, user)
return HttpResponseRedirect(reverse('datalakes'))
# must be wrong
app_context = {'msg': "Wrong username or password!"}
return render(
request,
'common_page.html',
context={
'user': request.user,
'sub_title': "Login",
'scripts': ['/static/js-bundle/login.js'],
'nav_item_role': 'login',
'app_context':
JSONRenderer().render(app_context).decode("utf-8"),
},
)
def signup_validate(request):
if request.method != 'GET':
# only work for GET
return HttpResponseForbidden()
username = request.GET.get('username', '').strip()
token = request.GET.get('token', '').strip()
users = User.objects.filter(username=username)
if len(users) == 0:
return HttpResponseForbidden()
user = users[0]
if not AccessToken.authenticate(user, token,
AccessToken.Purpose.SIGNUP_VALIDATE):
return HttpResponseForbidden()
if user.is_active:
# already activated
return HttpResponseForbidden()
user.is_active = True
user.save()
if request.user.is_authenticated:
do_logout(request)
do_login(request, user)
return HttpResponseRedirect('/explorer/datalakes')
def login(request):
if request.method == "POST": # GIG POST significa que el usuario envio datos que debemos procesar
nomusuario = request.POST.get("username")
pwdenviada = request.POST.get("password")
user = authenticate(request=request,
username=nomusuario,
password=pwdenviada)
if user is not None:
try:
do_login(
request, user
) # MML guarda el id del usuario en la sesion almacenado en {{ user }} y aqui se accede como request.session.get("user")
#request.session.set_expiry(settings.EXPIRY_TIME)
return redirect('home')
except Exception:
return render(request, 'login.html', {
"form": FormularioLogin,
"errores": "Error al iniciar sesión"
})
else:
return render(
request, 'login.html', {
"form": FormularioLogin,
"errores": "Usuario y/o contraseña inválidos."
})
elif request.method == "GET":
return render(request, "login.html", {"form": FormularioLogin})
def login_global(request):
if request.method == 'POST':
nomuser = request.POST.get("username")
conuser = request.POST.get("password")
user = authenticate(request, username=nomuser, password=conuser)
if user is not None:
if user.is_superuser:
try:
do_login(request, user)
return redirect('global:index')
except Exception:
return render(
request, 'global/login_global.html', {
"form": FormularioLogin,
"errores": "Error al iniciar sesión"
})
else:
return render(
request, 'login.html', {
"form": FormularioLogin,
"errores": "Usuario por favor inicia sesion aquí."
})
else:
return render(
request, 'global/login_global.html', {
"form": FormularioLogin,
"errores": "Usuario y/o contraseña inválidos."
})
elif request.method == "GET":
return render(request, "global/login_global.html",
{"form": FormularioLogin})
def register(request):
# Creamos el formulario de autenticación vacío
form = UCFWithEmail()
# Establecemos
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = UCFWithEmail(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
user = form.save()
# Si existe el usuario
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('/')
# Si queremos borramos los campos de ayuda
form.fields['username'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "users/registro.html", {'form': form})
def login(request):
if request.user.is_authenticated:
return redirect('/home')
# Creamos el formulario de autenticación vacío
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Recuperamos las credenciales validadas
username = form.cleaned_data['username']
password = form.cleaned_data['password']
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('/home')
# Si llegamos al final renderizamos el formulario
return render(request, "empleados/inicio-sesion.html", {'form': form})
def login(request):
form = login2(request.POST)
mensaje = "Hola"
variables={
"form":form,
"mensaje":mensaje,
}
if form.is_valid():
datos = form.cleaned_data
user = datos.get("usuario")
psw = datos.get("password")
usuario = auth.authenticate(username = user, password = psw)
if usuario is not None:
do_login(request,usuario)
auth.login(request, usuario)
return HttpResponseRedirect('../adminp');
else:
mensaje = "Usuario o Password incorrecto"
variables = {
"form": form,
"mensaje": mensaje,
}
return render(request, "inicio/login.html", {"form": form, "mensaje": mensaje}) #if user == row[0]:
# print("encontro")
#else
#return render_to_response('inicio/login.html',{"form":form})
return render(request, "inicio/login.html", variables)
def register(request):
try:
assert request.is_ajax()
phone = request.POST['phone']
code = request.POST['code']
password = request.POST['password']
confirm = request.POST['confirm']
nickname = request.POST['nickname']
assert 'agree' in request.POST
assert password == confirm
except (KeyError, AssertionError):
return HttpResponseBadRequest()
if not VerificationCode.objects.verify(phone, code):
return HttpResponseForbidden()
try:
user = User.objects.create_user(
username=phone, email="",
password=password)
except:
return HttpResponse(status=409)
user = authenticate(username=phone, password=password)
user.participator = Participator.objects.create(user=user,nickname=nickname)
do_login(request, user)
return HttpResponse(status=205)
def form_valid(self, form):
response = super().form_valid(form)
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password"])
if user is not None:
do_login(self.request, user)
return response
def register(request):
# Creamos el formulario de autenticación vacío
form = UserCreationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = UserCreationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
user = form.save()
# Si el usuario se crea correctamente
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('/')
form.fields['username'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "users/register.html", {'form': form})
def login(request):
if request.method == 'POST':
nomuser = request.POST.get("username")
conuser = request.POST.get("password")
user = authenticate(request, username=nomuser, password=conuser)
if user is not None:
if user.is_superuser:
try:
do_login(request, user)
return redirect('adminMain')
except Exception:
return render(
request, 'puntoVentaTemplates/login.html', {
"form": FormularioLogin,
"errores": "Error al iniciar sesión"
})
else:
do_login(request, user)
return redirect('clientes')
else:
print("el usuario cayo aqui")
return render(
request, 'puntoVentaTemplates/login.html', {
"form": FormularioLogin,
"errores": "Usuario y/o contraseña inválidos."
})
elif request.method == "GET":
return render(request, "puntoVentaTemplates/login.html",
{"form": FormularioLogin})
def login_frontend(request):
# Creamos el formulario de autenticación vacío
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
print("verificando")
if form.is_valid():
# Recuperamos las credenciales validadas
username = form.cleaned_data['email']
password = form.cleaned_data['password']
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
print("verificando")
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
print("si existe")
response_data = {
#'es_admin_restaurante': user.es_admin_restaurante
'token': "asdsad",
}
response = Response(data=response_data)
# Y le redireccionamos a la portada
return response
# Si llegamos al final renderizamos el formulario
return render(request, "views/login.html", {'form': form})
def register(request):
# Creamos el formulario de autenticación vacío
form = UserCreationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = UserCreationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
user = form.save()
comprador = Comprador.objects.get_or_create(usuario=user,
nombre=user)
cliente = Comprador.objects.get(nombre=user.username)
pedido = Pedido.objects.get_or_create(
comprador=cliente,
completado=False,
id_transaccion=user.username + str(2020))
# Si el usuario se crea correctamente
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('tienda')
form.fields['username'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "tienda/registro.html", {'form': form})
def edit_username(request):
if(request.method=='POST'):
formulario = editUsername(request.POST)
if(formulario.is_valid()):
username1 = request.user.username
username = formulario.cleaned_data['username']
password = formulario.cleaned_data['password']
user1 = authenticate(username=username1, password=password)
if user1 is None:
formulario.add_error('password','Contraseña actual incorrecta')
if(formulario.errors):
return render(request,"newuser.html",{"form":formulario})
User.objects.filter(id=request.user.id).update(username=username)
user = get_object_or_404(User,pk=request.user.id)
do_logout(request)
do_login(request, user)
return redirect('/profile/{}'.format(user.id))
else:
formulario = editUsername()
formulario.fields["username"].initial = request.user.username
return render(request,"newuser.html",{"form":formulario})
def login(request):
#messages.debug(request, "Debug!")
#messages.info(request, "Info!")
#messages.success(request, "Success!")
#messages.warning(request, "Warning!")
#messages.error(request, "Error!")
if request.user.is_authenticated():
return redirect("/student")
context = {}
if request.method == "POST":
form = AuthenticationForm(None, request.POST)
if form.is_valid():
user = form.get_user()
print(user)
if user.is_active:
do_login(request, user)
return redirect("/student")
else:
messages.error(request, "Benutzeraccount ist deaktiviert!")
else:
form = AuthenticationForm()
context["form"] = form
return render(request, "session/login.html", context, context_instance=RequestContext(request))
def login_propio(request):
# Creamos el formulario de autenticación vacío
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Recuperamos las credenciales validadas
username = form.cleaned_data['username']
password = form.cleaned_data['password']
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
return redirect('/select_perfil')
# Si llegamos al final renderizamos el formulario
publicacion=Billboard.objects.filter(mostrar_en_home=True)
libros = Book.objects.filter(mostrar_en_home=True)
return render(request, "bookflix/login.html", {'form': form, 'publicaciones':publicacion, "libros":libros})
def edit_pass(request):
if(request.method=='POST'):
formulario = editPass(request.POST)
if(formulario.is_valid()):
username = request.user.username
password1 = formulario.cleaned_data['password3']
user1 = authenticate(username=username, password=password1)
if user1 is None:
formulario.add_error('password3','Contraseña actual incorrecta')
if(formulario.cleaned_data['password1']!=formulario.cleaned_data['password2']):
formulario.add_error('password2','No coinciden las contraseñas')
if(formulario.errors):
return render(request,"newuser.html",{"form":formulario})
password = make_password(formulario.cleaned_data['password1'])
User.objects.filter(id=request.user.id).update(password=password)
user = get_object_or_404(User,pk=request.user.id)
do_logout(request)
do_login(request, user)
return redirect('/profile/{}'.format(user.id))
else:
formulario = editPass()
return render(request,"newuser.html",{"form":formulario})
def login_view(request):
if 'recurso' in request.GET:
recurso_us = request.GET['recurso']
else:
recurso_us = '/'
if request.method == "POST":
action = request.POST['action']
request.POST = request.POST.copy()
if action=="Registrar":
request.POST['password1'] = request.POST['password']
form = RegistrationForm(data=request.POST)
msg = _("Informacion de autenticacion no valida, o el usuario ya tiene cuenta")
else:
form = AuthenticationForm(data=request.POST)
msg = _("El usuario o la contraseña no son correctos")
if form.is_valid():
if action=="Registrar":
user = form.save()
pagUs = PagUsuario(usuario = user)
pagUs.save()
else:
# Verificamos las credenciales del usuario
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
# Si existe un usuario con ese nombre y contraseña, o se crea correctamente
if user is not None:
do_login(request, user)
else:
context = {'recurso_us': recurso_us, 'error': msg, 'recurso_us': '/'}
return render(request, 'miscosas/pag_error.html', context)
return redirect(recurso_us)
def register(request):
# validate invite code
if request.method == "POST":
form = forms.PersonForm(data=request.POST)
if form.is_valid():
form.cleaned_data['date_joined'] = datetime.now().strftime("%Y-%m-%d %H:%M")
form.cleaned_data['last_login'] = datetime.now().strftime("%Y-%m-%d %H:%M")
form.cleaned_data['username'] = form.cleaned_data['email']
person = form.save()
user = User.objects.get(username__exact=person.username)
user.set_password(form.cleaned_data['password'])
user.save()
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
do_login(request, user)
request.session['person'] = person
return HttpResponseRedirect(reverse(add_interests))
else:
form = forms.PersonForm(label_suffix="")
state_select = forms.StateSelect()
return render(request, 'register.html', {'form': form, 'state_select': state_select})
def login(request):
# Creamos el formulario de autenticación vacío
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
#if form.is_valid():
# Recuperamos las credenciales validadas
username = request.POST["email"]
password = request.POST["pass"]
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
if user.is_superuser:
return redirect("/admin") # or your url name
# Y le redireccionamos a la portada
else:
return redirect('/')
#return render(request, "index.html")
else:
return redirect('/register')
#else:
#return redirect('/register')
# Si llegamos al final renderizamos el formulario
return render(request, "login.html", {'form': form})
def login(request):
form = AuthenticationForm()
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = AuthenticationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Recuperamos las credenciales validadas
username = form.cleaned_data['username']
password = form.cleaned_data['password']
# Verificamos las credenciales del usuario
user = authenticate(username=username, password=password)
# Si existe un usuario con ese nombre y contraseña
if user is not None:
# Hacemos el login manualmente
do_login(request, user)
# Y le redireccionamos a la portada
products_user_pub = len(Product.objects.filter(owner=request.user))
products_users_pub = len(Product.objects.all())
context = {
'user': user,
'products_user_pub': products_user_pub,
'products_users_pub': products_users_pub,
}
return render(request, 'users/mySpace.html', context)
# Si llegamos al final renderizamos el formulario
return render(request, "users/login.html", {'form': form})
def register(self, request, **cleaned_data):
username, email, password = cleaned_data['username'], cleaned_data['email'], cleaned_data['password1']
Account.objects.create_user(username, email, password, last_name=username)
new_user = authenticate(username=username, password=password)
do_login(request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=request)
return new_user
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
user = form.login()
if user:
do_login(request, user)
next = request.GET["next"] if hasattr(request.GET, "next") else None
if next:
return HttpResponseRedirect(next)
else:
return redirect(reverse("home"))
else:
return render(request, "login.html", {"form": form})
def login(request):
if request.method == "POST":
form = AuthenticationForm(request, data=request.POST)
if form.is_valid():
# Okay, security check complete. Log the user in.
do_login(request, form.get_user())
return redirect('account:display-current')
else:
form = AuthenticationForm(request)
return render(request, 'account/login.html' if not request.GET.get('xhr') else 'account/_login.html', {
'form': form
})
def register(request):
if request.POST:
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, u'恭喜你，注册成功。')
do_login(request, authenticate(username=form.cleaned_data['email'],
password=form.cleaned_data['password1']))
return shortcuts.redirect(reverse('account-home'))
else:
form = RegisterForm()
return shortcuts.render_to_response('account/register.html',
{'form': form},
context_instance=RequestContext(request))
def login(request):
print request.session.get("invite_code")
if request.method == "POST":
form = forms.LoginForm(data=request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
if user:
do_login(request, user)
return HttpResponseRedirect(request.GET.get('next','/'))
else:
form.errors['_all'] = "NOOOO"
else:
form = forms.LoginForm()
return render(request, 'login.html', {'next':next, 'form': form})
def login(request):
if request.method == 'GET':
if request.user.is_authenticated():
return redirect('/')
return render(request, 'loginpage.html')
elif request.method == 'POST':
email = request.POST['userlogin']
password = request.POST['passlogin']
user = authenticate(username = email, password = password)
if user:
do_login(request, user)
return redirect('/')
else:
context = {'invalid_login': True}
return render(request, 'loginpage.html', context)
def login(request):
try:
assert request.is_ajax()
identity = request.POST['identity']
password = request.POST['password']
assert len(identity) > 0
except (KeyError,AssertionError):
return HttpResponseBadRequest()
user = authenticate(username=identity,password=password)
if user is None:
return HttpResponseForbidden()
do_login(request,user)
if not request.POST.get('memorize'):
request.session.set_expiry(0)
return HttpResponse(status=205)
def login(request):
if request.method == "POST":
lf = LoginForm(request.POST)
if lf.is_valid():
user = authenticate(username = lf.cleaned_data.get('username'),password = lf.cleaned_data.get('password'))
print user
if user:
do_login(request, user)
client=Client.objects.get(user=user)
rc = RequestContext(request,{'client':client})
return HttpResponseRedirect(reverse('home_profile'))
else:
lf = LoginForm()
rc = RequestContext(request, {'form' : lf})
return render_to_response('index.html',rc)
def register(request):
query = request.POST
email = query.get('email', None)
password = query.get('password', None)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
user = User.objects.create_user(email, email, password)
profile = Profile.objects.create(user=user, email=email)
user = authenticate(username=email, password=password)
if user is not None:
do_login(request, user)
return redirect(query.get('next', '/'))
