def register_user(request):
if request.method == 'POST':
register = RegisterForm(request.POST, prefix='register')
usrprofile = ProfileForm(request.POST, prefix='profile')
print(register.is_valid(), register.errors)
print(usrprofile.is_valid())
if register.is_valid() * usrprofile.is_valid():
user = register.save()
usrprof = usrprofile.save(commit=False)
usrprof.user = user
usrprof.set_token()
usrprof.subscribed = '1'
usrprof.save()
return HttpResponseRedirect('/account/')
else:
messages.info(request, 'Password do not match!')
userform = RegisterForm(prefix='register')
userprofileform = ProfileForm(prefix='profile')
#return HttpResponse('errors')
return render(
request, 'accounts/register.html', {
'messages': messages.get_messages(request),
'userform': userform,
'userprofileform': userprofileform
})
else:
userform = RegisterForm(prefix='register')
userprofileform = ProfileForm(prefix='profile')
return render(request, 'accounts/register.html', {
'userform': userform,
'userprofileform': userprofileform
})
def ModifyProfileView(request, owner):
if request.method == "POST":
if owner == "profile":
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
else:
profile_form = ProfileFormP(request.POST,
instance=request.user.profilep)
user_form = UpdateFormRegistrazione(request.POST,
instance=request.user)
if user_form.is_valid() and profile_form.is_valid():
profile_form.save()
user_form.save()
return HttpResponseRedirect('/')
else:
print("modifica profilo non valida")
user_form = UpdateFormRegistrazione()
if owner == "profile":
profile_form = ProfileForm()
else:
profile_form = ProfileFormP()
context = {"u_form": user_form, "p_form": profile_form}
return render(request, 'core/modify_profile.html', context)
def update_profile(request):
"""
Updates the user profile
"""
instance = get_object_or_404(Profile, user__username=request.user.username)
form = ProfileForm(request.POST or None,
request.FILES or None,
instance=instance)
if request.POST:
if form.is_valid():
instance = form.save(commit=False)
instance.save()
messages.success(request, "Edited nicely!")
return HttpResponseRedirect(instance.get_absolute_url())
else:
messages.error(request,
"Sorry! Unable to Register Updates.",
extra_tags="")
context = {
"instance": instance,
}
return render(request, 'accounts/update_profile.html', context)
def registration(request):
if request.user.is_authenticated:
return redirect(reverse('index'))
if request.method == "POST":
registration_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm(request.POST, request.FILES)
if registration_form.is_valid() and profile_form.is_valid():
user = registration_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password1'])
if user:
auth.login(user=user, request=request)
messages.success(request, "Registered!")
return render(request, 'index.html')
else:
messages.error(
request, "Unable to register your account at this time.")
else:
registration_form = UserRegistrationForm()
profile_form = ProfileForm()
return render(request, 'registration.html', {
"registration_form": registration_form,
"profile_form": profile_form
})
def post(self, request, *args, **kwargs):
print(request)
oldUser = User.objects.get(id=request.user.id)
user_form = UserForm(request.POST, oldUser)
profile = oldUser.userprofile
profile.user = oldUser
profile_form = ProfileForm(request.POST or None,
request.FILES or None,
instance=profile)
print(profile_form)
if profile_form.is_valid():
profile_form.save()
print('Registering : ' + str(request.user))
return render(
request, 'accounts/message_page.html', {
'header': "Signed Up!",
'details': '',
'redirect': reverse('customer:homepage')
})
else:
return render(
request, 'accounts/message_page.html', {
'header': "Error!",
'details': 'Try Again',
'redirect': reverse('customer:homepage')
})
pass
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return self.form_valid(form)
else:
return self.form_invalid(form)
def test_valid_form(self):
data = {
"description":
"few words which any is not longer than 45 characters"
}
form = ProfileForm(data)
self.assertTrue(form.is_valid())
def register_user(request):
if request.method == 'GET':
if request.user.is_authenticated:
return redirect('all quotes')
context = {
'user_form': RegisterForm(),
'profile_form': ProfileForm(),
}
return render(request, 'registration/register.html', context)
else:
user_form = RegisterForm(request.POST)
profile_form = ProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
login(request, user)
return redirect('all quotes')
context = {
'user_form': user_form,
'profile_form': profile_form,
}
return render(request, 'registration/register.html', context)
def test_max_description_characters(self):
form_data = {
'city':
'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque tempor cursus iaculis. Maecenas at diam sed tellus cursus pellentesque non a quam.Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque tempor cursus iaculis. Maecenas at diam sed tellus cursus pellentesque non a quam.'
}
profile_form = ProfileForm(data=form_data)
self.assertFalse(profile_form.is_valid())
def update_profile(request):
"""
Fetch data from user and user profile and render it on the form.
Update both models.
"""
if not request.user.is_authenticated:
return redirect('login')
else:
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profiles)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, ('Your profile has been updated successfully!'))
return redirect('user_profile')
else:
messages.error(request, ('Please correct the error below.'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profiles)
context = {
'user_form': user_form,
'profile_form': profile_form,
'title': 'Update',
'profile': 'profile'
}
return render(request, 'update_profile.html', context)
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
profile_form = ProfileForm(data=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 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
return redirect('tender:all')
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = ProfileForm()
return render(
request, 'registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def profile_view(request):
try:
profile = Profile.objects.get(user=request.user)
except:
return redirect('accounts:signup')
if request.user.is_authenticated:
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
try:
if request.POST['terms_and_conditions']:
profile = form.save(commit=False)
profile.terms_and_conditions = True
profile.save()
except:
profile = form.save(commit=False)
profile.terms_and_conditions = False
profile.save()
return redirect("/")
template_name = 'registration/profile.html'
context = {}
return render(request, template_name, context)
else:
return redirect('accounts:signup')
def user_profile_edit(request, pk):
user = User.objects.get(pk=pk)
if request.user != user.userprofile.user:
return render(request, 'no_permission.html')
if request.method == 'GET':
context = {
'form_user_profile': UserProfileEditForm(instance=user),
'form_profile': ProfileForm(instance=user.userprofile),
}
return render(request, 'accounts/profile_edit.html', context)
else:
form_user = UserProfileEditForm(request.POST, instance=user)
form_profile = ProfileForm(request.POST,
request.FILES,
instance=user.userprofile)
if form_user.is_valid() and form_profile.is_valid():
form_user.save()
form_profile.save()
return redirect('user profile', user.pk)
context = {
'form_user_profile': UserProfileEditForm(instance=user),
'form_profile': ProfileForm(instance=user.userprofile),
}
return render(request, 'accounts/profile_edit.html', context)
def SignUp(request):
registered = False
if request.method == "POST":
user_form = forms.UserCreateForm(data=request.POST)
profile_form = ProfileForm(data=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
profile.save()
registered = True
return HttpResponseRedirect(reverse_lazy('login'))
else:
print(user_form.errors, profile_form.errors)
else:
user_form = forms.UserCreateForm()
profile_form = ProfileForm()
return render(
request, 'signup.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def register(request):
if request.method == 'POST':
u_form = UserForm(request.POST)
p_form = ProfileForm(request.POST)
if u_form.is_valid() and p_form.is_valid():
user = u_form.save()
gender = p_form.cleaned_data.get('gender')
date_of_birth = p_form.cleaned_data.get('date_of_birth')
contact_number = p_form.cleaned_data.get('contact_number')
author = AuthorProfile.objects.create(
author=user,
gender=gender,
date_of_birth=date_of_birth,
contact_number=contact_number)
p_form = ProfileForm(request.POST, instance=author)
p_form.save()
messages.success(request, 'Your account has been created!')
return redirect('login')
else:
u_form = UserForm()
p_form = ProfileForm()
context = {'u_form': u_form, 'p_form': p_form}
return render(request, 'accounts/register.html', context)
def edit_profile(request):
"""
Create a view that allows us to edit your profile
"""
user = request.user
profile = user.profile
if request.method == 'POST':
# create a form instance and populate it with data from the request:
userForm = UserForm(request.POST)
profileForm = ProfileForm(request.POST,
request.FILES,
instance=profile)
# check whether it's valid:
if userForm.is_valid() and profileForm.is_valid():
# Save User model fields
user.first_name = request.POST['first_name']
user.last_name = request.POST['last_name']
user.email = request.POST['email']
user.save()
profile = profileForm.save(commit=False)
profile.save()
# if a GET (or any other method): create a blank form
else:
userForm = UserForm(instance=user)
profileForm = ProfileForm(instance=profile)
return render(request, 'profile.html', {
'userForm': userForm,
'profileForm': profileForm
})
def edit_user(request):
profile = User_Profile.objects.get(User_associated=request.user)
user = User.objects.get(id=request.user.id)
# img = None
if request.method == "POST":
profileForm = ProfileForm(request.POST, instance=profile, prefix="profile_form")
userForm = UserForm(request.POST, instance=user, prefix="user_form")
# passwordForm = PasswordChangeForm(data=request.POST, user=request.user, prefix="password_form")
if profileForm.is_valid() and userForm.is_valid():
profileForm.save()
userForm.save()
# passwordForm.save()
else:
profileForm = ProfileForm(prefix="profile_form", instance=profile,
initial={"Degree": profile.Degree,
"Year_first_enrolled": profile.Year_first_enrolled,})
userForm = UserForm(prefix="user_form", instance=user,
initial={'username': user.username,
'email': user.email,
'first_name': user.first_name,
'last_name': user.last_name})
return render_to_response("accounts/settings.html",
{"profile_form": profileForm, "user_form": userForm}, context_instance=RequestContext(request))
def job_apply(request, id):
job = Job.objects.get(id=id)
user = request.user
profile = Profile.objects.get(user=user)
personal_info = user.candidate
profile_form = ProfileForm(instance=profile)
personal_info_form = EmployeeForm(instance=personal_info)
if request.method == "POST":
profile_form = ProfileForm(request.POST, instance=profile)
personal_info_form = EmployeeForm(request.POST,
request.FILES,
instance=personal_info)
if profile_form.is_valid() and personal_info_form.is_valid():
form2 = profile_form.save(commit=False)
form2.save()
form3 = personal_info_form.save(commit=False)
form3.save()
form3.jobs.add(job)
personal_info_form.save_m2m()
messages.success(request, 'Your application has been accepted !')
subject = f'{user.username} applied for your {job.title} job '
message = f"{personal_info.cover_letter}"
cv = request.FILES.getlist('cv')
mail = EmailMessage(subject, message, settings.EMAIL_HOST_USER,
[job.owner.email])
for f in cv:
mail.attach(f.name, f.read(), f.content_type)
mail.send()
return redirect(reverse('jobs:job_list'))
context = {"form2": profile_form, "form3": personal_info_form, 'job': job}
return render(request, 'job/job_application.html', context)
def register(request):
if request.FILES:
print('file')
if request.method == 'POST':
userForm = UserCreationForm(request.POST)
profileForm = ProfileForm(request.POST)
if userForm.is_valid() and profileForm.is_valid():
user = userForm.save()
user.refresh_from_db()
profileForm = ProfileForm(request.POST,
request.FILES,
instance=user.profile)
profileForm.full_clean()
profileForm.save()
# return redirect('accounts/login.html')
url = 'accounts/dashboard/' + str(user.username) + '/'
return redirect('http://127.0.0.1:8000/' + url, permanent=True)
else:
return HttpResponse('failed')
else:
userForm = UserCreationForm()
profileForm = ProfileForm()
context = {'userForm': userForm, 'profileForm': profileForm}
return render(request, 'accounts/signup.html', context)
def update_user_details(request):
"""
Form to update user details
"""
if request.method == "POST":
user_form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return redirect(reverse("userarea:index"))
else:
messages.error(request, user_form.errors)
messages.error(request, profile_form.errors)
else:
user_form = UserUpdateForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return redirect(reverse("userarea:index"))
def edit_profile(request):
"""
Render a form to edit the user's profile but only if user is logged in
"""
user = request.user
if request.method == "POST":
edit_user_form = UserEditProfileForm(request.POST, instance=user)
edit_profile_form = ProfileForm(request.POST,
request.FILES,
instance=user.profile)
if edit_user_form.is_valid() and edit_profile_form.is_valid():
edit_user_form.save()
edit_profile_form.save()
return redirect('view_profile', request.user.id)
else:
messages.error(request, "Please check and amend the above.")
else:
"""render user and profile forms"""
edit_user_form = UserEditProfileForm(instance=user)
edit_profile_form = ProfileForm(instance=user.profile)
return render(request, "edit_profile.html", {
"edit_user_form": edit_user_form,
"edit_profile_form": edit_profile_form
})
def profilepage(request):
"""Displays Profile Page / Handles updating of profile"""
if request.method == 'POST':
if 'user-information' in request.POST:
user_form = UserDataForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, "User Information Updated.")
return redirect('profile')
else:
shipping_form = ShippingForm(request.POST,
instance=request.user.profile)
if shipping_form.is_valid():
shipping_form.save()
messages.success(request, "User Information Updated.")
return redirect('profile')
user_form = UserDataForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
shipping_form = ShippingForm(instance=request.user.profile)
forms = {
'UserDataForm': user_form,
'ProfileForm': profile_form,
'Shippingform': shipping_form
}
return render(request, 'profile.html', forms)
def update_profile(request):
"""Esta função exibe ou edita um perfil de um usuário, a depender do método da requisição"""
# Tenta obter o objeto com a pk informado. Se não conseguir, retorna um erro 404
profile = get_object_or_404(Profile, user=request.user)
# Se o usuário mandar dados, ou seja, se a requisição for POST
if request.method == "POST":
# Instancia um formulário vinculado a um objeto Turma com os dados recebidos da requisição POST
form = UserUpdateForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=profile)
if form.is_valid() and profile_form.is_valid():
form.save()
profile_form.save()
# Retorna para a página de lista de turmas
return redirect("dashboard:view_dashboard")
# Se o usuário apenas solicitar para acessar a página, ou seja, se a requisição for GET
else:
# Cria uma instância com os dados do objeto passado como parâmetro
form = UserUpdateForm(instance=request.user)
profile_form = ProfileForm(instance=profile)
context = {"form": form, "profile_form": profile_form, "link": "profile"}
# Renderiza a página de editar turma com os campos e seus respectivos dados
return render(request, "dashboard/profile.html", context)
def user_profile(request):
"""User's profile page with auction results and profile form to update"""
current_auctions = Auction.objects.filter(
winning_bidder=request.user.pk, auction_end_time__gte=timezone.now())
past_paid_auctions = Auction.objects.filter(
winning_bidder=request.user.pk,
auction_end_time__lt=timezone.now(),
paid=True)
past_unpaid_auctions = Auction.objects.filter(
winning_bidder=request.user.pk,
auction_end_time__lt=timezone.now(),
paid=False)
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, 'Your profile was successfully updated.')
return redirect('profile.html')
else:
messages.error(request, 'Please correct the error below.')
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(
request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form,
'current_auctions': current_auctions,
'past_paid_auctions': past_paid_auctions,
'past_unpaid_auctions': past_unpaid_auctions
})
def profile_edit(request):
profile_ = Profile.objects.get(
user=request.user
) # get profile qui a user(dans profile) = au user request
if request.method == 'POST':
userform = UserForm(request.POST, instance=request.user)
profileform = ProfileForm(
request.POST, request.FILES,
instance=profile_) # request.FILES : pour uplaod file
if userform.is_valid() and profileform.is_valid():
userform.save(
) # save user directement mais le profile nécessité la suivante
myform = profileform.save(
commit=False) # s'assurer que le profile est relié au user
myform.user = request.user # s'assurer que le profile est relié au user
myform.save() # save profile
messages.success(
request, 'updated') # qui sera affiché dans redirect template
return redirect('accounts:profile')
else: # (affichage)
userform = UserForm(
instance=request.user
) # request.user = data du user connecté (affichage)
profileform = ProfileForm(
instance=profile_
) # profile_ = profile du user connecté (affichage)
return render(request, 'accounts/profile/edit_profile.html', {
'userform': userform,
'profileform': profileform
})
def profile_edit_view(request):
if request.user.is_anonymous:
return redirect("accounts:login")
if request.method == 'POST':
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
update_form = UserUpdateForm(request.POST, instance=request.user)
if profile_form.is_valid() and update_form.is_valid():
if not request.user.profile.profile_img:
request.user.profile.profile_img = 'default.jpg'
profile_form.save()
update_form.save()
return redirect('/profile/' + request.user.username)
else:
profile_form = ProfileForm(instance=request.user.profile)
update_form = UserUpdateForm(instance=request.user)
context = {'profile_form':profile_form,
'update_form':update_form }
return render(request, 'accounts/profile_edit.html', context)
def signup_info(request):
# 회원 가입 정보 입력 페이지
if Profile.objects.filter(user=request.user).exists():
# 사용자 프로필 정보가 이미 존재할 경우 메인 페이지로
return redirect('cast:index')
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
profile = form.save(
commit=False) # 사용자한테 받아온 정보로 프로필 폼 인스턴스 생성(모델에 저장하지 않음)
profile.user = request.user # 프로필 유저에 유저 정보 저장
profile.user.username = profile.user.socialaccount_set.first(
).extra_data['properties']['nickname'] # 유저의 이름은 카카오톡 닉네임으로 저장
profile.user.email = profile.user.socialaccount_set.first(
).extra_data['kaccount_email'] # 유저의 이메일은 카카오톡 아이디로 저장
img = request.user.socialaccount_set.first().get_avatar_url(
) # 카카오 프로필의 이미지 경로를 받아온다.
image = ContentFile(
requests.get(img).content) # 불러온 이미지 데이터를 ContentFile객체로 랩핑한다.
profile.image.save(profile.user.username,
image) # 랩핑된 이미지 데이터를 profile에 저장
profile.user.save() # 유저 모델에 저장
profile.save() # 프로필 모델에 저장
return redirect('accounts:set_tag')
else:
form = ProfileForm()
return render(request, 'accounts/signup_info.html', {
'form': form,
})
def edit_profile(request):
if request.user.is_authenticated:
user = User.objects.get(email=request.user.email)
if request.method == "POST":
# user_form = UserCreationForm(request.FILES, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
print(profile_form)
if profile_form.is_valid(): # user_form.is_valid() and
# user_form.save()
profile_form.save()
messages.success(request, ('Your profile was successfully updated!'))
return render(request, 'profile.html', {'profile_form': profile_form}) # 'user_form': user_form,
else:
messages.error(request, 'forms not valid')
# profile_form = ProfileForm()
else:
# user_form = UserCreationForm(request.FILES, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
return render(request, 'edit_profile.html', {
# 'user_form': user_form,
'profile_form': profile_form
})
else:
return redirect('login')
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return self.form_valid(form)
else:
return self.form_invalid(form)
def user_profile(request):
profile = request.user.get_profile()
if request.method == "POST":
# Read params
form = ProfileForm(request.POST, instance=profile)
subscriptionform = SubscriptionForm(request.POST, instance=profile)
userform = UserForm(request.POST, instance=request.user)
if appsettings.DEMO_SERVER and request.user.username == "demo":
messages.warning(request, _("You can not change demo profile on the demo server."))
return redirect("profile")
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = redirect("profile")
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _("Your profile has been updated."))
return response
else:
form = ProfileForm(instance=profile)
subscriptionform = SubscriptionForm(instance=profile)
userform = UserForm(instance=request.user)
social = request.user.social_auth.all()
social_names = [assoc.provider for assoc in social]
new_backends = [x for x in load_backends(BACKENDS).keys() if x == "email" or x not in social_names]
response = render_to_response(
"accounts/profile.html",
RequestContext(
request,
{
"form": form,
"userform": userform,
"subscriptionform": subscriptionform,
"profile": profile,
"title": _("User profile"),
"licenses": Project.objects.exclude(license=""),
"associated": social,
"new_backends": new_backends,
},
),
)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language)
return response
def edit_profile(request):
profile = ""
UserProfiles = UserProfile.objects.all()
for prof in UserProfiles:
if request.user == prof.user:
profile = prof
if request.method == 'GET':
context = {
'profile': profile,
'form': ProfileForm(instance=profile),
}
return render(request, 'edit_profile.html', context)
elif request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
return redirect('accounts:User_Profile')
context = {
'profile': profile,
'form': ProfileForm(instance=profile),
}
return render(request, 'edit_profile.html', context)
def registration_next_steps(request):
"""
Loads next steps page to complete user registration
"""
referer = request.META.get('data[HTTP_REFERER]', '')
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
# associate profile with user object
next_step = form.save(commit=False)
next_step.user = request.user
# create a Stripe customer instance
customer = create_customer_stripe_account(
request.user, commit=False
)
next_step.stripe_id = customer.id
# create a customer balance object of 0
cbal = CustomerBalance.objects.create(customer=request.user)
cbal.save()
# save and redirect to home page
next_step.save()
return redirect('/')
else:
form = ProfileForm()
return render(request, 'form-next-step.html', {'form': form})
def IndexView(request):
if request.user.is_authenticated():
return HttpResponseRedirect('cricket_center')
else:
registered = False
user_form = UserForm(request.POST or None)
profile_form = ProfileForm(request.POST or None)
login_form = UserLogInForm(request.POST or None)
if request.method == 'POST':
if request.POST.get('submit') == 'Login':
login_form = UserLogInForm(data=request.POST)
if login_form.is_valid:
username = login_form.data.get("username")
password = login_form.data.get("password")
user = authenticate(username=username, password=password)
if user:
# Check it the account is active
if user.is_active:
# Log the user in.
login(request, user)
# user.profile.balance = user.profile.balance+10
# print(user.profile.balance)
user.save()
# print(request.user.profile.balance)
# print(request.user.profile.balance+10)
# request.user.profile.save()
# Send the user back to some page.
# In this case their homepage.
return HttpResponseRedirect('cricket_center')
else:
# If account is not active:
return HttpResponse("Your account is not active.")
else:
print("Someone tried to login and failed.")
print("They used username: {} and password: {}".format(
username, password))
return HttpResponse("Invalid login details supplied.")
if request.POST.get('submit') == 'Register':
user_form = UserForm(data=request.POST)
profile_form = ProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(commit=False)
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
return render(
request, 'index.html', {
'user_form': user_form,
'profile_form': profile_form,
'login_form': login_form,
'registered': registered
})
def profile(request):
form = ProfileForm(request.POST or None, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, PROFILE_MESSAGE)
return redirect(reverse('accounts:profile'))
context = {'form': form}
return render(request, 'accounts/profile.html', context)
def new_profile(request):
if request.method == "POST":
form = ProfileForm(request.POST)
if form.is_valid():
create_profile(request, form)
else:
form = ProfileForm()
return render(request, "accounts/profile_new.html", {"form": form})
def profile_edit(request):
from django.utils.translation import ugettext as _
if request.method == 'POST':
form = ProfileForm(request.user, request.POST)
if form.is_valid():
form.save()
raise RedirectException(redirect(request), notice_message=_(u'Changes to profile saved.'))
else:
form = ProfileForm(request.user)
return {'form': form}
def profile_form(request):
user = request.user
profile = request.user.p2puprofile
form = ProfileForm(instance=profile, initial={'first_name':user.first_name, 'last_name':user.last_name})
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
return redirect('project_form')
return direct_to_template(request, 'profile_form.html', locals())
def get(self, request, *args, **kwargs):
form = ProfileForm(request.POST or None, instance=self.request.user)
if form.is_valid():
form.save()
return redirect('dashboard')
context = self.get_context_data(**kwargs)
context['form'] = form
return self.render_to_response(context)
def profile_edit(request, l):
error_msg = None
me = l.get_ldap_node(request.session['ldap_binddn'])
if request.method == 'POST':
f = ProfileForm(request.POST)
if f.is_valid():
me.displayName = f.cleaned_data['name']
me.cn = f.cleaned_data['nick']
me.save()
passwd_new = f.cleaned_data['passwd']
email_new = f.cleaned_data['email']
if passwd_new:
me.set_password(passwd_new)
request.session['ldap_passwd'] = passwd_new
if email_new != str(me.mail):
req = Request()
req.type = Request.EMAIL
req.uid = me.uid
req.email = email_new
req.save()
t = loader.get_template('accounts/email_email_request')
c = Context({
'name': me.displayName,
'url': request.build_absolute_uri(
reverse(process, kwargs={ 'token': req.token })),
'expire_in': settings.REQ_EXPIRE_STR,
})
send_mail(u'Confirmation email FedeRez', t.render(c), settings.EMAIL_FROM,
[req.email], fail_silently=False)
return HttpResponseRedirect('/')
else:
f = ProfileForm(label_suffix='', initial={ 'email': me.mail,
'name': me.displayName,
'nick': me.cn })
c = { 'form': f,
'name': me.displayName,
'nick': me.cn,
'email': me.mail,
'error_msg': error_msg, }
c.update(csrf(request))
return render_to_response('accounts/edit.html', c,
context_instance=RequestContext(request))
def user_profile(request):
profile = request.user.get_profile()
if request.method == "POST":
# Read params
form = ProfileForm(request.POST, instance=profile)
subscriptionform = SubscriptionForm(request.POST, instance=profile)
userform = UserForm(request.POST, instance=request.user)
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = HttpResponseRedirect(reverse("profile"))
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _("Your profile has been updated."))
return response
else:
form = ProfileForm(instance=profile)
subscriptionform = SubscriptionForm(instance=profile)
userform = UserForm(instance=request.user)
response = render_to_response(
"profile.html",
RequestContext(
request,
{
"form": form,
"userform": userform,
"subscriptionform": subscriptionform,
"profile": profile,
"title": _("User profile"),
"licenses": Project.objects.exclude(license=""),
},
),
)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language)
return response
def edit(request):
profile = request.user.profile
def is_selected(prefix):
if request.method == "POST":
for name in request.POST.keys():
if name.startswith(prefix + '-'):
return True
if request.FILES:
for name in request.FILES.keys():
if name.startswith(prefix + '-'):
return True
return False
if is_selected("profile"):
had_enabled_stream_emails = profile.enabled_stream_emails
profile_form = ProfileForm(request, request.POST, instance=profile, prefix="profile")
if profile_form.is_valid():
enabled_stream_emails = profile_form.cleaned_data.get("enabled_stream_emails")
# If is enabling stream emails, set last_stream_email_sent to now
if not had_enabled_stream_emails and enabled_stream_emails:
profile.last_stream_email_sent = datetime.datetime.now()
profile.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
profile_form = ProfileForm(request, instance=profile, prefix="profile")
if is_selected("image"):
image_form = AvatarForm(request.POST, request.FILES, prefix="image")
if image_form.is_valid():
if image_form.cleaned_data["remove"]:
profile.has_avatar = False
profile.save()
else:
handle_uploaded_image(profile, image_form.cleaned_data["file"])
profile.has_avatar = True
profile.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
image_form = AvatarForm(prefix="image")
has_granted_permissions = AccessToken.objects.filter(user=request.user).count()
tvars = {
'profile': profile,
'profile_form': profile_form,
'image_form': image_form,
'has_granted_permissions': has_granted_permissions
}
return render(request, 'accounts/edit.html', tvars)
def register_person(request):
if not 'confirmation_code' in request.session:
raise Http404
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
confirmation_code = request.session['confirmation_code']
try:
registrationManager = RegistrationManager.objects.get(confirmation_code=confirmation_code)
except RegistrationManager.DoesNotExist:
raise Http404
email = registrationManager.email
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
password = form.cleaned_data['password']
picture = form.cleaned_data['picture']
user = User(username=email, first_name=first_name, last_name=last_name, email=email)
user.set_password(password)
user.save()
email_domain = email.split('@')[1]
try:
organization = Organization.objects.get(email_domain=email_domain)
group = organization.primary_group
except Organization.DoesNotExist: # first user for organization
organization = None
group = None
person = Person(user=user, organization=organization, picture=picture, group=group)
person.save()
del request.session['confirmation_code']
registrationManager.delete()
user = authenticate(username=email, password=password)
login(request, user)
return HttpResponseRedirect('/')
else:
form = ProfileForm()
c = RequestContext(request, {'form': form })
c.update(csrf(request))
return render_to_response('registration/register_person.html', c)
def form(request):
form = ProfileForm(auto_id='%s')
if request.POST:
form = ProfileForm(auto_id='%s', data=request.POST)
if(form.is_valid()):
return render_to_response('accounts/register/thanx.html', { 'email': register_inactive(
form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['first_name'],
form.cleaned_data['last_name'],
form.cleaned_data['sur_name'],
).email }, context_instance=RequestContext(request))
return render_to_response(
'accounts/register/form.html',
{'form': form},
context_instance=RequestContext(request)
)
def edit(request):
profile = request.user.profile
def is_selected(prefix):
if request.method == "POST":
for name in request.POST.keys():
if name.startswith(prefix + '-'):
return True
if request.FILES:
for name in request.FILES.keys():
if name.startswith(prefix + '-'):
return True
return False
if is_selected("profile"):
profile_form = ProfileForm(request, request.POST, instance=profile, prefix="profile")
if profile_form.is_valid():
profile_form.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
profile_form = ProfileForm(request,instance=profile, prefix="profile")
if is_selected("image"):
image_form = AvatarForm(request.POST, request.FILES, prefix="image")
if image_form.is_valid():
if image_form.cleaned_data["remove"]:
profile.has_avatar = False
profile.save()
else:
handle_uploaded_image(profile, image_form.cleaned_data["file"])
profile.has_avatar = True
profile.save()
return HttpResponseRedirect(reverse("accounts-home"))
else:
image_form = AvatarForm(prefix="image")
return render_to_response('accounts/edit.html', dict(profile=profile, profile_form=profile_form, image_form=image_form), context_instance=RequestContext(request))
def save_profile(request):
title = "Edit My Profile"
icon = "edit"
if request.POST.get('save_changes'):
form = ProfileForm(data=request.POST, files=request.FILES, instance=request.user.profile)
if form.is_valid():
if request.POST.get('username', request.user.username) != request.user.username:
# change username
try:
check = User.objects.get(username=request.POST.get('username'))
messages.error(request, 'That username has already been taken!')
return locals()
except User.DoesNotExist:
request.user.username = request.POST.get('username')
request.user.save()
form.save()
request.user.first_name = request.POST.get('first_name', request.user.first_name)
request.user.last_name = request.POST.get('last_name', request.user.last_name)
request.user.save()
messages.success(request, 'Your profile has been updated!')
else:
messages.error(request, 'Unable to save changes to your profile!')
return locals()
return view_profile(request)
def form(request):
profile = Profile.objects.get(user=request.user)
form = ProfileForm(auto_id='%s', initial={
'id' : request.user.id,
'username' : request.user.username,
'email' : request.user.email,
'avatar' : profile.avatar,
'first_name': request.user.first_name,
'sur_name' : profile.sur_name,
'last_name' : request.user.last_name,
'gender' : profile.gender,
'birthdate' : profile.birthdate,
'phone' : profile.phone,
'icq' : profile.icq,
})
if request.POST:
form = ProfileForm(auto_id='%s', data=request.POST, files=request.FILES)
if(form.is_valid()):
# update user info and profile
User.objects.filter(id=request.user.id).update(
username = form.cleaned_data.get('username'),
email = form.cleaned_data.get('email'),
first_name = form.cleaned_data.get('first_name'),
last_name = form.cleaned_data.get('last_name')
)
Profile.objects.filter(id=request.user.get_profile().id).update(
user = request.user,
avatar = request.FILES and 'upload/avatars/'+str(request.user.id) or '',
sur_name = form.cleaned_data.get('sur_name'),
gender = form.cleaned_data.get('gender'),
birthdate = form.cleaned_data.get('birthdate'),
phone = form.cleaned_data.get('phone'),
icq = form.cleaned_data.get('icq')
)
# resize and save uploaded avatar
if request.FILES:
filename = settings.UPLOAD_ROOT+'avatars/'+str(request.user.id)
avatar = open(filename,'wb+')
for chunk in request.FILES['avatar'].chunks(): avatar.write(chunk)
avatar.close()
image = Image.open(filename)
if image.mode not in ('L', 'RGB'):
image = image.convert('RGB')
image.thumbnail((70, 70), Image.ANTIALIAS)
image.save(filename, image.format)
Profile.objects.filter(id=form.cleaned_data.get('id')).update(
avatar='upload/avatars/'+str(request.user.id)
)
profile = Profile.objects.get(user=request.user)
return render_to_response('accounts/profile.html', {
'form' : form,
'profile': profile,
}, context_instance=RequestContext(request))
def user_profile(request):
profile = request.user.get_profile()
if request.method == 'POST':
# Read params
form = ProfileForm(
request.POST,
instance=profile
)
subscriptionform = SubscriptionForm(
request.POST,
instance=profile
)
userform = UserForm(
request.POST,
instance=request.user
)
if (form.is_valid()
and userform.is_valid()
and subscriptionform.is_valid()):
# Save changes
form.save()
subscriptionform.save()
userform.save()
# Change language
set_lang(request.user, request=request, user=request.user)
# Redirect after saving (and possibly changing language)
response = HttpResponseRedirect(reverse('profile'))
# Set language cookie and activate new language (for message below)
lang_code = profile.language
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
messages.info(request, _('Your profile has been updated.'))
return response
else:
form = ProfileForm(
instance=profile
)
subscriptionform = SubscriptionForm(
instance=profile
)
userform = UserForm(
instance=request.user
)
response = render_to_response('profile.html', RequestContext(request, {
'form': form,
'userform': userform,
'subscriptionform': subscriptionform,
'profile': profile,
'title': _('User profile'),
}))
response.set_cookie(
settings.LANGUAGE_COOKIE_NAME,
profile.language
)
return response
def update(request):
'''
Данная функция отвечает за обноление всех данных о пользователе: Профиль, Юр. данные, Инф. о доставке.
Она принимает на вход всего 1 форму и в зависимости от параметров расбрасывает эти данные в набор моделей.
'''
if request.method == 'POST': # Если пришли данные от формы
form = ProfileForm(request.POST, request.FILES) # Создадним экземпляр формы
if form.is_valid(): # Если все данные введены корректно...
# Если произошли изменения в модели пользователя
user = User.objects.get(id=request.user.id)
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
# Если произошли изменения в модели профиля
profile = Profile.objects.get(user=user)
profile.phone = form.cleaned_data['phone']
is_legal = int(form.cleaned_data['is_legal'])
# Подгрузка аватарки на сервер
try:
profile.img = handle_uploaded_file(request.FILES['img'], 'user_pic')
except:
pass
# Проверка, является ли пользователь юр.лицом
if is_legal == 0:
profile.is_legal = False
else:
profile.is_legal = True
profile.save()
# Если пользователь становится юр.лицом, необходимо сохранить в базе его юридические данные
form = LegalForm(request.POST)
if form.is_valid():
try:
legal = Legal.objects.get(profile=profile)
legal.title = form.cleaned_data['legal_name']
legal.inn = form.cleaned_data['inn']
legal.kpp = form.cleaned_data['kpp']
legal.bik = form.cleaned_data['bik']
legal.rs = int(form.cleaned_data['rs'])
legal.ks = int(form.cleaned_data['ks'])
legal.post = form.cleaned_data['post']
except:
legal = Legal(
profile = profile,
title = form.cleaned_data['legal_name'],
inn = form.cleaned_data['inn'],
kpp = form.cleaned_data['kpp'],
bik = form.cleaned_data['bik'],
rs = int(form.cleaned_data['rs']),
ks = int(form.cleaned_data['ks']),
post = form.cleaned_data['post'],
)
legal.save()
# Если пользователь вводит свои данные по доставке
form = DeliveryForm(request.POST)
if form.is_valid():
try:
delivery = Delivery.objects.get(profile=profile)
delivery.title = form.cleaned_data['delivery_name']
delivery.address = form.cleaned_data['address']
delivery.city = form.cleaned_data['city']
except:
delivery = Delivery(
profile = profile,
title = form.cleaned_data['delivery_name'],
address = form.cleaned_data['address'],
city = form.cleaned_data['city']
)
delivery.save()
return HttpResponseRedirect('/profile/')
