def handle(self, *args, **options):
try:
email = options['email']
EmailValidator()(email)
except ValidationError as exc:
raise CommandError(exc)
with transaction.atomic():
try:
user = User.objects.create_user(options['username'],
email,
options['password'],
is_staff=True)
user.save()
except IntegrityError as exc:
raise CommandError(exc)
token = options.get('token')
if token:
t = Token(user_id=user.id, key=token)
else:
t = Token(user_id=user.id)
t.save()
msg = ('successfully create user(username="******", email="{}")'
' with token "{}".').format(options['username'], email,
t.key)
self.stdout.write(self.style.SUCCESS(msg))
def setUp(self):
self.client = Client()
User(id=1, username="******", password="******").save()
User(id=2, username="******", password="******").save()
Token(user_id=1, created=datetime.now(), key="testToken1").save()
Token(user_id=2, created=datetime.now(), key="testToken2").save()
Friends(user_one_id=1, user_two_id=2).save()
def test_two_different_demo_users_when_no_cookie(self):
response = self.client.put(self.url)
demo_token = Token(response.data['token'])
client2 = APIClient()
response2 = client2.put(self.url)
demo_token2 = Token(response2.data['token'])
self.assertNotEqual(demo_token, demo_token2)
def setUp(self):
self.client = APIClient()
mods.mock_query(self.client)
u1 = User(first_name='User', last_name='Voting', username='******')
u1.set_password('123')
u1.save()
self.user1 = u1
t1 = Token(user=u1)
t1.save()
self.token1 = t1
u2 = User(first_name='User',
last_name='Voting2',
username='******',
email='*****@*****.**')
u2.set_password('123')
u2.save()
self.user2 = u2
vu2 = VotingUser(user=u2,
dni='45454545T',
sexo='Man',
titulo='Software',
curso='First',
edad=18)
vu2.save()
self.votingUser = vu2
t2 = Token(user=u2)
t2.save()
self.token2 = t2
u3 = User(first_name='User', last_name='Voting3', username='******')
u3.set_password('123')
u3.save()
self.user3 = u3
def _create_token(user, key):
"""
Instantiate the new token
:param user:
:param key:
:return:
"""
if key:
token = Token(user=user, created=datetime.datetime.now(), key=key)
else:
token = Token(user=user, created=datetime.datetime.now())
token.save()
return token
def forgot_password(request):
serial = ForgotPassword(data=request.data)
if serial.is_valid():
email = serial.validated_data['email']
try:
user = User.objects.get(email=email)
except:
user = None
if user is not None:
token = Token(key=secrets.token_urlsafe(10), user_id=user.id)
token.save()
else:
raise serializers.ValidationError(
{'email': 'user with the email address not exist '})
subject = 'Tribalmart Mail'
message = 'Please click the below link to reset your password \nhttp://localhost:8000/account/reset/' + str(
token)
from_email = settings.EMAIL_HOST_USER
tolist = [email]
send_mail(subject, message, from_email, tolist)
data = {'reset': 'reset password'}
else:
data = serial.errors
return Response(data)
def post(self, request, format=None):
try:
data = request.data
except ParseError as error:
return Response('Invalid JSON - {0}'.format(error.detail),
status=status.HTTP_400_BAD_REQUEST)
response = {}
u = User(username=data['mobile'])
u.set_password(data['password'])
u.save()
response['U_ID'] = u.id
d = Doctor(
name=data['name'],
mobile=data['mobile'],
email=data['email'],
hospital=data['hospital'],
# fcm=data['fcm'],
user=u)
d.save()
response['ID'] = d.id
t = Token(user=u)
t.save()
response['Token'] = t.key
return JsonResponse(response,
safe=False,
content_type='application/json')
def post(self, request, format=None):
try:
data = request.data
except ParseError as error:
return Response('Invalid JSON - {0}'.format(error.detail),
status=status.HTTP_400_BAD_REQUEST)
response = {}
u = User(username=data['mobile'])
u.set_password(data['password'])
u.save()
response['U_ID'] = u.id
d = Doctor.objects.get(id=data['doctor'])
p = Patient(name=data['name'],
mobile=data['mobile'],
email=data['email'],
address=data['address'],
date_of_birth=data['date_of_birth'],
gender=data['gender'],
user=u,
doctor=d)
p.save()
response['ID'] = p.id
t = Token(user=u)
t.save()
response['Token'] = t.key
return JsonResponse(response,
safe=False,
content_type='application/json')
def generate_code(self, request):
"""
Get function for generate_code
"""
"""Function to generate the otp send it to the user as well as set it for the user"""
email = request.data.get('email') or None
user = None
try:
user = User.objects.get(email=email)
except Exception as e:
return Response(data={'success': False, 'msg': 'Email does not exist'},status=status.HTTP_200_OK)
token = jwt.encode({'exp': datetime.utcnow() + timedelta(hours=1)}, 'password',algorithm='HS256')
token = token.decode('utf-8')
code=generate_random_code()
Token.objects.filter(user=user).delete()
try:
tok = Token()
tok.user=user
tok.token=token
tok.code=code
tok.save()
url = settings.SERVER_ADDRESS + 'auth/reset/password/?token=' + token
dict_to_send = {"email": email,'url':'none',"site_name":settings.SITE_NAME, 'code':code, "subject": settings.SITE_NAME+"!Forgot Password",
"template_name": 'auth/email/user_forgot_passwprd_template.html'}
send_email(**dict_to_send)
return Response(data={'success': True, 'token':token, 'msg': 'Kindly check your email to reset password'},status=status.HTTP_200_OK)
except Exception as e:
return Response(data={'status': False, 'msg': 'No such email found in our records. Kindly register with us'},status=status.HTTP_200_OK)
return Response(data={'status': False, 'msg': 'No such email found in our records. Kindly register with us'},status=status.HTTP_200_OK)
def test_user_pointer_story(self):
self.client.logout()
user2 = User.objects.create_user(username="******", \
password="******", email="email2")
user3 = User.objects.create_user(username="******", \
password="******", email="email3")
user4 = User.objects.create_user(username="******", \
password="******", email="email4")
self.create_pointer_with_user(user2, 'party1')
self.create_pointer_with_user(user3, 'party2')
self.create_pointer_with_user(user4, 'party3')
self.create_pointer_with_user(user2, 'party123')
fr1 = Friendship.objects.create_friendship(self.user1, user2)
Friendship.objects.create_friendship(self.user1, user3)
Friendship.objects.create_friendship(self.user1, user4)
# not friends with self.user5
token = Token(user=self.user1)
token.save()
request = self.client.get('/point/user_story_list/',
HTTP_AUTHORIZATION="Token {}".format(token))
self.assertEqual(len(request.data), 4)
# if self.user1 not friends with user2 then only 2 pointer in story
fr1.delete()
request = self.client.get('/point/user_story_list/',
HTTP_AUTHORIZATION="Token {}".format(token))
self.assertEqual(len(request.data), 2)
def test_get_pointer_data_with_pk(self):
point = self.create_pointer_with_user(self.user2, 'party1')
token = Token(user=self.user2)
token.save()
request = self.client.get('/point/pointer_data/' + str(point.id) + '/',
HTTP_AUTHORIZATION="Token {}".format(token))
self.assertEqual(request.status_code, 200)
def create(self, request, *args, **kwargs):
LOGGER.debug("Received request for creating user")
with transaction.atomic():
serializer = self.get_serializer_class()(data=request.data)
serializer.is_valid(raise_exception=True)
user_instance = serializer.save()
password = request.data["password"]
user_instance.set_password(password)
user_instance.is_active = False
user_instance.save()
#create token for newly created user
LOGGER.debug("creating token for user")
user_token = Token(user=user_instance)
user_token.save()
LOGGER.debug("Created token for user")
target_url = request.build_absolute_uri(reverse("signup-activate"))
send_account_activation_email.delay(user_instance.id, target_url, task_id=uuid.uuid4())
LOGGER.debug("Added task for sending request to user asynchronously")
user_dtls_serializer = UserPrimaryDtlsSerializer(instance=user_instance)
LOGGER.info("User: %s created successfully", user_instance.username)
return Response(user_dtls_serializer.data, status=HTTP_201_CREATED)
def post(self, request):
# 做一个表单验证判断
login_form = LoginForm(request.POST)
# 如果数据合法,就执行接下来的操作
if login_form.is_valid():
user_name = request.POST.get("username", "")
pass_word = request.POST.get("password", "")
# 判断该用户是否存在于用户表中(即已经注册过)
if UserProfile.objects.filter(
username=user_name) or UserProfile.objects.filter(
email=user_name):
# 引入authenticate方法对用户的用户名和密码做一个认证操作
user = authenticate(username=user_name, password=pass_word)
if user is not None:
if user.is_active:
# 判断用户是否为激活状态
# login函数的作用能根据用户的信息生成session id,并保存在django的session中，当退出浏览器后，将会清空这个表
# cookie:一种保存文件在本地的机制，可在用户访问时带上这些信息，但是不安全，所以需要session，它会从数据库中生成一段随机的session id,用户访问时带上这个id，可以实现自动登录，但是一段时间后便会过期
login(request, user)
# 登录完成后,对用户的token进行一个更新,这里调用generate_key方法来产生新的token
new_token = Token().generate_key()
Token.objects.update(user=user, key=new_token)
return redirect("/index/", {'user': user_name})
else:
return render(request, 'login.html',
{'msg': '用户未激活!请到注册的邮箱中激活该用户！'})
else:
return render(request, 'login.html', {'msg': '用户名或密码错误！'})
else:
return render(request, 'login.html', {'msg': '该用户未注册！'})
def setUp(self):
self.users = UserFactory.create_batch(size=2)
self.factory = APIRequestFactory()
self.client = APIClient()
token = Token(user=self.users[0])
token.save()
self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)
def token_generate():
queryset = MyUser.objects.all()
Token.objects.filter(user__in=queryset).delete()
new_tokens = [
Token(user=u, key=Token.generate_key()) for u in queryset.iterator()
]
Token.objects.bulk_create(new_tokens)
def setUp(self):
self.crowd = Crowd(name='test_crowd')
self.crowd.save()
self.user = UserProfile(username='******',
email='*****@*****.**',
password='******',
crowd=self.crowd)
self.user.save()
# Include an appropriate `Authorization:` header on all requests.
self.token = Token(user=self.user)
self.token.save()
self.category = Category(created_by=self.user,
name='test_category',
color='red',
crowd=self.crowd)
self.category.save()
self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key)
self.viewset = PostViewSet.as_view({
'get': 'retrieve',
'put': 'update',
'patch': 'partial_update',
'delete': 'destroy'
})
def setUp(self):
lauren = User(username='******')
lauren.save()
lauren_token = Token(user=lauren)
lauren_token.save()
hagstjorn = Subject(name='Hagstjórn', number=1)
hagstjorn.save()
fjarreidur = Subject(name='Fjárreiður ríkisins',
parent=hagstjorn,
number=2)
fjarreidur.save()
parliament = Parliament(name='Parliament',
start_date='2017-01-01',
end_date='2017-01-01')
parliament.save()
promise1 = Promise(name='Promise 1', parliament=parliament)
promise2 = Promise(name='Promise 2', parliament=parliament)
promise1.save()
promise2.save()
promise1_hagstjorn = PromiseSubject(subject=hagstjorn,
promise=promise1)
promise2_fjarreidur = PromiseSubject(subject=fjarreidur,
promise=promise2)
promise1_hagstjorn.save()
promise2_fjarreidur.save()
def post(self, request, *args, **kwargs):
"""
Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
"""
form = self.get_form()
if form.is_valid():
username = request.POST['username']
try:
query_user = User.objects.get(username=username)
except Exception:
query_user = None
if query_user is not None:
if query_user.username == username:
password = form.cleaned_data.get("password")
user = authenticate(username=username, password=password)
request.session['user'] = user.username
if user:
user_token = Token(user=query_user)
user_token.save()
else:
return self.form_invalid(form)
return self.form_valid(form)
else:
return self.form_invalid(form)
def setUp(self):
User(id=1,
username="******",
password="******",
is_superuser=True).save()
Token(user_id=1, created=datetime.now(), key="testToken1").save()
self.client = Client()
def setUpClass(cls):
user = User.objects.create_user(username="******", password="******")
t = Token(user=user)
t.save()
user_token = t.key
cls.client = APIClient()
#cls.client.login(username="******", password="******")
cls.client.credentials(HTTP_AUTHORIZATION='Token ' + user_token)
def test_that_generating_a_key_uses_SHA512(self):
with patch(
'postcode_api.custom_token_generators.'
'SHA512KeyGenerator.generate',
return_value='foo') as mock:
key = Token().generate_key()
self.assertTrue(mock.called)
self.assertEqual(key, 'foo')
def post(self, request, token):
user = get_object_or_404(User, auth_token__key=token)
Token.objects.filter(user=user).update(key=Token().generate_key())
user.is_active = True
user.save()
return Response({'message': 'Registration confirmed.'},
status.HTTP_200_OK)
def patch(self, request):
serializer = ResetPassSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = request
user.set_password(serializer.validated_data['new_password'])
user.save()
Token.objects.filter(user=user).update(key=Token().generate_key())
return Response(status=status.HTTP_204_NO_CONTENT)
def twitter(request):
request_token_url = 'https://api.twitter.com/oauth/request_token'
access_token_url = 'https://api.twitter.com/oauth/access_token'
authenticate_url = 'https://api.twitter.com/oauth/authenticate'
consumer_key = settings.SOSH["twitter"]["CONSUMER_KEY"]
consumer_secret = settings.SOSH["twitter"]["CONSUMER_SECRET"]
callback = settings.SOSH["twitter"]["CALLBACK_URL"]
if request.GET.get('oauth_token') and request.GET.get('oauth_verifier'):
auth = OAuth1(consumer_key,
consumer_secret,
request.GET.get("oauth_token"),
verifier=request.GET.get("oauth_verifier"))
r = requests.post(access_token_url, auth=auth)
profile = dict(parse_qsl(r.text))
provider = "twitter"
uid = profile["user_id"]
display_name = profile["screen_name"]
username = "******" % (provider, uid)
try:
social_user = SocialUser.objects.get(uid=uid, provider="twitter")
social_user.access_token = "Twitter"
social_user.extra_data = profile
social_user.save()
token = Token.objects.get(user=social_user.user)
except SocialUser.DoesNotExist:
user, created = get_user_model() \
.objects.get_or_create(username=username,
display_name=display_name)
if created:
token = Token(user=user)
token.save()
else:
token = Token.objects.get(user=user)
social_user, created = SocialUser \
.objects.get_or_create(
provider="twitter", user=user, uid=uid)
if created:
social_user.display_name = display_name
social_user.access_token = "Twitter"
social_user.extra_data = profile
social_user.save()
output = {}
output["key"] = token.key
return HttpResponse(json.dumps(output))
else:
oauth = OAuth1(consumer_key,
client_secret=consumer_secret,
callback_uri=callback)
r = requests.post(request_token_url, auth=oauth)
oauth_token = dict(parse_qsl(r.text))
qs = urlencode(dict(oauth_token=oauth_token['oauth_token']))
return redirect("%s?%s" % (authenticate_url, qs))
def test_pointer_data_serializer_with_members(self):
Friendship.objects.create_friendship(self.user1, self.user2)
point = self.create_pointer_with_user(self.user1, 'party123')
token = Token(user=self.user1)
token.save()
request = self.client.get('/point/pointer_data/' + str(point.id) + '/',
HTTP_AUTHORIZATION="Token {}".format(token))
self.assertEqual(len(request.data["members"]), 0)
def build_test_user():
user = TwitterishUser.objects.create_user("name", "email", "password")
token = Token()
token.user = user
token.key = "123456789"
token.save()
return user, token
def google(request):
data = json.loads(request.body)
access_token_url = 'https://accounts.google.com/o/oauth2/token'
people_api_url = \
'https://www.googleapis.com/plus/v1/people/me/openIdConnect'
payload = dict(client_id=data["clientId"],
redirect_uri=data['redirectUri'],
client_secret=settings.SOSH["google"]["CLIENT_SECRET"],
code=data['code'],
grant_type="authorization_code")
r = requests.post(access_token_url, data=payload)
token = json.loads(r.text)
access_token = token["access_token"]
headers = {'Authorization': 'Bearer %s' % (access_token)}
r = requests.get(people_api_url, headers=headers)
profile = json.loads(r.text)
provider = "google"
uid = profile["sub"]
display_name = profile["name"]
username = "******" % (provider, uid)
email = None
if "email" in profile:
email = profile["email"]
try:
social_user = SocialUser.objects.get(uid=uid, provider="google")
social_user.access_token = access_token
social_user.extra_data = profile
social_user.save()
token = Token.objects.get(user=social_user.user)
except SocialUser.DoesNotExist:
user, created = get_user_model() \
.objects.get_or_create(
username=username,
display_name=display_name,
avatar=profile["picture"],
email=email)
if created:
token = Token(user=user)
token.save()
else:
token = Token.objects.get(user=user)
social_user, created = SocialUser \
.objects.get_or_create(provider="google", user=user, uid=uid)
if created:
social_user.display_name = display_name
social_user.access_token = access_token
social_user.extra_data = profile
social_user.save()
output = {}
output["key"] = token.key
return HttpResponse(json.dumps(output))
def post(self, request):
global response
email = request.data["email"]
response = {
'success': False,
'message': "not a vaild email ",
'data': []
}
# email validation is done here
if email == "":
response[
'message'] = 'email field is empty please provide vaild input'
return HttpResponse(json.dumps(response), status=400)
else:
try:
validate_email(email)
except Exception:
return HttpResponse(json.dumps(response), status=400)
try:
user = User.objects.filter(email=email)
useremail = user.values()[0]["email"]
username = user.values()[0]["username"]
id = user.values()[0]["id"]
# here user is not none then token is generated
if useremail is not None:
token = Token(username, id)
url = str(token)
surl = get_surl(url)
# email is generated where it is sent the email address entered in the form
mail_subject = "Activate your account by clicking below link"
mail_message = {
'user': username,
'domain': get_current_site(request).domain,
}
recipientemail = email
email = EmailMessage('send_email', recipientemail,
mail_message, mail_subject)
email.send()
response = {
'success': True,
'message': "check email for vaildation ",
'data': []
}
# here email is sent to user
return HttpResponse(json.dumps(response), status=201)
except Exception as e:
print(e)
response['message'] = "something went wrong"
return HttpResponse(json.dumps(response), status=400)
def token_expire_handler(token):
""" if token is expired new token will be established
If token is expired then it will be removed
and new one with different key will be created """
is_expired = is_token_expired(token)
if is_expired:
token.delete()
token = Token(user=token.user)
return is_expired, token
def test_with_point_list(self):
self.client.logout()
self.create_pointer(title="party1")
self.create_pointer(title="party2")
token = Token(user=self.user1)
token.save()
request = self.client.get('/point/author_pointer_list/',
HTTP_AUTHORIZATION="Token {}".format(token))
self.assertEqual(len(request.data), 2)
