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 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 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 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 active_user(request, uidb36=None, token=None,
template_name='register/activation_confirm.html',
token_generator=default_token_generator,
current_app=None, extra_context=None):
"""
View that checks the hash in a active user link and make user to be active
"""
assert uidb36 is not None and token is not None # checked by URLconf
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(id=uid_int)
except (ValueError, User.DoesNotExist):
user = None
if user is not None and token_generator.check_token(user, token):
validlink = True
user.is_active = True
user.save()
#初始化userprofile
profile_count = UserProfile.objects.filter(user=user).count()
if profile_count == 0:
profile = UserProfile()
profile.user = user
profile.song_ord_filed = 'post_datetime'
profile.save()
else:
validlink = False
context = {
'validlink': validlink,
}
context.update(extra_context or {})
return render_to_response(template_name, context,
context_instance=RequestContext(request, current_app=current_app))
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 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 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 save(self, commit=True):
user = super(UserCreateForm, self).save(commit=False)
user.email = self.cleaned_data["email"]
user.first_name = self.cleaned_data["first_name"]
user.last_name = self.cleaned_data["last_name"]
if commit:
domain = settings.BASE_URL
user.is_active = False # not active until he opens activation link
user.save()
username = user.username
email = user.email
random_string = str(random.random()).encode("utf8")
salt = hashlib.sha1(random_string).hexdigest()[:5]
salted = (salt + email).encode("utf8")
activation_key = hashlib.sha1(salted).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
# Create and save user profile
new_profile = UserProfile(user=user, activation_key=activation_key, key_expires=key_expires)
new_profile.save()
# Send email with activation key
email_subject = "Account confirmation"
email_body = (
"Hey %s, thanks for signing up. To activate your account, click this link within 48 hours: %saccounts/confirm/%s/"
% (user.first_name, domain, activation_key)
)
send_mail(email_subject, email_body, settings.EMAIL_HOST_EMAIL, [user.email], fail_silently=False)
return user
def save(self,request):
if self.cleaned_data['city'] or self.cleaned_data['website'] or self.cleaned_data['intro'] or self.cleaned_data['qq'] or self.cleaned_data['msn'] or self.cleaned_data['avatar']:
current_user = request.user
try:
profile = current_user.get_profile()
except UserProfile.DoesNotExist:
profile = None
if not profile:
profile = UserProfile()
profile.user = current_user
profile.song_ord_filed = 'post_datetime'
profile.city = self.cleaned_data['city']
profile.website = self.cleaned_data['website']
profile.intro = self.cleaned_data['intro']
profile.qq = self.cleaned_data['qq']
profile.msn = self.cleaned_data['msn']
if 'avatar' in request.FILES:
#删除掉原头像
import os
if profile and profile.avatar and os.path.exists(profile.avatar.path):
os.remove(profile.avatar.path)
profile.avatar = self.cleaned_data['avatar']#request.FILES["avatar"]
profile.save()
if self.cleaned_data['username'] != current_user.username:
current_user.username = self.cleaned_data['username']
current_user.save()
def register(self, request, **kwargs):
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
print site
user = User()
user.username = kwargs['username']
user.email = kwargs['email']
password = kwargs['password1']
user.set_password(password)
user.first_name = kwargs['first_name']
user.last_name = kwargs['last_name']
user.is_active = False
user.save()
profile_user = UserProfile()
# Любое совпадение наименования полей и аргументов- случайно :), так
# проще не ошибиться
profile_user.country = kwargs['country']
profile_user.city = kwargs['city']
profile_user.company = kwargs['company']
profile_user.dokladchik = kwargs['dokladchik']
profile_user.surname = kwargs['surname']
profile_user.job = kwargs['job']
profile_user.accepted_eula = kwargs['accepted_eula']
profile_user.user = user
profile_user.save()
prof = RegistrationProfile.objects.create_profile(user)
prof.send_activation_email(site)
return user
def retrieve(request):
try:
profile = request.user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=request.user)
profile.save()
return profile
def _profile(user):
"""
Create an User Profile
"""
profile = UserProfile()
profile.user_id = user.id
profile.save()
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 signup(request):
context = {}
context['title'] = _('Register')
user = User()
if request.user.is_authenticated():
return redirect('accounts_accounts')
userProfile = UserProfile()
if request.method == 'POST':
userForm = UserForm(request.POST, instance=user)
userProfileForm = UserProfileForm(request.POST, instance=userProfile)
if userForm.is_valid() and userProfileForm.is_valid():
userData = userForm.cleaned_data
user.username = userData['username']
user.first_name = userData['first_name']
user.last_name = userData['last_name']
user.email = userData['email']
user.set_password(userData['password'])
user.save()
userProfile = user.get_profile()
userProfileData = userProfileForm.cleaned_data
userProfile.gender = userProfileData['gender']
userProfile.birthday = userProfileData['birthday']
userProfile.save()
user = authenticate(username=userData['username'], password=userData['password'])
login(request, user)
return redirect('accounts_accounts')
else:
userForm = UserForm(instance=user)
userProfileForm = UserProfileForm(instance=userProfile)
context['userForm'] = userForm
context['userProfileForm'] = userProfileForm
return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
def register(request):
print 'register started in views.py'
if request.method == 'POST':
form = UserCreationForm(request.POST)
print 'were in post'
print 'email valid: '
print form.is_valid()
if form.is_valid():
print 'form first name %s'%form.cleaned_data['first_name']
user = User.objects.create_user(form.cleaned_data['email'], form.cleaned_data['email'],form.cleaned_data['password1'] )
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
profile = UserProfile(user=user)
profile.save()
print 'logging user in'
user = authenticate(username=request.POST['email'],password=request.POST['password1'])
if user is not None:
# the password verified for the user
if user.is_active:
print("User is valid, active and authenticated")
else:
print("The password is valid, but the account has been disabled!")
else:
# the authentication system was unable to verify the username and password
print("The username and password were incorrect.")
auth_login (request,user)
print 'form being submitted'
return HttpResponseRedirect(reverse('news'))
else:
form = UserCreationForm()
print 'form created'
return render(request, 'accounts/register.html',{'form':form})
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 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 detail(request, poll_id):
print 'exec detail'
p = get_object_or_404(Poll, pk=poll_id)
user = request.user
hasVoted = True
print 'has_voted_one:'
try:
profile = UserProfile.objects.get(userObject=user)
except ObjectDoesNotExist:
profile = UserProfile(userObject=user)
profile.save()
print 'created profile for user'
#hasVotedOnPoll = p in pollsVoted.objects.get(pk=1)
print profile.pollsVoted.all()
hasVotedOnPoll = True
try:
profile.pollsVoted.get(pk=poll_id)
except ObjectDoesNotExist:
hasVotedOnPoll=False
print 'caught exc and hasvoted=false'
print 'hasVotedOnPoll'
print hasVotedOnPoll
try:
poll = Poll.objects.get(pk=poll_id)
except Poll.DoesNotExist:
raise Http404
return render(request, 'polls/detail.html', {'poll': poll, 'hasAlreadyVoted':hasVotedOnPoll})
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 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 signup(request, **kwargs):
form_class = kwargs.pop("form_class", SignupForm)
template_name = kwargs.pop("template_name", "account/signup.html")
redirect_field_name = kwargs.pop("redirect_field_name", "next")
success_url = kwargs.pop("success_url", None)
if success_url is None:
success_url = get_default_redirect(request, redirect_field_name)
if request.method == "POST":
form = form_class(request.POST)
if form.is_valid():
user = form.save(request=request)
# Begin default profile creation
profile = UserProfile(user=user)
profile.save()
# End default profile creation
return complete_signup(request, user, success_url)
else:
form = form_class()
ctx = {"signuppage": True,
"form": form,
"login_url": passthrough_login_redirect_url(request,
reverse("account_login")),
"redirect_field_name": redirect_field_name,
"redirect_field_value": request.REQUEST.get(redirect_field_name) }
return render_to_response(template_name, RequestContext(request, ctx))
def create_user(request):
"""
PUT http://localhost:8000/api/v1/accounts/user/
"""
data = json.loads(request.body.decode("utf-8"))
new_user = UserProfile(
email=data['email'],
password=make_password(data['password']),
first_name=data['first_name'],
last_name=data['last_name'],
phone=data['phone'],
school=data['school'],
rating=0
)
new_user.save()
dataresult = {
'status': str(HTTP_201_CREATED),
'user_id': str(new_user.id),
'email': new_user.email,
'first_name': new_user.first_name,
'last_name': new_user.last_name,
'phone': new_user.phone,
'school': new_user.school,
'rating': str(new_user.rating)
}
return JsonResponse(dataresult, status=HTTP_201_CREATED)
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_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 retrieve(request):
# Authenticated user required
try:
profile = request.user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=request.user)
profile.save()
return profile
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 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 retrieve(request):
""" gets the UserProfile instance for a user, creates one if it does not exist """
try:
profile = request.user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=request.user)
profile.save()
return profile
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 save(self, commit=True):
user = super(UserCreationForm, self).save(commit=False)
user.set_password(self.cleaned_data["password1"])
user.email = self.cleaned_data["email"]
nickname = self.cleaned_data["nickname"]
if commit:
user.save()
user_profile = UserProfile(nickname=nickname, user=user)
user_profile.save()
return user
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 home(request):
try:
profile = UserProfile.objects.get(user = request.user)
except:
profile = UserProfile(user = request.user, receive_email = False)
profile.save()
profile.update_user_info() # NO UPDATE
return render(request, 'account_details.html',{
'profile': profile,
})
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
def signup(request):
"""
username_raw = "xiaoming"
password_raw = "123456"
user = authenticate(username=username_raw, password=password_raw)
if user is None:
# The only way to create user info is the User.objects.create_user(**)
user = User.objects.create_user(username=username_raw,password=password_raw)
userprofile = UserProfile(
user = user,
user_type = "Candidate",
)
userprofile.save()
user = authenticate(username=username_raw, password=password_raw)
permission = Permission.objects.get(codename="add_experience")
user.user_permissions.add(permission)
if user.has_perm("experiences.add_experience"):
print("has permission")
print("login:"******"/manager")
"""
# --------------------------------
print("--------------------------------------------")
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
#step1: store to table user_auth
#form.save()
#step2: register the userprofile
data = form.data
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user_type = form.cleaned_data.get('user_type')
user = authenticate(username=username, password=raw_password)
if not user:# means the user not exist
print("Create User ", username, raw_password, user_type)
user = User.objects.create_user(username=username, password=raw_password)
userprofile = UserProfile(
user = user,
user_type = user_type,
)
userprofile.save()
user = authenticate(username=username, password=raw_password)
#step3: login and redirect
login(request, user)
return HttpResponseRedirect("/manager")
else:
# https://docs.djangoproject.com/en/2.2/ref/forms/api/
print("form is invalid ..", form.errors)
return render(request, 'accounts/signup.html')
def retrieve(request):
""" gets the UserProfile instance for a user, or creates one if it does not exist
note that this requires an authenticated user before we try calling it
"""
try:
# profile = request.user.get_profile()
profile = request.user.myprofile.user_profile
except UserProfile.DoesNotExist:
profile = UserProfile(user_profile=request.user)
profile.save()
return profile
def signup(self, request, user):
user.first_name = self.cleaned_data['first_name']
user.last_name = self.cleaned_data['last_name']
user.save()
profile = UserProfile()
profile.user = user
profile.user = user
profile.phone_no = self.cleaned_data['phone_no']
profile.save()
def save(self, profile_callback=None):
new_user = RegistrationProfile.objects.create_inactive_user(
user=self.cleaned_data['username'],
password=self.cleaned_data['password1'],
email=self.cleaned_data['email'])
new_profile = UserProfile(
user=new_user)
new_profile.save()
return new_user
def save(self, commit=True):
user = super().save(commit=True)
profile = UserProfile(
user=user,
age=self.cleaned_data.get('age'),
gender=self.cleaned_data.get('gender'),
accepted_terms=self.cleaned_data.get('accepted_terms'),
)
if commit:
profile.save()
return user
def test_change_qrcode_admin_group(self):
a = QRcodeList.objects.create(code_content='Physics', is_poster=True, group=0)
d = QRcodeList.objects.create(code_content='Night', is_poster=False, group=1)
b = UserProfile(user=self.user, usable_points=0)
b.save()
response = self.client.get('/QRcode/b04202048/Physics/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/QRcode/b04202048/Night/')
self.assertIn(str('此QRcode已無法使用').encode(), response.content)
def register(request):
if request.method == 'POST':
form = UserCreationFormExtended(request.POST,request.FILES)
if form.is_valid():
new_user = form.save()
new_profile = UserProfile(user=new_user) #create new profile with new_user instance
new_profile.save()
return HttpResponseRedirect(reverse('success'))
else:
form = UserCreationFormExtended()
return render_to_response("register.html", locals(), context_instance=RequestContext(request))
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 check_email(user):
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_key = sha.new(salt+user.username).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
new_profile = UserProfile(user=user,activation_key=activation_key,key_expires=key_expires)
new_profile.save()
email_subject = u'Pk7lover 账户激活'
email_body = u'你好, %s, 感谢你注册Pklover的账户!\n\n请在48小时内点击下面的链接，以激活你的账户(如果不能点击，请手动复制地址到浏览器的地址栏访问):\n\nhttp://pk7lover.com/accounts/confirm/%s' % (user.username, new_profile.activation_key)
send_mail(email_subject,
email_body,
'*****@*****.**',
[user.email])
def register(request):
if request.method == "POST":
# request.post will contain all the field values
form = RegistrationForm(request.POST)
if form.is_valid(
): # if form has all the required field and validations
# fetching all field from request.pOSt
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
phone_number = form.cleaned_data['phone_number']
password = form.cleaned_data['password']
# if email is [email protected] we will get only basu coz indexing is 0
username = email.split('@')[0]
user = Account.objects.create_user(first_name=first_name,
last_name=last_name,
email=email,
username=username,
password=password)
# we did like this coz phone_number argument is not specified in create_user
user.phone_number = phone_number
user.save()
# create user profile
profile = UserProfile()
profile.user_id = user.id
profile.profile_picture = 'default/default-user.png'
profile.save()
# User activation
current_site = get_current_site(request)
mail_subject = 'Please activate your account'
message = render_to_string(
'accounts/account_verification_email.html', {
'user': user,
'domain': current_site,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': default_token_generator.make_token(user),
})
to_email = email
send_email = EmailMessage(mail_subject, message, to=[to_email])
send_email.send()
# messages.success(
# request, 'Thank you for registering with us.We have sent you an verification email.Please Verify it')
return redirect('/accounts/login/?command=verification&email=' +
email)
else:
form = RegistrationForm()
context = {
'form': form,
}
return render(request, 'accounts/register.html', context)
def songs_by_user(request, uid, template_name):
if long(uid) == request.user.id:
return my_songs(request, template_name)
else:
user_profile = None
u = None
template_var = {}
try:
u = User.objects.get(id=uid)
songs = Song.objects.select_related().filter(user=u)
try:
user_profile = u.get_profile()
except UserProfile.DoesNotExist:
user_profile = UserProfile()
user_profile.user = u
user_profile.save()
if request.user.is_authenticated():
my_blacklist = BlackList.objects.filter(user=request.user,
bad_guy=u)
if my_blacklist:
template_var['in_my_blacklist'] = True
except User.DoesNotExist:
songs = None
try:
if request.user.is_authenticated():
user_follower = UserFollower.objects.get(user=u,
follower=request.user)
template_var['user_follower'] = user_follower
except UserFollower.DoesNotExist:
template_var['user_follower'] = None
paginator = Paginator(songs, 20)
try:
page = int(request.GET.get('page', '1'))
except ValueError:
page = 1
try:
songs = paginator.page(page)
except (EmptyPage, InvalidPage):
songs = paginator.page(paginator.num_pages)
template_var['favorite_action'] = 'add'
template_var['current_tabnav'] = 'user_songs'
template_var['user_profile'] = user_profile
template_var['songs'] = songs
return render_to_response(template_name,
template_var,
context_instance=RequestContext(request))
def createBranchAdmin():
user = User()
user.username = '******'
user.first_name = 'A分部管理員'
user.set_password('branchA')
user.email = '*****@*****.**'
user.save()
userProfile = UserProfile()
userProfile.branch = Branch.objects.create(name='分部A', address='分部A', phone='0912345678')
userProfile.user = user
userProfile.save()
return user
def create(self, validated_data):
user = validated_data['user']
company = validated_data['company']
city = validated_data['city']
position = validated_data['position']
userObj = User.objects.get(user=user)
companyObj = CompanyModel.objects.get(name=company)
userProfileObj = UserProfile(user=userObj,
company=companyObj,
position=position,
city=city)
userProfileObj.save()
return validated_data
def _process_signup(request, data, account):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
email = data.get('email')
if auto_signup:
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
# Oops, another user already has this address. We
# cannot simply connect this social account to the
# existing user. Reason is that the email adress may
# not be verified, meaning, the user may be a hacker
# that has added your email address to his account in
# the hope that you fall in his trap. We cannot check
# on 'email_address.verified' either, because
# 'email_address' is not guaranteed to be verified.
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif account_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
if not auto_signup:
request.session['socialaccount_signup'] = dict(data=data,
account=account)
url = reverse('socialaccount_signup')
next = request.REQUEST.get('next')
if next:
url = url + '?' + urlencode(dict(next=next))
ret = HttpResponseRedirect(url)
else:
# FIXME: There is some duplication of logic inhere
# (create user, send email, in active etc..)
username = generate_unique_username \
(data.get('username', email or 'user'))
u = User(username=username,
email=email or '',
last_name = data.get('last_name', '')[0:User._meta.get_field('last_name').max_length],
first_name = data.get('first_name', '')[0:User._meta.get_field('first_name').max_length])
u.set_unusable_password()
u.is_active = not account_settings.EMAIL_VERIFICATION
u.save()
account.user = u
account.save()
profile = UserProfile(user=u)
profile.save()
send_email_confirmation(u, request=request)
ret = complete_social_signup(request, u, account)
return ret
def index(request,u_id,page=1):
"""
查看用户个人资料
"""
# 初始化
try:
u_id = int(u_id)
except :
return HttpResponse(u_id)
# 根据ID得到用户对象
try:
user = User.objects.get(id=u_id)
except User.DoesNotExist:
raise Http404()
# 如果是当前用户自己则跳转到个人中心
if request.user == user:
return HttpResponseRedirect('/home/')
elif request.user.is_authenticated():
visitor,visitor_created= Visitor.objects.get_or_create(master=user,visitor=request.user)
visitor.sub_time = datetime.datetime.now()
visitor.save()
# 得到用户档案
try:
profile = user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile()
profile.user = user
profile.save()
# 如果账号以删除
if profile.deleted == True:
return render('home_none.html',locals(),context_instance=RequestContext(request))
# 对未登录的用户只显示前15条动态
if not request.user.is_authenticated():
develop_all = Develop.objects.filter(user=profile.user)[:5]
else:
develop_all = Develop.objects.filter(user=profile.user)
paginator = Paginator(develop_all,15)
pre_url = 'home/%d' %profile.user.id
current_page = 'develop'
try:
develops = paginator.page(page)
except (EmptyPage,InvalidPage):
develops = paginator.page(paginator.num_pages)
return render('home_index.html',locals(),context_instance=RequestContext(request))
def create_userprofile(user): p = UserProfile() p.user = user p.birth = datetime.datetime.now() p.mobile = '+417X1234567' p.private_phone = '+41221234567' p.instrument = random.choice([k[0] for k in UserProfile.instrument_choices]) p.language = random.choice([k[0] for k in settings.LANGUAGES]) p.im = user.email p.im_carrier = random.choice([k[0] for k in UserProfile.im_choices]) p.website = 'www.example.com' p.saying = 'Nothing to say' p.address = 'Do not known St, xyz, No Country' p.save()
def createSuperuser():
admin = User()
admin.username = '******'
admin.first_name = '管理員'
admin.set_password('admin')
admin.email = '*****@*****.**'
admin.is_staff = True
admin.is_superuser = True
admin.save()
userProfile = UserProfile()
userProfile.branch = Branch.objects.create(name='總部', address='XX', phone='0912345678')
userProfile.user = admin
userProfile.save()
return admin
def songs_by_user(request, uid, template_name):
if long(uid) == request.user.id:
return my_songs(request, template_name)
else:
user_profile = None
u = None
template_var = {}
try:
u = User.objects.get(id=uid)
songs = Song.objects.select_related().filter(user=u)
try:
user_profile = u.get_profile()
except UserProfile.DoesNotExist:
user_profile = UserProfile()
user_profile.user = u
user_profile.save()
if request.user.is_authenticated():
my_blacklist = BlackList.objects.filter(user=request.user, bad_guy=u)
if my_blacklist:
template_var["in_my_blacklist"] = True
except User.DoesNotExist:
songs = None
try:
if request.user.is_authenticated():
user_follower = UserFollower.objects.get(user=u, follower=request.user)
template_var["user_follower"] = user_follower
except UserFollower.DoesNotExist:
template_var["user_follower"] = None
paginator = Paginator(songs, 20)
try:
page = int(request.GET.get("page", "1"))
except ValueError:
page = 1
try:
songs = paginator.page(page)
except (EmptyPage, InvalidPage):
songs = paginator.page(paginator.num_pages)
template_var["favorite_action"] = "add"
template_var["current_tabnav"] = "user_songs"
template_var["user_profile"] = user_profile
template_var["songs"] = songs
return render_to_response(template_name, template_var, context_instance=RequestContext(request))
def save(self, commit=True):
if not commit:
raise NotImplementedError("Can't create User and UserProfile without database save")
user = super(UserCreateForm, self).save(commit=False) #this should trigger the signal handler to create a UserProfile instance, but not commit
user_profile = user.profile
user_profile.mobitel=self.cleaned_data["mobitel"]
user_profile.zupanija=self.cleaned_data["zupanija"]
user_profile.email=self.cleaned_data["email"]
if commit:
user.save()
user_profile.save()
user_profile = UserProfile(user=user, email = self.cleaned_data["email"], mobitel = self.cleaned_data["mobitel"], zupanija = self.cleaned_data["zupanija"])
user_profile.save()
def getprofile(user):
'''
Get the user profile, and if it's not there make it.
arguments:
*request* - The request object
return:
The logged in user's profile
'''
try:
profile = user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=user, pagingprefs=10)
profile.save()
return profile
def register(request):
if request.method == "POST":
form = UserProfileForm(request.POST)
if form.is_valid():
user = User.objects.create_user(request.POST['username'],request.POST['email'],request.POST['password1'])
user.save()
userp = UserProfile(user=user)
userp.save()
messages.info(request, "Thanks for registering. You are now logged in.")
new_user = authenticate(username=request.POST['username'],
password=request.POST['password2'])
login_after_registration(request, new_user)
return HttpResponseRedirect("/events/")
else:
form = UserProfileForm()
return render_to_response("accounts/register.html", {'form':form },context_instance=RequestContext(request))
def create_new_user(email, name = None):
ups = UserProfile.objects.filter(email = email)
if len(ups) > 0:
print (len(ups))
print ("User(s) with email {} already exists, aborting user creation!".
format(email))
return None
username = new_user_name()
user = User.objects.create_user(username, email = None, password = None)
user.is_active = True
user.is_staff = False
user.is_superuser = False
# The following fields are fields we store in the UserProfile object instead
# user.first_name
# user.last_name
# user.email
user.save()
up = UserProfile()
up.user = user
up.password_is_set = False
up.magic_login_code = random.randint(100000000, 999999999)
# If the user doesn't specify a name, email is used as the default
if name is None:
up.name = email
else:
up.name = name
up.email = email
up.phone = ''
up.verification_code = new_phone_verification_number()
up.is_verified = False
up.state = 'CA'
up.message_frequency = 3
up.forecast_email = False
up.set_equipment([])
up.beta_test = True
# In the future, we should separate phone-number, etc., into a separate model
up.save()
print ("User {} created.".format(email))
return user
