def post(self, request, format=None):
user = request.user
print(user.id)
try:
query_set = User.objects.get(pk=user.id)
print(user.id)
print(user.address_1)
print(user.postcode)
except User.DoesNotExist:
return Response("no user found", status=HTTP_404_NOT_FOUND)
print("we got a queryset")
data = request.data
print("we got data")
print(data)
serializer = UserProfileSerializer(request.user, data=data)
if serializer.is_valid():
serializer.save()
return Response("Yay we did it!", HTTP_200_OK)
else:
return Response(serializer.errors)
def register_user(request):
if request.method == 'POST':
serializers = UserProfileSerializer(data=request.data)
if serializers.is_valid():
serializers.save()
return Response(serializers.data, status=status.HTTP_201_CREATED)
return Response(serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None):
user = request.user
profile = get_object_or_404(UserProfile, user=user)
serializer = UserProfileSerializer(data=request.data)
if serializer.is_valid():
serializer.update(instance=profile, validated_data=serializer.data)
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, username, format=None):
profile = self.get_object(username)
serializer = UserProfileSerializer(profile, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_serializer_accepts_valid_data(self):
"""
Serializer.is_valid() should return true when instantiated with
valid data.
"""
serializer = UserProfileSerializer(
data=self.data, context=self.context
)
self.assertTrue(serializer.is_valid())
def post(self,request,*args, **kwargs):
user=request.user
user_profile=UserProfile.objects.get_or_create(user=user)
serializer=UserProfileSerializer(user_profile[0],data=request.data)
if serializer.is_valid():
serializer.save()
return JsonResponse({'detail':'success'})
else:
print("pp:",serializer.errors)
return JsonResponse(serializer.errors,status=400)
def test_save_updates_correct_fields(self):
"""
Calling `.save()` should update correct fields on model.
"""
serializer = UserProfileSerializer(
self.profile, data=self.data, context=self.context
)
if serializer.is_valid():
new_profile = serializer.save()
self.assertEqual(new_profile.website, self.data['website'])
self.assertEqual(new_profile.about_me, self.data['about_me'])
self.assertEqual(new_profile.user, self.user)
def elm_settings(user):
try:
profile = user.profile
except AttributeError:
profile = UserProfile.nullProfile()
config = SiteConfiguration.get_solo()
elm = {
'userPerms':
UserProfileSerializer(profile).data,
'twilioSendingCost':
settings.TWILIO_SENDING_COST,
'twilioFromNumber':
settings.TWILIO_FROM_NUM,
'smsCharLimit':
config.sms_char_limit,
'defaultNumberPrefix':
config.default_number_prefix,
'noAccessMessage':
config.not_approved_msg,
'blockedKeywords': [
x.keyword for x in Keyword.objects.all().prefetch_related('owners')
if x.is_locked and not x.can_user_access(user)
],
}
return mark_safe(json.dumps(elm))
def elm_settings(user):
try:
profile = user.profile
except AttributeError:
profile = UserProfile.nullProfile()
config = SiteConfiguration.get_solo()
try:
twilio_settings = config.get_twilio_settings()
# remove sensitive settings:
del twilio_settings['auth_token']
del twilio_settings['sid']
except ConfigurationError:
twilio_settings = None
bk_key = f'blocked_keywords_user_{user.pk}'
blocked_keywords = cache.get(bk_key)
if blocked_keywords is None:
blocked_keywords = [
x.keyword for x in Keyword.objects.all().prefetch_related('owners') if not x.can_user_access(user)
]
cache.set(bk_key, blocked_keywords, 120)
elm = {
'userPerms': UserProfileSerializer(profile).data,
'twilio': twilio_settings,
'isEmailSetup': config.is_email_setup(),
'smsCharLimit': config.sms_char_limit,
'defaultNumberPrefix': config.default_number_prefix,
'noAccessMessage': config.not_approved_msg,
'blockedKeywords': blocked_keywords,
}
return mark_safe(json.dumps(elm))
def get(self, request):
try:
profile = request.user.userprofile
serializer = UserProfileSerializer(profile, context={'request': request})
return Response(serializer.data)
except AttributeError:
return Response({'nodetail': 'Anonymous User'})
def elm_settings(user):
try:
profile = user.profile
except AttributeError:
profile = UserProfile.nullProfile()
config = SiteConfiguration.get_solo()
try:
twilio_settings = config.get_twilio_settings()
# remove sensitive settings:
del twilio_settings["auth_token"]
del twilio_settings["sid"]
except ConfigurationError:
twilio_settings = None
bk_key = f"blocked_keywords_user_{user.pk}"
blocked_keywords = cache.get(bk_key)
if blocked_keywords is None:
blocked_keywords = [
x.keyword for x in Keyword.objects.all().prefetch_related("owners")
if not x.can_user_access(user)
]
cache.set(bk_key, blocked_keywords, 120)
elm = {
"userPerms": UserProfileSerializer(profile).data,
"twilio": twilio_settings,
"isEmailSetup": config.is_email_setup(),
"smsCharLimit": config.sms_char_limit,
"defaultNumberPrefix": config.default_number_prefix,
"noAccessMessage": config.not_approved_msg,
"blockedKeywords": blocked_keywords,
}
return mark_safe(json.dumps(elm))
def get(self,request,*args,**kwargs):
user = request.user
obj = UserProfile.objects.get(user=user)
serializer = UserProfileSerializer(obj)
return JsonResponse(serializer.data)
def post(self, request, pk=0):
# create profile
serializer = UserProfileSerializer(data=request.data)
try:
if serializer.is_valid(raise_exception=True):
if serializer.create(serializer.data) is not None:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except Exception:
strerr = "Erreur post profile : [{}] [{}]".format(
sys.exc_info()[0],
sys.exc_info()[1])
return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
user = serializer.validated_data['user']
token, created = Token.objects.get_or_create(user=user)
user_profile = UserProfile.objects.get(user=user)
user_profile_serializer = UserProfileSerializer(user_profile)
return Response({'token': token.key, 'user_profile': user_profile_serializer.data})
def update(self, request, pk=None):
#get the authenticated user
user = request.user
data = request.data
serializer = UserProfileSerializer(user, data=data)
if serializer.is_valid():
serializer.save()
if user:
return Response("user profile updated successfully",
HTTP_200_OK)
else:
return Response(serializer.errors, HTTP_400_BAD_REQUEST)
def put(self, request, pk):
# modify profile
if pk == "":
profile = get_object_or_404(Profile, uzer_id=request.user.pk)
pk = profile.pk
instance = get_object_or_404(Profile, pk=pk)
serializer = UserProfileSerializer(instance,
data=request.data,
partial=True)
try:
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except Exception:
strerr = "Erreur put profile : [{}] [{}]".format(
sys.exc_info()[0],
sys.exc_info()[1])
return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = AvatarSerializer(data=request.data)
if serializer.is_valid():
profile = request.user.userprofile
if 'avatar' in serializer.data:
curr_avatar = profile.avatar
if curr_avatar.name != 'no-avatar.svg':
profile.avatar.delete()
_handle_avatar_upload(request.FILES['avatar'], profile)
serializer_out = UserProfileSerializer(profile)
return Response(serializer_out.data,
status=status.HTTP_201_CREATED)
def authenticate_user(email, password,request=None):
user = User.objects.get(email=email)
user = authenticate(email=email,password=password)
if user:
seralizer=UserProfileSerializer(user,data=request.DATA)
seralizer_dict=seralizer.data
seralizer_dict["message"]="Login Successful"
return Response(seralizer_dict, status=status.HTTP_200_OK)
else:
return Response(
messages.INVALID_EMAIL_OR_PASSWORD,
status=status.HTTP_401_UNAUTHORIZED)
def test_get_includes_expected_fields(self):
"""
GET requests should include url, user, created_date, slug, picture,
website, and about_me fields.
"""
serializer = UserProfileSerializer(self.profile, context=self.context)
expeted_fields = ['url', 'user', 'created_date', 'slug', 'website',
'about_me']
for field in expeted_fields:
self.assertIn(field, serializer.data)
def current(self, request, pk=None):
"""get the current user profile data for an authenticated user"""
user = request.user
if user: #just make sure we have data for the user here
serializer = UserProfileSerializer(user)
return Response(serializer.data, HTTP_200_OK)
else:
return Response("userProfile not found", HTTP_404_NOT_FOUND)
def post(self, request, format=None):
userprofile_serializer = UserProfileSerializer(data=request.DATA)
reg_serializer = RegistrationSerializer(data=request.DATA)
if 'device' in request.DATA:
phone_serializer = DeviceSerializer(data=request.DATA['device'])
else:
phone_serializer = DeviceSerializer(data=request.DATA)
errors = {}
if userprofile_serializer.is_valid() and reg_serializer.is_valid() and phone_serializer.is_valid():
user = reg_serializer.save()
data = reg_serializer.data
phone = phone_serializer.object
phone.user = user
phone_serializer.save()
data.update(phone_serializer.data)
user_profile = userprofile_serializer.object
user_profile.user = user
userprofile_serializer.save()
data.update(userprofile_serializer.data)
# trigger user activation to send welcome email
signals.user_activated.send(sender=self.__class__,
user=user,
request=request)
# return the right client
client = Client.objects.get(pk=1)
data.update({'client_id': client.client_id, 'client_secret': client.client_secret})
return Response(data, status=status.HTTP_201_CREATED)
errors.update(reg_serializer.errors)
errors.update(phone_serializer.errors)
errors.update(userprofile_serializer.errors)
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def userinfo(request, id=None):
if request.method == 'GET':
if not id:
id = request.user.id
base_user = User.objects.filter(pk=id)
if not base_user:
return generate_response(message="No such user", status=status.HTTP_400_BAD_REQUEST)
serializer = UserProfileSerializer(base_user[0])
return generate_response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, pk):
# get profile
if pk == "":
profile = get_object_or_404(Profile, uzer_id=request.user.pk)
pk = profile.pk
instance = get_object_or_404(Profile, pk=pk)
serializer = UserProfileSerializer(instance)
try:
return Response(serializer.data)
except Exception:
strerr = "Erreur get profile : [{}] [{}]".format(
sys.exc_info()[0],
sys.exc_info()[1])
return Response(strerr, status=status.HTTP_400_BAD_REQUEST)
def search_user(request):
username = request.data.get("username")
password = request.data.get("password")
if User.objects.filter(password=password, username=username).exists():
user = User.objects.get(password=password, username=username)
user_profile = UserProfile.objects.get(user=user)
data = {
**UserSerializer(user).data,
**UserProfileSerializer(user_profile).data
}
return Response(data, status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
user = request.user
try:
profile = UserProfile.objects.get(user=user)
serializer = UserProfileSerializer(profile)
return Response(serializer.data, status=status.HTTP_200_OK)
except UserProfile.DoesNotExist:
serializer = UserProfileSerializer(data=request.data)
if serializer.is_valid():
serializer.save(user=request.user)
_create_default_labels(request.user)
_create_customer_profile(request.user)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
try:
user = User.objects.create_user(
username=request.POST.get('username'),
first_name=request.POST.get('first_name'),
last_name=request.POST.get('last_name'),
email=request.POST.get('email'),
password=request.POST.get('password'),
)
profile = UserProfile.objects.create(
user=user,
avatar=request.FILES.get('avatar')
)
serializer = UserProfileSerializer(
profile, context={'request': request})
return Response({'user': serializer.data})
except Exception as e:
return Response({'message': 'Fail to register an user.'})
def post(self, request):
try:
user = authenticate(
request=request,
username=request.POST.get('username'),
password=request.POST.get('password')
)
if user:
login( request, user )
try:
profile = user.userprofile
serializer = UserProfileSerializer(
profile, context={'request': request})
return Response({'user': serializer.data})
except AttributeError:
return Response({'message': 'wat'})
return Response({'message': 'Error on log in'})
except User.DoesNotExist:
return Response({'message': 'User dows not exist'})
def jwt_response_payload_handler(token, user=None, request=None):
try:
userdetail = applyApplication.objects.get(id=user.id)
userProject = 0
for project in Project.objects.all():
for member in project.members.all():
if member.id == user.id:
userProject = Project.objects.get(id=project.id)
break
except:
return {
'token': token,
'user': UserSerializer(user, context={'request': request}).data,
}
return {
'token': token,
'user': UserSerializer(user, context={'request': request}).data,
'userdetail':UserProfileSerializer(userdetail, context={'request':request}).data,
'userproject':ProjectSerializer(userProject, context={'request':request}).data
}
def get(self, request):
user = request.user
search = request.query_params
print(search)
if (user.is_staff == 1):
query_set = User.objects.all()
if ('first_name' in search):
query_set = query_set.filter(
first_name__icontains=search['first_name'].strip('"'))
if ('last_name' in search):
query_set = query_set.filter(
last_name__icontains=search['last_name'].strip('"'))
if ('dob_before' in search):
query_set = query_set.filter(dob__lte=search['dob'].strip('"'))
if ('dob_after' in search):
query_set = query_set.filter(dob__gte=search['dob'].strip('"'))
if ('is_staff' in search):
query_set = query_set.filter(
is_staff__iexact=search['is_staff'].strip('"'))
if ('is_driver' in search):
query_set = query_set.filter()
if query_set: #we got data
serializer = UserProfileSerializer(query_set, many=True)
print(serializer)
return Response(serializer.data, HTTP_200_OK)
else:
return Response("no users found", HTTP_404_NOT_FOUND)
def get(self, request):
user_profiles = UserProfile.objects.all()[:20]
data = UserProfileSerializer(user_profiles, many=True).data
return Response(data)
