def upt_engineer_profile(request, slug):
from forms import EngineerForm, UserForm
from django.contrib.auth.models import Permission
message = None
engineer = Engineer.objects.get(user__username=slug)
mailserver_list = get_mx_list(engineer.company)
user_form = UserForm(instance=engineer.user)
form = EngineerForm(instance=engineer)
if request.method == 'POST':
form = EngineerForm(data=request.POST, instance=engineer)
user_form = UserForm(data=request.POST, instance=engineer.user)
perm_form = EngineerPermForm(request.POST)
if form.is_valid() and user_form.is_valid() and perm_form.is_valid():
form.save()
user_form.save()
message = "Engineer updated successfully"
company = engineer.company
engineer_list = Engineer.objects.filter(company=company)
return render_to_response("profiles/engineer.html", {
'slug': slug,
'engineer_form': form.as_ul(),
'user_form': user_form.as_ul(),
'mailserver_list': mailserver_list,
'message': message,
'company': company,
'engineer_list': engineer_list,
},
context_instance=RequestContext(request))
def my_profile(request):
context = get_context(request)
if not request.user.is_authenticated():
return redirect('login')
else:
user_profile = UserProfile.objects.get(user=request.user)
if request.method == "POST":
user_form = UserForm(request.POST, instance=request.user)
user_profile_form = UserProfileForm(request.POST, instance=user_profile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
return redirect_after_profile_save(request, 'data')
else:
user_form = UserForm(instance=request.user)
user_profile_form = UserProfileForm(instance=user_profile)
user_form.helper.form_tag = False
user_profile_form.helper.form_tag = False
context['user_form'] = user_form
context['user_profile_form'] = user_profile_form
context['user_profile_page_form'] = UserProfilePageForm(instance=user_profile)
context['user_cover_letter_form'] = UserCoverLetterForm(instance=user_profile)
context['user_info_page_form'] = UserInfoPageForm(instance=user_profile.user_info)
context['is_editing_profile'] = True
context['title'] = u'Mój profil'
return render(request, 'profile.html', context)
def my_profile(request):
context = get_context(request)
if not request.user.is_authenticated():
return redirect('login')
else:
user_profile = UserProfile.objects.get(user=request.user)
if request.method == "POST":
user_form = UserForm(request.POST, instance=request.user)
user_profile_form = UserProfileForm(request.POST,
instance=user_profile)
if user_form.is_valid() and user_profile_form.is_valid():
user_form.save()
user_profile_form.save()
return redirect_after_profile_save(request, 'data')
else:
user_form = UserForm(instance=request.user)
user_profile_form = UserProfileForm(instance=user_profile)
user_form.helper.form_tag = False
user_profile_form.helper.form_tag = False
context['user_form'] = user_form
context['user_profile_form'] = user_profile_form
context['user_profile_page_form'] = UserProfilePageForm(
instance=user_profile)
context['user_cover_letter_form'] = UserCoverLetterForm(
instance=user_profile)
context['user_info_page_form'] = UserInfoPageForm(
instance=user_profile.user_info)
context['is_editing_profile'] = True
context['title'] = u'Mój profil'
return render(request, '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 registered(request): #registered=注册
if request.method == 'POST':
user = UserForm(request.POST, request.FILES)
#print (request.POST.get('sex'))
print(1111111111111111111111111111111111111111111111111)
if user.is_valid():
print(22222222222222222222222222222222222222222222222)
# img=User(head_portrait=request.FILES.get('head_portrait'))
# img.save()
user.save()
print(3333333333333333333333333333333333333333333333)
request.session['name'] = request.POST[
'name'] #设置注册成功后自动加入session缓存
#两种重导向分别需要导入的模块
#from django.shortcuts import render,redirect
#from django.core.urlresolvers import reverse
#from django.http import HttpResponseRedirect
print(444444444444444444444444444444444444444444444444)
return redirect(reverse('forging:success'))
#return HttpResponseRedirect(reverse('forging:success'))
else:
return HttpResponse('注册失败')
else:
user = UserForm()
return render(request, 'forging/registered.html', {'user': user})
def addUser(request):
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST)
form.save()
return redirect('/user/')
return render(request, 'rbac/add.html', locals())
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):
# We always have the user, but not always the profile. And we need a bit
# of a hack around the normal forms code since we have two different
# models on a single form.
(profile, created) = UserProfile.objects.get_or_create(pk=request.user.pk)
if request.method == "POST":
# Process this form
userform = UserForm(data=request.POST, instance=request.user)
profileform = UserProfileForm(data=request.POST, instance=profile)
if userform.is_valid() and profileform.is_valid():
userform.save()
profileform.save()
return HttpResponseRedirect("/account/")
else:
# Generate form
userform = UserForm(instance=request.user)
profileform = UserProfileForm(instance=profile)
return render_to_response(
"account/userprofileform.html",
{"userform": userform, "profileform": profileform},
NavContext(request, "account"),
)
def edit_account(request, name=None):
if name and not has_role(request.user, ['staff', 'dev']):
return redirect('edit_account')
if name:
user = McUser.objects.get(norm_name=normalize_name(name)).user
else:
user = request.user
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user, user=user)
if user_form.is_valid():
user_form.save()
messages.add_message(request, messages.SUCCESS, 'Changes saved!')
if name:
return redirect('edit_other_account', name)
return redirect('edit_account')
else:
messages.add_message(request, messages.WARNING,
'Passwords do not match.')
user_form = UserForm(instance=user, user=user)
else:
user_form = UserForm(instance=user, user=user)
context = {
'form': user_form,
}
if name:
context['name'] = user.mcuser.get_full_name()
return render(request, 'core/edit_account.html', context)
def register(request):
context = RequestContext(request)
er1 = ""
if request.POST:
postform = UserForm(data=request.POST)
if postform.is_valid():
pwd = request.POST['password']
rpwd = request.POST['password1']
if pwd == rpwd:
postform.save(commit=True)
return HttpResponseRedirect('/index/')
else:
er1 = "Passwords don't match"
else:
print postform.errors
else:
postform = UserForm()
context_dict = {
'postform': postform,
'er1': er1,
}
return render_to_response("register.html", context_dict, context)
def profile(request):
# id = request.user.id
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
# speed_army = form.cleaned_data['speed_army']
# speed_captain = form.cleaned_data['speed_captain']
# id = request.user.id
form.save()
return TemplateResponse(request, "registration/profile.html", {"user": request.user, 'form':form})
else:
id = request.user.id
try: #MyProfile.objects.get(id=int(id))
speed_army = MyProfile.objects.get(id=int(id)).speed_army
speed_captain = MyProfile.objects.get(id=int(id)).speed_captain
speed_merchant = MyProfile.objects.get(id=int(id)).speed_merchant
speed_monk = MyProfile.objects.get(id=int(id)).speed_monk
form = UserForm(initial={'id': id,
'speed_army': speed_army,
'speed_captain': speed_captain,
'speed_merchant': speed_merchant,
'speed_monk': speed_monk})
except:
form = UserForm(initial={'id': id})
# def form_valid(self, form):
# form.save()
# return super(profile, self).form_valid(form)
return TemplateResponse(request, "registration/profile.html", {"user": request.user, 'form':form})
def user_(request):
# user = User.objects.get(pk=get_user(request).pk)
# u_profile = MyUserModel.objects.get(user=user)
# profile_form = MultiUserForm(instance=u_profile)
# return render(request, 'userprofile/user.html', {'profile_form': profile_form})
user = User.objects.get(pk=get_user(request).pk)
try:
u_profile = MyUserModel.objects.get(user=user)
except(Exception):
u_profile = MyUserModel(user=user)
if request.method == "POST":
profile_form = UserProfileForm(request.POST, request.FILES, instance=u_profile)
if profile_form.is_valid():
profile_form.save()
user_form = UserForm(request.POST, instance=user)
if user_form.is_valid():
user_form.save(commit=False)
if "password" in request.POST:
user.set_password(request.POST["password"])
user_form.save()
else:
profile_form = UserProfileForm(instance=u_profile)
user_form = UserForm(instance=user)
return render(request, 'userprofile/user.html', {'profile_form': profile_form, 'user_form': user_form})
def upt_engineer_profile(request, slug):
from forms import EngineerForm, UserForm
from django.contrib.auth.models import Permission
message = None
engineer = Engineer.objects.get(user__username=slug)
mailserver_list = get_mx_list(engineer.company)
user_form = UserForm(instance=engineer.user)
form = EngineerForm(instance=engineer)
if request.method == 'POST':
form = EngineerForm(data=request.POST, instance=engineer)
user_form = UserForm(data=request.POST, instance=engineer.user)
perm_form = EngineerPermForm(request.POST)
if form.is_valid() and user_form.is_valid() and perm_form.is_valid():
form.save()
user_form.save()
message = "Engineer updated successfully"
company = engineer.company
engineer_list = Engineer.objects.filter(company=company)
return render_to_response("profiles/engineer.html", {
'slug': slug,
'engineer_form': form.as_ul(),
'user_form': user_form.as_ul(),
'mailserver_list': mailserver_list,
'message': message,
'company': company,
'engineer_list': engineer_list,
},
context_instance=RequestContext(request))
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 CreateUser(request):
if request.method == 'POST':
# save form, creates user with post variables
if 'android' in request.POST:
try:
form = UserForm(request.POST)
except:
return HttpResponse(STATUS_INVALID_PARAM)
if form.is_valid():
usr = form.save();
usr.backend='django.contrib.auth.backends.ModelBackend'
login(request, usr)
return HttpResponse(STATUS_SUCCESS)
return HttpResponse(STATUS_INVALID_PARAM)
else:
form = UserForm(request.POST)
if form.is_valid():
usr = form.save()
# mocking what autheticate does
usr.backend='django.contrib.auth.backends.ModelBackend'
login(request, usr)
if 'forward' in request.session:
forward = request.session['forward']
return render(request, 'eventster/login_success.html', {'user': request.user, 'forward': forward})
return render(request, 'eventster/login_success.html', {'user': request.user})
else:
form = UserForm()
return render(request, "eventster/register_form.html", {'form': form, 'user': request.user})
def edit_account(request, name=None):
if name and not has_role(request.user, ['staff', 'dev']):
return redirect('edit_account')
if name:
user = McUser.objects.get(norm_name=normalize_name(name)).user
else:
user = request.user
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user, user=user)
if user_form.is_valid():
user_form.save()
messages.add_message(request, messages.SUCCESS, 'Changes saved!')
if name:
return redirect('edit_other_account', name)
return redirect('edit_account')
else:
messages.add_message(request, messages.WARNING, 'Passwords do not match.')
user_form = UserForm(instance=user, user=user)
else:
user_form = UserForm(instance=user, user=user)
context = {
'form': user_form,
}
if name:
context['name'] = user.mcuser.get_full_name()
return render(request, 'core/edit_account.html', context)
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 post(self, request):
user_form = UserForm(request.POST, instance=request.user)
if user_form.is_valid():
user_form.save()
return HttpResponse('{"status":"success"}',
content_type='application/json')
return HttpResponse(json.dumps(user_form.errors),
content_type='application/json')
def post(self, request):
uf = UserForm(request.POST, prefix='user')
if uf.is_valid():
uf.save()
else:
#raise form errors
return django.shortcuts.render_to_response('falcon/register.html', dict(form=uf), context_instance=django.template.RequestContext(request))
return django.http.HttpResponseRedirect("/")
def post(self, request):
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
else:
form = UserForm
return render(request, self.template_name, {"form": form})
def index(request):
if request.method == "GET":
userform = UserForm(request.GET)
if userform.is_valid():
userform.save()
return HttpResponse('ok')
else:
userform = UserForm()
return render_to_response('index.html', locals())
def profile(request):
if request.method == 'POST':
form = UserForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
return redirect("/profile/")
else:
form = UserForm(instance=request.user)
return render(request, "profile.html", {'form': form})
def add_player(request):
form = UserForm()
if request.method == "POST":
user = UserForm(data = request.POST)
if user.is_valid():
user.save()
return HttpResponseRedirect(reverse('wouso.interface.cpanel.views.players'))
else:
form = user
return render_to_response('cpanel/add_player.html', {'form': form}, context_instance=RequestContext(request))
def profile(request):
if request.method == 'POST':
form = UserForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
return redirect("/profile/")
else:
form = UserForm(instance=request.user)
return render(request, "profile.html", {'form': form})
def register(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
else:
print "form not valid!"
else:
form = UserForm()
return render(request, 'register.html', {'form': form})
def main_page(request):
if len(request.POST) > 0:
form = UserForm(request.POST)
if form.is_valid():
form.save()
else:
user = User.objects.latest('pk')
form = UserForm(instance=user)
form.fields.keyOrder.reverse()
return render_to_response('main.html', {'form': form}, context_instance=RequestContext(request))
def profile(request):
user_form = None
calendar_formset = None
locationalias_formset = None
was_saved = False
task_id = None
CalendarFormSet = get_calendar_formset(ICalURLForm,
extra=1, can_delete=True)
LocationAliasFormSet = get_locationalias_formset(ICalURLForm,
extra=1, can_delete=True)
if request.user.is_authenticated():
user = request.user
profile = request.user.userprofile
calendar_prefix = 'calendar'
locationalias_prefix = 'locationalias'
if request.method == 'POST':
user_form = UserForm(request.POST, instance=user)
calendar_formset = CalendarFormSet(request.POST, instance=profile,
prefix=calendar_prefix)
locationalias_formset = LocationAliasFormSet(
request.POST, instance=profile, prefix=locationalias_prefix)
if user_form.is_valid():
user_form.save()
was_saved = True
if (calendar_formset.is_valid() and locationalias_formset.is_valid()):
calendar_formset.save()
task_id = reload_user_calendars.delay(request.user).task_id
request.session['task_id'] = task_id
locationalias_formset.save()
was_saved = True
calendar_formset = CalendarFormSet(instance=profile,
prefix=calendar_prefix)
locationalias_formset = LocationAliasFormSet(
instance=profile, prefix=locationalias_prefix)
else:
user_form = UserForm(instance=request.user)
calendar_formset = CalendarFormSet(instance=profile,
prefix=calendar_prefix)
locationalias_formset = LocationAliasFormSet(
instance=profile, prefix=locationalias_prefix)
return render(request, 'profile.html',
{'authenticated': request.user.is_authenticated(),
'user_form': user_form,
'user_name': request.user.get_username(),
'user_id': request.user.id,
'was_saved': was_saved,
'task_id': task_id,
'calendar_formset': calendar_formset,
'locationalias_formset': locationalias_formset})
def edit_profile(request):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, ugettext('Profile successfully updated'))
return redirect("edit_profile")
else:
form = UserForm(instance=request.user)
return render(request, 'auth2/edit.html', {'form': form})
def profile_update(request, user_id):
user = User.objects.get(id=user_id)
if request.method == "POST":
form = UserForm(request.POST, request.FILES, instance=user)
if form.is_valid():
form.save()
return redirect("profile")
else:
form = UserForm(instance=user)
data = {"user": request.user, "form": form}
return render(request, "profile/profile_update.html", data)
def add_player(request):
form = UserForm()
if request.method == "POST":
user = UserForm(data = request.POST)
if user.is_valid():
user.instance.set_password(request.POST['password'])
user.save()
return HttpResponseRedirect(reverse('wouso.interface.cpanel.views.players'))
else:
form = user
return render_to_response('cpanel/add_player.html', {'form': form}, context_instance=RequestContext(request))
def account_change(request):
success = False
if request.method == 'POST':
user_form = UserForm(data=request.POST, instance=request.user)
if user_form.is_valid():
user_form.save()
success = True
else:
user_form = UserForm(instance=request.user)
return render(request, 'registration/edit_account.html', {'user_form': user_form, 'success': success})
def edit_player(request, user_id):
user = get_object_or_404(User, pk=user_id)
if request.method == "POST":
form = UserForm(data = request.POST, instance = user)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('wouso.interface.cpanel.views.players'))
else:
form = UserForm(instance=user)
form.fields['password'].widget.attrs['readonly'] = True
return render_to_response('cpanel/edit_player.html', {'form':form}, context_instance=RequestContext(request))
def editUser(request, id):
user_obj = models.User.objects.filter(id=id).first()
form = UserForm(instance=user_obj)
if request.method == 'POST':
form = UserForm(request.POST, instance=user_obj)
form.save()
return redirect('/user/')
return render(
request, 'rbac/edit.html',
locals()) #首先在根目录下templates下找对应的html，若未找到在按app注册顺序找各app下的templates文件
def profile_update(request, profile_username):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
return redirect('profile_by_username', profile_username=request.user.username)
elif request.user.username != profile_username:
return redirect('profile')
else:
form = UserForm(instance=request.user)
return render(request, "profile.html", {'form': form})
def edit_profile(request):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, ugettext('Profile successfully updated'))
return redirect("edit_profile")
else:
form = UserForm(instance=request.user)
return render(request, 'auth2/edit.html', {'form': form})
def settings(request):
if request.method == 'POST':
form = UserForm(request.POST, instance= request.user)
if form.is_valid():
form.save()
return HttpResponseRedirect('/he')
else:
form = UserForm(instance=request.user)
form.fields['username'].widget.attrs['readonly'] = True
return render_to_response('userprofile/settings.html', { 'user_form': form}, context_instance=RequestContext(request))
def create_user(request):
if(request.method == "GET"):
form = UserForm()
return render(request, "new_user.html", {"form": form.as_p()})
if(request.method == "POST"):
newuser=UserForm(request.POST)
print newuser.is_valid()
print newuser.errors
if(newuser.is_valid()):
newuser.save()
return redirect("login")
def edit_player(request, user_id):
user = get_object_or_404(User, pk=user_id)
if request.method == "POST":
form = UserForm(data = request.POST, instance = user)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('wouso.interface.cpanel.views.players'))
else:
form = UserForm(instance=user)
form.fields['password'].widget.attrs['readonly'] = True
return render_to_response('cpanel/edit_player.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 post(self, request, *args, **kwargs):
user_form = UserForm(request.POST, instance=request.user)
sp_form = SocialProfileForm(request.POST, instance=request.user.social_profile)
if user_form.is_valid() & sp_form.is_valid():
user_form.save()
sp_form.save()
messages.add_message(self.request, messages.INFO, _('Your profile has been updated.'))
return HttpResponseRedirect(sp_form.cleaned_data.get('returnTo', DEFAULT_RETURNTO_PATH))
else:
messages.add_message(self.request, messages.INFO, _('Your profile has NOT been updated.'))
return self.render_to_response({'sp_form': sp_form, 'user_form': user_form})
def join(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('wineries/thanks')
else:
print form.errors
return Http404()
else:
form = UserForm()
return render_to_response('wineries/join.html', {'form': form}, RequestContext(request))
def profile_update(request, profile_username):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES, instance=request.user)
if form.is_valid():
form.save()
return redirect('profile_by_username',
profile_username=request.user.username)
elif request.user.username != profile_username:
return redirect('profile')
else:
form = UserForm(instance=request.user)
return render(request, "profile.html", {'form': form})
def register(request):
"""
User registration
"""
if len(request.POST) > 0:
# Create form instances from POST data or build empty ones
if 'password' in request.POST:
user_form = UserForm(request.POST)
student_form = StudentProfileForm()
if 'ma_classe' in request.POST:
student_form = StudentProfileForm(request.POST)
user_form = UserForm()
if user_form.is_valid():
# Save a new User object from the form's data.
user_form.save()
# Retrieve the username from the last POST
username = request.POST.get('username')
#Retrieve the underlying User object from DB
user = User.objects.get(username=username)
#Create an non-validating object
eleve = student_form.save(commit=False)
#Pass it the desired user foreign key
eleve.user = user
#build a new "partial + Non validated" StudentProfileForm using the eleve instance
student_form = StudentProfileForm(None, instance=eleve)
return render(request,'MonEtablissement/user_profile.html', {'student_form': student_form, 'username': str(student_form.helper.attrs)})
elif student_form.is_valid():
student_form.save(commit=True)
return HttpResponseRedirect('/login')
elif not user_form.has_changed() and not user_form.is_valid() and user_form.is_bound :
#user_form: Case not valid, including empty form
return render (request, 'MonEtablissement/user_profile.html', {'user_form': user_form})
elif not student_form.is_valid() and student_form.is_bound :
return render (request, 'MonEtablissement/user_profile.html', {'student_form': student_form})
else:
return render (request, 'MonEtablissement/user_profile.html', {'user_form': user_form})
else:
user_form = UserForm()
student_form = StudentProfileForm()
return render (request, 'MonEtablissement/user_profile.html', {'user_form': user_form, 'student_form': student_form})
def register(request):
if request.method == 'POST':
uf = UserForm(request.POST, prefix='user')
if uf.is_valid():
uf.save()
return HttpResponseRedirect('%s%s' % (reverse('homepage'), '?r=1'))
else:
return render_to_response('home/register.html', { 'userform': uf },
context_instance=RequestContext(request))
else:
uf = UserForm(prefix='user')
return render_to_response('home/register.html', { 'userform': uf },
context_instance=RequestContext(request))
def user_form(request):
"""
"""
sauvegarde = False
form = UserForm(request.POST or None)
if form.is_valid():
form.save()
sauvegarde = True
return render(request, 'booking/userForm.html', {
'form': form,
'sauvegarde': sauvegarde
})
def join(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('wineries/thanks')
else:
print form.errors
return Http404()
else:
form = UserForm()
return render_to_response('wineries/join.html', {'form': form},
RequestContext(request))
def add_user(request):
list_users = User.objects.order_by('date_admit')
if request.POST:
form = UserForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/success/')
else:
form = UserForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['list_users'] = list_users
return render(request,'add_user.html',args)
def ajax_request(request):
form = UserForm(request.POST)
clean = form.is_valid()
rdict = {'bad' : 'false'}
if not clean:
rdict.update({'bad':'true'})
d = {}
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])})
rdict.update({'errs':d})
else:
form.save()
json = simplejson.dumps(rdict)
return HttpResponse(json, mimetype='application/javascript')
def CreateUserView(request):
if request.method == 'POST':
data = request.POST
form = UserForm(data)
if form.is_valid():
form.clean_username()
form.clean()
form.save()
return HttpResponseRedirect('login')
else:
return render(request, 'user_create.html', {'form': form})
else:
form = UserForm()
return render(request, 'user_create.html', {'form': form})
def register_user(request):
if(request.method == 'POST'):
form = UserForm(request.POST)
if(form.is_valid()):
form.save()
return HttpResponseRedirect('/dashboard/accounts/register_success')
args = {}
args.update(csrf(request))
args['form'] = UserForm()
return render_to_response('register.html', args)
def user_detail(request):
if request.method == "POST":
form = UserForm(request.POST, instance=request.user)
if form.is_valid():
form.save()
messages.success(request, 'User settings saved.')
return HttpResponseRedirect('/')
else:
messages.warning(request, 'Form validation error. Details below.')
else:
form = UserForm(instance=request.user)
return render(request, 'registration/profile.html', {
'form': form,
})
def profile_form(request):
if request.method == 'POST':
if 'cancel' in request.POST:
return redirect('/accounts/profile')
user = User.objects.get(username=request.user.username)
#post = request.POST.copy() # To keep Email Read-Only
#post['email'] = user.email
# and update original POST in the end
#request.POST = post
user_form = UserForm(request.POST, instance=user)
if user_form.is_valid():
user_form.save()
try:
profile_instance = Userprofile.objects.get(user_id=user.id)
except Userprofile.DoesNotExist:
profile_instance = Userprofile(user_id=user.id)
user_profile_form = ProfileForm(request.POST,
instance=profile_instance)
if user_profile_form.is_valid():
user_profile_form.save()
return redirect('/accounts/profile')
else:
user_profile = _get_profile(request)
print user_profile
user_form = \
UserForm(initial={'first_name': user_profile['first_name'],
'last_name': user_profile['last_name'], 'email':user_profile['email']})
phone = ''
address = ''
if 'phone' in user_profile:
phone = user_profile['phone']
if 'address' in user_profile:
address = user_profile['address']
user_profile = \
ProfileForm(initial={'phone': phone, 'address': address, } )
return render(
request,
'profile_form.html',
{
'user_form': user_form,
'user_profile': user_profile,
},
)
def profile(request):
# We always have the user, but not always the profile. And we need a bit
# of a hack around the normal forms code since we have two different
# models on a single form.
(profile, created) = UserProfile.objects.get_or_create(pk=request.user.pk)
# Don't allow users whose accounts were created via oauth to change
# their email, since that would kill the connection between the
# accounts.
can_change_email = (request.user.password != OAUTH_PASSWORD_STORE)
# We may have a contributor record - and we only show that part of the
# form if we have it for this user.
try:
contrib = Contributor.objects.get(user=request.user.pk)
except Contributor.DoesNotExist:
contrib = None
contribform = None
if request.method == 'POST':
# Process this form
userform = UserForm(data=request.POST, instance=request.user)
profileform = UserProfileForm(data=request.POST, instance=profile)
if contrib:
contribform = ContributorForm(data=request.POST, instance=contrib)
if userform.is_valid() and profileform.is_valid() and (
not contrib or contribform.is_valid()):
userform.save()
profileform.save()
if contrib:
contribform.save()
return HttpResponseRedirect("/account/")
else:
# Generate form
userform = UserForm(instance=request.user)
profileform = UserProfileForm(instance=profile)
if contrib:
contribform = ContributorForm(instance=contrib)
return render_pgweb(
request, 'account', 'account/userprofileform.html', {
'userform': userform,
'profileform': profileform,
'contribform': contribform,
'can_change_email': can_change_email,
})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save()
profile.user = user
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict = {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
}
return render(request, "register.html", context_dict)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
user_prof_form = UserProfForm(data=request.POST)
if user_form.is_valid():
if (user_prof_form.is_valid()):
user = user_form.save(commit=False)
user.set_password(user.password)
user.is_active = False
user.save()
user_profile = user_prof_form.save(commit=False)
user_profile.user = user
user_profile.save()
registered = True
else:
print user_prof_form.errors
else:
print user_form.errors
else:
user_form = UserForm()
user_prof_form = UserProfForm()
# Render the template depending on the context.
return render(
request, 'citadel/register.html', {
'user_form': user_form,
'user_prof_form': user_prof_form,
'registered': registered
})
def register_team(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
team_form = TeamForm(request.POST, request.FILES)
if user_form.is_valid():
if team_form.is_valid():
user = user_form.save()
# do i need these two lines anymore? Django 1.5, i think, handles this automatically now.
password = user.password
user.set_password(password)
user.save()
t = team_form.save(commit=False)
t.user = user
t.save()
registered = True
user = authenticate(username=user.username, password=password)
login(request, user)
return HttpResponseRedirect('/showcase/team/' + str(t.id) +
'/')
else:
print user_form.errors, team_form.errors
else:
user_form = UserForm()
team_form = TeamForm()
# Render the template depending on the context.
return render_to_response('showcase/team_registration.html', {
'user_form': user_form,
'team_form': team_form,
'registered': registered
}, context)
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
else:
print user_form.errors
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user.is_authenticated:
login(request, user)
profile = UserProfile(user_id=user.id)
profile.save()
return HttpResponseRedirect('../chooser')
else:
raise Exception("user is not authenticated")
else:
user_form = UserForm()
return render(request, 'users/register.html', {
'user_form': user_form,
'registered': registered
})
def register(request):
if request.session.get('patient_mode'):
return redirect('kiosk')
# If there's a user logged in, require them to log out
if request.user.is_authenticated():
return redirect('manual_logout')
# If it's post, the user has sent us their info and we need to try to set them up
if request.method == 'POST':
success = False
user_form = UserForm(data=request.POST)
if user_form.is_valid():
# Save the user and associate it with a new Doctor
user = user_form.save()
user.set_password(user.password)
user.save()
doctor = Doctor()
doctor.user = user
doctor.save()
success = True
# Registration done, let's get out of here.
# (note: I'm not actually sure whether it'd be more appropriate to
# have a new view for the result and redirect to it. That sort of thing
# seems common, but this seems simpler)
return render(request, 'registration_report.html', {
'success': success,
'user_form': user_form
})
# Otherwise we diplay the form for them to fill out and post to us
else:
return render(request, 'register.html', {'user_form': UserForm()})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request, 'register.html', { 'user_form': user_form,
'profile_form':profile_form,
'registered':registered }
)
def register(request):
uform = UserForm(request.POST or None)
form = PlayerForm(request.POST or None)
if uform.is_valid() and form.is_valid():
dj_user = uform.save()
player = form.save(commit=False)
player.user = dj_user
prof = Profile()
prof.save()
player.profile = prof
player.save()
#authenticate user
#dj_user = authenticate(username=uform.cleaned_data['username'],
# password=uform.cleaned_data['password'],
# )
#login(request, dj_user)
#success sends to map and the questions..
return redirect(reverse('login'))
#register invalid.. go back to register (test registration errors!! probably fix css for errors)
return render(request,
'registration/register.html',
context={
'form': form,
'uform': uform
})
