def register(request):
if request.method == 'GET':
return render(request, 'register.html')
if request.method == 'POST':
user_info = UserForm(request.POST)
if user_info.is_valid():
username = user_info.cleaned_data.get('username')
password = make_password(user_info.cleaned_data.get('password'))
mobile = user_info.cleaned_data.get('mobile')
cpwd = request.POST.get('cpwd')
email = request.POST.get('email')
allow = request.POST.get('allow')
if cpwd == user_info.cleaned_data.get('password'):
if allow:
User.objects.create(username=username,
password=password,
mobile=mobile,
email=email)
return HttpResponseRedirect(reverse('users:login'))
else:
return render(request, 'register.html',
{'error_allow': '请勾选同意”天天生鲜用户使用协议“'})
else:
return render(request, 'register.html',
{'error_cpwd': '两次输入不相同'})
else:
return render(request, 'register.html', {'form': user_info.errors})
def users(request):
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
conn = sqlite3.connect('/var/www/webvirtmgr/webvirtmgr/webvirtmgr.sqlite3')
connect = conn.cursor()
connect.execute("SELECT id,username,email,is_superuser,is_active,last_login FROM auth_user")
webusers = connect.fetchall()
conn.commit()
connect.close()
if request.method == 'POST':
if 'user_del' in request.POST:
user_id = request.POST.get('user_id', '')
connect = conn.cursor()
connect.execute("DELETE FROM auth_user WHERE id=?", (user_id,))
conn.commit()
connect.close()
return HttpResponseRedirect(request.get_full_path())
if 'user_add' in request.POST:
form = UserForm(request.POST)
if form.is_valid():
name = request.POST.get('name', '')
print(name)
return HttpResponseRedirect(request.get_full_path())
return render_to_response('users.html', locals(), context_instance=RequestContext(request))
def register(request):
if request.method == 'GET':
form = UserForm()
greeting = 'Please register an account'
context = {
'form': form,
'greeting': greeting
}
return render(request, 'users/register.html', context)
else:
form = UserForm(request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'])
user.set_password(form.cleaned_data['password'])
user.save()
profile = UserProfile(user=user)
profile.save()
return redirect('/login/')
else:
context = {
'form': form,
'greeting': 'Invalid fields, please check errors.'
}
return render(request, 'users/register.html', context)
def register(request):
if request.method == 'POST':
msj = {}
username = request.POST.get('username', None)
password = request.POST.get('password', None)
confirmation = request.POST.get('Confirmar', None)
if password==confirmation:
form = UserForm(request.POST)
existente=User.objects.filter(username=username)
if not existente:
if form.is_valid():
user = User.objects.create_user(username =username, email='None', password = password)
authenticated = authenticate(username = username, password = password)
auth.login(request, authenticated)
user.save()
return redirect('show_books')
else:
request.session['username']=username
msj['msj'] = '<center>The username already exists</center>'
msj['id']='error'
return render_to_response('register.html', {'form':form, 'msj':msj}, context_instance = RequestContext(request))
else:
return render_to_response('register.html', {'form':form}, context_instance = RequestContext(request))
return render_to_response('register.html', context_instance = RequestContext(request))
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
return redirect('/users/login/?error={}'.format("signup a success! now please login") )
else:
return render(request, 'users/create.html', {'error':"Not a valid name or password", 'form':UserForm(request.POST) } )
def post(self, request):
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
user.set_password(password)
user.save()
user = authenticate(username=user.username,
password=password)
login(self.request, user)
messages.add_message(
request,
messages.SUCCESS,
"Account Successfully Created.")
return redirect("/")
else:
return render(request, "users/register.html", {"form1": user_form, "form2": profile_form})
def login_demo(request):
if request.method == "POST":
login_form = UserForm(request.POST) # 自定义登录表单
if login_form.is_valid(): # 确保用户名和密码都不为空
username = login_form.cleaned_data['user_account']
password = login_form.cleaned_data['password']
try:
user = User.objects.get(user_account=username)
except:
return HttpResponse(json.dumps({'code': '301'})) # 用户不存在
if check_password(password, user.password):
# print ('数据库密码是：' + user.password)
temp = user
token = token_op.create_token(temp)
return HttpResponse(
json.dumps({
'code': '200', # 成功状态码
'token': token,
'user_id': user.user_id,
'user_account': user.user_account,
'user_url': user.user_url,
'user_name': user.user_name,
'user_gender': user.user_gender,
'email': user.email,
'user_phone': user.user_phone,
'user_credit': user.user_credit,
'status': user.status,
}))
else:
return HttpResponse(json.dumps({'code': '302'})) # 密码不正确
else:
return HttpResponse(json.dumps({'code': '402'})) # 输入框未填完
else:
return HttpResponse(json.dumps({'code': '404'})) # 请求非POST类型
def user_register(request):
if request.method == "GET":
user_form = UserForm()
profile_form = ProfileForm()
elif request.method == "POST":
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
# The form doesn't know to call this special method on user.
user.set_password(password)
user.save()
# You must call authenticate before login. :(
user = authenticate(username=user.username,
password=password)
login(request, user)
messages.add_message(
request,
messages.SUCCESS,
"Congratulations, {}, on creating your new account! You are now logged in.".format(
user.username))
return redirect('index')
return render(request, "users/register.html", {'user_form': user_form,
'profile_form': profile_form})
def create(self, request, *args, **kwargs):
registered = False
flag =1
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
User = get_user_model()
if user_form.is_valid() and profile_form.is_valid():
for User in User.objects.filter():
if user_form.cleaned_data['email'] == User.email:
flag =0
user_form.cleaned_data['username'] = "******"
print("This mail address already exists!")
if flag ==1:
user = user_form.save()
print("user saved")
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
print('found it')
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
else :
print("not-saved")
else:
print(user_form.errors,profile_form.errors)
return render(request,'users/registration.html',
{'user_form':user_form,
'profile_form':profile_form,
'registered':registered,
'flag':flag})
def register(request):
form = UserForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
context = {'form': form}
return render(request, 'index.html', context)
def register_rater(request):
if request.method == "POST":
user_form = UserForm(request.POST)
rater_form = RaterForm(request.POST)
if user_form.is_valid() and rater_form.is_valid():
user = user_form.save()
rater = rater_form.save(commit=False)
rater.user = user
rater.save()
password = user.password
user.set_password(password)
user.save()
user = authenticate(username=user.username,
password=password)
login(request, user)
messages.add_message(
request,
messages.SUCCESS,
"Welcome, {}. You have successfully created an account and are now logged in".format(user.username))
return redirect('top20')
else:
user_form = UserForm()
rater_form = RaterForm()
return render(request, "users/register.html", {'user_form': user_form,
'rater_form': rater_form})
def user_register(request):
form = UserForm()
if request.method == 'POST':
f = UserForm(request.POST)
#form.permissao = request.POST['permissao']
valido = False
if f.is_valid():
valido = True
u = f.save(commit=False)
u.date_joined = datetime.date.today()
# request.POST['permissao']
u.permissao = f.cleaned_data['permissao']
u.save()
c = {
'form': form,
}
if valido:
c['sucesso'] = True
else:
c['sucesso'] = False
return render(request, 'users/register.html', c)
# return redirect('user_login')
c = {
'form': form,
}
return render(request, 'users/register.html', c)
def post(self, request):
form = UserForm(request.POST, request.FILES, instance=request.user)
data = {"form": form}
if form.is_valid():
form.save()
return redirect(reverse("users:edit"))
return render(request, self.template_name, data)
def create_user(request):
if request.method == 'POST':
uform = UserForm(data=request.POST)
pform = UserProfileForm(data=request.POST)
if uform.is_valid() and pform.is_valid():
new_user = User.objects.create_user(
username=uform.cleaned_data['username'],
email=uform.cleaned_data['email'],
password=uform.cleaned_data['password1'],
first_name=uform.cleaned_data['first_name'],
last_name=uform.cleaned_data['last_name'])
role = pform.cleaned_data['role']
if role == 'M':
manager = Manager(manager=new_user)
manager.save()
if role == 'W':
waiter = Waiter(waiter=new_user)
waiter.save()
if role == 'B':
bartender = Bartender(bartender=new_user)
bartender.save()
return HttpResponseRedirect('/manager/')
else:
uform = UserForm(data=request.POST)
pform = UserForm(data=request.POST)
variables = RequestContext(request, {
'uform': uform,
'pform': pform
})
return render_to_response('create_user.html',
variables)
class UserProfileSettings(TemplateView, CategoryListMixin):
template_name, form, cities, citys = None, None, None, None
def get(self, request, *args, **kwargs):
self.template_name = get_my_template("profile/settings/profile.html",
request.user,
request.META['HTTP_USER_AGENT'])
if request.user.city:
self.citys = request.user.city.region.get_cities()
return super(UserProfileSettings, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
from users.forms import UserForm
from region.models import Region
context = super(UserProfileSettings, self).get_context_data(**kwargs)
context["form"] = UserForm()
context["regions"] = Region.objects.exclude(name="Все регионы",
is_deleted=True)
context["citys"] = self.citys
return context
def post(self, request, *args, **kwargs):
from users.forms import UserForm
self.form = UserForm(request.POST,
request.FILES,
instance=request.user)
if request.is_ajax() and self.form.is_valid():
self.form.save()
photo_input = request.FILES.get('s_avatar')
if photo_input:
request.user.create_s_avatar(photo_input)
return HttpResponse()
return super(UserProfileSettings, self).post(request, *args, **kwargs)
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
errors = {}
username = form.cleaned_data['username']
password1 = form.cleaned_data['password1']
password2 = form.cleaned_data['password2']
# message = form.cleaned_data['message']
UserFilter = User.objects.filter(username=username)
if UserFilter:
errors['username'] = '******'
return render(request, 'users/register.html',
{'errors': errors})
elif password1 != password2:
errors['password'] = '******'
return render(request, 'users/register.html',
{'errors': errors})
else:
user = User()
user.username = username
# user.email = message
user.password = make_password(password1)
user.is_active = False
user.save()
return render(request, 'users/login.html', {})
else:
return render(request, 'users/register.html', {'form': form})
def addUser(request):
form = UserForm(request.POST)
if form.is_valid():
try:
with transaction.atomic():
enterprise = Enterprise()
enterprise.save()
request.session['idEnterprise'] = enterprise.id;
location= Location(enterprise=enterprise, lat=0, lng=0, name='Main Office')
location.save()
user = User(location = location, email=form.cleaned_data['email'],
password=form.cleaned_data['password'])
user.save()
request.session['idUser'] = user.id;
profile = Profile(user = user, role="Administrator")
profile.save()
return render(request, 'users/dashboard.html')
except Exception as e:
print(e)
messages.error(request, 'Sorry, Internal Error')
else:
messages.error(request, 'Please fill the form')
return HttpResponseRedirect('/signup')
def new_user(request):
"""Create a new user"""
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = User.create(
name=data.get("username"),
password=data.get("password").encode("ascii", "ignore"),
email=data.get("email", ""),
administrator=data.get("administrator", False),
active=data.get("active", False),
username=request.user.name,
)
messages.add_message(
request,
messages.INFO,
"The user '{}' has been created".format(user.name),
)
return redirect("users:home")
else:
form = UserForm()
ctx = {
"form": form,
}
return render(request, "users/new.html", ctx)
def register(request):
form = UserForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
time = request.POST.get('time', '')
nama = request.POST.get('nama', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
pekerjaan = request.POST.get('pekerjaan', '')
institusi = request.POST.get('institusi', '')
user_obj = User(time=time,
nama=nama,
email=email,
phone=phone,
pekerjaan=pekerjaan,
institusi=institusi)
user_obj.save()
email_subject = 'Registrasi KLAS'
email_body = "Hallo, %s, terimaksih telah mendaftar. Jangan lupa ikuti event Cangkru'an." % (
nama)
send_mail(email_subject, email_body, '*****@*****.**',
[email])
return render(request, 'users/register.html', {
'user_obj': user_obj,
'is_registered': True
})
else:
form = UserForm()
return render(request, 'users/register.html', {'form': form})
def create_user(request):
if request.method== "POST":
form = UserForm(request.POST)
if form.is_valid():
password = get_random_string(length=7)
data = {
'user_name': form.data['user_name'],
'email' : form.data['email'],
'password': password
}
auth = User.objects.create_user(data)
user_profile = UsersProfile()
user_profile.email = form.data['email']
user_profile.user_type = form.data['user_type']
user_profile.user_name = form.data['user_name']
user_profile.user = auth
user_profile.save()
# send_mail(
# 'Customer creation',
# 'Please find the credentials.',
# 'from_email',
# [form.data['email']],
# html_message= 'username :% s' % form.data['user_name'],
# fail_silently=False,
# )
return redirect('/customer_list')
else:
form = UserForm()
return render(request, 'create_user.html', {'form': form})
def addUser(request):
form = UserForm(request.POST)
if form.is_valid():
try:
with transaction.atomic():
enterprise = Enterprise()
enterprise.save()
request.session['idEnterprise'] = enterprise.id
location = Location(enterprise=enterprise,
lat=0,
lng=0,
name='Main Office')
location.save()
user = User(location=location,
email=form.cleaned_data['email'],
password=form.cleaned_data['password'])
user.save()
request.session['idUser'] = user.id
profile = Profile(user=user, role="Administrator")
profile.save()
return render(request, 'users/dashboard.html')
except Exception as e:
print(e)
messages.error(request, 'Sorry, Internal Error')
else:
messages.error(request, 'Please fill the form')
return HttpResponseRedirect('/signup')
def _update(request, user):
was_superuser = user.is_superuser
form = UserForm(instance = user, data = request.PUT)
if form.is_valid():
user = form.save()
# Check if modified user is the last superuser in which case
# his super-user status must remain True
if was_superuser \
and not user.is_superuser \
and not User.objects.filter(is_superuser = True):
message = INFO_MSG%"Au moins un utilisateur doit être super-utilisateur."
request.user.message_set.create( message = message )
user.is_superuser = True
user.save()
# Changes have been made.
message = SUCCESS_MSG % "Modification effectuée avec succès."
request.user.message_set.create( message = message )
if request.user.is_superuser:
return redirect( 'user_collection' )
else:
return redirect( 'user_edit', request.user.id )
else:
message = ERROR_MSG % 'Le formulaire est invalide, veuillez corriger les erreurs suivantes.'
request.user.message_set.create( message = message )
return direct_to_template(request, "users/edit.html", {
'user': user,
'form': form
})
def register(request):
form = UserForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
time = request.POST.get('time', '')
nama = request.POST.get('nama', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
pekerjaan = request.POST.get('pekerjaan', '')
institusi = request.POST.get('institusi', '')
user_obj = User(time=time,
nama=nama,
email=email,
phone=phone,
pekerjaan=pekerjaan,
institusi=institusi)
user_obj.save()
return render(request, 'users/register.html', {
'user_obj': user_obj,
'is_registered': True
})
else:
form = UserForm()
return render(request, 'users/register.html', {'form': form})
def register(request):
Context = RequestContext(request)
if request.method == 'POST': #user bilgilerini girmis kayit ol butonuna basmis.
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()
#registered = True
profile = profile_form.save(commit = False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
return render(request, 'users/register_success.html')
else:
print user_form.errors, profile_form.errors
else: # henuz yeni register ekrani goren user icin
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response(
'users/registration.html',
{'user_form':user_form, 'profile_form':profile_form}, Context)
def post(self, request, *args, **kwargs):
user_form = UserForm(request.POST)
user_profile_form = SignUpProfileForm(request.POST)
if user_form.is_valid() and user_profile_form.is_valid():
user = user_form.save()
user_profile = UserProfile(
user = user,
city = user_profile_form.data['city'],
country = user_profile_form.data['country']
)
try:
user_profile.save()
user = authenticate(
username=user_form.data.get('username'),
password=user_form.data.get('password1')
)
login(self.request, user)
except:
transaction.rollback()
return HttpResponseRedirect(self.success_url)
else:
context = {}
context['user_form'] = user_form
context['user_profile_form'] = user_profile_form
context['cities'] = City.objects.all()
context['countries'] = Country.objects.all()
return self.render_to_response(context)
def login(request):
if request.method == 'GET':
return render(request, 'login.html')
if request.method == 'POST':
# 校验登录页面传递的参数
form = UserForm(request.POST)
# 使用is_valid()判断是否校验成功
if form.is_valid():
# 登录的设置
# 1. 通过用户名和密码获取当前的user对象 ===>> auth.authenticate
user = Users.objects.filter(username=form.cleaned_data['username']).first()
if user:
# 可以通过username获取到对象
# 将 user.password和form.cleaned_data[‘password’]进行校验
if check_password(form.cleaned_data['password'], user.password):
# 校验用户名和密码都成功
# 1. 向cookie中设置随机参数ticket
res = HttpResponseRedirect(reverse('users:index'))
# set_cookie(key, value, max_age='', expires='')
ticket = get_ticekt()
res.set_cookie('ticket', ticket, max_age=1000)
# 2. 向表user_ticket中存这个ticket和user的对应关系
UserTicket.objects.create(user=user, ticket=ticket)
return res
else:
return render(request, 'login.html')
else:
# 登录系统的用户名不存在
return render(request, 'login.html')
# 2. 设置cookie中的随机值 ====>> auth.login()
# 3. 设置user_ticket中的随机值
pass
else:
return render(request, 'login.html')
def update(request, id):
employee = UserModel.objects.get(uid=id)
form = UserForm(request.POST, instance=employee)
if form.is_valid():
form.save()
return redirect("/show")
return Response(status=status.HTTP_200_OK)
def post(self, request):
if request.GET.get('login'):
self.post_login(request)
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user:
if user.is_active:
login(request, user)
return redirect('tasks:index')
return render(request, 'users/login.html', {'user_form': UserForm(), 'profile_form': ProfileForm()})
else:
user_form = UserForm(data=request.POST)
profile_form = ProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
with atomic():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.creating = True
profile.updating = True
thread = Thread()
thread.save()
profile.thread = thread
profile.save()
login(request, user)
return redirect('tasks:index')
else:
return render(request, 'users/login.html', {'user_form':user_form, 'profile_form': profile_form})
def user_login(request):
post = request.POST.copy()
if request.method == 'POST':
post['username'] = post['username'].lower()
email = post['username']
first_name = post['first_name']
form = UserForm(post)
user_profile_form = UserProfileForm(post)
if email and first_name:
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
if form.is_valid():
user = form.save(commit=False)
user.set_password(user.username)
user = form.save()
user = authenticate(username=email, password=email)
if user is not None:
if user.is_active:
login(request, user)
# FIXME
post['user'] = user.id
user_profile_form = UserProfileForm(post)
if user_profile_form.is_valid():
try:
profile = user.get_profile()
except:
aux = UserProfile.objects
profile, created = aux.get_or_create(user=user)
newsletter = user_profile_form.clean()['newsletter']
profile.newsletter = newsletter
profile.save()
try:
spectacle = Spectacle.objects.get(status=True)
if spectacle.mode == SPECTACLE_MODE_EASY or \
spectacle.mode == SPECTACLE_MODE_RESET:
url = spectacle.get_easy_show_url()
else:
url = spectacle.get_hard_show_url()
return HttpResponseRedirect(url)
except Spectacle.MultipleObjectsReturned:
msg = '<h1>%s</h1>' % _('Spectacle not found')
return HttpResponseNotFound(msg)
else:
form = UserForm()
user_profile_form = UserProfileForm()
c = { 'form':form, 'user_profile_form':user_profile_form }
return render(request, 'login.html', c)
def test_user_form_valid(self):
form = UserForm(
data={
'username': '******',
'password': '******',
'password_confirm': 'temporary'
})
self.assertTrue(form.is_valid())
def signup(request):
form=UserForm(request.POST or None)
if form.is_valid():
save_it=form.save(commit=False)
save_it.save()
messages.success(request,'Thank you for Joining us')
return HttpResponseRedirect('/signup/')
return render_to_response("signup.html",locals(),context_instance=RequestContext(request))
def test_codename_visibility(self):
# Show for staff
self.assertIn('codename',
UserForm(instance=UserFactory(is_staff=True)).fields)
# Non-show for non-staff
self.assertNotIn('codename',
UserForm(instance=UserFactory(is_staff=False)).fields)
# Non show for new object
self.assertNotIn('codename', UserForm().fields)
def register(request):
context = RequestContext(request)
# Set boolean to false
registered = False
# if request is post
if request.method == 'POST':
# Initialize forms to collect user data
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# create user and userprofile classes to add data
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
# retrieve profile registration information
if 'first name' in request.FILES:
profile.fistName = request.FILES['first name']
if 'last name' in request.FILES:
profile.lastName = request.FILES['last name']
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
if 'school' in request.FILES:
profile.school = request.FILES['school']
if 'are you a teacher?' in request.FILES:
profile.isTeacher = request.FILES['are you a teacher?']
profile.save()
registered = True
# logs you in if your registration details check out
user = authenticate(username=request.POST['username'], password=request.POST['password'])
login(request, user)
return HttpResponseRedirect('/forum/')
else:
print user_form.errors, profile_form.errors
# if request is not post
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render_to_response(
'users/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered},
context)
def post(self, request):
new_user = UserForm(request.POST)
if new_user.is_valid():
hashed = make_password(request.POST['password'])
user = User(username=request.POST['username'], password=hashed)
user.save()
request.session['user_id'] = user.id
return redirect('/characters/')
return redirect('/users/')
def registration(request):
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(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
# 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.
user = user_form.save(commit=False)
# Now we hash the password with the set_password method.
user.set_password(user.password)
profile = profile_form.save(commit=False)
# 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 'avatar' in request.FILES:
profile.avatar = request.FILES['avatar']
# Now we save the UserProfile and User model instance.
user.save()
profile.user = user
profile.save()
# Update our variable to tell the template registration was successful.
messages.success(request, _('Registration successful, you can log in.'))
return HttpResponseRedirect(reverse('users:login'))
# 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( 'users/registration.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context)
def create(request):
form = UserForm(request.POST)
if form.is_valid():
user = form.save()
return JsonResponse({
'success': True,
'chat ID': user.id
})
return JsonResponse({'errors': form.errors}, status=400)
def user_edit(request, pk):
form = UserForm(request.POST or None, instance=User.get(pk))
if form.is_valid():
obj = form.save(commit=False)
obj.save()
return HttpResponseRedirect(reverse("user-list"))
return direct_to_template(request, "user_edit.html", extra_context={
"form": form,
"nav": {"selected": "users",},
})
def post(self,request):
submitted_form = UserForm(request.POST)
username = submitted_form._raw_value('username')
password = submitted_form._raw_value('password')
authenticated_user = authenticate(username=username, password=password)
if authenticated_user:
login(request,authenticated_user)
auth_user = User.objects.filter(username=authenticated_user)[0]
return redirect('interface:profile', username = auth_user.username)
return redirect('interface:login')
def post(self, request):
username = request.POST["username"]
encoded = Hasher.make_password(request.POST["password"])
data = {'username':username, 'password':encoded}
form = UserForm(data)
if form.is_valid():
new_user = User(**data)
new_user.save()
request.session['user_id'] = new_user.id
return redirect("/welcome/")
return redirect("/")
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('home')
context = {'form': form}
return render(request, 'users/new_user.html', context)
def create_user(request):
if "POST" == request.method:
form = UserForm(request.POST)
if form.is_valid():
new_user = form.save()
return JsonResponse({
'msg': 'Пользователь создан',
'id': new_user.id,
})
return JsonResponse({'errors': form.errors}, status=400)
return HttpResponseNotAllowed(['POST'])
def user_form(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
user_name = form.cleaned_data['user_name']
password = form.cleaned_data['password']
User.objects.create_user(user_name, password)
return HttpResponseRedirect('../')
else:
form = UserForm()
return render(request, 'users/login_or_register.html', {'form': form})
def join(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
if user_form.is_valid():
User.objects.create_user(**user_form.cleaned_data)
return redirect('/')
else:
user_form = UserForm()
return render(request, 'join.html', {'user_form': user_form})
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
return redirect('/users/login/?error={}'.format(
"signup a success! now please login"))
else:
return render(
request, 'users/create.html', {
'error': "Not a valid name or password",
'form': UserForm(request.POST)
})
def scrape_diesel(request):
# POSTメソッドだけでリクエストしてくる想定
form = UserForm(request.POST)
form.is_valid() # エラーを出さない想定
if not auth_user(form.cleaned_data['user_id'],
form.cleaned_data['password']):
return "正しいユーザーIDとパスワードを送ってください"
url = "https://www.dressinn.com/%E3%83%95%E3%82%A1%E3%83%83%E3%82%B7%E3%83%A7%E3%83%B3/diesel/303/mm"
json_obj = scrape_popular_items(url)
return HttpResponse(json_obj, content_type='application/json')
def post(self, request):
uform = UserForm(data=request.POST)
if uform.is_valid():
user = uform.save()
user.set_password(user.password)
user.save()
self.registered = True
else:
print uform.errors
context = self.get_context_data()
context['registered'] = self.registered
return render(request, self.template_name, context)
def profile(request):
form = UserForm(request.POST or None,
request.FILES or None,
instance=request.user)
args = {}
args['form'] = form
args['article'] = Article.objects.all()
if request.method == 'POST':
if form.is_valid():
form.save()
return redirect('users:profile')
return render(request, 'profile.html', args)
def register(request):
# Initial value set to False. Code changes value to True when registration succeeds.
registered = False
if request.method == 'POST':
# Get form information.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
picture_form = PictureForm(data=request.POST)
# If the forms are valid
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Hash the password with the set_password method.
user.set_password(user.password)
user.save()
# Sort out the UserProfile instance.
profile = profile_form.save(commit=False)
image = picture_form.save(commit=False)
profile.user_extended = user
image.user = user
# User provides a photo
if 'file' in request.FILES:
image.file = request.FILES['file']
# Save the UserProfile model instance.
profile.save()
image.save()
# Update our variable to tell the template registration was successful.
registered = True
return HttpResponseRedirect('/login/')
# Print problems to the terminal, show to the user.
else:
print(user_form.errors, profile_form.errors)
# Blank forms, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
picture_form = PictureForm()
# Render the template depending on the context.
return render(request,
'register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered,
'picture_form': picture_form} )
def post(self, request, *args, **kwargs):
from users.forms import UserForm
self.form = UserForm(request.POST,
request.FILES,
instance=request.user)
if request.is_ajax() and self.form.is_valid():
self.form.save()
photo_input = request.FILES.get('s_avatar')
if photo_input:
request.user.create_s_avatar(photo_input)
return HttpResponse()
return super(UserProfileSettings, self).post(request, *args, **kwargs)
def post(self,request):
submitted_form = UserForm(request.POST)
print(submitted_form)
if submitted_form.is_valid():
username = submitted_form.cleaned_data.get('username')
submitted_password = submitted_form.cleaned_data.get('password')
password = make_password(submitted_password)
new_user = User(username=username,password=password)
new_user.save()
request.session.flush()
request.session['user_id'] = new_user.id
return redirect('/trivia')
return render(request,self.template,{'error':'Invalid input, please try again (password must be at least 7 characters long).', 'user_form':self.empty_form})
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.set_password(form.cleaned_data['password'])
new_user.save()
return redirect('post_list')
else:
message = "Se ha producido un error"
context = {"form": form, "message": message}
return render(request, 'register.html', context)
def user_edit(request, pk):
user = User.get(pk)
form = UserForm(request.POST or None, instance=user)
profile = ProfileForm(request.POST or None, instance=get_profile(user))
if form.is_valid() and profile.is_valid():
form.save()
profile.save()
return HttpResponseRedirect(reverse("user-list"))
return direct_to_template(request, "user_edit.html", extra_context={
"form": form,
"profile": profile,
"nav": {"selected": "users",},
})
def post(self,request):
submitted_form = UserForm(request.POST)
if submitted_form.is_valid():
submitted_username = submitted_form.cleaned_data.get('username')
submitted_password = submitted_form.cleaned_data.get('password')
new_user = User.objects.create_user(username = submitted_username, password = submitted_password)
if new_user:
new_user_profile = UserProfile(user=new_user)
new_user_profile.save()
authenticated_user = authenticate(username=submitted_username,password=submitted_password)
login(request,authenticated_user)
return redirect('interface:profile', username = new_user.username)
return redirect('interface:register')
def registration(request):
form = None
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse_lazy('user_profile'))
else:
form = UserForm()
return render(request, 'user/registration.html', {'form': form})
def post(self,request):
submitted_form = UserForm(request.POST)
if request.session.get('_auth_user_id'):
active_user_id = int(request.session.get('_auth_user_id'))
if submitted_form.is_valid():
username = submitted_form.cleaned_data.get('username')
submitted_password = submitted_form.cleaned_data.get('password')
new_user = User.objects.create_user(username = username, password = submitted_password)
new_user_profile = UserProfile(user=new_user)
new_user_profile.save()
authorized_user = authenticate(username=username,password=submitted_password)
login(request,authorized_user)
return redirect('/users/{}/'.format(authorized_user.username))
return render(request,self.template,{'error':'Invalid input, please try again', 'user_form':self.empty_form})
def test_user_form(self):
"""Test the combined User and SystersUser form"""
form = UserForm(instance=self.user)
self.assertEqual(type(form.systers_user_form), SystersUserForm)
data = {'first_name': 'Foo',
'last_name': 'Bar',
'blog_url': 'http://example.com/'}
form = UserForm(data=data, instance=self.user)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(self.user.first_name, 'Foo')
self.assertEqual(self.user.last_name, 'Bar')
systers_user = SystersUser.objects.get(user=self.user)
self.assertEqual(systers_user.blog_url, 'http://example.com/')
def register(request):
#Get the request context
context = RequestContext(request)
#Registration success/failure boolean
registered = False
#If HTTP POST, process form
if request.method == 'POST':
#Grab raw data from UserForm and UserProfileForm
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
#If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
#Save the user's form data to the database
user = user_form.save()
#Hash the password and update the user object
user.set_password(user.password)
user.save()
#Save UserProfile data
profile = profile_form.save(commit=False)
profile.user = user
#Did the user provide a profile image
if 'profile_image' in request.FILES:
profile.profile_image = request.FILES['profile_image']
#Save the UserProfile model instance
profile.save()
#Set registration boolean to true
registered = True
#Invalid forms?
else:
print(user_form.errors, profile_form.errors)
#Not a HTTP POST? Render blank forms
else:
user_form = UserForm()
profile_form = UserProfileForm()
#Render the template
return render_to_response(
'users/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered':registered},
context)
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
new_user = User()
new_user.first_name = form.cleaned_data.get('first_name')
new_user.last_name = form.cleaned_data.get('last_name')
new_user.username = form.cleaned_data.get('username')
new_user.email = form.cleaned_data.get('email')
new_user.set_password(form.cleaned_data.get('password'))
new_user.save()
messages.success(request, 'User {0} created successfully!'.format(new_user.username))
form = UserForm()
return render(request, 'users/new_user.html', {'form': form})
