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 register(request):
res = create_exception(
request, __name__, exception="unknown request method")
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
user_obj = form.save()
user_obj.first_name = user_obj.first_name.capitalize()
user_obj.last_name = user_obj.last_name.capitalize()
username = user_obj.first_name.lower(
)[0] + user_obj.last_name.lower() + str(randint(1, 10000))
user_obj.username = username
user_details_obj = Personal_Info(username=username, date_of_birth=form.cleaned_data['date_of_birth'],
pin_code=form.cleaned_data['pin_code'], address=form.cleaned_data['address'],
city=form.cleaned_data['city'], email_verified=False)
try:
user_obj.save()
user_details_obj.save()
print("{} : {} {} added".format(
username, user_obj.first_name, user_obj.last_name))
except Exception as e:
print(e)
res = create_exception(request, __name__, exception=e)
else:
res = redirect('dashboard')
else:
res = create_exception(request, __name__, str(
ValueError("form data in request not valid")))
elif request.method == "GET":
empty_form = UserForm()
res = render(request, "users/register.html", {"form": empty_form, "helper": empty_form.get_helper()})
return res
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 cadastro(request):
if request.method == 'POST':
form = UserForm(request.POST)
form_perfil = PerfilForm(request.POST)
print(form_perfil.is_valid())
if form.is_valid() and form_perfil.is_valid():
user = form.save()
perfil = form_perfil.save(commit=False)
perfil.user = user
perfil.save()
email = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
user = authenticate(username=email, password=password)
auth_login(request, user)
return redirect('/')
else:
form = UserForm(request.POST)
form_perfil = PerfilForm(request.POST)
contexto = {
'form': form,
'form_perfil': form_perfil,
}
return render(request, 'cadastro.html', contexto)
def settings(request):
usr = request.user
form = UserForm(instance=usr)
try:
pno = usr.contactdetails
# print(pno, usr.contactdetails)
pform = UpdatePhoneNo(instance=pno)
except:
pno = None
pform = UpdatePhoneNo()
if request.method == 'POST':
pform = UpdatePhoneNo(data=request.POST, instance=pno)
form = UserForm(data=request.POST, instance=usr)
if pform.is_valid():
p_obj = pform.save(commit=False)
p_obj.user = request.user
p_obj.save()
if form.is_valid():
form.save()
return render(request, 'users/settings.html', locals())
else:
return render(request, 'users/settings.html', locals())
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)
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 post(self,request):
user = User()
form = UserForm(data=request.POST)
form.instance = user
if form.is_valid():
user.first_name = form.cleaned_data.get('first_name')
user.last_name = form.cleaned_data.get('last_name')
user.email = form.cleaned_data.get('email')
user.username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user.set_password(password)
user.save()
blog = Blog(user=user)
blog.name = form.cleaned_data.get('blog_name')
blog.description = form.cleaned_data.get('blog_description')
blog.save()
# logeamos al usaurio
authenticate_user = authenticate(username=user.username, password=password)
django_login(request, authenticate_user)
# vaciamos el formulario
form = UserForm()
url = reverse("create_post")
message = "User with blog created successfully!"
message += '<a href="{0}">Create you first post</a>'.format(url)
# enviamos mensaje de exito con un enlace al blog que acabamos de crear
messages.success(request, message)
return render(request, "singup_form.html", {'form': form})
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 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 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 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 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 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 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 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
return render(request, 'login.html', {})
else:
print(user_form.errors)
else:
user_form = UserForm()
# Render the template depending on the context.
return render(request, 'register.html', {
'user_form': user_form,
'registered': registered
})
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 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 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 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 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 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 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 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(request):
registed = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
custom_form = CustomUserForm(data=request.POST)
if user_form.is_valid() and custom_form.is_valid():
user = user_form.save()
user.save()
custom = custom_form.save(commit=False)
custom.user = user
custom.save()
registed = True
return HttpResponseRedirect(reverse('login'))
else:
print(user_form.errors, custom_form.errors)
else:
user_form = UserForm()
custom_form = CustomUserForm
return render(request, 'users/register.html', {
'registed': registed,
'user_form': user_form,
'custom_form': custom_form
})
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 register_customer(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
customer_form = CustomerForm(data=request.POST)
if user_form.is_valid() and customer_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
customer = customer_form.save(commit=False)
customer.user = user
customer.save()
registered = True
else:
print(user_form.errors, customer_form.errors)
else:
user_form = UserForm()
customer_form = CustomerForm()
return render(
request, 'users/register_customer.html', {
'user_form': user_form,
'customer_form': customer_form,
'registered': registered
})
def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
u = user_form.save()
u.set_password(request.POST['password'])
u.save()
Profile.objects.get_or_create(
user=u,
position=request.POST.get('position'),
phone=request.POST.get('phone'),
address=request.POST.get('address'),
birth_date=request.POST.get('birth_date'),
joined_date=request.POST.get('joined_date'),
image=request.FILES.get('image'))
# profile_form.save()
messages.success(request,
('Your profile was successfully updated!'))
return redirect('core:main_dashboard')
else:
messages.error(request, ('Please correct the error below.'))
else:
user_form = UserForm()
profile_form = ProfileForm()
# user_form = UserForm(instance=request.user)
# profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'core/register_new_member.html', {
'user_form': user_form,
'profile_form': profile_form
})
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):
""" Register a new user """
# Set registered to false by default
registered = False
if request.method != 'POST': # This SHOULD always be post
form = UserForm()
account_form = UserAccountForm()
else:
form = UserForm(data=request.POST)
account_form = UserAccountForm(data=request.POST)
if form.is_valid() and account_form.is_valid():
new_user = form.save()
new_user.set_password(new_user.password)
new_user.save()
account = account_form.save(commit=False)
account.user = new_user
account.save()
registered = True
login(request, new_user)
return redirect('book_keeping:index')
else:
print(form.errors, account_form.errors)
context = {
'form': form,
'account_form': account_form,
'registered': registered
}
return render(request, 'users/register.html', 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 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 register(request):
if request.method == 'POST':
form = UserForm(request.POST)
# print(form.errors.as_data())
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
pwd = form.cleaned_data['password']
user.set_password(pwd)
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'users/activatemail.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.id)),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return HttpResponse(
'Please confirm your email address to complete the registration'
)
else:
form = UserForm()
return render(request, 'users/registration.html', {'user_form': form})
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 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 SignUp(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(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 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered=True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(request, 'signup.html',{'user_form':user_form,'profile_form':profile_form, 'registered':registered})
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 accept_invite(request, token):
invite = get_object_or_404(Invite, token=token)
if not invite.is_tokened:
invite.is_tokened = True
invite.save()
user = User.objects.filter(email=invite.email)
if user.exists():
_create_event_member(user[0], invite.event)
login(request, user[0])
return redirect('post_details', invite.event.id)
else:
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
password = form.cleaned_data['password']
email = form.cleaned_data['email']
member = form.save()
_create_event_member(member, invite.event)
user = authenticate(email=email, password=password)
if user is not None:
login(request, user)
return redirect('post_details', invite.event.id)
return render(request, 'users/signup.html', {'form': form})
else:
raise Http404("Token does not exist")
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 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):
activate(request.LANGUAGE_CODE)
if not isinstance(request.user, models.AnonymousUser):
logout(request)
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserExtendedForm(data=request.POST)
user_tz = request.POST.get('timezone')
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
profile = profile_form.save(commit=False)
profile.user = user
if user_tz:
profile.timezone = user_tz
try:
profile.save()
except:
raise ValidationError("Can't save user to the database!")
user.save()
return HttpResponseRedirect(reverse('users:login'))
else:
user_form = UserForm()
profile_form = UserExtendedForm()
return render(
request, 'users/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'timezones': pytz.common_timezones,
'def_timezone': settings.DEF_USER['timezone']
})
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 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 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 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 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 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):
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 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 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 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 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 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):
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 reg_page(request):
c = get_common_context(request)
if request.method == 'GET':
client_form = ClientForm()
profile_form = ProfileForm()
user_form = UserForm()
elif request.method == 'POST':
client_form = ClientForm(request.POST)
profile_form = ProfileForm(request.POST)
user_form = UserForm(request.POST)
if request.POST.get('confirm', None) is None:
user_form.errors['confirm'] = ErrorList([u'Необходимо согласиться с договором.'])
elif user_form.data['passwd1'] != user_form.data['passwd2']:
user_form.errors['passwd1'] = ErrorList([u'Пароли не совпадают.'])
elif not user_form.data['email']:
user_form.errors['email'] = ErrorList([u'Обязательное поле.'])
elif client_form.is_valid() and profile_form.is_valid() and user_form.is_valid():
try:
u = auth.models.User(username=user_form.data['email'],
email=user_form.data['email'],
first_name=user_form.data['first_name'],
)
u.save()
u.set_password(user_form.data['passwd1'])
u.save()
except:
u = None
user_form.errors['email'] = ErrorList([u'Пользователь с таким email уже существует'])
if u: # user saved, all is right
p = u.get_profile()
p.phone = profile_form.data['phone']
p.work_phone=profile_form.data['work_phone']
p.qiwi=profile_form.data['qiwi']
p.user = u
p.type = 'c'
p.save()
Client.add(u, client_form.data['name'])
user = auth.authenticate(username=user_form.data['email'], password=user_form.data['passwd1'])
auth.login(request, user)
messages.success(request, u'Вы успешно зарегистрировались в системе в качестве клиента.')
return HttpResponseRedirect('/cabinet')
c['client_form'] = client_form
c['profile_form'] = profile_form
c['user_form'] = user_form
return render_to_response('client/reg.html', c, context_instance=RequestContext(request))
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 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 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/')