def register(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
# Create a new user object but avoid saving it yet
new_user = form.save(commit=False)
# Set the chosen password
new_user.set_password(form.cleaned_data['password'])
# Save the User object
new_user.save()
profile = Profile(user=new_user)
profile.save()
# 記錄系統事件
if is_event_open(request):
log = Log(user_id=new_user.id, event='註冊帳號成功')
log.save()
# create Message
title = "請洽詢任課教師課程名稱及選課密碼"
url = "/student/classroom/add"
message = Message.create(title=title, url=url, time=timezone.now())
message.save()
# message for group member
messagepoll = MessagePoll.create(message_id=message.id,
reader_id=new_user.id)
messagepoll.save()
return render(request, 'account/register_done.html',
{'new_user': new_user})
else:
form = UserRegistrationForm()
return render(request, 'account/register.html', {'form': form})
def user_register(request, template_name="users/user_registration.html"):
registration_form = UserRegistrationForm()
if request.method == 'POST':
registration_form = UserRegistrationForm(request.POST)
if registration_form.is_valid():
user = registration_form.save()
# generate random activation code
random.seed()
code = random.getrandbits(128)
activation = UserActivationCode(user=user, code=code)
activation.save()
code_url = reverse('user_activation', args=[code])
activation_url = "http://%s%s" % (settings.SITE_DOMAIN, code_url)
send_mail(ACTIVATION_MAIL_SUBJECT,
ACTIVATION_MAIL_CONTENT % activation_url,
settings.ACTIVATION_FROM_EMAIL, [user.email])
return direct_to_template(request,
"users/user_registration_confirm.html")
extra_context = {
'registration_form': registration_form
}
return direct_to_template(request, template_name,
extra_context=extra_context)
def register(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
form.save()
user = auth.authenticate(email=request.POST.get('email'),
password=request.POST.get('password1'))
if user:
auth.login(request, user)
messages.success(request, "You have successfully registered")
return redirect(reverse('profile'))
else:
messages.error(request, "unable to log you in at this time!")
else:
today = datetime.date.today()
form = UserRegistrationForm()
args = {'form': form}
args.update(csrf(request))
return render(request, 'register.html', args)
def add_user(request):
username = request.POST.get("username")
email = request.POST.get("emailid")
password = request.POST.get("password")
fname = request.POST.get("fname")
lname = request.POST.get("lname")
address = request.POST.get("address")
phone = request.POST.get("phone")
tech = request.POST.get("tech")
print('.........address........', address)
if request.method == 'GET':
print('get here')
form = UserRegistrationForm() # object creation
else:
print('form in post')
form = UserRegistrationForm(request.POST)
if form.is_valid():
print('user registration from valid')
user = User.objects.create_user(username, email, password)
user.first_name = fname
user.last_name = lname
user.save()
a = UserProfile(user_id=user.id,
address=address,
phone=phone,
tech=tech)
a.save()
print('saved')
return HttpResponseRedirect('/homepage/')
return render(request, 'registration.html', {
'form': form,
})
def registration_view(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
userprofile_form = UserProfileRegistrationForm(request.POST)
if user_form.is_valid() and userprofile_form.is_valid():
user = user_form.save(commit=False)
user.is_active = False
new_profile = userprofile_form.save(commit=False)
#attempt = try_user_sending(request, u'Невозможно завершить регистрацию', settings.STORAGE_CREATE_USER_HOST,
# user=user)
#if attempt: # if something went wrong
# return attempt
user.save()
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt + user.email).hexdigest()
new_profile.user = user
new_profile.activation_key = activation_key
activation_link = u'{}/accounts/confirm/{}'.format(request.get_host(), activation_key)
email_subject = '[Томограф] Подтверждение регистрации'
email_body = u"Приветствуем Вас на сайте Robo-Tom, {}!\n\
Для активации аккаунта пройдите по следующей ссылке: {}".format(user.username, activation_link)
try:
send_mail(email_subject, email_body, '*****@*****.**',
[user.email], fail_silently=False)
except BaseException as e:
import traceback
main_logger.error(traceback.print_exc())
main_logger.error(e)
messages.warning(request,
'Произошла ошибка при отправке письма о подтверждении регистрации. Попробуйте \
зарегистрироваться повторно, указав корректный email')
else:
messages.success(request,
'На указанный Вами адрес было отправлено письмо. Для завершения регистрации и \
подтверждения адреса перейдите по ссылке, указанной в письме')
new_profile.save()
userprofile_form.save_m2m()
return redirect(reverse('main:done'))
else:
return render(request, 'registration/registration_form.html', {
'user_form': user_form,
'userprofile_form': userprofile_form,
'caption': 'Регистрация'
})
return render(request, 'registration/registration_form.html', {
'user_form': UserRegistrationForm(),
'userprofile_form': UserProfileRegistrationForm(),
'caption': 'Регистрация'
})
def register_view(request):
if request.method == "POST":
form = UserRegistrationForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
username = request.POST.get('username')
password = request.POST.get('password')
print "username:"******"password", password
return login_user(request, username, password)
else:
form = UserRegistrationForm()
return render(request, 'ncqs/register.html', {'form': form})
def register(request):
if request.method == "POST":
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
profile = Profile.objects.create(user=new_user)
create_action(new_user,'has created an account')
return render(request,'account/register_done.html',{'new_user':new_user})
else:
user_form = UserRegistrationForm()
return render(request,'account/register.html',{'user_form': user_form})
def register():
# caricamento dati provenienti dal form
if request.method == 'POST':
if request.form['password'] != request.form['confirm_password']:
flash('Le password inserite sono diverse!')
return redirect(url_for('auth.register'))
form = UserRegistrationForm(request.form)
# per il check del form devo guardare anche le tariffe
tariffe = Tariffa.query(Tariffa.visibilita == True).order(
Tariffa.order).fetch()
my_choices = []
for i, tar in enumerate(tariffe):
my_choices.append((str(i + 1), tar.tariffa))
form.tariffa.choices = my_choices
# check form
if form.validate():
if insert_user(form):
return render_template('login/not_allowed.html')
else:
flash('Registration error!')
return redirect(url_for('auth.register'))
# caricamento vista registrazione
elif request.method == 'GET':
form = UserRegistrationForm()
# aggiunta tariffe possibili
tariffe = Tariffa.query(Tariffa.visibilita == True).order(
Tariffa.order).fetch()
my_choices = []
for i, tar in enumerate(tariffe):
my_choices.append((str(i + 1), tar.tariffa))
form.tariffa.choices = my_choices
if len(tariffe) > 0:
return render_template(
'login/registration.html',
form=form,
len=len(tariffe),
nomi_tariffe=[tar.tariffa for tar in tariffe],
prezzo_tariffe=[tar.prezzo for tar in tariffe],
descr_tariffe=[tar.description for tar in tariffe])
else:
return render_template('login/registration.html',
form=form,
len=1,
nomi_tariffe=["Non ci sono tariffe."],
descr_tariffe=["Tutti gratis, paliazzu!!"])
def register(request):
from tuition.settings import SITE_SUPPORT_EMAIL
from forms import UserRegistrationForm
from tuition.utils.manager import AppManager
from tuition.utils.utils import URLCreator
from tuition.urlPatterns import UrlPattern
from tuition.utils.utils import GooglePlusService
queryString = int(request.GET.get('firstLogin', 0))
loggedInEmployee = AppManager.getCurrentLoggedInUser()
if not AppManager.isCurrentUserAppAdmin():
if not queryString or AppManager.getUserByEmail(
AppManager.getCurrentLoggedInUser().email()):
raise Exception('Unauthorized Access')
else:
loggedInEmployee = AppManager.getUserByEmail(
AppManager.getCurrentLoggedInUser().email())
template_values = {
'form': UserRegistrationForm(),
'loggedInEmployee': loggedInEmployee,
'queryString': queryString
}
return render_to_response('userRegistration.html',
template_values,
context_instance=RequestContext(request))
def user_registration():
"""User Registration Page"""
form = UserRegistrationForm()
if form.validate_on_submit():
username = form.username.data
password = form.password.data
email = form.email.data
first_name = form.first_name.data
last_name = form.last_name.data
zip_code = form.zip_code.data
new_user = User.register(username, password, email, first_name,
last_name, zip_code)
db.session.add(new_user)
try:
db.session.commit()
except IntegrityError:
form.username.errors.append("Username is taken")
return render_template('users/register.html', form=form)
session["username"] = new_user.username # Keeps user logged in
flash(f"Welcome {first_name}, we successfully created your account!",
"success")
return redirect('/')
else:
return render_template('users/register.html', form=form)
def register():
"""
Take care of user registration by either sending them the form, or
registering them and signing them in.
:return:
"""
form = UserRegistrationForm()
if request.method == 'POST':
if not form.validate():
# If the form isn't properly validated, return a json saying why
return jsonify(
{
'success': False,
'errors': form.errors
}
)
new_user = User(
firstname=form.name.data,
lastname=form.surname.data,
email=form.email.data,
username=form.username.data,
)
new_user.set_password(password=form.password.data)
db.session.add(new_user)
db.session.commit()
return redirect(url_for('login'), code=307)
return render_template('register-form.html', form=form)
def test_registration_form(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'password1': 'tester33',
'password2': 'tester33',
})
self.assertTrue(form.is_valid())
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
user_type = request.args.get('type')
form = StoreRegistrationForm() if user_type == 'store' else UserRegistrationForm()
if form.validate_on_submit():
user = User(name=form.name.data, username=form.username.data, email=form.email.data, mobile=form.mobile.data)
user.set_password(form.password.data)
if user_type == 'store':
user.userType = 1
store = Store(storeName=form.storeName.data, country=form.country.data, state=form.state.data,
city=form.city.data, street=form.street.data, zipCode=form.zipCode.data,
latitude=form.latitude.data, longitude=form.longitude.data)
db.session.add(store)
db.session.add(user)
usm = UserStoreMap(userId=User.query.filter_by(username=form.username.data).first().id,
storeId=Store.query.filter_by(latitude=form.latitude.data,
longitude=form.longitude.data).first().storeId)
# usm = UserStoreMap(userId=user.id, storeId=store.storeId)
db.session.add(usm)
else:
user.userType = 0
db.session.add(user)
db.session.commit()
flash('Sign-in to continue')
return redirect(url_for('login'))
return render_template('register.html', title="Register", form=form, type=user_type)
def add_user():
stringvalue=["Already Have an Account", "Sign in", "User", "Admin Singin", "admin_login",]
form = UserRegistrationForm()
if not form.validate_on_submit():
flash('please enter valid user details')
else:
entrynumber = form.entryNumber.data
name = form.name.data
password = form.password.data
emailid = form.emailId.data
if request.method == 'POST' and userNotAvailabe(entrynumber) and len(entrynumber)>4 and len(name) > 3 and len(password) > 7 and '@' in emailid and not pendingAvailable(entrynumber):
insertstmt = "insert into pending values ('{}', '{}', '{}', '{}',{},{},{});".format(entrynumber, name, password, emailid,0,0,0)
cursor.execute(insertstmt)
connection.commit()
flash("Please wait till confirmation")
return redirect(url_for('login_user'))
elif request.method=='POST' and len(entrynumber) < 6:
flash('length of userid is too sort at least 7 char')
elif request.method=='POST' and len(name) < 4:
flash('length of name is too sort')
elif request.method=='POST' and len(password) < 8:
flash('Please enter at least 8 word password')
elif request.method=='POST' and ('@' not in emailid):
flash('Please enter valid email id')
elif request.method=='POST' and pendingAvailable(entrynumber):
flash("Already signup....Please wait till confirmation")
elif request.method=='POST' and not userNotAvailabe(entrynumber):
flash("Userid Already taken please try different userid")
return render_template('register.html',title='Register',form=form, stringvalue=stringvalue)
def register(request, **kwargs):
if request.POST:
new_data = request.POST.copy()
#Create form with user data
account_type = int(new_data['form_type'])
if account_type is UserProfile.ACCOUNT_VOLUNTEER:
registration = UserRegistrationForm(new_data)
elif account_type is UserProfile.ACCOUNT_ORGANIZATION:
registration = OrganizationRegistrationForm(new_data)
else:
raise InvalidRegistrationRequest
#Process data
if registration.is_valid():
#Create user
new_user = registration.save()
try:
activation_key = get_object_or_404(ActivationKey,
user=new_user)
except MultipleObjectsReturned:
return render_to_response('confirm.djhtml', {'success': False})
#Activation URL
url = request.get_host() + "/register/confirm/%u/%s" % (
new_user.id, activation_key.activation_key)
#Send email
send_email(new_user.username, "Activation Email", url)
return render_to_response('register_thankyou.djhtml', {'url': url})
else:
context = RequestContext(request, {
'errors': registration.errors,
'form': registration
})
return render_to_response('register_manual.djhtml', context)
#Show new form
if kwargs['type'] == UserProfile.ACCOUNT_VOLUNTEER:
registration = UserRegistrationForm()
elif kwargs['type'] == UserProfile.ACCOUNT_ORGANIZATION:
registration = OrganizationRegistrationForm()
else:
registration = UserRegistrationForm()
context = RequestContext(request, {'form': registration})
return render_to_response('register_manual.djhtml', context)
def test_registration_form_success(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'public_name': 'test name 1',
'password1': 'testpassword1',
'password2': 'testpassword1'
})
self.assertTrue(form.is_valid())
def test_registration_form_password_missing(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'password1': 'tester40',
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Second Password is missing",
form.full_clean())
def test_registration_form_passwords_not_matching(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'password1': 'tester38',
'password2': 'tester39',
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Passwords do not match", form.full_clean())
def test_registration_form_fails_with_missing_password2(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'public_name': 'test name 4',
'password1': 'testpassword1'
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Passwords do not match", form.full_clean())
def test_registration_form(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'letmein1',
'password2': 'letmein1',
})
self.assertTrue(form.is_valid())
def test_registration_form_missing_email(self):
form = UserRegistrationForm({
'password1': 'test35',
'password2': 'test35',
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Please enter your email address",
form.full_clean())
def register(request):
is_post = request.method == 'POST'
if is_post:
form = UserRegistrationForm(request.POST)
if form.is_valid():
form.save()
data = create_user_json(request)
return HttpResponse(data, mimetype='application/json')
return HttpResponse(status=401)
args = {}
args.update(csrf(request))
args['form'] = UserRegistrationForm()
return render_to_response('users/register.html', args)
def test_registration_form_fails_with_missing_public_name(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'password1': 'testpassword1',
'password2': 'testpassword1'
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Please fill in this field",
form.full_clean())
def test_registration_form_fails_wih_passwords_that_dont_match(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'testing1',
'password2': 'testing2'
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Passwords do not match", form.full_clean())
def test_registration_form_fails_with_missing_password(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'letmein1',
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"please enter both passwords",
form.full_clean())
def test_form_is_valid(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'letmein1',
'password2': 'letmein1',
'first_name': 'test',
'last_name': 'test',
'company': 'test'
})
self.assertTrue(form.is_valid())
def registerUser(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
if form.cleaned_data['choice'] == 'advertiser':
folderPath = ADVERTISERS_ROOT + 'user_' + str(user.id)
advertisersGrp = Group.objects.get(name='Advertisers')
advertisersGrp.user_set.add(user)
advertisersGrp.save()
user.is_staff = True
user.save()
os.mkdir(folderPath)
login(request,user)
return redirect(reverse('index'))
else:
form = UserRegistrationForm()
return render(request, 'oglasnik/userRegistration.html', {'form': form})
def test_form_fails_when_missing_password2(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'letmein1',
'first_name': 'test',
'last_name': 'test',
'company': 'test'
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Please confirm your password")
def test_registration_form(self):
form = UserRegistrationForm({
'email': '*****@*****.**',
'password1': 'letmein1',
'password2': 'letmein1',
'stripe_id': settings.STRIPE_SECRET,
'credit_card_number': 4242424242424242,
'cvv': 123,
'expiry_month': 1,
'expiry_year': 2033
})
self.assertTrue(form.is_valid())
def test_form_fails_when_password_dont_match(self):
form = UserRegistrationForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'letmein1',
'password2': 'letmein2',
'first_name': 'test',
'last_name': 'test',
'company': 'test'
})
self.assertFalse(form.is_valid())
self.assertRaisesMessage(forms.ValidationError,
"Passwords do not match")
