def test_userprofile_without_required_fields_is_invalid(self): no_user_model = UserProfile( user=None, date_of_birth=self.valid_dob, bio=self.valid_bio ) no_dob_model = UserProfile( user=self.valid_user, date_of_birth=None, bio=self.valid_bio ) second_valid_user = User.objects.create(email="*****@*****.**") no_bio_model = UserProfile( user=second_valid_user, date_of_birth=self.valid_dob, bio=None ) for model in [ no_user_model, no_dob_model, no_bio_model, ]: with self.assertRaises(IntegrityError): model.save()
def test_create_profile(self): from accounts.models import UserProfile assert not hasattr(self.user, 'userprofile') valid_data = { 'user': self.user, "year_of_admission": 2000, "department": "cs" } invalid_data = [{ 'user': self.user, "year_of_admission": 1000, "department": "cs" }, { "year_of_admission": 1000, "department": "cs" }] profile = UserProfile(**valid_data) # year of admission must be in (1800 ~ 2500) for data in invalid_data: with self.assertRaises(ValidationError): UserProfile(**data).save() profile.save() assert hasattr(self.user, 'userprofile') self.assertEqual(self.user.username, profile.username)
def setUp(self): form = ChopRegistrationForm(self.test_user) form.save() # Manually create existing user with profile. existing_user = User(**self.existing_user) existing_user.set_password(self.existing_user['password']) existing_user.save() UserProfile(user=existing_user).save() test_user = User.objects.get(email=self.test_user['email']) UserProfile(user=test_user).save()
def create_user_from_weibo(request, template_name='register/create_user_from_weibo.html' ): oauth_access_token = request.session.get('oauth_access_token', None) if request.user.is_authenticated() or oauth_access_token is None: return HttpResponseRedirect(reverse('home.views.index')) client = APIClient(app_key=APP_KEY, app_secret=APP_SECRET, redirect_uri=_get_weibo_callback_url(request)) client.set_access_token(oauth_access_token['access_token'], oauth_access_token['expires_in']) weibo_user = client.get.users__show(uid=oauth_access_token['uid']) weibo_username = weibo_user.screen_name template_var = {} form = RegistrationForm(initial={'username': weibo_username}) if request.method == 'POST': form = RegistrationForm(request.POST.copy()) if request.method == 'POST': if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] password = form.cleaned_data['password'] user = User.objects.create_user(username, email, password) user.is_active = True user.save() profile = UserProfile() profile.user = user profile.song_ord_filed = 'post_datetime' profile.save() #weibo信息记录 w_user = WeiboUser() w_user.user = user w_user.weibo_user_id = oauth_access_token['uid'] w_user.weibo_username = weibo_username w_user.oauth_access_token = oauth_access_token['access_token'] w_user.save() #发微博提示 if request.POST.get('update_msg'): msg = request.POST.get('bind_msg')[0:140] client.post.statuses__update(status=msg) user = authenticate(username=username, password=password) auth_login(request, user) return HttpResponseRedirect(reverse('songs.views.my_home')) template_var['form'] = form template_var['weibo_username'] = weibo_username return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def signup_user(request): if request.method == 'GET': context = { 'form': SignUpForm(), } return render(request, 'accounts/signup', context) else: form = SignUpForm(request.POST) if form.is_valid(): user = form.save() profile = UserProfile( user=user, ) profile.save() login(request, user) return redirect('index') context = { 'form': form, } return render(request, 'accounts/signup.html', context)
def delete(self, request, user_pk, format=None): profile = self.get_object(user_pk) self.delete_profile_picture_from_storage(profile=profile) # Restore default profile picture profile.profile_picture = UserProfile().profile_picture profile.save() return Response(status=status.HTTP_204_NO_CONTENT)
def save(self): user = User( email=self.validated_data['email'], username=self.validated_data['username'], first_name=self.validated_data['first_name'], last_name=self.validated_data['last_name'], ) password = self.validated_data['password'] password2 = self.validated_data['password2'] if password != password2: raise serializers.ValidationError( {"Password": "******"}) user.set_password(password) user.save() phone = self.validated_data['phone'] photo = self.validated_data['photo'] is_tutor = self.validated_data['is_tutor'] profile = UserProfile(user=user, phone=phone, photo=photo, is_tutor=is_tutor) profile.save() return user
def form_valid(self, form): user = form.save() if user.user_profile is None: profile = UserProfile(user=user) else: profile = user.user_profile gender = form.cleaned_data.get('gender') if gender is not None and not 'x' in gender: profile.gender = gender profile.send_newsletters = form.cleaned_data.get( 'marketing_optin') != 'false' profile.activation_key = profile.generate_activation_key() profile.detected_country = self.request.country profile.preferred_currency = self.request.session.get( 'preferred_currency', '') profile.save() Events(self.request).user_signup(user) # login user password = form.cleaned_data.get('password') user = authenticate(username=user.username, password=password) login(self.request, user) messages.success(self.request, REGISTER_SUCCESS_MESSAGE) return render(self.request, "mailing_lists/fragments/capture_complete.html")
def save(self): """ Override the save method to create a custom profile for the user. """ # All username names should be lower-case. self.cleaned_data['username'] = self.cleaned_data['username'].lower() # Save the parent form and get the user new_user = super(CustomSignupForm, self).save() # Remove the profile that's automatically created by Userena new_user.profile.delete() new_user.profile = UserProfile( ar_first_name=self.cleaned_data['ar_first_name'], ar_middle_name=self.cleaned_data['ar_middle_name'], ar_last_name=self.cleaned_data['ar_last_name'], en_first_name=self.cleaned_data['en_first_name'], en_middle_name=self.cleaned_data['en_middle_name'], en_last_name=self.cleaned_data['en_last_name'], mobile=self.cleaned_data['mobile'], state=State.objects.get(pk=self.cleaned_data['state']), university=self.cleaned_data['university'], academic_year=self.cleaned_data['academic_year'], specialty=self.cleaned_data['specialty'], ) new_user.profile.save() return new_user
def create(self, validated_data): profile_data = validated_data.pop('profile', None) username = validated_data['username'] email = validated_data['email'] password = validated_data['password'] user = User( username = username, email = email ) user.set_password(password) user.save() avatar = profile_data.get('avatar') or None if not avatar: avatar = 'https://api.adorable.io/avatar/200/' + username profile = UserProfile( user = user, bio = profile_data.get('bio', ''), license = profile_data.get('license', ''), avatar = avatar, name = profile_data.get('name', ''), status = profile_data.get('status', 'Member') ) profile.save() return user
def persist_pet(request, pet, template_name): user = request.user.id if request.method == 'GET': pet.user_id = UserProfile(user) form = PetForm(instance=pet) context = { 'form': form, 'pet': pet, } return render(request, f'{template_name}.html', context) else: old_image = pet.image form = PetForm( request.POST, request.FILES, instance=pet, ) if form.is_valid(): if old_image: clean_up_files(old_image.path) form.save() Like.objects.filter(pet_id=pet.id).delete() return redirect('pet details or comment', pet.pk) context = { 'form': form, 'pet': pet, } return render(request, f'{template_name}.html', context)
def testValidPostalAddresses(self): # Must not raise exception up = UserProfile(**self.f_fixture) self.assertEqual(self.f_postal_address['address'], up.postal_address.address) self.assertEqual(self.f_postal_address['address'], up.delivery_address.address)
def test_can_create_read_update_userprofile(self): # test that user can create userProfile userprofile = UserProfile(user=self.user, country=2, location=84, occupation='Developer', phonenumber='08020202020', intlnumber='+12334567789') userprofile.save() self.assertNotEqual(UserProfile.objects.count(), 0) # test that a userprofile record has been added userprofile = UserProfile.objects.get(id=userprofile.id) self.assertIsNotNone(userprofile.id) # update a userprofile record new_occupation = "Architect" another_userprofile = UserProfile.objects.get(id=userprofile.id) another_userprofile.occupation = new_occupation another_userprofile.save() # test that update has taken effect another_userprofile = UserProfile.objects.get(id=userprofile.id) self.assertEquals(another_userprofile.occupation, new_occupation) # delete a userprofile record another_userprofile = UserProfile.objects.get(id=userprofile.id) UserProfile.delete(another_userprofile) with self.assertRaises(UserProfile.DoesNotExist) as context: UserProfile.objects.get(id=userprofile.id) self.assertTrue("does not exist" in context.exception.message)
def test_boughtItem_model_works_well(self): item_yes = ItemList.objects.create(name="餅乾", price=10, remain=10) a = UserProfile(user=self.user, usable_points=100, history_points=100) a.save() response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') b = BoughtItems.objects.filter(user=self.user).count() self.assertEqual(b, 1) response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') c = BoughtItems.objects.filter(user=self.user).count() self.assertEqual(c, 1) c1 = BoughtItems.objects.get(user=self.user) self.assertEqual(c1.item_quantity, 2) d = BoughtItems.objects.get(user=self.user) d.has_redeemed = True d.save() response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') e = BoughtItems.objects.filter(user=self.user).count() self.assertNotEqual(e, 1) response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') f = BoughtItems.objects.filter(user=self.user).filter( has_redeemed=False) self.assertEqual(f[0].item_quantity, 2)
def test_buy_more_than_maximun(self): item_yes = ItemList.objects.create(name="餅乾", price=10, remain=10, max_per_person=2) a = UserProfile(user=self.user, usable_points=100, history_points=100) a.save() response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') self.assertIn(str('購買成功').encode(), response.content) response1 = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') self.assertIn(str('購買成功').encode(), response1.content) b = BoughtItems.objects.get(user=self.user) self.assertEqual(b.item_quantity, 2) response2 = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') self.assertIn( str('很抱歉!您已超過此項目購買上限!請選購其他商品').encode(), response2.content) response3 = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') self.assertIn( str('很抱歉!您已超過此項目購買上限!請選購其他商品').encode(), response3.content)
def get(self, request: HttpRequest) -> JsonResponse: """ Return the current profile data, as json :param request: GET request to get the profile data :type request: HttpRequest :return: current profile details for the user :rtype: JsonResponse """ # First check if the user has a profile configured, or else create a new profile try: p = self.request.user.userprofile except ObjectDoesNotExist: request.user.userprofile = UserProfile() p = request.user.userprofile data = dict() data['first_name'] = request.user.first_name data['last_name'] = request.user.last_name data['gender'] = p.gender data['phone'] = p.phone data['is_seller'] = bool(request.user.groups.filter(name='Merchant')) if data['is_seller']: data['store_name'] = request.user.sellerprofile.store_name data['address'] = request.user.sellerprofile.address data['pincode'] = request.user.sellerprofile.pincode return JsonResponse(data, status=200)
def _profile(user): """ Create an User Profile """ profile = UserProfile() profile.user_id = user.id profile.save()
def create(self, validated_data): # Create User user_obj = User.objects.create(**validated_data['user']) user_obj.set_password(validated_data['user']['password']) user_obj.save() # Create Address address_obj = Address.objects.create(**validated_data['address']) # Create User Profile club_name = validated_data['football_club']["club"] football_club = FootballClub.objects.get(club=club_name) # football_club = validated_data['football_club'] gender = validated_data['gender'] birth_date = validated_data['birth_date'] weight = validated_data['weight'] # photo = validated_data['photo'] profile_obj = UserProfile( user = user_obj, address = address_obj, football_club = football_club, gender = gender, birth_date = birth_date, weight = weight, # photo = photo, allowed_club_change = True, total_points = 0 ) profile_obj.save() return validated_data
def register(request): if request.user != None and request.user.is_authenticated(): return redirect('/') if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): #Create the user email = form.cleaned_data.get('email') passwd = form.cleaned_data.get('password1') user = User(email=email) user.set_password(passwd) user.save() user.username = user.pk user.save() user_profile = UserProfile(user=user) user_profile.save() user.backend = 'user_backends.email_username.EmailOrUsernameModelBackend' #logs the new user login(request, user) return redirect('/') else: form = RegistrationForm() return locals()
def form_valid(self, form): valid = super().form_valid(form) user = form.save() profile = UserProfile(user=user) profile.save() login(self.request, user) return valid
def register(request): print('Hello') if request.method == 'POST': form = SignUpForm(request.POST) print('Hello') if form.is_valid(): objuser = form.save() print(objuser.id) username = form.cleaned_data.get('username') raw_password = form.cleaned_data.get('password1') print(request.user.id) objt = UserProfile(user=objuser, UID=request.POST.get('UID'), branch=request.POST.get('Branch'), year=request.POST.get('Year'), contactno=request.POST.get('ContactNo')) print(objt) objt.save() user = authenticate(username=username, password=raw_password) login(request, user) return redirect('http://127.0.0.1:8000/accounts') else: form = SignUpForm() print('Hello') return render(request, 'accounts/signup.html', {'form': form})
def test_buy(self): item_no = ItemList.objects.create(name="蛋糕", price=10, remain=0) item_yes = ItemList.objects.create(name="餅乾", price=10, remain=10) a = UserProfile(user=self.user, usable_points=100, history_points=100) a.save() self.assertEqual(a.user, self.user) self.assertEqual(a.usable_points, 100) self.assertEqual(a.history_points, 100) response = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') b = UserProfile.objects.get(user=self.user) self.assertEqual(b.usable_points, 90) self.assertEqual(b.history_points, 100) item_yes_final = ItemList.objects.get(name=item_yes.name) c = BoughtItems.objects.count() d = BoughtRecord.objects.count() self.assertNotEqual(c, 0) self.assertNotEqual(d, 0) response2 = self.client.get('/shop/b04202048/' + str(item_yes.pk) + '/') e = BoughtItems.objects.get(user=self.user) self.assertEqual(e.item_quantity, 2) response3 = self.client.get('/shop/b04202048/4/') self.assertIn(str('物品不存在').encode(), response3.content) self.assertEqual(item_yes_final.remain, 9) self.assertEqual(response.status_code, 200)
def test_not_enough_money(self): item = ItemList.objects.create(name="蛋糕", price=10, remain=2) a = UserProfile(user=self.user, usable_points=5) a.save() response = self.client.get('/shop/b04202048/' + str(item.pk) + '/') self.assertIn(str('您的點數不足').encode(), response.content)
def retrieve(request): ''' note that this requires an authenticated user before we try calling it ''' try: profile = request.user.get_profile() except UserProfile.DoesNotExist: profile = UserProfile(user=request.user) profile.save() return profile
def testBlankBirthDate(self): """ Must raise ValidationError. """ f = self.__copyFixture() f['birth_date'] = '' with self.assertRaises(ValidationError): UserProfile(**f)
def add(request): if request.method == 'POST': user = UserProfile(username=request.POST.get('username'), birthday=request.POST.get('birthday')) user.save() return redirect('/') return render(request, 'accounts/add.html')
def create_inactive_user(self, name, email, password, site='', send_email=True): """ Creates a new User and a new ActionRecord for that User, generates an activation key, and mails it. Pass ``send_email=False`` to disable sending the email. You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True """ send_email = not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False) # Create the user. new_user = User(username=email.replace('@', '-'), email=email, first_name=name) new_user.set_password(password) new_user.is_active = False new_user.save() from accounts.models import UserProfile UserProfile(user=new_user, site=site).save() # Generate a salted SHA1 hash to use as a key. salt = sha.new(str(random.random())).hexdigest()[:5] action_key = sha.new(salt + slugify(new_user.email)).hexdigest() # And finally create the record. new_record = self.create(user=new_user, action_key=action_key, type='A') if send_email: current_domain = Site.objects.get_current().domain subject = "Activate your new account at %s" % current_domain message_template = loader.get_template( 'accounts/activation_email.txt') message_context = Context({ 'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain), 'action_key': action_key, 'expiration_days': settings.ACTION_RECORD_DAYS, 'password': password, 'user': new_user }) message = message_template.render(message_context) new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL) return new_user
def testTooYoungClient(self): f = self.__copyFixture() f['birth_date'] = "%d-01-01" % datetime.date.today().year # Must raise exception with self.assertRaises(ValidationError) as cm: up = UserProfile(**f) up.full_clean() err = cm.exception self.assertIn(_(u"You must be min"), err.messages[0])
def form_valid(self, form): user = form.save(commit=False) userprofile = UserProfile( user=user, telephone_number=form.cleaned_data['phone_number'], email=form.cleaned_data['email']) user.save() userprofile.save() login(self.request, user) return redirect('home page')
def retrieve(request): """ note that this requires an authenticated user before we try calling it """ try: profile = request.user.userprofile print(profile) except UserProfile.DoesNotExist: profile = UserProfile(user=request.user) print(profile) profile.save() return profile