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 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 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 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 account_data(self, test_value):
"""
Returns a dict with test data for all the user/profile fields.
"""
# User fields
data = {"email": test_value + "@example.com"}
for field in ("first_name", "last_name", "username",
"password1", "password2"):
if field.startswith("password"):
value = "x" * settings.ACCOUNTS_MIN_PASSWORD_LENGTH
else:
value = test_value
data[field] = value
# Profile fields
try:
profile_form = ProfileForm()
ProfileFieldsForm = profile_form.get_profile_fields_form()
for name, field in ProfileFieldsForm().fields.items():
if name != "id":
if hasattr(field, "choices"):
value = list(field.choices)[0][0]
elif isinstance(field, (DateField, DateTimeField)):
value = "9001-04-20"
else:
value = test_value
data[name] = value
except ProfileNotConfigured:
pass
return data
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 account_data(self, test_value):
"""
Returns a dict with test data for all the user/profile fields.
"""
# User fields
data = {"email": test_value + "@example.com"}
for field in ("first_name", "last_name", "username", "password1",
"password2"):
if field.startswith("password"):
value = "x" * settings.ACCOUNTS_MIN_PASSWORD_LENGTH
else:
value = test_value
data[field] = value
# Profile fields
try:
profile_form = ProfileForm()
ProfileFieldsForm = profile_form.get_profile_fields_form()
for name, field in ProfileFieldsForm().fields.items():
if name != "id":
if hasattr(field, "choices"):
value = list(field.choices)[0][0]
elif isinstance(field, (DateField, DateTimeField)):
value = "9001-04-20"
else:
value = test_value
data[name] = value
except ProfileNotConfigured:
pass
return data
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 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 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 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_invalid_when_any_word_of_description_is_longer_than_45_characters(
self):
data = {
"description":
"one_very_long_word_and_that_should_raise_a_validation_error"
}
form = ProfileForm(data)
self.assertFalse(form.is_valid())
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 test_can_create_profile(self):
form = ProfileForm({
'phone': '0123456789',
'address': '5 Downshire Road',
'town': 'Johnstown',
'postcode': 'BY67 7HJ',
'country': 'Ireland'
})
self.assertTrue(form.is_valid())
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 test_is_form_valid(self):
form_data = {
'city': 'bialystok',
'description': 'test-description',
'image': 'test.jpg',
'website': 'http://google.com'
}
profile_form = ProfileForm(data=form_data)
self.assertTrue(profile_form.is_valid())
self.assertEqual(self.profile1.profile_img, 'default.jpg')
def test_saveProfileInput_whenValid_ShouldPassTest(self):
data = {
'username': '******',
'first_name': 'Alelia',
'last_name': 'Georgieva',
'email': '*****@*****.**',
}
form = ProfileForm(data)
self.assertTrue(form.is_valid())
def test_Profile_WhenInvalidLastName_ShouldPassTest(self):
data = {
'username': '******',
'first_name': 'Amelia',
'last_name': 'georgieva',
'email': '*****@*****.**',
}
form = ProfileForm(data)
self.assertFalse(form.is_valid())
def test_profile_form(self):
form = ProfileForm(data={
"area": 1,
"prefecture": 1,
"x": 0,
"y": 0,
"width": 0,
"height": 0
})
self.assertTrue(form.is_valid())
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 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 post(self, request):
form = ProfileForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.save()
return redirect('/account/form')
args = {'form': form}
return render(request, self.template_name, args)
def register_view(request):
form1 = CustomUserForm
form2 = ProfileForm
if request.method == 'POST' and request.is_ajax():
form1 = CustomUserForm(request.POST)
form2 = ProfileForm(request.POST)
print(form1)
print("entered here 1")
if form1.is_valid() and form2.is_valid():
user = form1.save(commit=False)
user.is_active = False
user.save()
print(user)
profile = form2.save(commit=False)
profile.user = user
username = form1.cleaned_data.get('username')
phone = form2.cleaned_data.get('phone')
x_otp = random.randint(99999, 999999)
profile.otp_x = x_otp
profile.save()
# url = "https://www.fast2sms.com/dev/bulk"
# querystring = {"authorization":"YOUR_API_KEY","sender_id":"FSTSMS","language":"english","route":"qt","numbers":"","message":"YOUR_QT_TEMPLATE_ID","variables":"{AA}|{CC}","variables_values":"12345|asdaswdx"}
# headers = {
# 'cache-control': "no-cache"
# }
# response = requests.request("GET", url, headers=headers, params=querystring)
return JsonResponse(
{
'status': "success",
'message': "account created success fully",
'user': username,
'phone': phone
},
status=200)
else:
try:
formerror = form1.errors
except:
formerror = form2.errors
return JsonResponse(
{
'status': "failed",
'message': "failed to create user",
"errors": formerror
},
status=200)
return JsonResponse({'seconds': "hello"}, status=200)
context = {
"form1": form1,
"form2": form2,
}
return render(request, 'auth/register.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 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 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 post(self, request, *args, **kwargs):
form = ProfileForm(request.POST or None)
if form.is_valid():
user_data = CustomUser.objects.get(id=request.user.id)
user_data.first_name = form.cleaned_data['first_name']
user_data.last_name = form.cleaned_data['last_name']
user_data.department = form.cleaned_data['department']
user_data.save()
return redirect('profile')
return render(request, 'accounts/profile.html', {'form': form})
def test_profile_update(self):
form = ProfileForm(
data={
"area": 2,
"prefecture": 6,
"x": 0,
"y": 0,
"width": 0,
"height": 0,
"about_me": "Now I'm testing about me",
"webpage": "https://www.google.com",
})
self.assertTrue(form.is_valid())
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST or None)
if form.is_valid():
user_data = CustomUser.objects.get(id=request.user.id)
user_data.name = form.cleaned_data['name']
user_data.furigana = form.cleaned_data['furigana']
user_data.description = form.cleaned_data['description']
if request.FILES.get('image'):
user_data.image = request.FILES.get('image')
user_data.save()
return redirect('profile')
return render(request, 'accounts/profile.html', {'form': form})
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 post(self, request, *args, **kwargs):
ctxt = {}
form = ProfileForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
if form.save():
messages.success(request, 'Data saved')
return HttpResponseRedirect(request.path)
else:
ctxt['form'] = form
return render(request, self.template_name,
self.get_context_data(request, **ctxt))
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 test_profile_form_normal_user(self):
"""ProfileForm: 正常値"""
# form
params = {'describe': 'd' * 80}
form = ProfileForm(params)
# assert form validation
self.assertTrue(form.is_valid())
# response
path = reverse('accounts:profile', kwargs={'pk': self.test_user.id})
# avoid LoginRequiredMixin
self.client.login(username='******', password='******')
response = self.client.post(path, params)
# assert http status
self.assertEqual(response.status_code, 302)
def signup(request):
signup_form = SignupForm(request.POST or None)
profile_form = ProfileForm(request.POST or None, request.FILES or None)
if request.method == "POST":
if signup_form.is_valid() and profile_form.is_valid():
user = signup_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
return redirect(reverse('main:showMain'))
return render(request, 'accounts/signup.html', {
'signup_form': signup_form,
'profile_form': profile_form,
})
def new_bio(request, username=None):
form = ProfileForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user
instance.save()
return HttpResponseRedirect("/")
context = {
"form" : form,
"tab_text" : "Save"
}
return render(request, 'general_form.html', context)
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 update_profile(request):
form = ProfileForm(request.POST or None,
request.FILES or None,
instance=request.user.profile)
if request.method == "POST" and form.is_valid():
profile = form.save()
return redirect(
reverse('accounts:profile_detail',
kwargs={
'username': profile.user.username,
}))
ctx = {
'form': form,
}
return render(request, 'accounts/edit_profile.html', ctx)
def user_profile(request):
profile = Profile.objects.get(user=request.user)
form = ProfileForm(instance=profile)
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
messages.success(request,'Profile updated successfully')
form = ProfileForm(instance=profile)
return render( request, 'accounts/profile-update.html', context={'form':form})
def change_profile(request):
profile = UserProfile.objects.get(user=request.user)
form = ProfileForm(instance=profile)
if request.method == 'POST':
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
form = ProfileForm(instance=profile)
return render(request,
'accounts/user_profile.html',
context={'profile_form': form})
def get_context_data(request, **kwargs):
if 'form' not in kwargs:
kwargs['form'] = ProfileForm(instance=request.user)
orders = Order.objects.filter(owner=request.user)
favorites = Favorites.objects.filter(user=request.user)
# todo how rewrite below especially queries
product_ids = []
for order in orders:
if order.status == Order.COMPLETED:
# get list of products in orders
product_ids += order.items.all().values_list('product__id',
flat=True)
product_ids = list(set(product_ids))
rated_products = ProductRating.objects\
.filter(product__in=product_ids, user=request.user).defer('user')
products_to_rate = Product.objects \
.exclude(id__in=[rating.product.id for rating in rated_products]) \
.filter(id__in=product_ids)
context = {
'orders': orders,
'favorites': favorites,
'rated_products': rated_products,
'products_to_rate': products_to_rate,
}
kwargs = {**kwargs, **context}
return kwargs
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 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/')
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))
