def post(self, request):
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data["user"]
django_login(request, user)
token, created = Token.objects.get_or_create(user=user)
return Response({"token": token.key}, status=200)
def post(self, request):
# Serializer to get our login details.
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
authenticated_user = serializer.validated_data['authenticated_user']
# Authenticate with the public.
login(self.request, authenticated_user)
# Get our web application authorization.
application = Application.objects.filter(
name=settings.MIKAID_RESOURCE_SERVER_NAME).first()
# Generate our access token which does not have a time limit.
aware_dt = timezone.now()
expires_dt = aware_dt.replace(aware_dt.year + 1776)
access_token, created = AccessToken.objects.update_or_create(
application=application,
user=authenticated_user,
defaults={
'user': authenticated_user,
'application': application,
'expires': expires_dt,
'token': generate_token(),
'scope': 'read,write,introspection'
},
scope='read,write,introspection')
# Return our new token.
return Response(data={
'token': str(access_token),
'scope': access_token.scope,
},
status=status.HTTP_200_OK)
def post(self, request):
serializer = LoginSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = authenticate(username=serializer.validated_data['username'],
password=serializer.validated_data['password'])
if user is None:
return Response({'detail': 'fail'})
login(request, user)
return Response({'detail': 'ok'})
def post(self, request):
serializer = LoginSerializer(data=request.data, context={
'request': request,
})
serializer.is_valid(raise_exception=True)
serializer.save()
return response.Response(
status=status.HTTP_200_OK,
data={
'details': 'You have been logged in successfully!'
},
)
def post(self, request):
data = LoginSerializer(data=request.data)
data.is_valid(raise_exception=True)
user = data.validated_data['user']
login(request, user)
token, created = Token.objects.get_or_create(user=user)
jwt = RefreshToken.for_user(user)
return Response({
'token': token.key,
'access_token': str(jwt.access_token),
'refresh_token': str(jwt)
})
def post(self, request):
login_serializer = LoginSerializer(data=request.data,
context={
'request': request,
})
login_serializer.is_valid(raise_exception=True)
login_serializer.save()
return response.Response(status=status.HTTP_200_OK,
data={
'message': 'Login successfully.',
})
def post(self, request):
my_data = request.data
serializer = LoginSerializer(data=my_data)
if serializer.is_valid(raise_exception=True):
valid_data = serializer.data
return Response(valid_data, status=HTTP_200_OK)
return Response(serializer.errors, HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
user = serializer.validated_data["user"]
token, _ = Token.objects.get_or_create(user=user)
return Response({"user_id": user.id, "token": token.key})
return Response(serializer.errors, status=status.HTTP_401_UNAUTHORIZED)
def sign_in(self, request, pk=None):
"""
Function will fetch the login credentials and either log the user in
or return error. To call this function, use this URL:
--------------------------------------------
/api/logins/0/sign_in/?format=json
--------------------------------------------
"""
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
username = serializer.data['username'].lower()
password = serializer.data['password']
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return Response({'status': 'failed', 'message': 'username not found'})
# Check to see if our username and password authenticate with our system.
user = authenticate(
username=username,
password=password
)
# Generate the return message according to whether we are logged in or not.
if user is not None:
if user.is_active:
# Login
login(request, user)
# Fetch the token id for the user if it exists. If token
# doesn't work then we need to create it right now.
try:
token = Token.objects.get(user_id=request.user.id)
except Token.DoesNotExist:
token = Token.objects.create(user_id=request.user.id)
# Return the success status.
response_data = {
'status': 'success',
'message': 'logged in',
'user_id': user.id,
'token': str(token)
}
else:
response_data = {'status' : 'failure', 'message' : 'you are suspended'}
else:
response_data = {'status' : 'failure', 'message' : 'wrong username or password'}
return Response(response_data)
else:
return Response({'status': 'failed', 'message': 'username and/or password are blank'})
def sign_in(self, request, pk=None):
"""
Function will fetch the login credentials and either log the user in
or return error. To call this function, use this URL:
--------------------------------------------
/api/logins/0/sign_in/?format=json
--------------------------------------------
"""
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
username = serializer.data['username'].lower()
password = serializer.data['password']
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return Response({'status': 'failed', 'message': 'username not found'})
# Check to see if our username and password authenticate with our system.
user = authenticate(
username=username,
password=password
)
# Generate the return message according to whether we are logged in or not.
if user is not None:
if user.is_active:
# Login
login(request, user)
# Fetch the token id for the user if it exists. If token
# doesn't work then we need to create it right now.
try:
token = Token.objects.get(user_id=request.user.id)
except Token.DoesNotExist:
token = Token.objects.create(user_id=request.user.id)
# Return the success status.
response_data = {
'status': 'success',
'message': 'logged in',
'user_id': user.id,
'token': str(token)
}
else:
response_data = {'status' : 'failure', 'message' : 'you are suspended'}
else:
response_data = {'status' : 'failure', 'message' : 'wrong username or password'}
return Response(response_data)
else:
return Response({'status': 'failed', 'message': 'username and/or password are blank'})
def sign_in(self, request, pk=None):
"""
Function will fetch the login credentials and either log the user in
or return error. To call this function, use this URL:
--------------------------------------------
/api/logins/0/sign_in/?format=json
--------------------------------------------
"""
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
username = serializer.data['username'].lower()
password = serializer.data['password']
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return Response({
'status': 'failed',
'message': 'username not found'
})
# Check to see if our username and password authenticate with our system.
user = authenticate(username=username, password=password)
# Generate the return message according to whether we are logged in or not.
if user is not None:
if user.is_active:
login(request, user)
response_data = {
'status': 'success',
'message': 'logged in',
'user_id': user.id,
#'csrf_token': get_new_csrf_key(),
}
else:
response_data = {
'status': 'failure',
'message': 'you are suspended'
}
else:
response_data = {
'status': 'failure',
'message': 'wrong username or password'
}
return Response(response_data)
else:
return Response({
'status': 'failed',
'message': 'username and/or password are blank'
})
def get(self, request, user_name=None, password=None, format=None):
"""
Build login API url using payload which is form by username, password,
clientid, clientsecret.
login API sample URL : http://www.sample.com/mws/oauth/token
Args:
request: represents a single HTTP request. Request objects also have
a few useful methods like GET,POST,DELETE,SESSION etc.
user_name: string
Grabs username string
Default: None
password: string
Grabs password string
Default: None
format: string
Grabs format string
Default: None
Returns:
login_data, which is reponse of login API url if serializer is valid
else returns string 'Config page'
Raises:
None
"""
list_creds = []
dict = {}
dict["username"] = user_name
dict["password"] = password
client_id = self.CLIENTID
client_secret = self.CLIENTSECRET
list_creds.append(dict)
serializer = LoginSerializer(data=list_creds, many=True)
if serializer.is_valid():
try:
payload = "?grant_type=password" + "&username="******"&password="******"&client_id=" + client_id + "&client_secret=" + client_secret
loginApi_url = self.baseUrl_login + payload
login_data = requests.post(loginApi_url)
return login_data
except Exception as e:
return "Config page"
return Response(serializer.errors)
def login(self, request):
serializer = LoginSerializer(data=request.data,
context={'request': request})
if serializer.is_valid():
user = serializer.validated_data.get('user')
auth_login(request, user)
return custom_reponse('succes',
200,
token=user.token,
message='Login success')
return custom_reponse('error',
400,
serializer=serializer,
message='login_invalid')
def login(request):
serializer = LoginSerializer(data=request.data)
data = {}
if serializer.is_valid():
user = User.objects.get(email=serializer.validated_data['email'])
token, _ = Token.objects.get_or_create(user=user)
return Response({
'token': token.key,
'token_type': "bearer"
},
status=HTTP_200_OK)
else:
data['message'] = 'The given data was invalid.'
data['errors'] = serializer.errors
return Response(data=data, status=HTTP_422_UNPROCESSABLE_ENTITY)
def post(self, request):
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
user = serializer.validated_data["user"]
if user:
login(request, user)
token, created = Token.objects.get_or_create(user=user)
USER_LOGS.info("Token Successfully generated for the ---> " +
str(user))
return Response({"Your Token": token.key}, status=200)
else:
return Response(
"Given User is not valid !!! Either wrong Credentials!!!!!!!"
)
else:
return Response("Plz Give Both the Credentials!!!")
def post(self, request, *args, **kwargs):
credentials = LoginSerializer(data=request.data)
if not credentials.is_valid():
return Response(status=status.HTTP_400_BAD_REQUEST)
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
if not user:
return Response(status=status.HTTP_401_UNAUTHORIZED)
# Okay, security check complete. Log the user in.
login(request, user)
serializer = UserSerializer(user)
return Response(serializer.data, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
credentials = LoginSerializer(data=request.data)
if not credentials.is_valid():
return Response(status=status.HTTP_400_BAD_REQUEST)
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
if not user:
return Response(status=status.HTTP_401_UNAUTHORIZED)
# Okay, security check complete. Log the user in.
login(request, user)
serializer = UserSerializer(user)
return Response(serializer.data, status=status.HTTP_200_OK)
def post(self,request):
ser = LoginSerializer(data=request.data)
if not ser.is_valid():
return Response({'code': 500, 'msg':'登陆失败！'})
phone = ser.validated_data.get('phone')
avatar = ser.validated_data.get('avatar')
nick = ser.validated_data.get('nick')
user_obj,flag = models.User.objects.get_or_create(phone=phone)
print(user_obj, flag)
token = logic.get_token(user_obj)
print(token)
# 获取当前微信用户的信息，保存到数据库
user_obj.avatar = avatar
user_obj.nick = nick
user_obj.save()
return Response({'token': token, 'code':200,'msg':'登陆成功！'})
def post(self, request):
serializer = LoginSerializer(data = request.DATA)
if not serializer.is_valid():
return Response({"message":serializer.errors.keys()[0] + " - " + serializer.errors[serializer.errors.keys()[0]][0]}, status.HTTP_400_BAD_REQUEST)
username = request.DATA['username']
password = request.DATA['password']
user = authenticate(username = username, password = password)
if user is None:
return Response({"message":"User does not exist"}, status.HTTP_400_BAD_REQUEST)
if not user.is_active:
return Response({"message":"User is inactive"}, status.HTTP_400_BAD_REQUEST)
login(request, user)
return Response({"message":"OK"}, status.HTTP_200_OK)
def post(self, request, **kwargs):
try:
serializer = LoginSerializer(data=request.data)
if serializer.is_valid():
user = authenticate(**serializer.data)
if user is not None:
user_token, created = Token.objects.get_or_create(
user=user)
return Response(
{
'user': self.response_serializer(user).data,
'token': user_token.key
},
status=status.HTTP_200_OK)
return Response(
{
'success': False,
'error': "user is not authenticated"
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as ex:
return Response({'error': ex.__str__(), 'success': False})
