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 index(request):
# Process the form data
if request.method == "POST":
crisisUserForm = CrisisUserForm(request.POST)
userForm = UserForm(request.POST)
assert crisisUserForm.is_valid()
assert userForm.is_valid()
if crisisUserForm.is_valid() and userForm.is_valid():
crisisUserForm_data = crisisUserForm.cleaned_data
userForm_data = userForm.cleaned_data
new_user = User.objects.create_user(**userForm_data)
new_user.save()
crisis_user = CrisisUser.objects.create(user=new_user, **crisisUserForm_data)
crisis_user.save()
return HttpResponseRedirect(reverse('bluehack:register', args=(userForm_data['username'],)))
return render(request, 'bluehack/index.html', {'error': 'Failed to register'})
# Create a blank form if any other method
else:
crisisUserForm = CrisisUserForm()
userForm = UserForm()
return render(request, 'bluehack/index.html', {
'error': '',
'crisisUserForm': crisisUserForm,
'userForm': userForm
})
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 home_base(request):
if request.method == "POST":
form = UserForm(request.POST)
print form.is_valid()
new_user_a = authenticate(username=request.POST['username'],
password=request.POST['password'])
login(request, new_user_a)
return redirect('logged_in')
else:
form = UserForm()
return render(request, 'home/home_base.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':
userForm = UserForm(data=request.POST)
profileForm = UserProfileForm(data=request.POST)
locationForm = LocationForm(data=request.POST)
if userForm.is_valid() and profileForm.is_valid() and \
locationForm.is_valid():
userObj = userForm.save()
userObj.set_password(userObj.password)
userObj.save()
location = locationForm.save(commit=False)
location.name = 'Home'
location.save()
profileObj = profileForm.save(commit=False)
profileObj.user = userObj
profileObj.address = location
profileObj.save()
profileObj.locations.add(location)
profileObj.save()
userObj = authenticate(username=userObj.username,
password=userObj.password)
login(request, userObj)
return render(request, 'socketbox/index.html', {})
else:
if not locationForm.is_valid():
print("Location is bad!")
print locationForm.errors
if not userForm.is_valid():
print("user is bad!")
print userForm.errors
print request.POST
if not profileForm.is_valid():
print("profile is bad!")
print profileForm.errors
return index(request)
else:
profileForm = UserProfile()
locationForm = Location()
userForm = User()
contextDict = {'profileForm': profileForm, 'locationForm': locationForm,
'userForm': userForm}
return render(request, "registration/registration_form.html", contextDict)
def regist(req):
errors1 = []
if req.method == 'POST':
uf = UserForm(req.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
email = uf.cleaned_data['email']
if User.objects.filter(username=username):
errors1.append('用户名已经存在，请换一个啦')
return render_to_response('index2.html', {'errors1': errors1},
context_instance=RequestContext(req))
else:
User.objects.create(username=username, password=password)
f = User.objects.get(username=username)
create_time = timezone.now()
modify_time = timezone.now()
f.userinfo_set.create(email=email,
tel='8888888',
address='default')
f.folder_set.create(folder_name='默认文件夹',
create_time=create_time,
modify_time=modify_time)
return render_to_response('index2.html',
context_instance=RequestContext(req))
else:
uf = UserForm()
return render_to_response('index2.html', {'uf': uf},
context_instance=RequestContext(req))
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 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 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 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 register(request):
if request.method == 'POST':
#加载request.POST 里面的数据
uform = UserForm(request.POST)
if uform.is_valid():
data = uform.cleaned_data
#创建用户
try:
user = User.objects.create_user(nickname=data['nickname'],
username=data['phone'],
password=data['password'],
email=data['email'],
phone=data['phone'])
print(user)
if user:
code = str(uuid.uuid4()).replace('-', '')
#放到缓存中
cache.set(code, user)
#发送邮件
sendemail.delay(code, data['email'])
return HttpResponse('注册成功，请尽快进入邮箱激活使用')
except Exception as err:
print('user register---------------------------->', err)
return render(request, 'auth/register.html')
else:
return render(request, 'auth/register.html')
else:
return render(request, 'auth/register.html')
def profile_form(request,username,use_openid=False):
if request.user.username != username:
return HttpResponse("You cannot access another user's profile.", status=401)
else:
user = User.objects.get(username=username)
try:
user_profile = UserProfile.objects.get(user=user)
except UserProfile.DoesNotExist:
user_profile = UserProfile.objects.create(user=user)
user_assoc = UserAssociation.objects.filter(user__id=user.id)
if request.method == 'GET':
uform = UserForm(instance=user)
pform = UserProfileForm(instance=user_profile)
return render_to_response('user_profile/user_profile_form.html',
{'profile': user_profile, 'assoc': user_assoc, 'uform': uform, 'pform': pform,
'group_request_email': settings.GROUP_REQUEST_EMAIL, 'use_openid': use_openid, 'MEDIA_URL':settings.MEDIA_URL})
elif request.method == 'POST':
uform = UserForm(data=request.POST, instance=user)
pform = UserProfileForm(data=request.POST, instance=user_profile)
if uform.is_valid():
user.save()
if pform.is_valid():
user_profile.save()
#return HttpResponseRedirect(reverse('user_profile-form', args=[username]))
return HttpResponseRedirect(reverse('map'))
else:
return HttpResponse("Received unexpected " + request.method + " request.", status=400)
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 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 publisher_settings_users_add(request):
''' View to allow a Publisher the ability to create a new User '''
from atrinsic.base.models import User, UserProfile
from forms import UserForm
print 'test5'
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
u = User()
u.first_name = form.cleaned_data['first_name']
u.last_name = form.cleaned_data['last_name']
u.email = form.cleaned_data['email']
u.username = u.email.replace('@', '-')
u.set_password(form.cleaned_data['password'])
u.save()
up = UserProfile.objects.create(user=u)
up.organizations.add(request.organization)
return HttpResponseRedirect('/publisher/settings/users/')
else:
form = UserForm()
return AQ_render_to_response(request,
'publisher/settings/users-add.html', {
'form': form,
},
context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
form = UserForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
name = form.cleaned_data['name']
tele = form.cleaned_data['tele']
email = form.cleaned_data['email']
usergroups = form.cleaned_data['usergroups']
key = form.cleaned_data['key']
if key != 'ac5b4a2f96cc':
errors = form._errors.setdefault("key", ErrorList())
errors.append(u"认证码不正确，请向监控管理员索要！")
return self.form_invalid(form=form)
zabbixs =[]
for zabbix in settings.ZABBIX_LIST:
zabbixs.append(ZabbixClinet(idc=zabbix['idc'], address=zabbix['address'], username=zabbix['username'], password=zabbix['password']))
for zabbix in zabbixs:
zabbix.user_create(user={'username':username, 'name':name, 'tel':tele, 'email':email, 'usergroups':[get_usergroups(usergroup) for usergroup in usergroups]})
zabbix.user_logout()
else:
return self.form_invalid(form=form)
return super(UserAddView, self).post(request, *args, **kwargs)
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 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 Register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
c_form = UserCreateForm(data=request.POST)
if user_form.is_valid() and c_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
c = c_form.save(commit=False)
c.user = user
c.save()
c_form.save_m2m()
registered = True
else:
print user_form.errors, c_form.errors
else:
user_form = UserForm()
c_form = UserCreateForm()
return render(request, 'gadgetapp/register.html',
{'user_form': user_form, 'c_form': c_form, 'registered': registered}, RequestContext(request))
def profile_save(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = UserForm(request.POST)
username = request.POST['username']
user_error = None
user = None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
pass
if user is not None and user.username.lower() != request.user.username.lower():
user_error = 'Username is already taken!'
if form.is_valid() and user_error is None:
request.user.username = username
request.user.first_name = form.cleaned_data['first_name']
request.user.last_name = form.cleaned_data['last_name']
request.user.bio = form.cleaned_data['bio']
request.user.website = form.cleaned_data['website']
request.user.facebook = form.cleaned_data['facebook']
request.user.twitter = form.cleaned_data['twitter']
request.user.linkedin = form.cleaned_data['linkedin']
request.user.github = form.cleaned_data['github']
request.user.save()
return render(request, 'profile/edit.html', {'ok': 'Changes saved!'})
else:
return render(request, 'profile/edit.html', {'ok': None, 'errors': form.errors, 'user_error': user_error})
return HttpResponseRedirect('/profile/edit/')
def List(request):
try:
if CheckAccess(request,'23') != 'OK':
return render_to_response("mtmc/notaccess/mtmc.html")
except:
return HttpResponseRedirect('/')
if request.method == 'POST':
formuser = UserForm(request.POST)
if formuser.is_valid():
user = formuser.cleaned_data['user']
request.session['user_id'] = user
formsearch = SearchForm(request.POST)
if formsearch.is_valid():
search = formsearch.cleaned_data['search']
r = FindKey(search)
if len(r) == 1:
return HttpResponseRedirect('/mtmcedit/?eq_id=%s' % search)
### --- Сохранное занчение user_id ---
try:
user_id = request.session['user_id']
except:
user_id = ''
try:
print_ok = request.GET['print']
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="list.pdf"'
buff = StringIO()
result = PrintForm(buff,user_id)
response.write(result.getvalue())
buff.close()
return response
except:
pass
formmove = MoveForm(None)
formsearch = SearchForm(None)
formuser = UserForm(None)
formuser.fields['user'].initial = user_id
data = GetList(user_id)
if len(data)!=0 and user_id != 'ALL':
print_ok = True
else:
print_ok = False
c = RequestContext(request,{'data':data,'formuser':formuser,'formsearch':formsearch,'formmove':formmove,'print_ok':print_ok})
c.update(csrf(request))
return render_to_response("mtmc/list.html",c)
def signup(request,group=None):
'''验证手机号，创建账号'''
if request.user.is_authenticated():
if request.user.state > 2:
from django.contrib.auth import logout
logout(request)
return HttpResponseRedirect('/signin')
else:
return HttpResponseRedirect(reverse('apply_profile_info'))
request.session['group'] = group
userform = UserForm()
if request.method == 'POST':
userform = UserForm(request.POST)
if userform.is_valid():
user = userform.create_user() #todo:添加事务支持
from django.contrib.auth import authenticate, login
user = authenticate(username=user.username, \
password=userform.cleaned_data['password'])
login(request, user)
request.session['group'] = group
return HttpResponseRedirect(reverse('apply_profile_info'))
return render_to_response('%s/signup.html'%SIGNUP_TEMPLATE_ROOT,
{"userform": userform},
context_instance=RequestContext(request))
def login_dl(request):
if request.user.is_authenticated:
return redirect('index')
else:
if request.method == 'GET':
login_form = UserForm()
if request.method == 'POST':
login_form = UserForm(request.POST)
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
user = authenticate(username=username, password=password)
print 111111
print username
print password
if user:
print 222222
login(request, user)
print 333333
return redirect('index')
else:
return redirect('https://www.baidu.com/')
return render(request, 'login.html', locals())
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):
# 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):
if request.method == "POST":
uf = UserForm(request.POST)
if uf.is_valid():
#返回注册成功页面
#往Django user表里再插入一条数据
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
realname = uf.cleaned_data['realname']
email = username+"@lyi.com"
try:
user = User.objects.create_user(username=username, email=email, password=password)
user.save()
except:
uf = UserForm()
return render_to_response('register.html',{'list':department.objects.all(), 'error':'注册的用户名已存在'},context_instance=RequestContext(request))
user_new = uf.save();
#登录
uid = models.user.objects.filter(username=username)[0].id
request.session['username'] = username
request.session['realname'] = realname
request.session['id'] = uid
#Django 认证系统的登录
user = auth.authenticate(username=username, password=password)
auth.login(request, user)
return HttpResponseRedirect("/personal_homepage")
else:
uf = UserForm()
return render_to_response('register.html',{'list':department.objects.all()},context_instance=RequestContext(request))
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
firstname = user_form['first_name'].value()
lastname = user_form['last_name'].value()
subject = 'Report Viewer Registration: {}, {}'.format(
lastname, firstname)
message = 'User {} {} <{}> has registered and needs to be vetted.'.format(
firstname, lastname, user.email)
send_mail(subject, message, '*****@*****.**',
['*****@*****.**'], fail_silently=False)
else:
print user_form.errors
else:
user_form = UserForm()
context = {'user_form': user_form, 'registered': registered}
context.update(csrf(request))
return render_to_response('viewer/register.html', context,
context_instance=RequestContext(request))
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_rater(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
password = user.password
user.set_password(user.password)
user.save()
r = Rater(user=user, active=True)
r.save()
registered = True
user = authenticate(username=user.username, password=password)
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
return HttpResponseRedirect('/showcase/')
else:
print user_form.errors
else:
user_form = UserForm()
# Render the template depending on the context.
return render_to_response(
'showcase/rater_registration.html',
{'user_form': user_form, 'registered': registered},
context)
def register(request):
if request.method == 'POST':
userform = UserForm(request.POST)
if userform.is_valid():
userid = userform.cleaned_data['userid']
username = userform.cleaned_data['username']
password1 = userform.cleaned_data['password1']
password2 = userform.cleaned_data['password2']
if password1 != password2:
render(
request, 'register.html', {
'userform': userform,
'is_err': True,
'err_message': '再次输入的密码不一致'
})
email = userform.cleaned_data['email']
phone = userform.cleaned_data['phone']
UserInfo.objects.create(userid=userid,
username=username,
password=password1,
email=email,
phone=phone)
# obj_userinfo = UserInfo(userid=userid, username=username, password=password1, email=email, phone=phone)
# obj_userinfo.save()
return redirect(to='index')
else:
userform = UserForm()
return render(request, 'register.html', {
'userform': userform,
'is_err': True,
'err_message': '注册成功'
})
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 register(request): # 实现注册功能
if request.method == "POST":
uf = UserForm(request.POST)
if uf.is_valid():
#获取表单信息
username = uf.cleaned_data['username']
password1 = uf.cleaned_data['password1']
password2 = uf.cleaned_data['password2']
email = uf.cleaned_data['email']
user = User.objects.filter(username=username)
if user.exists():
return render_to_response('register_fail.html',
{'data': "用户名已被占用！请更换"})
if password1 != password2:
return render_to_response('register_fail.html',
{'data': "前后密码不一致"})
#将表单写入数据库
user = User.objects.create_user(username=username,
email=email,
password=password2)
'''user.username = username
user.password = password2
user.email = email'''
user.save()
#返回注册成功页面
return render(request, 'register_success.html',
{'username': username})
else:
uf = UserForm()
return render(request, 'register.html', {'uf': uf})
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
})
def signup(request):
#http://stackoverflow.com/questions/21107655/using-django-registration-with-a-flat-ui-template
#http://stackoverflow.com/questions/2339369/how-can-i-override-the-django-authenticationform-input-css-class
#http://stackoverflow.com/questions/1453488/how-to-markup-form-fields-with-div-class-field-type-in-django/1504903#1504903
context = RequestContext(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)
#created django user
user.save()
#created racehub user, link django user to it
new_racehub_user = UserProfile(user=user)
new_racehub_user.save()
registered = True
else:
user_form = UserForm()
context_dict = {'user_form': user_form, 'registered': registered}
return render_to_response('signup.html', context_dict, 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 register(request):
# Like before, get the request's context.
context = RequestContext(request)
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(request.POST,request.FILES)
# p = UserProfileForm(data=request.FILES)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():# and p.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Did the user provide a profile picture?
# If so, we need to get it from the input form and put it in the UserProfile model.
if 'picture' in request.FILES:
# p.picture = request.FILES['picture']
# p.save()
profile.picture = request.FILES['picture']
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print user_form.errors, profile_form.errors
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render_to_response(
'registration.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered},
context)
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 home(request):
context = {}
year = settings.CONSTITUENCY_YEAR
constituencies = Constituency.objects.filter(year=year)
count = CustomUser.objects\
.aggregate(Count('constituencies',
distinct=True)).values()[0]
total = constituencies.count()
context['volunteers'] = CustomUser.objects.count()
context['total'] = total
context['count'] = count
if total:
context['percent_complete'] = int(float(count) / total * 100)
else:
context['percent_complete'] = 0
if request.method == "POST":
form = UserForm(request.POST, request.FILES)
if form.is_valid():
profile = form.save()
user = authenticate(username=profile.user.email)
login(request, user)
return HttpResponseRedirect("/")
else:
context['form'] = form
else:
context['form'] = UserForm()
return render_with_context(request, 'home.html', context)
def register(request):
context = RequestContext(request)
registered = False
cat_list = get_category_list()
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_to_response(
'rango/register.html',
{'user_form': user_form, 'profile_form':profile_form, 'cat_list':cat_list, 'registered': registered},
context)
def post(self, request, user_id):
form = UserForm(request.POST or None)
hidden_form = CoursesForm(request.POST or None)
if form.is_valid() and hidden_form.is_valid():
data = form.cleaned_data
user_courses = hidden_form.cleaned_data.get('courses')
db = Database()
db.update_records(user_id, user_courses)
db.update_user(user_id=user_id, **data)
all_courses = db.get_all_courses()
user_courses = db.get_user_courses(user_id)
template = loader.get_template('edit.html')
all_courses = json.dumps(all_courses)
user_courses = json.dumps(user_courses)
form.fields['user_name'].widget.attrs['readonly'] = True
context = dict(form=form, success=True, all_courses=all_courses, user_courses=user_courses)
return HttpResponse(template.render(context, request))
else:
db = Database()
all_courses = db.get_all_courses()
user_courses = db.get_user_courses(user_id)
template = loader.get_template('edit.html')
form = UserForm(request.POST)
hidden_form = CoursesForm(request.POST)
form.fields['user_name'].widget.attrs['readonly'] = True
context = dict(form=form, hidden_form=hidden_form, all_courses=all_courses, user_courses=user_courses)
return HttpResponse(template.render(context, 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 signup(request):
if request.method == 'POST':
print "Tried to make new user!"
user_form = UserForm(data=request.POST)
un = request.POST['username']
pswd = request.POST['password']
conf = request.POST['confirmation']
if user_form.is_valid() and pswd == conf:
print "saving user and period"
user = user_form.save()
user.set_password(user.password)
user.save()
print "saved user!"
cur_user = authenticate(username = un, password = pswd)
if user:
login(request, cur_user)
return HttpResponseRedirect('/myschedule/')
else:
return HttpResponse("your account is invalid")
else:
return HttpResponse("You suck")
else:
return render(request, 'period/signup.html')
def edit_admin(request, pk):
admin_form = AdminForm(prefix="adm")
user_form = UserForm(prefix="usr")
user = get_object_or_404(User, pk=pk)
admin = get_object_or_404(Admin, user_id=user.pk)
if request.method == 'POST':
admin_form = AdminForm(request.POST, prefix="adm", instance=admin)
user_form = UserForm(request.POST, prefix="usr", instance=admin.user)
if user_form.is_valid() and admin_form.is_valid():
user = user_form.save()
admin = admin_form.save(commit=False)
admin.user = user
admin.pic = request.FILES['adm-pic']
admin.save()
#request.user = user
request.user.save()
return redirect('admin_details', matriculation=admin.matriculation)
else:
messages.error(request, "Error")
return render(request, 'locker_manager/register_admin.html',{'admin_form':admin_form, 'user_form':user_form})
else:
admin_form = AdminForm(prefix="adm", instance=admin)
user_form = UserForm(prefix="usr", instance=admin.user)
return render(request, 'locker_manager/register_admin.html',{'admin_form':admin_form, 'user_form':user_form})
def register(request):
# Like before, get the request's context.
context = RequestContext(request)
if request.user.is_authenticated:
#return HttpResponseRedirect('/profile')
#else:
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
validation_form = ValidationForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid(
) and validation_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.user_since = datetime.datetime.today()
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
user_id = user.id
if user_id % 2 is 0:
profile.condition = 1
elif user_id % 2 is not 0:
profile.condition = 2
profile.save()
registered = True
new_user = authenticate(username=request.POST['username'],
password=request.POST['password'])
login(request, new_user)
else:
print user_form.errors, profile_form.errors, validation_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
validation_form = ValidationForm()
return render_to_response(
'badsearch/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'validation_form': validation_form,
'registered': registered
}, context)
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, 'rango/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def regist(req):
errors1 = []
if req.method == 'POST':
uf = UserForm(req.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
email = uf.cleaned_data['email']
if User.objects.filter(username=username):
errors1.append('用户名已经存在，请换一个啦')
return render_to_response('index2.html', {'errors1': errors1}, context_instance=RequestContext(req))
else:
User.objects.create(username=username, password=password)
f = User.objects.get(username=username)
create_time = timezone.now()
modify_time = timezone.now()
f.userinfo_set.create(email=email, tel='8888888', address='default')
f.folder_set.create(folder_name='默认文件夹', create_time=create_time, modify_time=modify_time)
return render_to_response('index2.html', context_instance=RequestContext(req))
else:
uf = UserForm()
return render_to_response('index2.html', {'uf': uf}, context_instance=RequestContext(req))
def signup(request):
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
user = User(email=form.cleaned_data['email'])
user.first_name = form.cleaned_data['firstName']
user.last_name = form.cleaned_data['lastName']
user.username = user.email
user.set_password(form.cleaned_data['password'])
user.is_active = False
user.save()
userProfile = UserProfile.objects.get_or_create(
user=user,
birthdate=form.cleaned_data['birthdate'],
gender=form.cleaned_data['gender'],
profilePhoto='images/default.png')
registration = Registration.objects.create_registration(user)
registration.send_activation_mail()
return HttpResponseRedirect(reverse("login-user"))
else:
form = UserForm()
data = {'form': form, 'title': 'SignUp'}
return render_to_response("email_app/signup.html", data)
def register_rater(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
password = user.password
user.set_password(user.password)
user.save()
r = Rater(user=user, active=True)
r.save()
registered = True
user = authenticate(username=user.username, password=password)
user.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user)
return HttpResponseRedirect('/showcase/')
else:
print user_form.errors
else:
user_form = UserForm()
# Render the template depending on the context.
return render_to_response('showcase/rater_registration.html', {
'user_form': user_form,
'registered': registered
}, context)
def register(request):
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']
print profile.picture
print type(profile.picture)
profile.save()
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
login(request, user)
return redirect('/blog/')
else:
print user_form.errors
error = user_form.errors.as_data().values()[0][0].messages[0]
print type(error)
return render(request, 'blog/auth/register.html',
{'error': error})
else:
return render(request, 'blog/auth/register.html')
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_view(request):
if request.user.is_authenticated():
print "user is authenticated"
return HttpResponseRedirect(reverse('home_url'))
if request.method=='POST':
form = UserForm(request.POST)
if form.is_valid():
print "form is valid"
email_exists = User.objects.filter(email=form.cleaned_data['email']).exists()
if email_exists:
print "email exists"
return render(request, 'first/register.html', {'form':form, 'email_exists':True, 'fail':True})
username = form.cleaned_data['username']
password = form.cleaned_data['password']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
user = User.objects.create_user(username, email, password)
user.last_name = last_name
user.first_name = first_name
user.save()
user=authenticate(username=username, password=password)
login(request, user)
url = reverse('home_url')
return HttpResponseRedirect(url)
else:
return render(request, 'first/register.html', {'form':form, 'fail':True})
else:
form = UserForm()
return render(request, 'first/register.html', {'form':form, 'fail':False})
def signup(request):
if request.method == 'GET':
logger.info("creating new user form")
form = UserForm()
return render(request, 'signup.html', {
'form': form,
})
elif request.method == 'POST':
logger.info("saving a new list")
form = UserForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
password = form.cleaned_data['password']
user = User.objects.create_user(username=username, email=email, password=password)
user.first_name = first_name
user.last_name = last_name
user.save()
emailutil.send_welcome_email(user)
user = auth.authenticate(username=username, password=password)
auth.login(request, user)
return HttpResponseRedirect('/home/') # Redirect after POST
else:
return render(request, 'signup.html', {
'form': form
})
else:
logger.info("invalid operation")
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(request):
context = RequestContext(request)
# boolean to determine if registation was succesful
registered = False
# if HTTP post then process from data
if request.method == 'POST':
# grab info
user_form = UserForm(data = request.POST)
#profile_form = UserProfileForm(data = request.POST)
if user_form.is_valid():
# save form to dadabase
user = user_form.save()
user.set_password(user.password)
user.save()
# sort user profile instance, set as false to avoid integrity problems
#profile = profile_form.save(commit = False)
#proifle.user = user
registered = True
return render_to_response('tasks/index.html', {'user', user}, context)
else:
# if form not complete or wrong
print(user_form.errors)
else:
user_form = UserForm()
#profile form doesn't work, cant get django to add ID#
#profile_form = UserProfileForm()
context_dict = {'user_form': user_form, 'registered': registered}
return render_to_response('tasks/index.html', context_dict, context)
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 edit_user(request, id):
user = get_object_or_404(User, id=id)
if request.method == 'POST':
form = UserForm(request.POST, instance=user)
if form.is_valid():
user = form.save(commit=False)
if form.cleaned_data['password']:
user.set_password(form.cleaned_data['password'])
if form.cleaned_data['groups']:
user.groups = form.cleaned_data['groups']
else:
user.groups.clear()
if form.cleaned_data['user_permissions']:
user.user_permissions = form.cleaned_data['user_permissions']
else:
user.user_permissions.clear()
user.save()
return redirect('accounts:administration:users_list')
else:
form = UserForm(instance=user)
return render(request, 'accounts/administration/edit_user.html', {
'form': form
})
def profile(request):
if request.session['email']:
if request.method=='POST':
a=Register.objects.get(email=request.session['email'])
try:
b=UserEditPro.objects.get(user=a)
except:
b=UserEditPro(user=a)
b.save()
b=UserEditPro.objects.get(user=a)
form=UserForm(request.POST,instance=b)
if form.is_valid():
f=form.save(commit=False)
f.user=a
f.save()
return HttpResponseRedirect('/blog/login/')
else:
return render(request,'blog/profile.html',{'form':form})
else:
a=Register.objects.get(email=request.session['email'])
try:
b=UserEditPro.objects.get(user=a)
except:
b = UserEditPro(user=a)
b.save()
b=UserEditPro.objects.get(user=a)
form=UserForm(instance=b)
return render(request,'blog/profile.html',{'form':form})
else:
return HttpResponseRedirect('blog/login/')
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
})
