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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.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_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 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 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 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):
u = request.user
p = u.get_profile()
if request.method == 'POST':
previous_email = u.email
user_form = UserUpdateForm(request.POST, instance=u)
profile_form = ProfileForm(request.POST, request.FILES, instance=p)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
# Check if email change was requested
# Note: request.POST['email'] should be safe below since it's a valid email
if u.email != request.POST['email']:
p.new_email = request.POST['email']
p.email_change_key = random_string(16)
p.save()
send_email(
"Action required to change your email at TempSurge",
"accounts/emails/email_change", settings.FROM_EMAIL,
p.new_email, {
'change_email_url':
"http://tempsurge.com/accounts/change-email/" +
str(u.id) + "/" + p.email_change_key
})
return render(
request, "accounts/message.html", {
'app':
"accounts",
'connotation':
"warning",
'message':
"Please check your email (%s) and follow the reactivation instructions."
% p.new_email
})
messages.success(request,
"Your profile has been successfully updated.",
extra_tags="profile_updated")
return redirect("/accounts/profile/")
else:
user_form = UserUpdateForm(instance=u)
profile_form = ProfileForm(instance=p)
return render(
request, 'accounts/profile.html', {
'user': u,
'profile': p,
'user_form': user_form,
'profile_form': profile_form,
'random': random_string()
})
def profile(request):
if request.method == "POST":
form = ProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
messages.success(request, "Akun Anda berhasil di update!")
return redirect("home:home")
else:
form = ProfileForm(instance=request.user.profile)
return render(request, "accounts/update_profile.html", {"form": form})
def profile_edit(request: HttpRequest):
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, "profile edited!!")
redirect("/")
else:
form = ProfileForm(instance=request.user)
return render(request, "accounts/profile_edit_form.html", {"form": form})
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 profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, 'Your Profile has been Updated!')
return redirect('accounts:profile')
else:
form = ProfileForm(instance=request.user)
return render(request, 'accounts/profile.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
profile = form.save(commit=False)
profile.username = profile.email
profile.save()
return redirect('user_login')
else:
form = ProfileForm()
return render(request, 'accounts/signup.html', {'form': form})
