def create(self, request):
""" Use the ObtainAuthToken APIView to validate and create/POST a token. """
# Now we need to do a POST request through to the ObtainAuthToken APIView and call the POST function So
# it return ObtainAuthToken().post(request)
return ObtainAuthToken().post(request)
def create(self, request):
"""Use the ObtainAuthToken APIView to validate and create a token."""
token = ObtainAuthToken().post(request)
user = request.user
user.last_login = timezone.now()
return token
def create(self, request):
"""
Use the ObtainAuthToken APIView to validate and create a token
:param request:
:return:
"""
return ObtainAuthToken().post(request)
def create(self, request):
"""Use the ObtainAuthToken APIView to validate and create a token"""
response = ObtainAuthToken().post(request)
token = Token.objects.get(key=response.data['token'])
loginUser = models.UserProfile.objects.get(pk=token.user_id)
userSerializer = serializers.UserProfileSerializer(loginUser)
return Response({'token':token.key, 'user':userSerializer.data})
def create(self, request):
"""So, DRF has an APIView for login. we create this viewset class
and will use this apiview and convert it to a viewsetself.
so, we are using this ObtainAuthToken APIView to validate
and create a token. we call the ObtainAuthToken apiview and
and call it's post method (bcoz remember post in apiview == create in viewsets)
and send in the request"""
return ObtainAuthToken().post(request)
def create(self, request):
print("shlomo osnat")
return ObtainAuthToken().post(request)
# class CustomSearchFilter(filters.SearchFilter):
# def get_search_fields(self, view, request):
# if request.query_params.get('user_name'):
# return ['user_name']
# return super(CustomSearchFilter, self).get_search_fields(view, request)
def create(self, request):
serializer_class = serializers.LoginSerializer
print("create")
auth_token = ObtainAuthToken().post(request).data
result = models.UserProfile.objects.filter(
email=self.request.data.get('username', None))[0]
data = serializers.LoginSerializer(result).data
login_detail = auth_token
login_detail.update(data)
return Response(login_detail)
def create(self, request):
"""Use the ObtainAuthToken APIView to validate and create a token."""
result = ObtainAuthToken().post(request)
token = Token.objects.get(key=result.data['token'])
user = User.objects.filter(pk= token.user_id)[0]
update_last_login(None, token.user)
# return result
return Response({'token': token.key, 'id': token.user_id, 'username': user.username,
'first_name': user.first_name, 'last_name': user.last_name,
'is_staff': user.is_staff , 'email': user.email,
'date_joined': user.date_joined})
def create(self, request):
_response = ObtainAuthToken().post(request)
_useremail = request.data.get('username')
if _useremail is not None:
_user = models.UserProfile.objects.filter(email=_useremail)
if _user is not None:
print("User profile", _user)
return _response
def create(self, request):
if ObtainAuthToken().post(request).data:
username = request.data.get("username")
token = ObtainAuthToken().post(request).data['token']
user_model = models.UserProfile.objects.get(email=username)
plan_model = models.UserPlan.objects.get(user=user_model, status=1)
try:
user_history = models.UserProcessHistory.objects.get(user_profile = user_model, status = 1)
except models.UserProcessHistory.DoesNotExist:
user_history = models.UserProcessHistory(
user_profile = user_model,
description = "Login usuario",
full_storage = plan_model.plan.storage,
filled_storage = 0,
filled_storage_doc = 0,
filled_storage_music = 0,
filled_storage_video = 0,
filled_storage_image = 0
)
user_history.save()
return Response({'token':token,
'name':user_model.name,
'lastname':user_model.lastname,
'plan_id':plan_model.plan.id,
'plan_name':plan_model.plan.name,
'plan_price':plan_model.plan.price,
'plan_storage':plan_model.plan.storage,
'plan_details':plan_model.plan.detail,
'filled_storage': user_history.filled_storage,
'filled_storage_doc': user_history.filled_storage_doc,
'filled_storage_music': user_history.filled_storage_music,
'filled_storage_video': user_history.filled_storage_video,
'filled_storage_image':user_history.filled_storage_image
})
"""Use the ObtainAuthToken APIView to validate and create a token."""
return ObtainAuthToken().post(request)
def create(self, request):
"""Use the ObtainAuthToken APIView to validate and create a token"""
# pass request and call the POST function
# () <- making new object
# it returns a temporary token
# "token": "59a999eb165158d2b3c0713332c174d551fb0160"
# the client has to ensure the token is included in every HTTP request
# Authorization HTTP Header will include our token.
# Then we can check if HTTP request has VALID token.
# If the token is valid, 200.
# If it's not valid. return 401 or authorize response to regenerate token!
# HTTP header is like meta-data : data about request
return ObtainAuthToken().post(request)
def post(self, request):
try:
username = request.data.get('username')
user = User.objects.filter(username=username)
approved_user = UserProfile.objects.get(user=user[0]).approved_user
if approved_user == 1:
token = ObtainAuthToken().post(request)
login = LoginViewSet
return login.create(self, request)
else:
return Response(
{"response": {
'error': 'Please wait for verification'
}})
except:
return Response(
{"response": {
'error': 'username or password is incorrect.'
}})
def create(self, request):
"""Use the ObtainAuthToken APIView to validate and create a token."""
print(request.META)
return ObtainAuthToken().post(request)
def create(self, request): # uses ObtainAuthToken APIview
return ObtainAuthToken().post(request)
def create(self, request):
""" Use the obtain Auth token to validate and create a token """
return ObtainAuthToken().post(request)
def create(self, request):
"""Create unique token for each user"""
return ObtainAuthToken().post(request)
def create(self, request):
"""user the obtainAuthtoken apivew to validate and create a token"""
return ObtainAuthToken().post(request)
def create(self, request):
"""Create and validate a token."""
return ObtainAuthToken().post(request)
def create(self, request):
"""Use the obtainedAuthgToken APIView to validate and create a token."""
return ObtainAuthToken().post(request)
def create(self, request):
"""use the obtainAuthtoken"""
return ObtainAuthToken().post(request)
def create(self, request):
"""
create a token
"""
return ObtainAuthToken().post(request)
def create(self, request):
""" Use the obtainAuthToken API view to validate & create a token"""
return ObtainAuthToken().post(request)
def create(self, request):
return ObtainAuthToken().post(request)
def create(self, request):
#call post fn
return ObtainAuthToken().post(request)
def create(self, request):
"""Use the obtain auth token APIView to validate and create a token"""
# passing request to ObtainAuthToken APIView
return ObtainAuthToken().post(request)
def create( self, request ): """use the ObtainAuthToken APIView to validate and create a token""" return ObtainAuthToken().post( request )
def create(self, request):
"""Usa ObtainAuthToken APIView para validar y crear un token"""
return ObtainAuthToken().post(request)
def create(self, request):
"""
USE THE ObtainAuthToken APIView TO VALIDATE AND CREATE A TOKEN.
"""
return ObtainAuthToken().post(request)
def create(self, request):
return ObtainAuthToken().post(request) #calling through viewset
def create(self, request): #this is where post requests get to. im sure you know that
"""Use the ObtainAuthToken APIView to validate and create a token"""
return ObtainAuthToken().post(request)
