def test_1_process(self):
self.assertEqual(
PostponedTaskPrototype._model_class.objects.all().count(), 0)
self.assertEqual(
ChangeCredentialsTaskPrototype._model_class.objects.all().count(),
0)
new_password = self.task.process(logger=mock.Mock())
self.assertTrue(self.task.is_processed)
self.assertEqual(
django_authenticate(nick=self.account.nick, password='******').id,
self.account.id)
self.assertEqual(
PostponedTaskPrototype._model_class.objects.all().count(), 1)
self.assertEqual(
ChangeCredentialsTaskPrototype._model_class.objects.all().count(),
1)
PostponedTaskPrototype._db_get_object(0).process(logger=mock.Mock())
self.assertEqual(
django_authenticate(nick=self.account.nick, password='******'),
None)
self.assertEqual(
django_authenticate(nick=self.account.nick,
password=new_password).id, self.account.id)
def login_user(request):
context = {}
if request.method == "POST":
username = request.POST['username']
password = request.POST['password']
user = django_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
django_login(request, user)
return redirect('user_profile:client')
else:
context['message'] = 'Account disabled'
else:
context['message'] = "Invalid"
return render(request, 'registration/login.html', context)
elif request.user.is_authenticated:
username = request.POST.get('username')
password = request.POST.get('password')
user = django_authenticate(username=username, password=password)
if user is not None:
if user.is_active:
django_login(request, user)
return redirect('user_profile:client')
else:
context['message'] = 'Account Disabled'
else:
context['message'] = 'Invalid Login'
return render(request, 'registration/login.html', context)
else:
return render(request, 'registration/login.html',
{'errormsg': 'error'})
def get_resource(request, file_location):
try:
username = request.session.get('username', None)
remote_ip = request.META.get('REMOTE_ADDR', None)
if remote_ip is not None:
#Authenticated if the instance requests resource.
instances = Instance.objects.filter(ip_address=remote_ip)
authenticated = len(instances) > 0
elif username is not None:
django_authenticate(username=username, password="")
#User Authenticated by this line
authenticated = True
if not authenticated:
raise Exception("Unauthorized access")
path = settings.PROJECT_ROOT+"/init_files/"+file_location
if os.path.exists(path):
file = open(path, 'r')
content = file.read()
response = HttpResponse(content)
#Download it, even if it looks like text
response['Content-Disposition'] = \
'attachment; filename=%s' % file_location.split("/")[-1]
return response
template = get_template('404.html')
variables = RequestContext(request, {
'message': '%s not found' % (file_location,)
})
output = template.render(variables)
return HttpResponse(output)
except Exception, e:
logger.debug("Resource request failed")
logger.exception(e)
return HttpResponseRedirect(settings.REDIRECT_URL+"/login")
def get_resource(request, file_location):
try:
username = request.session.get('username', None)
remote_ip = request.META.get('REMOTE_ADDR', None)
if remote_ip is not None:
#Authenticated if the instance requests resource.
instances = Instance.objects.filter(ip_address=remote_ip)
authenticated = len(instances) > 0
elif username is not None:
django_authenticate(username=username, password="")
#User Authenticated by this line
authenticated = True
if not authenticated:
raise Exception("Unauthorized access")
path = settings.PROJECT_ROOT + "/init_files/" + file_location
if os.path.exists(path):
file = open(path, 'r')
content = file.read()
response = HttpResponse(content)
#Download it, even if it looks like text
response['Content-Disposition'] = \
'attachment; filename=%s' % file_location.split("/")[-1]
return response
template = get_template('404.html')
variables = RequestContext(
request, {'message': '%s not found' % (file_location, )})
output = template.render(variables)
return HttpResponse(output)
except Exception, e:
logger.debug("Resource request failed")
logger.exception(e)
return HttpResponseRedirect(settings.REDIRECT_URL + "/login")
def test_change_credentials_email(self):
self.account.change_credentials(new_email='*****@*****.**')
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, '*****@*****.**')
self.assertEqual(django_authenticate(nick='test_user', password='******').id, self.account.id)
self.assertEqual(django_authenticate(nick='test_user', password='******').nick, 'test_user')
def authenticate(username, password):
if DJANGO_VERSION[1] > 10:
request = create_request()
return django_authenticate(request=request,
username=username,
password=password)
else:
return django_authenticate(username=username, password=password)
def test_change_credentials_email(self):
self.account.change_credentials(new_email="*****@*****.**")
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, "*****@*****.**")
self.assertEqual(django_authenticate(nick="test_user", password="******").id, self.account.id)
self.assertEqual(django_authenticate(nick="test_user", password="******").nick, "test_user")
def test_profile_update_duplicate_nick(self):
register_user('duplicated_user', '*****@*****.**', '111111')
self.request_login(self.account.email)
response = self.client.post(reverse('accounts:profile:update'), {'nick': 'duplicated_user', 'email': '*****@*****.**'})
self.check_ajax_error(response, 'accounts.profile.update.used_nick')
self.assertEqual(ChangeCredentialsTask.objects.all().count(), 0)
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(django_authenticate(nick=self.account_nick, password='******').id, self.account.id)
self.assertEqual(django_authenticate(nick=self.account_nick, password='******').email, self.account_email)
def test_profile_update_email(self):
self.request_login(self.account.email)
response = self.client.post(reverse('accounts:profile:update'), {'email': '*****@*****.**', 'nick': 'test_nick'})
self.assertEqual(response.status_code, 200)
self.check_ajax_ok(response, data={'next_url': reverse('accounts:profile:confirm-email-request')})
self.assertEqual(ChangeCredentialsTask.objects.all().count(), 1)
self.assertEqual(ChangeCredentialsTask.objects.all()[0].state, relations.CHANGE_CREDENTIALS_TASK_STATE.EMAIL_SENT)
self.assertEqual(Message.objects.all().count(), 1)
self.assertEqual(django_authenticate(nick=self.account_nick, password='******').id, self.account.id)
self.assertEqual(django_authenticate(nick=self.account_nick, password='******').email, self.account_email)
def test_change_credentials_email(self):
nick = self.account.nick
self.account.change_credentials(new_email='*****@*****.**')
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, '*****@*****.**')
self.assertEqual(django_authenticate(nick=nick, password='******').id, self.account.id)
self.assertEqual(django_authenticate(nick=nick, password='******').nick, nick)
def test_profile_update_duplicate_nick(self):
account = self.accounts_factory.create_account()
self.request_login(self.account.email)
response = self.client.post(
reverse("accounts:profile:update"), {"nick": account.nick, "email": "*****@*****.**"}
)
self.check_ajax_error(response, "accounts.profile.update.used_nick")
self.assertEqual(ChangeCredentialsTask.objects.all().count(), 0)
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(django_authenticate(nick=self.account_nick, password="******").id, self.account.id)
self.assertEqual(django_authenticate(nick=self.account_nick, password="******").email, self.account_email)
def test_process_email_sent(self):
task = ChangeCredentialsTaskPrototype.create(self.test_account, new_email='*****@*****.**', new_password='******')
postponed_task = task.process(FakeLogger())
self.assertEqual(postponed_task, None)
self.assertEqual(task.state, relations.CHANGE_CREDENTIALS_TASK_STATE.EMAIL_SENT)
self.assertEqual(Message.objects.all().count(), 1)
self.assertEqual(django_authenticate(nick='test_user', password='******').id, task.account.id)
self.assertEqual(django_authenticate(nick='test_user', password='******'), None)
postponed_task = task.process(FakeLogger())
self.assertEqual(task.state, relations.CHANGE_CREDENTIALS_TASK_STATE.CHANGING)
self.assertNotEqual(postponed_task, None)
def test_1_process(self):
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 0)
self.assertEqual(ChangeCredentialsTaskPrototype._model_class.objects.all().count(), 0)
new_password = self.task.process(logger=mock.Mock())
self.assertTrue(self.task.is_processed)
self.assertEqual(django_authenticate(nick='test_user', password='******').id, self.account.id)
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 1)
self.assertEqual(ChangeCredentialsTaskPrototype._model_class.objects.all().count(), 1)
PostponedTaskPrototype._db_get_object(0).process(logger=mock.Mock())
self.assertEqual(django_authenticate(nick='test_user', password='******'), None)
self.assertEqual(django_authenticate(nick='test_user', password=new_password).id, self.account.id)
def login(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
errors = []
form = LoginForm(data=request.POST)
if form.is_valid():
account = django_authenticate(email=request.POST['email'],
password=request.POST['password'])
if account and account.is_active:
django_login(request, account)
return HttpResponseRedirect('/')
else:
errors.append("Login failed")
return render(request, 'authentication/login.html', {
'form': form,
'errors': errors
})
else:
errors.append("Form invalid")
return render(request, 'authentication/login.html', {
'form': form,
'errors': errors
})
else:
form = LoginForm()
return render(request, 'authentication/login.html', {'form': form})
def login(request):
if request.user.is_authenticated:
return redirect('home')
else:
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
email = request.POST['email']
password = request.POST['password']
user = django_authenticate(email=email, password=password)
if user is not None:
if user.is_active:
django_login(request, user)
# user is redirected to dashboard
return redirect('home')
else:
messages.error(request, 'username or password not correct')
return redirect('login')
else:
form = AuthenticationForm()
page_title = 'Login Page'
return render(request, 'accounts/login.html', {
'form': form,
'page_title': page_title
})
def login(self, request):
# get username and password from request
# data就是用户post的request中的数据
# check request
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid(): # 如果登录出错
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
},
status=400)
# validation ok
# check password
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "Username and password does not match.",
},
status=400)
# login
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(user).data,
})
def update_password(request):
if not request.method == 'POST':
return JSON_error("error")
d = JSON_parse(request.POST.get('data'))
if 'current_password' not in d or 'password1' not in d or 'password2' not in d:
return JSON_error('error', _('Something went wrong during password saving. Contact support.'))
if d['password1'] != d['password2']:
return JSON_error('new_password_mismatch', _('New passwords do not match'))
if not min_password_requirments(d['password1']):
return JSON_error('min_pass_requirement_failed', _('Password minimal requirments failed.'))
user = django_authenticate(username=request.user.email, password=d['current_password'])
if user is None:
return JSON_error('wrong_current_password')
if user is not None:
# saves in django table
user.set_password(d['password1'])
user.save()
user.update_user_profile()
return JSON_ok()
return JSON_error('error', _('Something went wrong during password saving. Contact support.'))
def callback(request, redirect_url=None):
odesk_client = DefaultClient()
if request.session.get(ODESK_REQUEST_TOKEN):
t, s = request.session.get(ODESK_REQUEST_TOKEN)
odesk_client.auth.request_token = t
odesk_client.auth.request_token_secret = s
del request.session[ODESK_REQUEST_TOKEN]
else:
return HttpResponseRedirect(odesk_client.auth.get_authorize_url())
verifer = request.GET.get('oauth_verifier', None)
access_token = odesk_client.auth.get_access_token(verifer)
if access_token:
request.session[ODESK_ACCESS_TOKEN] = access_token
#TODO: Get rid of (conceptually correct) additional request to odesk.com
user = django_authenticate(token = access_token)
if user:
login(request, user)
else:
pass
#Probably the odesk auth backend is missing. Should we raise an error?
redirect_url = request.session.pop(ODESK_REDIRECT_SESSION_KEY,
redirect_url)
response = HttpResponseRedirect(redirect_url or '/')
return response
else:
return HttpResponseRedirect(odesk_client.auth.get_authorize_url())
def login(request):
"""
Check (lowercased) usename and password and do login if they matched.
Only POST request is allowed.
Return status and message in a dictionary.
"""
success = False
data = {}
message = u''
if request.method != 'POST':
message = _("Only POST method is allowed when you log in.")
return False, None, message
sessionid = None
if "username" in request.POST and "password" in request.POST:
user = django_authenticate(username=request.POST["username"].lower(),
password=request.POST["password"])
else:
message = _("Missing username and/or password parameter.")
return False, None, message
if user is not None:
if user.is_active:
success = True
message = _("Login OK")
# This puts sessionid cookie into the response headers:
django_login(request, user)
sessionid = request.session.session_key
else:
message = _("Your account has been disabled!")
else:
message = _("Your username and password did not match.")
data = {"sessionid": sessionid}
return success, data, message
def callback(request, redirect_url=None):
odesk_client = DefaultClient()
frob = request.GET.get('frob', None)
if frob:
try:
token, auth_user = odesk_client.auth.get_token(frob)
except:
if not redirect_url:
redirect_url = '/'
return HttpResponseRedirect(redirect_url)
request.session[ODESK_TOKEN_SESSION_KEY] = token
#TODO: Get rid of (conceptually correct) additional request to odesk.com
user = django_authenticate(token=token)
if user:
login(request, user)
else:
pass
#Probably the odesk auth backend is missing. Should we raise an error?
redirect_url = request.session.pop(ODESK_REDIRECT_SESSION_KEY,
redirect_url)
if not redirect_url:
redirect_url = '/'
return HttpResponseRedirect(redirect_url)
else:
return HttpResponseRedirect(odesk_client.auth.auth_url())
def test_process_timeout(self):
task = ChangeCredentialsTaskPrototype.create(self.test_account, new_email='*****@*****.**')
task._model.created_at = datetime.datetime.fromtimestamp(0)
task.process(FakeLogger())
self.assertEqual(task.state, relations.CHANGE_CREDENTIALS_TASK_STATE.TIMEOUT)
self.assertEqual(task._model.comment, 'timeout')
self.assertEqual(django_authenticate(nick='test_user', password='******').id, task.account.id)
def post(self, request, *args, **kwargs):
data = request.data
print(request.data)
username = data.get('phone', None)
password = data.get('password', None)
dat = json.dumps({"username": username, "password": password})
try:
req = Request(
config('HOST_URL') + '/api/token-auth',
bytes(dat, encoding="utf-8"),
{'Content-Type': 'application/json'})
req.data
response_body = urlopen(req)
data = response_body.read()
encoding = response_body.info().get_content_charset('utf-8')
result = json.loads(data.decode(encoding))
user = django_authenticate(username=username, password=password)
if user is not None:
django_login(request, user)
result_data = {"user_id": user.id, "token": result['token']}
return Response(result_data, status=status.HTTP_200_OK)
return Response({"error": "User not found."},
status=status.HTTP_404_NOT_FOUND)
except User.DoesNotExist:
return Response({"error": 'User does not exist.'},
status=status.HTTP_404_NOT_FOUND)
except:
return Response({"error": "Incorrect username or password"},
status=status.HTTP_400_BAD_REQUEST)
def authenticate(self, request, **kwargs):
'''
Checks a user's basic auth credentials against the current
Django auth backend.
Should return either ``True`` if allowed, ``False`` if not or an
``HttpResponse`` if you need something custom.
'''
if not request.META.get('HTTP_AUTHORIZATION'):
self._unauthorized()
try:
(auth_type, data) = request.META['HTTP_AUTHORIZATION'].split()
if auth_type.lower() != 'basic':
return self._unauthorized()
user_pass = base64.b64decode(data)
except:
self._unauthorized()
bits = user_pass.split(':')
if len(bits) != 2:
self._unauthorized()
if self.backend:
user = self.backend.authenticate(username=bits[0], password=bits[1])
else:
user = django_authenticate(username=bits[0], password=bits[1])
if user is None:
self._unauthorized()
request.user = user
def test_profile_update_duplicate_nick(self):
account = self.accounts_factory.create_account()
self.request_login(self.account.email)
response = self.client.post(reverse('accounts:profile:update'), {
'nick': account.nick,
'email': '*****@*****.**'
})
self.check_ajax_error(response, 'accounts.profile.update.used_nick')
self.assertEqual(ChangeCredentialsTask.objects.all().count(), 0)
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(
django_authenticate(nick=self.account_nick, password='******').id,
self.account.id)
self.assertEqual(
django_authenticate(nick=self.account_nick,
password='******').email, self.account_email)
def login(request):
'''Take in a username and password, check it against DB'''
#Get the username and password. We'll use python's .get for dicts to
# ensure that something is returned, albeit an empty string
username = cgi.escape(request.POST.get('username', ''))
password = cgi.escape(request.POST.get('password', ''))
#Create an empty response string
res = 'Success'
#Return an user object if the username and password match
user = django_authenticate(username=username, password=password)
#See if we got back a user
if user is not None:
#We got a user
#For now, set a character to logged in
cur_character = Character.objects.get(account=user.get_profile())
cur_character.is_logged_in = True
cur_character.save()
#Call django's built in login
django_login(request, user)
else:
#Raise an error so the requester knows the login was incorrect
raise Http404
return HttpResponse(res)
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Input is not valid. Please check input",
"errors": serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success":
False,
"message":
"Username and password are not matched. Please try again",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(user).data,
})
def callback(request, redirect_url=None):
odesk_client = DefaultClient()
frob = request.GET.get('frob', None)
if frob:
try:
token, auth_user = odesk_client.auth.get_token(frob)
except Exception, exc:
msg = "get_token(%(frob)r) failed with %(exc)s" % {
'frob': frob,
'exc': exc,
'req': request,
}
logging.error(msg)
return HttpResponseRedirect(redirect_url or '/')
request.session[ODESK_TOKEN_SESSION_KEY] = token
#TODO: Get rid of (conceptually correct) additional request to odesk.com
user = django_authenticate(token = token)
if user:
login(request, user)
else:
pass
#Probably the odesk auth backend is missing. Should we raise an error?
redirect_url = request.session.pop(ODESK_REDIRECT_SESSION_KEY,
redirect_url)
return HttpResponseRedirect(redirect_url or '/')
def authenticate(self, request):
# Get the username and password
username = request.data['username']
password = request.data['password']
print('USERNAME', username)
print('PASSWORD', password)
if not username or not password:
raise exceptions.AuthenticationFailed(
"No credentials provided. You're probably logged out. Please login to continue."
)
credentials = {
get_user_model().USERNAME_FIELD: username,
'password': password
}
user = django_authenticate(**credentials)
if user is None:
raise exceptions.AuthenticationFailed('Invalid username/password.')
if not user.is_active:
raise exceptions.AuthenticationFailed('User inactive or deleted.')
return (user, None) # authentication successful
def generate_new_user(request):
username = get_rand_name()
if User.objects.filter(username__exact=username).exists():
user = User.objects.get(username=username)
else:
if User.objects.exclude(sid__exact="")\
.exclude(sid__exact="Deleted Content").count() == 0:
# if there are no users with sids, give sid "s1"
sid = "s1"
else:
previous_sid = User.objects.all()\
.exclude(sid__exact="Deleted Content")\
.last().sid
previous_sid_num = previous_sid[1:]
new_sid_num = int(previous_sid_num) + 1
sid = "s" + str(new_sid_num)
user = User.objects.create_user(username=username, password="",
sid=sid)
user.slug = slugify(user.username, max_length=100)
user.save()
user = django_authenticate(username=user.username, password="")
if user is not None and settings.ENVIRONMENT == "dev":
# django.contrib.auth.login only works in development environments. In
# production, use django.contrib.auth.views.login.
django_auth_login(request, user)
return user
else:
raise Exception("User is None, or you tried to generate a new user "
"in a production environment!")
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
# queryset = User.objects.filter(username=username)
# print(queryset.query)
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
'success': False,
'message': "username and password does not match",
},
status=400)
django_login(request, user)
return Response({
'success': True,
'user': UserSerializer(instance=user).data
})
def test_fast_profile_confirm_email(self):
self.client.post(reverse('accounts:registration:fast'))
PostponedTaskPrototype(model=PostponedTask.objects.all()[0]).process(
FakeLogger())
self.client.post(
reverse('accounts:profile:update'), {
'email': '*****@*****.**',
'nick': 'test_nick',
'password': '******'
})
self.assertEqual(Message.objects.all().count(), 1)
uuid = ChangeCredentialsTask.objects.all()[0].uuid
response = self.client.get(
reverse('accounts:profile:confirm-email') + '?uuid=' + uuid)
self.check_response_redirect(
response,
PostponedTaskPrototype._db_get_object(1).wait_url)
self.assertEqual(ChangeCredentialsTask.objects.all().count(), 1)
self.assertEqual(ChangeCredentialsTask.objects.all()[0].state,
relations.CHANGE_CREDENTIALS_TASK_STATE.CHANGING)
self.assertEqual(
django_authenticate(nick='test_nick', password='******'), None)
def login_execute(request, form: LoginForm):
user = User.objects.filter(email=form.cleaned_data['email']).first()
if user == None:
form.add_error('email', 'Incorrect email.')
return render(request, 'main/login.html', {'form': form})
if not user.organization_set.filter(
id=form.cleaned_data['organization']).exists():
form.add_error('organization',
'This user have not access to this organization.')
return render(request, 'main/login.html', {'form': form})
user = django_authenticate(username=user.username,
password=form.cleaned_data['password'])
if user is None:
form.add_error('password', 'Incorrect password.')
return render(request, 'main/login.html', {'form': form})
else:
django_login(request, user)
organization = Organization.objects.get(
id=form.cleaned_data['organization'])
request.session['org_id'] = organization.id
request.session['org_name'] = organization.name
return HttpResponseRedirect(reverse('main:task_lists'))
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"massage": "Please check input.",
"errors": serializer.errors,
},
status=400)
#validation ok , login
username = serializer.validated_data['username']
password = serializer.validated_data['password']
if not User.objects.filter(username=username).exists():
return Response(
{
"success": False,
"massage": "User does not exists."
},
status=400)
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"massage": "Username and password does not match.",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(instance=user).data
})
def login(self, request):
"""
默认的 username 是 admin, password 也是 admin
"""
# get post request body
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response({
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
}, status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
# User.objects.filter(username=username) will be translated to a query
# you can debug by
# queryset = User.objects.filter(username=username)
# print(queryset.query)
if not User.objects.filter(username=username).exists():
return Response({
"success": False,
"message": "Please check input."
}, status=400)
if not user or user.is_anonymous:
return Response({
"success": False,
"message": "Username and password does not match.",
}, status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(instance=user).data,
})
def authenticate(self, context, required=False):
for (k, v) in context.invocation_metadata():
if (k.lower() == "authorization"):
(method, auth) = v.split(" ", 1)
if (method.lower() == "basic"):
auth = base64.b64decode(auth)
(username, password) = auth.split(":")
user = django_authenticate(username=username,
password=password)
if not user:
raise XOSPermissionDenied(
"failed to authenticate %s:%s" %
(username, password))
print "authenticated %s:%s as %s" % (username, password,
user)
return user
elif (k.lower() == "x-xossession"):
s = SessionStore(session_key=v)
id = s.get("_auth_user_id", None)
if not id:
raise XOSPermissionDenied(
"failed to authenticate token %s" % v)
user = User.objects.get(id=id)
print "authenticated sessionid %s as %s" % (v, user)
return user
if required:
raise XOSPermissionDenied("This API requires authentication")
return None
def _let_user_login(request, user, email, password, next=''):
user = django_authenticate(email=email, password=password)
django_login(request, user)
if next:
return HttpResponseRedirect(redirect_to=next)
return HttpResponseRedirect(redirect_to='/')
def test_change_credentials__with_referral(self):
self.fast_account._model.referral_of = self.account._model
self.fast_account.save()
self.assertTrue(AccountPrototype.get_by_id(self.fast_account.id).is_fast)
with mock.patch("the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data") as fake_cmd:
with mock.patch(
"the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method"
) as cmd_run_account_method:
self.fast_account.change_credentials(
new_email="*****@*****.**", new_password=make_password("222222"), new_nick="test_nick"
)
self.assertEqual(cmd_run_account_method.call_count, 1)
self.assertEqual(
cmd_run_account_method.call_args,
mock.call(
account_id=self.account.id, method_name=AccountPrototype.update_referrals_number.__name__, data={}
),
)
self.assertEqual(django_authenticate(nick="test_nick", password="******").id, self.fast_account.id)
self.assertFalse(AccountPrototype.get_by_id(self.fast_account.id).is_fast)
self.assertEqual(fake_cmd.call_count, 1)
self.assertFalse(fake_cmd.call_args[1]["is_fast"])
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response({
"success": False,
"error": serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
# login
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(request,
username=username,
password=password)
# username and password not match
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "Username and password not match"
},
status=status.HTTP_400_BAD_REQUEST)
# valid username and password
django_login(request, user)
return Response(
{
"success": True,
"user": UserSerializer(instance=user).data,
},
status=status.HTTP_200_OK)
def test_process(self):
self.assertEqual(self.postponed_task.process(main_task=mock.Mock()),
POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertTrue(self.postponed_task.state.is_PROCESSED)
self.assertEqual(
django_authenticate(nick='test_nick', password='******').email,
'*****@*****.**')
def login(request):
# Actually `username` can represent nickname and email
username = str(request.POST['username'])
password = str(request.POST['password'])
# Authenticate
user = django_authenticate(username=username, password=password)
# Generate Response
if user:
# Check destroyed
if user.destroyed:
result = {"status": False, "result": _("User destroyed!")}
return JsonResponse(result)
# Check is_active
if not user.is_active:
result = {"status": False, "result": _("User is not active!")}
return JsonResponse(result)
# Check Blocked
if user.blocked:
result = {"status": False, "result": _("User blocked!")}
return JsonResponse(result)
# Set session
django_login(request, user)
result = {"status": True, "result": _("Login succeed!")}
return JsonResponse(result)
result = {"status": False, "result": _("Login Failed!")}
return JsonResponse(result)
def login(request):
if request.method == 'POST':
form = AuthenticationForm(data = request.POST)
if form.is_valid():
email = request.POST['email']
password = request.POST['password']
user = django_authenticate(email=email, password=password)
if user is not None:
if user.is_active and user.is_staff:
django_login(request,user)
return redirect('/dashboard') #user is redirected to dashboard
else:
django_login(request,user)
return redirect('/dashboard2')
else:
form = AuthenticationForm()
return render(request,'My_App/login.html',{'form':form,'error':'Incorrent Email and Password Try Again!'})
else:
if request.user.is_authenticated and request.user.is_staff:
return redirect('/dashboard')
elif request.user.is_authenticated:
return redirect('/dashboard2')
form = AuthenticationForm()
return render(request,'My_App/login.html',{'form':form,})
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
username = request.POST['username']
password = request.POST['password']
user = django_authenticate(username=username, password=password)
if user:
if not user.is_validated:
msg = _('User is not validated.')
form._errors['__all__'] = form.error_class([msg])
elif user.is_locked:
if datetime.now(pytz.utc) < user.locked_until:
msg = _('Your account is locked. Please try again in an hour')
form._errors['__all__'] = form.error_class([msg])
else:
user.unlock_user
return self.login_user(user)
else:
return self.login_user(user)
else:
try:
user = User.objects.get(username=username)
user.add_login_attempt()
except User.DoesNotExist:
pass
if user.is_locked:
msg = _('Your account is locked. Please try again in an hour')
form._errors['__all__'] = form.error_class([msg])
else:
msg = _('Invalid password.')
form._errors['password'] = form.error_class([msg])
return self.render_to_response({'form': form})
def test_change_credentials__with_referral(self):
self.fast_account._model.referral_of = self.account._model
self.fast_account.save()
self.assertTrue(
AccountPrototype.get_by_id(self.fast_account.id).is_fast)
with mock.patch(
'the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data'
) as fake_cmd:
with mock.patch(
'the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method'
) as cmd_run_account_method:
self.fast_account.change_credentials(
new_email='*****@*****.**',
new_password=make_password('222222'),
new_nick='test_nick')
self.assertEqual(cmd_run_account_method.call_count, 1)
self.assertEqual(
cmd_run_account_method.call_args,
mock.call(
account_id=self.account.id,
method_name=AccountPrototype.update_referrals_number.__name__,
data={}))
self.assertEqual(
django_authenticate(nick='test_nick', password='******').id,
self.fast_account.id)
self.assertFalse(
AccountPrototype.get_by_id(self.fast_account.id).is_fast)
self.assertEqual(fake_cmd.call_count, 1)
self.assertFalse(fake_cmd.call_args[1]['is_fast'])
def login(self, request):
"""
默认的 username 是 admin, password 也是 admin
"""
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Please check input",
"errors": serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "username and password does not match",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(instance=user).data,
})
def test_change_credentials_password(self):
self.account.change_credentials(new_password=make_password('222222'))
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, '*****@*****.**')
user = django_authenticate(nick='test_user', password='******')
self.assertEqual(user.id, self.account.id)
def test_reset_password_success(self):
self.check_ajax_ok(
self.client.post(reverse('accounts:profile:reset-password'),
{'email': self.account.email}))
self.assertEqual(
django_authenticate(nick=self.account.nick, password='******').id,
self.account.id)
self.assertEqual(ResetPasswordTask.objects.all().count(), 1)
def test_change_credentials_password(self):
self.account.change_credentials(new_password=make_password("222222"))
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, "*****@*****.**")
user = django_authenticate(nick="test_user", password="******")
self.assertEqual(user.id, self.account.id)
def test_change_credentials_nick(self):
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as fake_cmd:
self.account.change_credentials(new_nick='test_nick')
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(fake_cmd.call_count, 0)
self.assertEqual(django_authenticate(nick='test_nick', password='******').id, self.account.id)
def test_change_credentials_password(self):
self.account.change_credentials(new_password=make_password('222222'))
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, '*****@*****.**')
user = django_authenticate(nick='test_user', password='******')
self.assertEqual(user.id, self.account.id)
def test_change_credentials_nick(self):
with mock.patch("the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data") as fake_cmd:
self.account.change_credentials(new_nick="test_nick")
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(fake_cmd.call_count, 0)
self.assertEqual(django_authenticate(nick="test_nick", password="******").id, self.account.id)
def test_reset_password_page_for_wrong_email(self):
self.check_ajax_error(
self.client.post(reverse('accounts:profile:reset-password'),
{'email': '*****@*****.**'}),
'accounts.profile.reset_password.wrong_email')
self.assertEqual(
django_authenticate(nick=self.account.nick, password='******').id,
self.account.id)
self.assertEqual(ResetPasswordTask.objects.all().count(), 0)
def login_user(request, nick=None, password=None, remember=False):
user = django_authenticate(nick=nick, password=password)
if request.user.id != user.id:
request.session.flush()
django_login(request, user)
if remember:
request.session.set_expiry(accounts_settings.SESSION_REMEMBER_TIME)
def authenticate(username, password):
"""
Authenticate a given username/password with Django and make sure
they're also a staff user.
"""
user = django_authenticate(username=username, password=password)
if not user or not user.is_staff:
return False
else:
return True
def setUp(self):
super(TestRequestsBase, self).setUp()
create_test_map()
self.client = client.Client()
register_user('test_user', '*****@*****.**', '111111')
register_user('test_user_2', '*****@*****.**', '111111')
account = django_authenticate(nick='test_user_2', password='******')
account.is_staff = True
account.save()
def setUp(self):
super(TestRequestsBase, self).setUp()
create_test_map()
self.client = client.Client()
self.account_1 = self.accounts_factory.create_account()
self.account_2 = self.accounts_factory.create_account()
staff_account = django_authenticate(nick=self.account_2.nick, password='******')
staff_account.is_staff = True
staff_account.save()
def test_change_credentials_password(self):
nick = self.account.nick
email = self.account.email
self.account.change_credentials(new_password=make_password('222222'))
self.assertEqual(Message.objects.all().count(), 0)
self.assertEqual(self.account.email, email)
user = django_authenticate(nick=nick, password='******')
self.assertEqual(user.id, self.account.id)
def authenticate(request):
user = django_authenticate()
if user is not None:
django_login(request, user)
#redirect to valid logged page (preferably the user's request)
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = '/'
return HttpResponseRedirect(redirect_to)
else:
# return invalid login page
return HttpResponseRedirect('/invalid')
def test_reset_password_processed(self):
task = ResetPasswordTaskPrototype.create(self.account)
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 0)
self.assertEqual(ChangeCredentialsTaskPrototype._model_class.objects.all().count(), 0)
self.check_html_ok(self.request_html(reverse('accounts:profile:reset-password-processed') + ('?task=%s' % task.uuid)))
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 1)
self.assertEqual(ChangeCredentialsTaskPrototype._model_class.objects.all().count(), 1)
self.assertEqual(django_authenticate(nick='test_user', password='******').id, self.account.id)
def authenticate(request):
user = django_authenticate(request=request)
if user is not None:
django_login(request, user)
#redirect to valid login page
response = HttpResponseRedirect(request.GET.get('next', '/'))
set_cookie(response, "fb_user", user.id,
max_age=30 * 86400)
return response
else:
# return invalid login page
return HttpResponse('Invalid', 'text/plain')
