def login(request):
#si tot es POST:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if user and user.is_active:
#si tot és ok:
authLogin(request, user)
next = request.GET.get('next')
messages.info(request, "Benvingut")
return redirect(next or 'discos:index')
else:
messages.error(
request, "Usuari o password incorrecte o usuari no actiu")
else:
form = LoginForm()
ctx = {
'form': form,
}
form.fields['username'].widget.attrs['placeholder'] = "Email"
form.fields['password'].widget.attrs['placeholder'] = "Contrasenya"
form.fields['username'].widget.attrs['required'] = "required"
form.fields['password'].widget.attrs['required'] = "required"
return render(request, 'login.html', ctx)
def login(request):
helper = Helper()
allPatientTypes = helper.getUnclearedPatientPerf()
allPatientTypes["user"] = request.user
if request.user.is_authenticated():
return render_to_response("pta/index.html",allPatientTypes, context_instance = RequestContext(request))
else:
errorMessage = ""
if request.POST:
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password= password)
if user is not None:
if user.is_active:
authLogin(request,user)
allPatientTypes["user"] = request.user
return render_to_response("pta/index.html",allPatientTypes, context_instance = RequestContext(request))
else:
errorMessage = "The user " +username+ " is no longer active. If this is a mistake, email [email protected] and notify them."
return render_to_response("pta/error.html",{"error":errorMessage}, context_instance = RequestContext(request))
else:
errorMessage = " Invalid username or password for '" +username+ "'. If this is a mistake, email [email protected] and notify them."
return render_to_response("pta/error.html",{"error":errorMessage}, context_instance = RequestContext(request))
else:
return render_to_response("pta/login.html", locals(), context_instance = RequestContext(request))
def login(request):
context = {}
if request.user.is_authenticated():
return redirect(reverse('index'))
if request.method == "GET":
context['form'] = LoginForm()
return render(request, 'login.html', context)
form = LoginForm(request.POST)
context['form'] = form
if not form.is_valid():
return render(request, 'login.html', context)
authenticated_user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if not authenticated_user:
context['error'] = 'Incorrect username or password.'
return render(request, 'login.html', context)
authLogin(request, authenticated_user)
next_page = request.GET.get('next')
if not next_page:
next_page = reverse('index')
return redirect(next_page)
def post(self, request):
# - Attempt to create User account.
user_serializer = self.register_user_serializer_class(
data=request.data)
if user_serializer.is_valid(raise_exception=True):
username = user_serializer.validated_data.get('username')
email = user_serializer.validated_data.get('email')
password = user_serializer.validated_data.get('password')
user = User.objects.create(username=username, email=email)
user.set_password(password)
user.save()
# Make sure each user gets an information model.
Information.objects.create(user=user)
new_user = authenticate(username=user.username, password=password)
# Log user in.
if new_user is not None:
authLogin(request, new_user)
# Send a welcome email.
send_welcome_email.delay(new_user)
# Everything went OK!
return Response(data={"detail": "Account Created"},
status=status.HTTP_201_CREATED)
# If there were user user_serializer errors, send em back to the user.
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def login(request):
logout(request)
username = password = branch = ''
queryset_branches = Branch.objects.all()
if request.POST:
username = request.POST['username']
password = request.POST['password']
branch = request.POST.get('branch', Branch.objects.first().id)
user = authenticate(username=username, password=password)
if user is not None and user.is_active:
request.session['branch'] = branch
authLogin(request, user)
try:
if (user.has_perm(FULL_SUPERVISION_PERMISSION)):
return HttpResponseRedirect(reverse(render_admin_page))
else:
return HttpResponseRedirect(reverse(render_volunteer_page))
except AttributeError: # If user account doesn't exist/some other error, show friendly error message
response = HttpResponseBadRequest(
"Invalid or missing login info. Make sure no fields are empty, and that the username exists in the system."
)
return render(request, 'login/login.html',
{'response': response.content})
return render(request, 'login/login.html', {'branches': queryset_branches})
def login(request):
username = request.POST.get("username")
password = request.POST.get("password")
if not username and not password:
body = request.body
try:
body = json.loads(body)
username = body.get("username")
password = body.get("password")
except ValueError:
pass
user = authenticate(username=username, password=password)
resp = None
if user is not None:
if user.is_active:
authLogin(request, user)
resp = HttpResponse(getUserData(user))
else:
resp = HttpResponse("User Not Active", error=1, status=401)
else:
resp = HttpResponse("Invalid Credentials", error=1, status=401)
return resp
def sign_up(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
try:
validate_email(username)
except ValidationError:
errors = form._errors.setdefault("username", ErrorList())
errors.append(username + u' is not a valid email address')
if not username[-7:] == 'mit.edu':
errors = form._errors.setdefault("username", ErrorList())
errors.append(username + u' is not an MIT email address')
else:
# TODO set email field as username.
new_user = form.save()
new_user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
authLogin(request, new_user)
return HttpResponseRedirect("/")
else:
form = RegisterForm()
return render_to_response("index.html", {'form': form},
RequestContext(request))
def signup(request):
form = SignUpForm()
if request.method == "POST":
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save()
authLogin(request, user)
return redirect('home')
return render(request, 'signup.html', {'form': form})
def signIn(request):
logForm = LoginForm(request.POST)
response = {'redirectUrl': '/'}
if logForm.is_valid():
user = User.objects.get(email=logForm.cleaned_data.get('email'))
authLogin(request, user)
return JsonResponse(response)
response['errors'] = logForm.errors
return JsonResponse(response)
def signUp(request):
regForm = SignUpForm(request.POST)
response = {"redirectUrl": "/"}
if regForm.is_valid():
user = regForm.save()
authLogin(request, user)
return JsonResponse(response)
response["errors"] = regForm.errors
return JsonResponse(response)
def register(request):
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=password)
authLogin(request, user)
return redirect('login')
return render(request, 'AppAuthentication/register.html', {'form': form})
def auth(request):
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
authLogin(request, user)
return HttpResponseRedirect(reverse('base:home'))
else:
return HttpResponseRedirect(reverse('base:invalidLogin'))
def login(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(request, username=username, password=password)
if user is not None:
authLogin(request, user)
return redirect('dashboard')
else:
messages.error(request, 'Username / Password is Incorrect')
return render(request, 'AppAuthentication/login.html')
def doLogin(request):
username = request.POST.get('username')
password = request.POST.get('password')
try:
authUser = authenticate(username=username, password=password)
if authUser is not None:
if authUser.is_active:
authLogin(request, authUser)
return redirect('/')
except Exception, e:
errorMessage = messages.SYSTEM_ERROR
def auth(request):
username = request.POST.get("username")
password = request.POST.get("password")
user = authenticate(username=username, password=password)
if user is not None:
authLogin(request, user)
return HttpResponseRedirect(reverse("base:home"))
else:
return HttpResponseRedirect(reverse("base:invalidLogin"))
def login(request):
if request.method == "POST":
username = request.POST["username"]
password = request.POST["password"]
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
authLogin(request, user)
return render(request, "finances/index.html")
return render(request, "finances/login.html", {"error": "true"})
return render(request, "finances/login.html")
def userLogin(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
authLogin(request, user)
return HttpResponseRedirect(redirect_to=reverse("mm:index"))
else:
return HttpResponseRedirect(redirect_to=reverse("mm:index"))
else:
return HttpResponseRedirect(redirect_to=reverse("mm:index"))
def post(request, *args, **kwargs):
args = request.data
user = authenticate(username=args.get('username'),
password=args.get('password'))
if user is not None:
authLogin(request, user)
#
# return a 201
return Response({}, status=status.HTTP_200_OK)
#
# the case they dont login properly
return Response({}, status=status.HTTP_401_UNAUTHORIZED)
def orgSignup(request):
if 'POST' != request.method:
response = render(request, 'organization/signup.html')
else:
# Get the form data
username = request.POST['username']
email = request.POST['email']
commercial_no = request.POST['commercial_no']
password = request.POST['password']
logo = request.FILES['logo']
# validation should go here
# a. create CustomUser
customUser = CustomUser(username=username,
email=email,
type=CustomUserType.Organization.value)
customUserProfile = CustomUserProfile(customUser)
# b. create the keystore that has the encrypted privatekey
ethAccount = EthAccount(main.web3Handler)
keystore = ethAccount.create(
password
) # this creates an account and returns its associated keysotre
customUser.publicKey = keystore['address']
customUser.keystore = keystore
try:
customUser.save()
org = Organization(customUser=customUser,
commertialNum=commercial_no,
logo=logo)
org.save()
# Add the organization into our Accounts Contract
accountsHandler = main.accsHandler
accountsHandler.addAccount(customUser.publicKey,
CustomUserType.Organization.value)
customUser = authenticate(request,
username=customUser.publicKey,
password=password,
ethAccount=ethAccount)
authLogin(request, customUser)
sendMail(customUser.publicKey, email)
response = redirect('org.home')
except IntegrityError:
errorMsg = 'Sorry! This account already exists!'
response = render(request, 'error.html', {'errorMsg': errorMsg})
return response
def login(request):
if request.user.is_authenticated:
return redirect(index)
if request.method == "POST":
username = request.POST['username']
password = request.POST['password']
user = authenticate(request, username=username, password=password)
print(user)
if user is not None:
authLogin(request, user)
return redirect(index)
else:
return render(request, 'accounts/login.html',
{'msg': "Invalid Credentials"})
else:
return render(request, 'accounts/login.html',
{'password_reset': request.GET.get('password_reset')})
def login(request):
if request.method == 'POST':
form = authforms.AuthenticationForm(data=request.POST)
if (form.is_valid()):
authLogin(request, form.get_user())
return redirect('profile', userID=form.get_user().id)
else:
form = authforms.AuthenticationForm()
template = loader.get_template('auth/login.html')
context = RequestContext(request)
form.fields['username'].required = False
form.fields['password'].required = False
context['forms'] = [form]
if (form.errors):
context['errors'] = True
context['title'] = 'Login'
return HttpResponse(template.render(context))
def login(request):
if 'POST' != request.method:
response = render(request, 'login.html')
else:
if not request.user.is_authenticated:
publicKey = request.POST['publickey']
password = request.POST['password']
ethAccount = EthAccount(main.web3Handler)
# teset
customUser = authenticate(request,
username=publicKey,
password=password,
ethAccount=ethAccount)
# authenticate
if customUser is not None:
# 1. determine if account exists
# HINT: accountExists = AccountsContract.accountExist(publicKey);
accountExists = True
if accountExists:
authLogin(request, customUser)
# 5. access our accounts contract to see its type={loaine, organization}
isLoanie = not customUser.type
if isLoanie:
response = redirect('loanie.home')
else:
response = redirect('org.home')
else:
errorMsg = 'This account does not exist. Please sign up.'
response = render(request, 'error.html',
{'errorMsg': errorMsg})
else:
# Return an 'invalid login' error message.
errorMsg = 'This account does not exist. Please sign up.'
response = render(request, 'error.html',
{'errorMsg': errorMsg})
else:
response = redirect('index')
return response
def signup(request):
user = request.user
if user.is_authenticated():
return redirect('new')
if request.method == 'POST':
form = forms.SignUpForm(request.POST, request.FILES)
if form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
authLogin(request, user)
return redirect('login')
else:
form = forms.SignUpForm()
return render(request, 'register.html', {
'form': form,
})
def login(request):
if request.method=='POST':
form=LoginForm( request.POST )
if form.is_valid():
user=authenticate( username = form.cleaned_data['username'],
password = form.cleaned_data['password'])
if user and user.is_active:
authLogin( request, user )
next = request.GET.get('next')
return redirect(next or 'videos:llista_videos')
else:
messages.error(request,"Usuari o password incorrecte o usuari no actiu")
else:
form=LoginForm()
ctx={ 'form':form,
'capcelera':"Formulari de Login"
}
for f in form.fields:
form.fields[f].widget.attrs['class'] = 'form-control'
return render(request, 'form.html', ctx )
def login(request):
user = request.user
if user.is_authenticated():
print('User is_authenticated')
print(user.username)
return redirect('new')
nextPage = request.GET.get('next')
if nextPage is None:
nextPage = 'new'
if request.method == 'POST':
form = forms.LoginForm(request.POST)
if form.is_valid():
authLogin(request, form.user)
print(form.user.username)
return redirect(nextPage)
else:
form = forms.LoginForm()
return render(request, 'login.html', {'form': form})
def authorize(request):
token = oauth.lichess.authorize_access_token(request)
response = oauth.lichess.get('/api/account/email', token=token)
email = response.json()['email']
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
return HttpResponseRedirect(reverse("login.unauthorized"))
try:
db_token = OAuth2Token.objects.get(user=user)
except OAuth2Token.DoesNotExist:
db_token = OAuth2Token(user=user)
db_token.update_from_token(user, token)
db_token.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
authLogin(request, user)
return HttpResponseRedirect(reverse("dashboard"))
def register(request):
context = {}
if request.method == "GET":
context['form'] = RegisterForm()
return render(request, 'register.html', context)
form = RegisterForm(request.POST)
context['form'] = form
if not form.is_valid():
return render(request, 'login.html', context)
new_user = User.objects.create_user(
username=form.cleaned_data['username'],
email=form.cleaned_data['username'],
name=form.cleaned_data['name'],
first_name=form.cleaned_data['name'],
password=form.cleaned_data['password'],
bio=form.cleaned_data['bio'],
birthdate=form.cleaned_data['birthdate'],
location_lon=0,
location_lat=0,
)
new_user.save()
preferences = Preferences(user=new_user)
preferences.save()
new_user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
authLogin(request, new_user)
send_registration_mail(request, new_user)
return redirect(reverse('index'))
def authorize(request):
token = oauth.lichess.authorize_access_token(request)
response = oauth.lichess.get("/api/account", token=token)
result = response.json()
username = result["username"]
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return HttpResponseRedirect(reverse("login.unauthorized"))
try:
db_token = OAuth2Token.objects.get(user=user)
except OAuth2Token.DoesNotExist:
db_token = OAuth2Token(user=user)
db_token.update_from_token(user, token)
db_token.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
authLogin(request, user)
return HttpResponseRedirect(reverse("dashboard"))
