def register_user(request):
template_name = 'kitchen/crispy.html'
if request.method == 'POST':
user_form = UserCreateForm(request.POST)
if user_form.is_valid():
username = user_form.clean_username()
password = user_form.clean_password2()
user_form.save()
user = authenticate(username=username, password=password)
if user:
# save extra parameters - email
user.email = user_form.data['email']
user.save()
#ASK - may be we should init it only in one place - on login?
initUser(user)
login(request, user)
return redirect('account-list')
return render(request, template_name, {'form': user_form})
args = {}
args.update(csrf(request))
args['form'] = UserCreateForm()
print args
return render(request, template_name, args)
def create_account(request):
if request.method == "POST":
form = UserCreateForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/success/')
else:
form = UserCreateForm()
return render(request, 'create.html', {'form': form})
def registration(request):
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect("/portal/")
else:
form = UserCreateForm()
return render(request, "registration/register.html", {
'form': form,
})
def register_user(request):
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
user = form.save()
return HttpResponse("yeah!")
else:
form = UserCreateForm()
return render(request, 'trainer/register.html', {'form': form})
def create_account(request):
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
new_user = form.save()
p = UserProfile(user=new_user)
p.save()
return HttpResponseRedirect('/create-account/success')
else:
form = UserCreateForm()
return render(request, 'homepage/create-account.html', {'form': form})
def register(request):
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect("/importinfo/")
else:
form = UserCreateForm()
return render_to_response("registration/register.html", {
'form': form,
},
context_instance=RequestContext(request))
def signup():
form = UserCreateForm()
if request.method == 'POST' and form.validate_on_submit():
request_data = {
'group': form.group.data,
'name': form.name.data,
'email': form.email.data,
'password': generate_password_hash(form.password1.data)
}
collection = db['users']
user_data = collection.find_one(
filter={'email': request_data['email']})
if user_data:
flash('이미 존재하는 사용자입니다.')
else:
user_data = collection.find_one(
filter={'group': request_data['group']})
request_data['admin'] = False
if user_data is None:
request_data['admin'] = True
user_data = collection.find_one(sort=[('create_time', -1)])
if user_data:
user_id = user_data['user_id'] + 1
else:
user_id = 1
request_data['create_time'] = str(datetime.now())
request_data['user_id'] = user_id
collection.insert(request_data)
return redirect(url_for('main.index'))
return render_template('/signup.html', form=form)
def create_user(request):
if request.POST:
user_form = UserCreateForm(request.POST)
if user_form.is_valid():
username = user_form.clean_username()
password = user_form.clean_password2()
user_form.save()
user = authenticate(username=username, password=password)
login(request, user)
request.session["notice"] = "User successfully logged in"
return HttpResponseRedirect("/")
else:
user_form = UserCreateForm()
return render_to_response('users/create_user.html',
{'user_form': user_form},
context_instance=RequestContext(request))
def create(request):
form = UserCreateForm(request.POST or None)
if form.is_valid():
form.save()
context = {
"forms": form,
}
return render(request,"home.html",context)
def create_user(self, version=0):
"""
Creates a UserProfile. Version is an integer that determines which userprofile to generate (one of two)
"""
registration_values = self.create_valid_user_vals(version)
user_form = UserCreateForm(registration_values)
if user_form.is_valid():
return user_form.save()
def post(self):
form = UserCreateForm()
if not form.validate_on_submit():
return form.errors, 422
user = User(form.email.data, form.password.data)
db.session.add(user)
db.session.commit()
return UserSerializer(user).data
def signup(request, template_name="registration/signup.html"):
if request.user.is_authenticated():
messages.warning(request, 'Logout to create a new user')
return redirect('/')
else:
form = UserCreateForm(request.POST or None)
if form.is_valid():
form.save()
messages.success(request,
'User Account Created. Please proceed to login.')
return redirect('/login/')
return render(request, template_name, {'form': form})
def index():
form = UserCreateForm()
if form.validate_on_submit():
if not form.validate_on_submit():
return form.errors, 422
user = User(form.email.data, form.password.data)
db.session.add(user)
db.session.commit()
return render_template('index.html', form=form)
def register(request):
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
u = form.save()
c = Country.objects.get(user=u)
b = Build(country=c)
b.save()
a = Army(country=c)
a.save()
t = Tech(country=c)
t.save()
r = Resource(country=c)
r.save()
return HttpResponseRedirect('/kotw/')
else:
form = UserCreateForm()
return render_to_response('form.html', {
'page_title': title,
'page_css': css,
'register_form': form
},
context_instance=RequestContext(request))
def sign_up(request, user_form=None, incomplete_form=None):
if request.method == 'POST' and incomplete_form is None:
user_form = UserCreateForm(data=request.POST)
if user_form.is_valid():
max_username = User.objects.all().aggregate(
Max('username'))['username__max']
if (max_username != None and max_username != 'admin'):
temp = 'ID00' + str(int(max_username[2:]) + 1)
else:
temp = 'ID001001'
user_form.cleaned_data['card_no'] = temp
user_form.cleaned_data['username'] = temp
password = user_form.clean_password2()
user_form.save()
user = authenticate(username=temp, password=password)
login(request, user)
return redirect('/')
else:
messages.error(request, "Form invalid")
return sign_up(request, user_form=user_form, incomplete_form=True)
if incomplete_form is None or not incomplete_form:
user_form = UserCreateForm()
return render(request, 'sign_up.html', {'user_form': user_form})
def sign_up(request):
if request.user.is_authenticated():
return redirect('app_events')
form = UserCreateForm(data=request.POST.copy() or None)
if form.is_bound and form.is_valid() and form.save():
messages.success(
request, _(u'Thank you for registering. You are now logged in.'))
login(
request,
authenticate(username=request.POST['username'],
password=request.POST['password1']))
return redirect('app_events')
return direct_to_template(request, 'auth/sign_up.html', {'form': form})
def joinus():
form = UserCreateForm()
if request.method == 'POST':
user = db.member.find_one({'id': form.userid.data})
if not user:
user = {
'id' : form.userid.data,
'password' : generate_password_hash(form.password1.data),
'name': form.name.data,
'email' : form.email.data,
'is_student' : form.is_student.data,
'department' : form.department.data
}
print(user)
db.member.insert_one(user)
return redirect(url_for('login'))
else:
flash('이미 존재하는 사용자입니다')
return render_template('joinus.html', form=form)
def user_add(request):
ad_suffix = GVSIGOL_LDAP['AD']
if not ad_suffix:
show_pass_form = True
else:
show_pass_form = False
if request.method == 'POST':
form = UserCreateForm(request.POST)
if form.is_valid():
assigned_groups = []
is_staff = False
if 'is_staff' in form.data:
is_staff = True
is_superuser = False
if 'is_superuser' in form.data:
is_superuser = True
is_staff = True
assigned_groups = []
for key in form.data:
if 'group-' in key:
assigned_groups.append(int(key.split('-')[1]))
try:
if form.data['password1'] == form.data['password2']:
user = User(username=form.data['username'].lower(),
first_name=u''.join(
form.data['first_name']).encode('utf-8'),
last_name=u''.join(
form.data['last_name']).encode('utf-8'),
email=form.data['email'].lower(),
is_superuser=is_superuser,
is_staff=is_staff)
user.set_password(form.data['password1'])
user.save()
#admin_group = UserGroup.objects.get(name__exact='admin')
aux = UserGroup.objects.filter(name="admin")
if aux.count() > 1:
print "WARNING: table gvsigol_auth_usergroup inconsistent !!!!!!!!!!!"
admin_group = aux[0]
if user.is_superuser:
core_services.ldap_add_user(user,
form.data['password1'],
True)
core_services.ldap_add_group_member(user, admin_group)
usergroup_user = UserGroupUser(user=user,
user_group=admin_group)
usergroup_user.save()
else:
core_services.ldap_add_user(user,
form.data['password1'],
False)
#core_services.ldap_add_group_member(user, admin_group)
for ag in assigned_groups:
user_group = UserGroup.objects.get(id=ag)
usergroup_user = UserGroupUser(user=user,
user_group=user_group)
usergroup_user.save()
core_services.ldap_add_group_member(user, user_group)
#User backend
if is_superuser or is_staff:
ugroup = UserGroup(
name='ug_' + form.data['username'].lower(),
description=_(u'User group for') + ': ' +
form.data['username'].lower())
ugroup.save()
ugroup_user = UserGroupUser(user=user,
user_group=ugroup)
ugroup_user.save()
core_services.ldap_add_group(ugroup)
core_services.add_data_directory(ugroup)
core_services.ldap_add_group_member(user, ugroup)
url = mapservice_backend.getBaseUrl() + '/'
ws_name = 'ws_' + form.data['username'].lower()
if mapservice_backend.createWorkspace(
ws_name, url + ws_name, '',
url + ws_name + '/wms', url + ws_name + '/wfs',
url + ws_name + '/wcs',
url + 'gwc/service/wms'):
# save it on DB if successfully created
newWs = Workspace(
name=ws_name,
description='',
uri=url + ws_name,
wms_endpoint=url + ws_name + '/wms',
wfs_endpoint=url + ws_name + '/wfs',
wcs_endpoint=url + ws_name + '/wcs',
cache_endpoint=url + 'gwc/service/wms',
created_by=user.username,
is_public=False)
newWs.save()
ds_name = 'ds_' + form.data['username'].lower()
services_utils.create_datastore(
request, user.username, ds_name, newWs)
mapservice_backend.reload_nodes()
auth_utils.sendMail(user, form.data['password1'])
return redirect('user_list')
except Exception as e:
print "ERROR: Problem creating user " + str(e)
errors = []
#errors.append({'message': _("The username already exists")})
groups = auth_utils.get_all_groups()
return render_to_response(
'user_add.html', {
'form': form,
'groups': groups,
'errors': errors,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
else:
groups = auth_utils.get_all_groups()
return render_to_response('user_add.html', {
'form': form,
'groups': groups,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
else:
form = UserCreateForm()
groups = auth_utils.get_all_groups()
return render_to_response('user_add.html', {
'form': form,
'groups': groups,
'show_pass_form': show_pass_form
},
context_instance=RequestContext(request))
def register(request):
if request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
user_information = {
'username': request.POST['username'],
'password1': request.POST['password1'],
'password2': request.POST['password2'],
'last_name': request.POST['last_name'],
'city': request.POST['city'],
'first_name': request.POST['first_name'],
'state': request.POST['state'],
'middle_initial': request.POST['middle_initial'],
'birth_date': request.POST['birth_date'],
'email': request.POST['email'],
'street_address': request.POST['street_address'],
'zip_code': request.POST['zip_code']
}
form = UserCreateForm(user_information)
if form.is_valid():
form.save()
return redirect('/')
else:
form_errors = form.errors
return render_to_response('register.html', {
'errors': form_errors,
'form': form
},
context_instance=RequestContext(request))
else: #AJAX form validation
request_copy = request.GET.copy()
if 'username' in request_copy: #Username in use?
name = request_copy['username']
response_data = {}
if UserProfile.objects.filter(username__iexact=name):
response_data['result'] = 'false'
else:
response_data['result'] = 'true'
return HttpResponse(response_data['result'],
content_type='text/plain')
# return HttpResponse(json.dumps(response_data), content_type = "application/json")
if 'email' in request_copy: #Email in use?
entered_email = request_copy['email']
response_data = {}
if UserProfile.objects.filter(email__iexact=entered_email):
response_data['result'] = 'false'
else:
response_data['result'] = 'true'
return HttpResponse(response_data['result'],
content_type='text/plain')
else:
form = UserCreateForm()
return render_to_response("register.html", {
'form': form,
'errors': form.errors
},
context_instance=RequestContext(request))
def test_form_should_validate_correctly(self):
self.assertFalse(UserCreateForm(self.invalid_user).is_valid())
self.assertTrue(UserCreateForm(self.valid_user).is_valid())
