def AplikacjaConfirm2(request, pk, username):
podanie = Podanie.objects.get(pk=pk)
username = username
profile_for = CustomUser.objects.get(username=username)
new_profile = None
if request.method == 'POST':
form = UserProfileForm(pk, username, request.POST)
if form.is_valid():
new_profile = form.save(commit=False)
new_profile.user = profile_for
new_profile.save()
return redirect('aplikacja_confirm3', podanie.pk, username)
else:
print(form.errors)
else:
form = UserProfileForm(pk, username)
context_dict = {
'podanie': podanie,
'username': username,
'profile_for': profile_for,
'new_profile': new_profile,
'form': form,
}
response = render(request,
'aplikacje/aplikacja_confirm2.html',
context=context_dict)
return response
def userprofile(request):
user = request.user
if request.method == 'POST':
form = UserProfileForm(request.POST,
request.FILES,
instance=user.profile)
if form.is_valid():
profile = form.save(commit=False)
profile.user = user
profile.save()
int_list = form.cleaned_data['interest']
#remove unchecked interests
for i in profile.interest.all():
if i not in int_list:
profile.interest.remove(i)
#add new interests
for i in int_list:
if i not in profile.interest.all():
profile.interest.add(i)
return redirect(reverse_lazy('dashboard'))
else:
form = UserProfileForm(instance=user.profile)
return render(request, 'users/profile.html', {'form': form})
def test_form(self):
# Test with no data supplied
# email is required
form_data = {}
form = UserProfileForm(data=form_data)
self.assertFalse(form.is_valid(),
"Email not supplied but form validated")
# Test with invalid email
form_data = {
'email': 'not an email address',
}
form = UserProfileForm(data=form_data)
self.assertFalse(form.is_valid(),
"Email is invalid, but form validated")
# Test with minimum required form data
form_data = {
'email': '*****@*****.**',
}
form = UserProfileForm(data=form_data)
self.assertTrue(form.is_valid(),
"Form is not valid with only email address")
# Test with all required form fields
form_data = {
'email': '*****@*****.**',
'first_name': "FIRST",
'last_name': "LAST",
'derby_name': "DERBY NAME",
'derby_number': "DERBY NUMBER",
}
form = UserProfileForm(data=form_data)
self.assertTrue(form.is_valid(),
"Form is not valid but all fields were filled out.")
def setup(request):
form = UserProfileForm()
if request.method == 'POST':
form = UserProfileForm(request.POST)
form.save(request.user)
context = {'form': form}
return render(request, 'users/setup.html', context)
def user_details(request, pk):
user = CustomUser.objects.get(pk=pk)
user_form = UserProfileForm(instance=user)
ProfileInlineFormset = inlineformset_factory(CustomUser, UserProfile, fields=('photo',))
formset = ProfileInlineFormset(instance=user)
if request.user.is_authenticated and request.user.id == user.id:
if request.method == "POST":
user_form = UserProfileForm(request.POST, request.FILES, instance=user)
formset = ProfileInlineFormset(request.POST, request.FILES, instance=user)
if user_form.is_valid():
created_user = user_form.save(commit=False)
formset = ProfileInlineFormset(request.POST, request.FILES, instance=created_user)
if formset.is_valid():
created_user.save()
formset.save()
return render(request, "blog/user_settings_profile_upd.html")
return render(request, "blog/user_details.html", {
"noodle": pk,
"noodle_form": user_form,
"formset": formset,
})
else:
raise PermissionDenied
def register_pharmacy(request):
if request.method == 'POST':
u_form = UserRegisterForm(request.POST)
p_form = UserProfileForm(request.POST)
p1_form = PharmacyProfileForm(request.POST)
if u_form.is_valid() and p_form.is_valid() and p1_form.is_valid():
user = u_form.save()
username = u_form.cleaned_data.get('username')
profile = p_form.save(commit=False)
profile.user = user
profile.is_pharmacy = True
profile.save()
pharmacy_profile = p1_form.save(commit=False)
pharmacy_profile.user = user
pharmacy_profile.save()
messages.success(
request,
f'O λογαριασμός δημιουργήθηκε. Μπορείτε τώρα να συνδεθείτε')
return redirect('login')
else:
u_form = UserRegisterForm()
p_form = UserProfileForm()
p1_form = PharmacyProfileForm()
context = {
'title': 'Εγγραφή Φαρμακευτικής Εταιρείας',
'role': 'pharmacy',
'u_form': u_form,
'p_form': p_form,
'p1_form': p1_form
}
return render(request, 'users/register.html', context)
def register(request):
if request.method == 'POST':
u_form = UserRegistrationForm(request.POST)
p_form = UserProfileForm(request.POST, request.FILES)
if u_form.is_valid() and p_form.is_valid():
check = User.objects.filter(
email=u_form.cleaned_data.get('email')).exists()
if check is False:
user = u_form.save()
user.save()
designation = p_form.cleaned_data.get('designation')
if designation == 'TEACHER':
group = Group.objects.get(name='Teacher')
user.groups.add(group)
else:
group = Group.objects.get(name='Student')
user.groups.add(group)
profile = p_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
messages.success(request,
"Your account has been created. Log In")
return redirect('login')
else:
messages.warning(request, "Email already exists")
return redirect('register')
else:
u_form = UserRegistrationForm()
p_form = UserProfileForm()
context = {'u_form': u_form, 'p_form': p_form}
return render(request, 'users/signup.html', context)
def Register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
login(request, user)
return redirect('home')
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'users/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print(user_form.errors, profile_form.errors)
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, 'register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def edit_profile(request, username):
user = User.objects.get(username=username)
user_profile = UserProfile.objects.get(user=user)
message = None
if request.user != user:
raise PermissionDenied
elif request.method == 'POST':
form = UserProfileForm(request.POST)
if form.is_valid():
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.email = form.cleaned_data['email']
if form.cleaned_data['password']:
user.set_password(form.cleaned_data['password'])
user_profile.alternate_email = form.cleaned_data['alternate_email']
user_profile.phone = form.cleaned_data['phone']
user_profile.tshirt = form.cleaned_data['tshirt']
user_profile.diet = form.cleaned_data['diet']
user_profile.location = form.cleaned_data['location']
user_profile.description = form.cleaned_data['description']
user_profile.notify_by_email = form.cleaned_data['notify_by_email']
user.save()
user_profile.save()
message = 'Updated profile.'
else:
form = UserProfileForm(
initial={
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
'alternate_email': user_profile.alternate_email,
'phone': user_profile.phone,
'tshirt': user_profile.tshirt,
'diet': user_profile.diet,
'location': user_profile.location,
'description': user_profile.description,
'notify_by_email': user_profile.notify_by_email,
})
env = common_env()
env['form'] = form
env['user_'] = user
env['message'] = message
env['user_profile'] = user_profile
return render(request, 'users/edit_profile.html', env)
def user_register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(commit=False)
user.is_active = False
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
if 'bio' in request.POST:
profile.bio = request.POST['bio']
profile.save()
registered = True
# send account confirmation email
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'users/acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'userid': user.pk,
'token': account_activation_token.make_token(user),
})
to_email = user_form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'users/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def editProfileView(request):
if request.method == 'POST':
form = UserProfileForm(request.POST,
request.FILES,
instance=request.user.userprofile)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('users:user_profile'))
else:
return render(request, 'users/userprofile_edit_form.html')
else:
form = UserProfileForm(instance=request.user.userprofile)
args = {'form': form}
return render(request, 'users/userprofile_edit_form.html', args)
def user_profile(request, username):
try:
profile_user = User.objects.get(username=username)
piechart_data = get_user_statistics(profile_user)
render_data = {}
render_data['profile_user'] = profile_user
render_data['piechart_data'] = dumps(piechart_data)
if request.user == profile_user and not is_public_user(profile_user):
render_data['profile_form'] = UserProfileForm(
instance=profile_user)
if can_change_userlevel(request.user, profile_user):
render_data['userlevel_form'] = UserLevelForm(instance=profile_user,
request_user=request.user)
if request.user == profile_user and request.method == 'POST' \
and 'profile_form' in request.POST:
profile_form = UserProfileForm(request.POST, instance=profile_user)
render_data['profile_form'] = profile_form
if profile_form.is_valid() and request.user == profile_user:
logger.info('User %s update profile' % username)
profile_form.save()
update_session_auth_hash(request, profile_user)
request.user = profile_user
messages.success(request, 'Update profile successfully!')
if request.method == 'POST' and 'userlevel_form' in request.POST:
userlevel_form = UserLevelForm(
request.POST, request_user=request.user)
if can_change_userlevel(request.user, profile_user):
if userlevel_form.is_valid(request.user):
user_level = userlevel_form.cleaned_data['user_level']
logger.info("User %s update %s's user level to %s" %
(request.user, username, user_level))
profile_user.user_level = user_level
profile_user.save()
render_data['userlevel_form'] = userlevel_form
messages.success(
request, 'Update user level successfully!')
else:
user_level = userlevel_form.cleaned_data['user_level']
messages.warning(request, "You can't switch user %s to %s" %
(profile_user, user_level))
return render_index(request, 'users/profile.html', render_data)
except User.DoesNotExist:
logger.warning('User %s does not exist' % username)
raise Http404('User %s does not exist' % username)
def update(self, request, *args, **kwargs):
form = UserProfileForm(data=request.data,
files=request.FILES,
instance=request.user)
if form.is_valid():
form.save()
return Response({'detail': 'user details saved'}, status=200)
def category(request):
categories = Category.__members__.items()
user_ip = get_client_ip(request)
ip = user_ip[0]
request.session['ip'] = ip
if request.user.is_authenticated:
user = CustomUser.objects.get(pk=request.user.pk)
user_form = UserProfileForm(instance=user)
ProfileInlineFormset = inlineformset_factory(CustomUser, UserProfile, fields=('photo',))
formset = ProfileInlineFormset(instance=user)
if request.user.id == user.id:
if request.method == "POST":
formset = ProfileInlineFormset(request.POST, request.FILES, instance=user)
return {
'categories' : categories,
'signup_form': CustomUserCreationForm(),
'isLoggedIn': True,
'userprofile': formset,
}
else :
return {
'categories' : categories,
'signup_form': CustomUserCreationForm(),
'isLoggedIn': False,
}
def create(self, request, *args, **kwargs):
registered = False
flag =1
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
User = get_user_model()
if user_form.is_valid() and profile_form.is_valid():
for User in User.objects.filter():
if user_form.cleaned_data['email'] == User.email:
flag =0
user_form.cleaned_data['username'] = "******"
print("This mail address already exists!")
if flag ==1:
user = user_form.save()
print("user saved")
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
print('found it')
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
else :
print("not-saved")
else:
print(user_form.errors,profile_form.errors)
return render(request,'users/registration.html',
{'user_form':user_form,
'profile_form':profile_form,
'registered':registered,
'flag':flag})
def get(self, request, user_id):
user = self.get_user(request, user_id)
form = UserProfileForm(instance=user)
return render(request, 'users/profile.html', {
'user': user,
'form': form,
})
def post(self,request):
print(request.POST)
_userForm = UserProfileForm(request.POST)
# print(_userForm)
if _userForm.is_valid():
try:
_userForm.cleaned_data['password'] = make_password('12345678')
_userForm.cleaned_data['is_active'] = True
data = _userForm.cleaned_data
print(data)
self.model.objects.create(**data)
res = {'code': 0, 'next_url': reverse("users:user_list"), 'result': '添加用户成功'}
except:
res = {'code': 1, 'next_url': reverse("users:user_list"), 'errmsg': '添加用户失败'}
# logging.error("edit user group pwoer error: %s" % traceback.format_exc())
else:
try:
# 获取自定义的表单错误的两种常用方式
print(_userForm.errors)
print(_userForm.errors.as_json())
print(_userForm.errors['phone'][0])
print(_userForm.errors['username'][0])
except Exception as e:
# res = {'code': 1, 'errmsg': _userForm.errors.as_json()}
res = {'code': 1, 'errmsg': _userForm.errors}
return render(request, settings.JUMP_PAGE, res)
def post(self, request):
_userForm = UserProfileForm(request.POST)
if _userForm.is_valid():
try:
_userForm.cleaned_data['password'] = make_password("12345678")
_userForm.cleaned_data['is_active'] = True
data = _userForm.cleaned_data
self.model.objects.create(**data)
res = {'code': 0, 'result': '添加用户成功。'}
except:
#logger.error("create user error: %s" % traceback.format_exc())
res = {'code': 1, 'errmsg': '添加用户失败。'}
else:
# 获取自定义的表单错误的两种常用方式
print(_userForm.errors)
# <ul class="errorlist">
# <li>phone<ul class="errorlist"><li>手机号码非法</li></ul></li>
# <li>username<ul class="errorlist"><li>已存在一位使用该名字的用户。</li></ul></li>
# </ul>
print(_userForm.errors.as_json())
# {"phone": [{"message": "\u624b\u673a\u53f7\u7801\u975e\u6cd5", "code": "invalid"}],
# "username": [{"message": "\u5df2\u5b4f7f\u7528\u8be5\u540d\u5b57\u7684\u7528\u6237\u3002",
# "code": "unique"}]}
if _userForm.errors.get('phone'):
print(_userForm.errors['phone'][0]) # 手机号码非法
if _userForm.errors.get('username'):
print(_userForm.errors['username'][0]) # 已存在一位使用该名字的用户
res = {'code': 1, 'errmsg': _userForm.errors.as_json()}
return JsonResponse(res, safe=True)
def all_categories(request):
signup_form = UserProfileForm()
login_form = UserLoginForm()
data = {}
for category in SUPERCATEGORY_CHOICES:
data.update(
{category[1]: Category.objects.filter(superCategory=category[0])})
return {'login_form': login_form, 'signup_form': signup_form, 'data': data}
def edit(request, username):
if request.user.username == username:
user = request.user
profile = user.get_profile()
if request.method == 'POST':
user_profile_form = UserProfileForm(request.POST, instance=profile)
if user_profile_form.is_valid():
user_profile = user_profile_form.save()
return redirect(user_profile)
else:
return render(request, 'user_edit.html',
{'form': user_profile_form})
else:
return render(request, 'user_edit.html', {
'form': UserProfileForm(instance=profile),
})
else:
raise PermissionDenied
def edit_profile(request, pk):
"""Edit an existing profile."""
profile = get_object_or_404(UserProfile, pk=pk)
user = profile.user
if request.method != "POST":
# Initial request; pre-fill form with the current entry.
form = UserProfileForm(instance=profile)
else:
# POST data submitted; process data.
form = UserProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
return redirect('users:profile', pk=pk)
context = {"profile": profile, "user": user, "form": form}
return render(request, "users/edit_profile.html", context)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(commit=False)
profile = profile_form.save(commit=False)
if User.objects.filter(email=user.email).exists():
messages.error(request, f'Your Email already exist')
return redirect("signup")
else:
user = user_form.save()
user.set_password(user.password)
user.save()
#profile = profile_form.save(commit=False)
profile.user = user
profile.save()
registered = True
if user and profile:
subject = 'Thank you for registering to our site'
message = ' Welcome to Credrank \n Thank you for registration '
email_from = settings.EMAIL_HOST_USER
recipient_list = [user.email]
send_mail(subject, message, email_from, recipient_list)
messages.error(
request,
f'Your account has been created. Please login.')
return redirect("login")
else:
messages.error(request, f'Your Email already exist')
return redirect("signup")
else:
messages.error(request, f'Your username already exist')
return redirect("signup")
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def list(self, request, *args, **kwargs):
registered = False
flag =1
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,'users/registration.html',
{'user_form':user_form,
'profile_form':profile_form,
'registered':registered,
'flag':flag})
def test_save(self):
form = UserProfileForm(data=self.data,
files=self.files,
instance=self.profile)
form.save()
self.profile.refresh_from_db()
assert self.profile.user.first_name == 'new'
assert self.profile.user.last_name == 'name'
assert self.profile.bio == 'test'
assert self.profile.user.username == 'rain2'
def profile(request):
user = get_object_or_404(UserProfile, user__username=request.user.username)
if request.user != user.user and not request.user.is_superuser:
raise Http404
if request.method == "POST":
form = UserProfileForm(user, request.POST)
if form.is_valid():
user.workunit = form.cleaned_data["company"]
user.telephone = form.cleaned_data["telephone"]
user.address = form.cleaned_data["location"]
user.save()
HttpResponseRedirect("/settings/profile")
else:
form = UserProfileForm(user)
data = {"form": form}
return render(request, "widgets/settings/profile.html", data)
def upload_pic(request):
#cur_user = models.User
if request.method == 'POST':
form = UserProfileForm(request.POST, request.FILES)
if form.is_valid():
m = UserProfile.objects.get()
m.model_pic = form.cleaned_data['image']
m.save()
return HttpResponse('image upload success')
return HttpResponseForbidden('allowed only via POST')
def register(request):
if request.method == "GET":
form = CustomUserCreationForm()
profile_form = UserProfileForm()
context = {'form': form, 'profile_form': profile_form}
return render(request, "register.html", context)
elif request.method == "POST":
form = CustomUserCreationForm(request.POST)
profile_form = UserProfileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
login(request, user)
return redirect(reverse("home"))
def user_profile(request, pk=None):
user = request.user if pk is None else User.objects.get(pk=pk)
if request.method == 'GET':
context = {
'profile_user': user,
'profile': user.userprofile,
'profile_form': UserProfileForm(),
'e_form': EmailSignupForm(),
}
return render(request, 'users/profile.html', context)
else:
form = UserProfileForm(request.POST,
request.FILES,
instance=user.userprofile)
if form.is_valid():
form.save()
return redirect('current user profile')
return redirect('current user profile')
def get(self, request, *args, **kwargs):
from users.forms import UserProfileForm
from users.model.profile import UserProfile
try:
self.info = UserProfile.objects.get(user=request.user)
except:
self.info = UserProfile.objects.create(user=request.user)
self.form = UserProfileForm(instance=self.info)
self.template_name = get_my_template("profile/settings/about.html",
request.user,
request.META['HTTP_USER_AGENT'])
return super(UserAboutSettings, self).get(request, *args, **kwargs)
