def old_profile(request):
try:
profile = request.user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile.objects.create(user=request.user)
if request.method == 'POST':
data = {
'user': request.user.id,
'home_address': request.POST['home_address'],
'home_city': request.POST['home_city'],
'mobile_num': request.POST['mobile_num']
}
form = ProfileForm(data, instance=profile)
print request.POST
print form.is_valid()
print form.errors
if form.is_valid():
print 'valid!'
form.save()
else:
form = ProfileForm(instance=profile)
commutes = Commute.objects.filter(user=request.user)
profile = request.user.get_profile()
return render(request, 'users/profile.html', {
'commutes': commutes,
'profile': profile,
'form': form
})
def test_create_profile(self):
form = ProfileForm({
'username': '******',
'password': '******',
'email': '*****@*****.**' })
self.assertTrue(form.is_valid(), 'Formularz jest niepoprawny.')
form = ProfileForm()
self.assertFalse(form.is_valid(), 'Formularz nie jest niepoprawny.')
def edit_profile(request, template_name="profile_edit.html"):
profile = get_object_or_404(Profile, pk=1)
CFormSet = modelformset_factory(ContactField, can_delete=True,
formset=ContactsFormSet,
extra=2,
fields=('uid', 'contact_type'))
if request.method == 'POST':
postdata = request.POST.copy()
profile_form = ProfileForm(postdata, instance=profile)
contact_forms = CFormSet(postdata, profile=profile)
if request.is_ajax():
# This is for formset validation if profile form is not valid
contact_forms.is_valid()
if profile_form.is_valid() and contact_forms.is_valid():
# Save changes in forms
profile_form.save()
contact_forms.save()
ret = {'status': 'ok'}
else:
ret = {
'status': 'fail',
'profile_errors': profile_form.errors,
'contacts_errors': contact_forms.errors,
'contacts_nonform_errors': contact_forms.non_form_errors(),
}
json = simplejson.dumps(ret)
return HttpResponse(json, mimetype='application/json')
else:
# This is for formset validation if profile form is not valid
contact_forms.is_valid()
if profile_form.is_valid() and contact_forms.is_valid():
# Save changes in forms
profile_form.save()
contact_forms.save()
return HttpResponseRedirect(reverse('edit_profile'))
else:
profile_form = ProfileForm(instance=profile)
contact_forms = CFormSet(profile=profile)
context_dict = {
'profile_form': profile_form,
'contatcs_forms': contact_forms,
}
return render_to_response(template_name,
context_dict,
context_instance=RequestContext(request))
def activate(request, activation_key,
template_name='userena/activate_fail.html',
extra_context=None):
"""
Activate a user with an activation key.
"""
user = UserenaSignup.objects.activate_user(activation_key)
if user:
# Sign the user in.
auth_user = authenticate(identification=user.username,
check_password=False)
UserDetail.set_activation_datetime(auth_user)
login(request, auth_user)
if userena_settings.USERENA_USE_MESSAGES:
messages.success(request, _('Congratulations -- your Art of Gratitude account is confirmed!'),
fail_silently=True)
if request.method == 'POST':
form = ProfileForm(request.POST, user=user)
if form.is_valid():
form.save()
redirect_to = settings.LOGIN_REDIRECT_URL % {'username': user.username }
return redirect(redirect_to)
else:
if not extra_context: extra_context = {}
return ExtraContextTemplateView.as_view(template_name=template_name,
extra_context=extra_context)(request)
def registration(request):
if(request.user.is_authenticated()):
return redirect(list_bundles)
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
login(request,user)
messages.success(request, 'You have successfully registered!')
if form.data['next']:
return redirect(form.data['next'])
return redirect('/')
else:
for error in form.non_field_errors():
messages.error(request,error)
return render_to_response('server/register.html',{'form': form, 'next': form.data['next']},
context_instance=RequestContext(request))
form = ProfileForm()
if 'next' in request.GET:
next_page = request.GET['next']
else:
next_page = ''
return render_to_response('server/register.html', {'form': form, 'next': next_page},
context_instance=RequestContext(request))
def update_profile(request):
try:
promoter = request.user.promoterprofile
except PromoterProfile.DoesNotExist:
error_meta = {
"method": "promoter.views.update_profile",
}
ErrorLog.objects.create_log(4, "Promoter Object Error", error_meta,
request)
raise SuspiciousOperation('Error Code: 4')
form = ProfileForm(request.POST or None, instance=promoter)
context = {"form": form}
if request.POST:
if form.is_valid():
form.save()
activity_meta = {
"method": "promoter.views.update_profile",
"form_validation": "True"
}
ActivityLog.objects.create_log(request, "Update Promoter Account",
activity_meta)
return redirect('/pr/account/')
else:
return render(request, "promoter/edit_profile.html", context)
else:
activity_meta = {
"method": "promoter.views.update_profile",
}
ActivityLog.objects.create_log(request, "Update Promoter Account",
activity_meta)
return render(request, "promoter/edit_profile.html", context)
def edit(request,
template_name='edit_profile.html',
redirect_to='auth_profile'):
form = ProfileForm(request.POST, instance=request.user.get_profile())
if request.POST:
if form.is_valid():
form.save()
u = request.user
u.email = form.data['email']
u.first_name = form.data['first_name']
u.last_name = form.data['last_name']
u.save()
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse(redirect_to))
else:
initial_dict = {
'email': request.user.email,
'username': request.user.username,
'first_name': request.user.first_name,
'last_name': request.user.last_name
}
form = ProfileForm(instance=request.user.get_profile(),
initial=initial_dict)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def profile_edit(request, username=None):
if username is None:
p = request.user.get_profile()
user = request.user
else:
user = User.objects.get(username=username)
p = user.get_profile()
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST, instance=p, editor=request.user)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
p = profile_form.save()
if 'is_active' in request.POST and request.user.has_perm('auth.change_user'):
user.is_active = True
user.save()
send_mail(
"Your myschoolcommute.com account has been approved",
"You may login at http://%s/%s" % (request.META['HTTP_HOST'], reverse('login'),),
settings.SERVER_EMAIL,
[user.email]
)
return HttpResponseRedirect(reverse('user_detail', args=[user.username]))
else:
user_form = UserForm(instance=user)
profile_form = ProfileForm(instance=p, editor=request.user)
profile_form.helper.add_input(Submit('submit', 'Save account'))
return render_to_response("accounts/edit.html", {
'user_form' : user_form, 'profile_form': profile_form, 'user': user
}, context_instance=RequestContext(request) )
def edit_profile(request, id=None):
context = {
'page_title': u'Perfis',
'edit_name': 'profile',
'has_back': False,
'features': get_user_features(request)
}
t = get_template('edit.html')
profile = None
form = ProfileForm()
try:
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
profile = _save_profile(cd)
messages.success(request, 'Perfil salvo com sucesso.')
form = ProfileForm(initial={})
elif id:
profile = Profile.objects.get(id=id)
initial = profile.__dict__
initial['features'] = profile.features.all()
form = ProfileForm(initial=initial)
except Exception as e:
log.error(e)
messages.error(
request,
u'Ocorreu um erro ao processar a requisição, por favor tente novamente.'
)
context = _set_profile_form_context(profile, form, context)
return render_to_response('edit.html',
context,
context_instance=RequestContext(request))
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 base_profile(request):
f_password = forms.PasswordChangeForm(request.POST)
f_profile = ProfileForm(instance=request.user.profile)
f_user = UserEditForm(instance=request.user)
commit = False
if request.method == "POST":
f_profile = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
f_user = UserEditForm(request.POST, request.FILES, instance=request.user)
if f_password.is_valid():
f_password.save(commit=True)
# handle_uploaded_file(request.FILES['avatar'])
f_profile.save(commit=True)
commit = True
if f_profile.is_valid():
f_profile.save(commit=True)
# handle_uploaded_file(request.FILES['avatar'])
commit = True
if f_user.is_valid():
user = f_user.save(commit=True)
commit = True
return render_to_response(
"user/profile.html",
{"profile": f_profile, "f_pw": f_password, "f_user": f_user, "commit": commit},
context_instance=RequestContext(request),
)
def signup(request):
if not request.user.is_authenticated:
if request.method == 'POST':
form = SignUpForm(request.POST)
profile_form = ProfileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
form.save()
user_name = form.cleaned_data['username']
profile_form.save(user_name)
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('/accounts')
else:
form = SignUpForm()
profile_form = ProfileForm()
return render(request, 'accounts/signup.html', {
'form': form,
'profile_form': profile_form
})
else:
return redirect('/accounts')
def edit(request, profile_id):
profile = UserProfile.objects.get(id=profile_id)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
user_profile = UserProfile.objects.get(id=profile_id)
user_profile.pic = cd['pic']
user_profile.url = cd['url']
user_profile.mobile = cd['mobile']
user_profile.save()
return HttpResponseRedirect('/')
else:
form = ProfileForm(
initial={
'id': profile.id,
'pic': profile.pic,
'url': profile.url,
'mobile': profile.mobile
})
args = {}
args.update(csrf(request))
args['form'] = form
return render(request, "edit.html", args)
def contact_edit(request, first_name, last_name):
'''
get contact page
@param request:
@param first_name: Profile.first_name
@param last_name: Profile.last_name
'''
profile = get_object_or_404(Mybio,
pk=1)
if request.method == "POST":
profile_form = ProfileForm(request.POST, instance=profile)
if profile_form.is_valid():
profile = profile_form.save()
if request.method == "GET":
profile_form = ProfileForm(instance=profile)
return {
"profile": profile,
"profile_form": profile_form,
"utility_links": ((reverse('profile-view',
kwargs={"first_name": profile.first_name,
"last_name": profile.last_name, }),
_("View profile"),
{}),)}
def profile(request):
if not request.user.is_authenticated():
raise PermissionDenied
record = request.user.courses_taken.all()
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
# Validate
if form.cleaned_data['password0']:
if form.cleaned_data['password0'] == form.cleaned_data[
'password1']:
request.user.set_password(form.cleaned_data['password0'])
messages.success(
request, "<strong>Success!</strong> Password changed.")
else:
messages.error(request, "The two passwords do not match.")
if request.user.option != form.cleaned_data['option']:
request.user.option = form.cleaned_data['option']
messages.success(request,
"<strong>Success!</strong> Option selected.")
request.user.save()
return HttpResponseRedirect(reverse('profile'))
else:
form = ProfileForm(initial={'option': request.user.option})
return render_to_response('student/edit-profile.html', {
'form': form,
'record': record
},
context_instance=RequestContext(request))
def edit(request):
""" Update UserProfile """
if request.method == 'POST':
form = ProfileForm(request.POST,
instance=UserProfile.objects.get(user=request.user))
if form.is_valid(): # All validation rules pass
try:
User.objects.filter(email=form.cleaned_data['email']).\
exclude(pk=request.user.pk).get()
request.session['flash'] = ['This e-mail is already in use',
'error']
return HttpResponseRedirect(
request.META.get('HTTP_REFERER', '/'))
except User.DoesNotExist:#Check if the e-mail is not already in use
pass
request.user.email = form.cleaned_data['email']
request.user.save()
form.save()
request.session['flash'] = ['Your profile has been updated',
'success']
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
else:
form = ProfileForm(instance=UserProfile.objects.get(user=request.user),
initial = {'email': request.user.email})
return render_to_response('accounts/edit.html', {'form': form},
context_instance=build_context(request))
def edit_profile(request):
'''
'''
user = request.user
form = ProfileForm()
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
'''
if len(data['name']) > NAME_MAX_LEN * 3:
messages.warning(request, u'名号输入过长，被自动截断')
if len(data['signature']) > SIGNATURE_MAX_LEN * 3:
messages.warning(request, u'签名输入过长，被自动截断')
'''
form.save(user.userprofile, data)
messages.success(request, u'个人资料修改成功')
else:
messages.error(request, u'你的输入有误')
profile = request.user.userprofile
return render_to_response('settings/edit_profile.html', {
'time_limit': PROFILE_NAME_CHANGE_DAYS,
'form': form,
'name': profile.name,
'website': profile.website,
'signature': profile.signature,
'detail': profile.detail,
},
context_instance=RequestContext(request))
def register(request):
if request.method == "POST":
data = json.loads(request.raw_post_data)
uForm = UserForm(data = data)
pForm = ProfileForm(data = data)
aForm = None
if data['artist']:
aForm = ArtistForm(data = data)
if uForm.is_valid() and pForm.is_valid() and (aForm == None or aForm.is_valid()):
user = uForm.save()
user.save()
profile = pForm.save(commit = False)
profile.user = user
if not profile.invites:
profile.invites = 0
profile.save()
if aForm:
artist = aForm.save(commit = False)
artist.profile = profile
artist.save()
user = authenticate(username = data['username'],
password = data['password1'])
login(request, user)
resp = HttpResponse(json.dumps({'success': 'true'}), mimetype="application/json")
resp.status_code = 201
return resp
else:
error = dict(uForm.errors.items()
+ pForm.errors.items())
else:
error = "The request must be a POST"
resp = HttpResponse(json.dumps({'error': error}), mimetype="applcation/json")
resp.status_code = 400
return resp
def edit(request, template_name='edit_profile.html',
redirect_to='auth_profile'):
form = ProfileForm(request.POST, instance=request.user.get_profile())
if request.POST:
if form.is_valid():
form.save()
u = request.user
u.email = form.data['email']
u.first_name = form.data['first_name']
u.last_name = form.data['last_name']
u.save()
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse(redirect_to))
else:
initial_dict = {'email': request.user.email,
'username': request.user.username,
'first_name': request.user.first_name,
'last_name': request.user.last_name}
form = ProfileForm(instance=request.user.get_profile(),
initial=initial_dict)
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
def obj_create(self, bundle, request=None, **kwargs):
try:
uForm = UserForm(data=bundle.data)
pForm = ProfileForm(data=bundle.data)
if uForm.is_valid() and pForm.is_valid():
user = uForm.save()
user.save()
profile = pForm.save(commit=False)
profile.user = user
if not profile.invites:
profile.invites = 0
profile.save()
user = authenticate(username=bundle.data.get('username'),
password=bundle.data.get('password'))
login(request, user)
bundle.obj = profile
else:
return self.create_response(request, {
'error':
dict(uForm.errors.items() + pForm.errors.items())
})
except IntegrityError:
pass
# do any other Profile instantiation stuff here
return bundle
def profile(request): #处理个人资料功能
if not request.user.is_authenticated():
return redirect('/weblogin')
user = request.user
if request.method =='GET':
form = ProfileForm(instance=user, initial={
'name': user.webuser.name,
'telephone': user.webuser.telephone,
'hospital': user.webuser.hospital,
'position': user.webuser.position,
'department': user.webuser.department,
'abstract': user.webuser.abstract
})
if request.user.is_superuser:
return render(request, 'adminuser/person_page_info.html', {'form': form})
return render(request, 'webuser/person_page_info.html', {'form': form})
else:
form = ProfileForm(request.POST)
if form.is_valid():
webuser = Webuser.objects.get(user=request.user)
webuser.name = form.cleaned_data.get('name')
webuser.telephone = form.cleaned_data.get('telephone')
webuser.hospital = form.cleaned_data.get('hospital')
webuser.position = form.cleaned_data.get('position')
webuser.department = form.cleaned_data.get('department')
webuser.abstract = form.cleaned_data.get('abstract')
webuser.save()
messages.add_message(request, messages.SUCCESS, u'您的资料已经编辑成功.')
if request.user.is_superuser:
return render(request, 'adminuser/person_page_info.html', {'form': form})
else:
return render(request, 'webuser/person_page_info.html', {'form': form})
def profile(request, tplname='userprefs/profile.html'):
update_password = True
if True in events.raiseQueryEvent("PasswordChange", request.user):
update_password = False
if request.method == "POST":
form = ProfileForm(update_password,
request.POST,
instance=request.user)
if form.is_valid():
form.save()
if update_password and form.cleaned_data["confirmation"] != "":
request.session["password"] = encrypt(
form.cleaned_data["confirmation"])
return ajax_simple_response(
dict(status="ok", respmsg=_("Profile updated")))
return ajax_simple_response({"status": "ko", "errors": form.errors})
form = ProfileForm(update_password, instance=request.user)
return ajax_simple_response({
"status":
"ok",
"content":
_render_to_string(request, tplname, {"form": form})
})
def update_profile(request):
if request.method == 'POST':
member_form = MemberForm(request.POST)
if not is_member(request.user):
if member_form.is_valid(
) and member_form.cleaned_data['becomeMember']:
group_name = models.SchoolYear.objects.current(
).get_member_group()
g = Group.objects.get(name=group_name)
g.user_set.add(request.user)
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')
else:
messages.error(request, 'Please correct the error below.')
else:
member_form = MemberForm()
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(
request, 'profile.html', {
'member_form': member_form,
'user_form': user_form,
'profile_form': profile_form,
'school_year': models.SchoolYear.objects.current()
})
def update_profile(request):
try:
promoter = request.user.promoterprofile
except PromoterProfile.DoesNotExist:
error_meta = {
"method": "promoter.views.update_profile",
}
ErrorLog.objects.create_log(4, "Promoter Object Error", error_meta, request)
raise SuspiciousOperation('Error Code: 4')
form = ProfileForm(request.POST or None, instance=promoter)
context = {
"form": form
}
if request.POST:
if form.is_valid():
form.save()
activity_meta = {
"method": "promoter.views.update_profile",
"form_validation": "True"
}
ActivityLog.objects.create_log(request, "Update Promoter Account", activity_meta)
return redirect('/pr/account/')
else:
return render(request, "promoter/edit_profile.html", context)
else:
activity_meta = {
"method": "promoter.views.update_profile",
}
ActivityLog.objects.create_log(request, "Update Promoter Account", activity_meta)
return render(request, "promoter/edit_profile.html", context)
def getProfile(request):
# get user profile
user = request.user
profile = user.get_profile()
if request.method == 'POST':
profile_form = ProfileForm(request.POST,
request.FILES,
instance=profile)
user_form = UserForm(request.POST,
instance=request.user)
if profile_form.is_valid() and user_form.is_valid():
profile_form.save()
user_form.save()
resize_post_image.delay(profile_form.save())
messages.success(request, _("Profile updated succesfully."))
return redirect('index')
else:
profile_form = ProfileForm(instance=profile)
user_form = UserForm(instance=request.user)
return render(request, 'account/profile.html', {
'formProfile': profile_form,
'formUser': user_form
})
def RegistroUsuario(request):
if request.method == 'POST':
user_form = RegistroForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
usuario = user_form.save()
profile_form = ProfileForm(request.POST, instance=usuario.profile)
profile = profile_form.save()
usuario.email = profile.email
usuario.save()
html_content = '<p>El usuario <strong>' + usuario.username + ' - ' + profile.empresa + '</strong> se ha registrado en INDICAGRO.</p>'
email = EmailMultiAlternatives('Usuario ' + usuario.username +
' creado exitosamente',
'Este es el mensaje del email',
to=['*****@*****.**'],
bcc=['*****@*****.**'])
email.attach_alternative(html_content, "text/html")
email.send()
print("se mando el email")
messages.success(
request,
'Ya te encuentras habilitado para aplicarte IndicAgro. '
'Gracias por formar parte de un #AgroComprometido!')
return redirect('usuarios:usuarios_home')
else:
user_form = RegistroForm()
profile_form = ProfileForm()
return render(request, 'usuarios/registrar.html', {
'user_form': user_form,
'profile_form': profile_form
})
def show_profile(request):
authenticated = False
if request.user.is_authenticated():
authenticated = True
try:
profile_obj = Profile.objects.get(user=request.user)
except:
profile_obj = None
form = ProfileForm(request.POST or None, instance=profile_obj)
if request.method == 'POST':
if form.is_valid():
profile = form.save(commit=False)
profile.user = request.user
profile.save()
borrowed_books = Borrow.objects.filter(
user=request.user, date_return__gte=datetime.now().date())
# TODO check if books are reserved
# What do we do if they are reserved? Don't show extend? How? :)
return render_to_response("profile.html",
context_instance=RequestContext(
request, {
'authenticated': authenticated,
'form': form,
'borrowed_books': borrowed_books
}))
def profile(request):
""" Edit profile settings """
profile = UserProfile.objects.get(user=request.user)
if 'email' in request.POST:
form = ProfileForm(request.POST)
if form.is_valid():
form.save_email(profile.user)
form.save_phone(profile)
return HttpResponseRedirect('?')
else:
form = ProfileForm()
form.initial.update({
'email': profile.user.email,
'phone': profile.phone_number,
})
if 'old_password' in request.POST:
form_p = PasswordChangeForm(request.user, request.POST)
if form_p.is_valid():
form_p.save()
return HttpResponseRedirect('?pc=1')
else:
form_p = PasswordChangeForm(request.user)
return {
'user': request.user,
'form': form,
'form_p': form_p,
'title': 'Settings',
'profile': profile,
'updated_pass': request.GET.get('pc'),
}
def edit_profile(request):
user = get_object_or_404(User, username=request.user.username)
if request.method == 'GET':
user_form = UserForm(instance=user)
profile_form = ProfileForm(instance=user.userprofile)
equipment_form = EquipmentForm()
context = {
'user_form': user_form,
'profile_form': profile_form,
'equipment_form': equipment_form,
}
return render(request, 'accounts/profile_form.html', context)
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST, instance=user.userprofile)
equipment_form = EquipmentForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
del (request.session['django_timezone'])
messages.success(request, "Profile sucessfully updated")
return redirect('profile', username=user.username)
else:
return render(
request, 'accounts/profile_form.html', {
'user_form': user_form,
'profile_form': profile_form,
'equipment_form': equipment_form
})
def profile(request, tplname='userprefs/profile.html'):
update_password = True
if True in events.raiseQueryEvent("PasswordChange", request.user):
update_password = False
if request.method == "POST":
form = ProfileForm(
update_password, request.POST, instance=request.user
)
if form.is_valid():
form.save()
if update_password and form.cleaned_data["confirmation"] != "":
request.session["password"] = encrypt(form.cleaned_data["confirmation"])
return ajax_simple_response(dict(
status="ok", respmsg=_("Profile updated")
))
return ajax_simple_response({
"status": "ko",
"errors": form.errors
})
form = ProfileForm(update_password, instance=request.user)
return ajax_simple_response({
"status": "ok",
"content": _render_to_string(request, tplname, {
"form": form
})
})
def edit_profile(request):
'''
'''
user = request.user
form = ProfileForm()
if request.method == "POST":
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
'''
if len(data['name']) > NAME_MAX_LEN * 3:
messages.warning(request, u'名号输入过长，被自动截断')
if len(data['signature']) > SIGNATURE_MAX_LEN * 3:
messages.warning(request, u'签名输入过长，被自动截断')
'''
form.save(user.userprofile, data)
messages.success(request, u'个人资料修改成功')
else:
messages.error(request, u'你的输入有误')
profile = request.user.userprofile
return render_to_response('settings/edit_profile.html',
{'time_limit': PROFILE_NAME_CHANGE_DAYS,
'form': form,
'name': profile.name,
'website': profile.website,
'signature': profile.signature,
'detail': profile.detail,
},
context_instance=RequestContext(request))
def edit(request):
key = ApiKey.objects.get(user = request.user)
if request.method == 'POST':
form = ProfileForm(request.POST,request=request)
if form.is_valid():
# update basic data
email = form.cleaned_data.get("email")
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
request.user.email = email
request.user.first_name = first_name
request.user.last_name = last_name
request.user.save()
messages.success(request, _(u"Profile updated"))
# if password should be changed
password = form.cleaned_data.get("password")
if password:
request.user.set_password(password)
request.user.save()
messages.success(request, _(u"Password updated"))
else:
form = ProfileForm(initial={'username':request.user.username,
'email':request.user.email,
'first_name':request.user.first_name,
'last_name':request.user.last_name,
'api_key': key.key},request=request)
return render(request, 'mquiz/profile/profile.html', {'form': form,})
def profile(request):
user = request.user
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
user.first_name, user.last_name, user.email = cd['first_name'], cd[
'last_name'], cd['email']
user.save()
return HttpResponseRedirect(reverse('books:updated'))
else:
form = ProfileForm(
initial={
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email
})
books = Book.objects.filter(user=user.id)
notes = Note.objects.filter(user=user.id)
return render(
request, 'books/profile.html', {
'user': user,
'form': form,
'tab_title': 'Reading List | Profile',
'books': books,
'notes': notes
})
def personal(request):
"""
Personal data of the user profile
"""
if (request.user.password == "!"):
return HttpResponseRedirect('/accounts/social')
profile, created = Profile.objects.get_or_create(user=request.user)
if request.method == "POST":
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("profile_edit_personal_done"))
else:
form = ProfileForm(instance=profile)
template = "userprofile/profile/personal.html"
data = {
'section': 'personal',
'GOOGLE_MAPS_API_KEY': GOOGLE_MAPS_API_KEY,
'form': form,
}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def my_account(request):
user_data = {
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email
}
try:
profile_obj = request.user.get_profile()
except ObjectDoesNotExist:
profile_obj = UserProfile(user=request.user, acct_type=1)
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=profile_obj)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return HttpResponseRedirect('/')
else:
user_form = UserForm(initial=user_data)
profile_form = ProfileForm(initial=get_profile_data(profile_obj))
context = {
'title': labels['profile'],
'username': request.user.username,
'user_form': user_form,
'profile_form': profile_form,
}
# Return response
t = get_template('my_account.html')
html = t.render(RequestContext(request, context))
return HttpResponse(html)
def profile(request):
if not request.user.is_authenticated():
raise PermissionDenied
record = request.user.courses_taken.all()
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
# Validate
if form.cleaned_data['password0']:
if form.cleaned_data['password0'] == form.cleaned_data['password1']:
request.user.set_password(form.cleaned_data['password0'])
messages.success(request, "<strong>Success!</strong> Password changed.")
else:
messages.error(request, "The two passwords do not match.")
if request.user.option != form.cleaned_data['option']:
request.user.option = form.cleaned_data['option']
messages.success(request, "<strong>Success!</strong> Option selected.")
request.user.save()
return HttpResponseRedirect(reverse('profile'))
else:
form = ProfileForm(initial={'option': request.user.option})
return render_to_response(
'student/edit-profile.html',
{'form': form, 'record': record},
context_instance=RequestContext(request))
def edit(request, profile_id):
profile = UserProfile.objects.get(id=profile_id)
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
user_profile = UserProfile.objects.get(id=profile_id)
user_profile.pic = cd['pic']
user_profile.url = cd['url']
user_profile.mobile = cd['mobile']
user_profile.save()
return HttpResponseRedirect('/')
else:
form = ProfileForm(initial={
'id': profile.id,
'pic': profile.pic,
'url': profile.url,
'mobile': profile.mobile})
args = {}
args.update(csrf(request))
args['form'] = form
return render(request, "edit.html", args)
def profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST)
buyer = request.user.buyer
if form.is_valid():
if form.cleaned_data['name'] != "":
buyer.name = form.cleaned_data['name']
if form.cleaned_data['address'] != "":
buyer.address = form.cleaned_data['address']
if form.cleaned_data['phone_number'] != "":
buyer.phone_number = form.cleaned_data['phone_number']
if form.cleaned_data['credit_card_number'] != "":
buyer.credit_card_number = form.cleaned_data['credit_card_number']
if form.cleaned_data['credit_card_exp'] != "":
buyer.credit_card_exp = form.cleaned_data['credit_card_exp']
if form.cleaned_data['credit_card_sec'] != "":
buyer.credit_card_sec = form.cleaned_data['credit_card_sec']
buyer.save()
#Process
buyer = request.user.buyer
ccn = "**** **** **** " + buyer.credit_card_number[12:17] if buyer.credit_card_number else "-"
cce = buyer.credit_card_exp if buyer.credit_card_exp else "-"
ccs = "***" if buyer.credit_card_sec else ""
defaults = {"name":buyer.name,"address":buyer.address,"phone_number":buyer.phone_number,"credit_card_number":ccn, "credit_card_expiration" : cce, "credit_card_security":ccs}
return render(request, "profile.html", {"form":form, "success":True,"defaults":defaults})
else:
return render(request, "profile.html", {"form":form, "error":True})
else:
form = ProfileForm()
buyer = request.user.buyer
ccn = "**** **** **** " + buyer.credit_card_number[12:17] if buyer.credit_card_number else "-"
cce = buyer.credit_card_exp if buyer.credit_card_exp else "-"
ccs = "***" if buyer.credit_card_sec else ""
defaults = {"name":buyer.name,"address":buyer.address,"phone_number":buyer.phone_number,"credit_card_number":ccn, "credit_card_expiration" : cce, "credit_card_security":ccs}
return render(request, "profile.html", {"form":form, "defaults":defaults})
def profile(req):
g = get_object_or_404(Gentleman, pk=req.user.gentleman.id)
if req.method == 'POST':
pf = ProfileForm(req.POST, req.FILES, instance=g)
if pf.is_valid():
ng = pf.save()
if 'before_pic' in req.FILES:
g.before_pic.file = req.FILES['before_pic']
if 'after_pic' in req.FILES:
g.after_pic.file = req.FILES['after_pic']
ng.user_id = g.user_id
ng.id = g.id
ng.save()
pf = ProfileForm(instance=ng)
messages.info(req, 'Gentleman updated successfully.')
else:
pf = ProfileForm(instance=g)
return render(req, 'voting/profile.html', {'pf': pf })
def post(self):
form = ProfileForm(data=self.request.POST)
if form.is_valid():
user = users.get_current_user()
username = self.request.get('username')
#profile = Profile.all().filter('user !=', user).filter('username ='******'username ='******'username_exists': ['%s is already exists'] }
profile = { 'username': username }
template_vars = { 'errors': errors, 'profile': profile }
self.render_response('profile/profile_edit.html', template_vars)
else:
profile = Profile.all().filter('user ='******'/profile')
else:
template_vars = { 'form': form }
self.render_response('profile/profile_edit.html', template_vars)
def add_tag(request):
"""
Adds tags to student's profile
"""
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
tags = form.cleaned_data["tags"]
tags = [x.strip() for x in tags.split(',')]
for tag in tags:
#TODO: tags comma separated
new_tag = Tag(name=tag)
try:
Tag.objects.get(name=tag)
new_tag = Tag.objects.get(name=tag)
messages.add_message(request, messages.INFO,
'You cannot add the same tags!')
return HttpResponseRedirect("/profile/")
except ObjectDoesNotExist:
new_tag.save()
new_tag.students.add(request.user)
return redirect_user_to_homepage(request.user.profile.user_type)
else:
# The form data was bad, display an error
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def edit_user(request):
profile_form = ProfileForm(request.POST, instance=request.user)
if profile_form.is_valid():
profile_form.save()
messages.success(request, 'Yup, changes made.')
else:
messages.error(request, 'Nop, something is wrong.')
return redirect('view_user', request.user.id)
def edit_user(request):
profile_form = ProfileForm(request.POST, instance=request.user)
if profile_form.is_valid():
profile_form.save()
messages.success(request, 'Yup, changes made.')
else:
messages.error(request, 'Nop, something is wrong.')
return redirect('view_user', request.user.id)
def post(self, request, pk=None):
if request.user.is_authenticated():
user = Profile.objects.get_or_create(user=request.user)[0]
form = ProfileForm(request.POST, request.FILES or None, instance=user)
if form.is_valid():
form.save()
return redirect("profile")
def profile_edit(request):
data = request.POST or None
profile_form = ProfileForm(data, instance=request.user)
if profile_form.is_valid():
profile_form.save()
messages.success(request, "Profile saved")
elif not data is None:
messages.error(request, "Profile could not be saved, because of invalid data")
return render(request, "profiles/edit.html", {'form': profile_form})
def edit_profile(request, curr_user):
"Edit Profile Page"
if request.method == 'POST':
form = ProfileForm(request.POST, instance=curr_user.user_obj)
if form.is_valid():
form.save()
return render(request, 'edit_profile.html', {'form': form, 'saved': True, 'links': main.myprofile_links})
else:
form = ProfileForm(instance=curr_user.user_obj)
return render(request, 'edit_profile.html', {'form': form, 'links': main.myprofile_links})
def profile(request):
form=ProfileForm(instance=request.user.get_profile())
if request.method=='POST':
form=ProfileForm(instance=request.user.get_profile(), data=request.POST, files=request.FILES)
if form.is_valid():
print "VALID"
form.save()
return redirect ('/accounts/profile/')
return render_to_response('sprof/profile.html',{'form':form}, context_instance=RequestContext(request))
def post(self, request):
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('settings:profile')
messages.error(request, _('Please correct the error below.'))
def configuracoes(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user.profile)
if form.is_valid():
form.save()
return redirect('principal')
else:
return redirect('configuracoes')
else:
form = ProfileForm(instance=request.user.profile)
return render(request, 'configuracoes.html', {'form': form})
def edit_profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance=request.user.get_profile())
if form.is_valid():
form.save()
else:
form = ProfileForm(instance=request.user.get_profile())
return render_to_response('users/edit_profile.html',
{'form': form},
context_instance=RequestContext(request))
def profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
instance = form.save(commit=False)
instance.User = request.user.username
instance.title = request.user.username
instance.save()
return HttpResponseRedirect("/blog/")
else:
form = ProfileForm()
return render_to_response("edit_profile.html", {'form': form}, context_instance=RequestContext(request))
def signup(request):
form = ProfileForm()
print form
if request.method=="POST":
print request.POST
form = ProfileForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("dashboard"))
else:
print form.errors
return render_to_response('profiles/signup.html', {'form': form}, context_instance=RequestContext(request))
def profile(request, user_id):
user = request.user
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES)
if form.is_valid():
user.description = form.cleaned_data['description']
user.city = form.cleaned_data['city']
user.job = form.cleaned_data['job']
user.img = form.cleaned_data['img']
user.save()
return redirect('polls:people', user_id=user_id)
return render_to_response('profile.html', {'user': user})
def my_profile(request):
if request.method == "POST":
form = ProfileForm(instance=request.user, data=request.POST)
if form.is_valid():
form.save()
messages.success(request, "Your account is now up to date !")
else:
form = ProfileForm(instance=request.user)
context = {}
context.update({"form": form})
return render(request, 'registration/my_profile.html', context)
def register(request):
if "back_button_register" in request.POST:
return HttpResponseRedirect('/login')
elif len(request.POST) > 0:
form = ProfileForm(request.POST)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/login')
else:
return render(request, 'user_profile.html', {'ban': form})
else:
form = ProfileForm()
return render(request, 'user_profile.html', {'ban': form})
def create_profile(request, args):
user_id = request.user.id
logging.debug("TEST CREATE PROFILE")
profile = Profile.objects.get(id=user_id)
if request.method == "POST":
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
print "CREATE PROFILE FORM VALID"
form.save()
return HttpResponseRedirect('/participate/profile')
else:
form = ProfileForm(instance=profile)
return render(request, 'accounts/create_profile.html', {'form': form})
def profile(request):
if (islogin(request)):
if request.method == "POST":
form = ProfileForm(request.POST)
if form.is_valid():
user = RegisteredUsers.objects.get(
email=request.session.get("email", None))
try:
user.email = form.cleaned_data["prof_emailid"]
user.name = form.cleaned_data["prof_name"]
user.dolbd = form.cleaned_data["prof_dolbd"]
user.mobile = str(form.cleaned_data["prof_mobile"])
user.city = form.cleaned_data["prof_city"]
# user.location = form.cleaned_data["reg_location"]
user.save()
except:
return HttpResponse(
"Error in Connection with Database , Please Try again "
+ str(vars(user)))
c = {}
c.update(csrf(request))
email = request.session.get('email', None)
name = request.session.get('name', None)
c.update({"oldemail": email, "user": name})
c.update({"userprof": user, "updated": True})
return render_to_response('profile.html', c)
else:
c = {}
email = request.session.get('email', None)
name = request.session.get('name', None)
c.update({"oldemail": email, "user": name})
c.update(csrf(request))
c.update({"userprof": form})
return render_to_response('profile.html', c)
c = {}
c.update(csrf(request))
email = request.session.get('email', None)
name = request.session.get('name', None)
userprof = RegisteredUsers.objects.get(email=email)
# location = userprof.location
#userprof = userprof[0]
#return HttpResponse(str(vars(userprof)))
c.update({"oldemail": email, "user": name})
c.update({"userprof": userprof})
# c.update({"location":location})
return render_to_response('profile.html', c)
# return render_to_response('profile.html',c)
else:
return HttpResponseRedirect("/")
def profile(request):
form = ProfileForm(instance=request.user.get_profile())
if request.method == 'POST':
form = ProfileForm(request.POST)
if form.is_valid():
profile = request.user.get_profile()
profile.nick = form.cleaned_data['nick']
profile.use_gravatar = form.cleaned_data['use_gravatar']
profile.save()
return render(request, 'profile.html', {
'form': form,
})
