def register(req):
if req.method == 'GET':
return render(req, 'user/register.html')
elif req.method == 'POST':
form = req.POST
User.create_user(username=form['username'], password=form['password'])
return redirect('index')
def register(request):
# errors = []
# if(request.POST.get('password','1') != request.POST.get('confirm_password','1')):
# errors.append('wrong_password')
# if(request.POST.get('username', "field is empty") == "" or request.POST.get('email', "field is empty") == "" or request.POST.get('password',"field is empty") == ""):
# errors.append('empty_field')
# if(len(errors) != 0):
# return render_to_response('profile/register.html', {'errors': errors}, RequestContext(request))
# else:
if request.user.is_authenticated():
my_user = MyUser.objects.get(user=User.objects.get(id=request.user.id))
return render_to_response('profile/profile.html', {'my_user': my_user}, RequestContext(request))
users_from_database = User.objects.all()
if request.POST:
User.create_user(username=request.POST['username'], email=request.POST['email'], password=request.POST['password'])
user = authenticate(username=request.POST['username'], password=request.POST['password'])
my_user = MyUser(point=0.0,comment_count=0,disease_added_count=0,article_added_count=0,discussion_added_count=0,forum_present_count=0)
my_user.user = user
my_user.save()
login(request, user)
return render_to_response('profile/account.html',{'users': users_from_database}, RequestContext(request))
else:
return render_to_response('profile/register.html',{'users': users_from_database}, RequestContext(request))
def testAccount(self):
Doc.objects(name=DOC_NAME)[0].delete(
) #strange bug happens when full collection from db is deleted :|
logger.debug('Start TestUI::testAccount.')
USER_NAME = 'testLogin'
driver = self.driver
driver.get(self.base_url)
time.sleep(1)
driver.find_element_by_css_selector("i.fa.fa-sign-in").click()
time.sleep(1)
driver.find_element_by_id("id_username").clear()
driver.find_element_by_id("id_username").send_keys(USER_NAME)
driver.find_element_by_id("id_password").clear()
driver.find_element_by_id("id_password").send_keys(USER_NAME)
driver.find_element_by_css_selector("input[type=\"submit\"]").click()
time.sleep(1)
self.assertEqual(
"Your username and password didn't match. Please try again.",
driver.find_element_by_css_selector("p").text)
User.create_user(USER_NAME, USER_NAME)
time.sleep(1)
driver.get(self.base_url)
time.sleep(1)
driver.find_element_by_css_selector("i.fa.fa-sign-in").click()
time.sleep(1)
driver.find_element_by_id("id_username").clear()
driver.find_element_by_id("id_username").send_keys(USER_NAME)
driver.find_element_by_id("id_password").clear()
driver.find_element_by_id("id_password").send_keys(USER_NAME)
driver.find_element_by_css_selector("input[type=\"submit\"]").click()
time.sleep(1)
self.assertEqual("Welcome, " + USER_NAME + ".",
driver.find_element_by_css_selector("p").text)
PRIVATE_DOC_NAME = "prywatny"
driver.find_element_by_class_name("has-menu").click()
driver.find_element_by_id("newDocumentMenu").click()
time.sleep(1)
driver.find_element_by_id("documentNameAtStart").clear()
driver.find_element_by_id("documentNameAtStart").send_keys(
PRIVATE_DOC_NAME)
driver.find_element_by_id("privateFlagAtStart").click()
driver.find_element_by_id("saveDocumentButtonAtStart").click()
time.sleep(10)
logger.debug('Critical point of TestUI::testAccount.')
doc = Doc.objects(name=PRIVATE_DOC_NAME)[0]
self.assertEqual(doc.name, PRIVATE_DOC_NAME)
self.assertTrue(doc.priv)
driver.get(self.base_url)
time.sleep(1)
driver.find_element_by_class_name("has-menu").click()
driver.find_element_by_id("documentListButton").click()
time.sleep(1)
self.assertEqual(PRIVATE_DOC_NAME,
driver.find_element_by_css_selector("td").text)
driver.find_element_by_id('accounts').click()
driver.find_element_by_id("logout").click()
time.sleep(1)
with self.assertRaises(NoSuchElementException):
driver.find_element_by_css_selector("td")
logger.debug('End TestUI::testAccount.')
def create_user(user_name, password, email):
user = User()
try:
# print user_name, password, email
user.create_user(user_name, password, email)
print "User Created!"
new_user = User.objects.get(username=user_name)
print "User Access Key", new_user.id
except Exception, e:
print "Error", e
def create_user(user_name, password, email):
user = User()
try:
# print user_name, password, email
user.create_user(user_name, password, email)
print "User Created!"
new_user = User.objects.get(username=user_name)
print "User Access Key", new_user.id
except Exception,e:
print "Error", e
def register_page(request):
if request.method=='POST':
form = RegistrationForm(request.POST)
if form.is_valid():
User.create_user(username=form.cleaned_data['username'],password=form.cleaned_data['password1'],email=form.cleaned_data['email'])
return HttpResponseRedirect("/register/success")
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response('registration/register.html',variables)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
User.create_user(form.cleaned_data['username'],form.cleaned_data['password1'])
messages.success(request, form.cleaned_data['username'] + ' you have been successfully registered')
return HttpResponseRedirect("/")
else:
form = RegistrationForm()
return render(request, "eventslist/register.html", {
'form': form,
})
def setup(request, template='socialregistration/setup.html',
form_class=UserForm, extra_context=dict()):
"""
Setup view to create a username & set email address after authentication
"""
try:
social_user = request.session['socialregistration_user']
social_profile = request.session['socialregistration_profile']
except KeyError:
return render_to_response(
template, dict(error=True), context_instance=RequestContext(request))
if not GENERATE_USERNAME:
# User can pick own username
if not request.method == "POST":
form = form_class(social_user, social_profile)
else:
form = form_class(social_user, social_profile, request.POST)
if form.is_valid():
form.save(request=request)
user = form.profile.authenticate()
login(request, user)
del request.session['socialregistration_user']
del request.session['socialregistration_profile']
return HttpResponseRedirect(_get_next(request))
extra_context.update(dict(form=form))
return render_to_response(template, extra_context,
context_instance=RequestContext(request))
else:
# Generate user and profile
#social_user.username = str(uuid.uuid4())[:30]
#social_user.save()
#social_profile.user = social_user
#social_profile.save()
# Authenticate and login
#user = social_profile.authenticate()
User.create_user(user_data['username'], user_data['password'], user_data['email'])
login(request, user)
# Clear & Redirect
del request.session['socialregistration_user']
del request.session['socialregistration_profile']
return HttpResponseRedirect(_get_next(request))
def __init__(self, bootstrap=False):
self.db = settings._MONGODB
if bootstrap:
# load bootstrap data
self.db.user.remove()
User.create_user(username='******', email='*****@*****.**', password='******')
self.db.menus.remove()
self.db.menus.insert(menus)
self.db.items.remove()
self.db.items.insert(items)
self.db.clients.remove()
self.db.clients.insert(clients)
self.db.orders.remove()
self.db.django_session.remove()
def create(request):
form = NewAccountForm(request.POST or None)
if form.is_valid():
# also attach the contact information to the anonymous request.user
new_user.first_name = request.POST['first_name']
new_user.last_name = request.POST['last_name']
username = request.POST['username']
email = request.POST['email']
password = request.POST['password2']
new_user = User.create_user(username=username, email=email,
password=password)
new_user.save()
# create the account instance
new_account = Account()
new_account.company = request.POST['company_name']
new_account.admin = new_user
new_account.save()
messages.success(request, new_account)
# now authenticate and login user
auth_user = authenticate(username=username, password=password)
login(request=request, user=auth_user)
messages.success(request, 'Successfully logged in as %s' % \
auth_user.username)
return HttpResponseRedirect('/welcome/')
data = {'title': 'Kolabria - Create a new Account ', 'form': form, }
return render_to_response('account/create.html', data,
context_instance=RequestContext(request))
def patientinfo(request):
message = ""
if request.method == 'POST':
if request.POST['requestType'] == 'newPatient':
firstName = request.POST['firstName']
lastName = request.POST['lastName']
birthDate = request.POST['birthDate']
if(helper.validate(birthDate)):
username = firstName + lastName
userNum = len(User.objects(__raw__={'username':{'$regex': '^' + username, '$options' : 'i'}}))
user = User.create_user(username + str(userNum), 'password')
user.first_name = firstName
user.last_name = lastName
user.save()
ion_user = IonUser(user=user, group='patient', birthdate=birthDate)
ion_user.save()
newPatient = patient(firstName=firstName, lastName=lastName, activeMeds = [], user=ion_user)
newPatient.save()
else:
message = "Invalid birth date format. (should be mm-dd-yyyy)"
if request.POST['requestType'] == 'deletePatient':
id = request.POST['id']
patient.objects(id=id)[0].delete()
# don't know if we actually want to give people the ability to delete medical records...
return render_to_response('patientinfo.html', {'Patients': patient.objects, 'message': message},
context_instance=RequestContext(request))
def create(request):
user = User.create_user('dispenser', 'password', '*****@*****.**')
#user.groups = ['patient']
user.save()
ion_user = IonUser(user=user, group='dispenser', birthdate=datetime.datetime.now())
ion_user.save()
return HttpResponse("Account create successful")
def user_register(request):
if request.method == 'POST':
uemail = request.POST.get('email', None)
upassword = request.POST.get('password', None)
if (not uemail) or (not upassword):
return {
'error': 'All fields are required',
'email': uemail
}
try:
user = User.create_user(uemail, upassword, request.POST['email'])
user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login(request, user)
request.session.set_expiry(60 * 60 * 10) # 10 hour timeout
return redirect('project_list')
except NotUniqueError:
return {
'error': 'User with this email already exist',
'email': uemail
}
except ValidationError:
return {
'error': 'Incorrect email',
'email': uemail
}
else:
return {}
def get_or_create(cls, loginza_response):
identity_qs = cls.objects.filter(identity=loginza_response['identity'])
if identity_qs.count():
identity = identity_qs.get()
else:
user_qs = User.objects.filter(
username=loginza_response['identity'])
if user_qs.count():
user = user_qs.get()
else:
user = User.create_user(
username=loginza_response['identity'],
password=UNUSABLE_PASSWORD,
email=loginza_response.get('email'))
identity = Identity(identity=loginza_response['identity'],
user=user)
del loginza_response['identity']
identity.info = loginza_response
identity.save()
return identity
def google_login_success(request):
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
values = {
p.split('.')[-1]: params[p]
for p in params.keys() if 'value' in p
}
mode = params['openid.mode']
if mode != 'id_res':
# The user declined to sign in at Google
return _fail_login(request, 'could not verify your credentials')
email = values['email']
firstname = values['firstname']
lastname = values['lastname']
handle = params['openid.claimed_id']
# Break apart the handle to find the user's ID
# Assumes there are no other parameters attached to URL in 'openid.claimed_id'
userid = handle.split("?")[-1].split("=")[-1]
association = params['openid.assoc_handle']
# Use the information from Google to retrieve this user's profile,
# or create a new user and profile.
# 1) Try to retrieve this user's profile by openid handle
try:
profile = UserProfile.objects.get(openid_auth_stub__claimed_id=userid)
except UserProfile.DoesNotExist:
# 2) Try to retrieve the user's profile by email address (username)
try:
user = User.objects.get(username=email)
profile = UserProfile.objects.get(user=user)
except User.DoesNotExist:
# 3) This person has never logged in before
user = User.create_user(email, random_string())
user.first_name = firstname
user.last_name = lastname
user.save()
profile = UserProfile(user=user)
# Save openid information when this user has never used openid before
# This should happen even if the user's profile already exists
profile.openid_auth_stub = OpenidAuthStub(association=association,
claimed_id=userid)
profile.save()
# Store the profile in the session
request.session['profile'] = profile
# Get the user's phone number if they do not have one already registered
if not profile.phone_number:
return HttpResponseRedirect(reverse('google_register'))
profile.user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login(request, profile.user)
return HttpResponseRedirect(reverse('user_landing'))
def create_user(request):
if request.method == 'POST':
user = User.create_user(request.POST['username'], request.POST['password'], request.POST['email'])
if user.is_active == True:
print('True')
return redirect('/techtopics/list')
elif request.method == 'GET':
return TemplateResponse(request, 'techtopics/user_create.html')
def createuser(request):
result = {}
try:
if request.data['is_admin'] is True or request.data[
'is_admin'] == "true" or request.data['is_admin'] == "True":
User.create_user(request.data['username'],
request.data['password'], request.data['email'])
user = User.objects.get(username=request.data['username'])
user.is_superuser = True
user.save()
else:
User.create_user(request.data['username'],
request.data['password'], request.data['email'])
result = {'result': True, 'message': "Register completed."}
return Response(result)
except Exception as e:
return Response(str(e), status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def register(request):
error = False
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
email = request.POST.get('email')
user = User.objects(username=username)
if not username or not password or not email or not len(user)==0 :
error = True
return render_to_response("registration/register.html",{'error':error},context_instance=RequestContext(request))
else:
User.create_user(username=username, password=password,email=email)
newuser = auth.authenticate(username=username, password=password)
auth.login(request, newuser)
return HttpResponseRedirect("/")
else:
return render_to_response("registration/register.html",{'error':error},context_instance=RequestContext(request))
def create_user(user_tup):
'''Boilerplate for making a new user with a profile'''
user = User.create_user(user_tup[2], "password")
user.first_name = user_tup[0]
user.last_name = user_tup[1]
user.is_active = True
user.save()
profile = models.UserProfile.objects.create(phone_number=user_tup[3], user=user)
return user, profile
def _fixture_setup(self):
c=Category(name='Musica')
c.save()
c=Category(name='Restauracion')
c.save()
user=User.create_user('john','john')
request = HttpRequest()
user=User.objects(username='******')
self.client.login(username='******',password='******')
def create_user(user_tup):
"""Boilerplate for making a new user with a profile"""
user = User.create_user(user_tup[2], "password")
user.first_name = user_tup[0]
user.last_name = user_tup[1]
user.is_active = True
user.save()
profile = models.UserProfile.objects.create(phone_number=user_tup[3], user=user)
return user, profile
def register(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
User_save = User.create_user(username=username,email=None,password=password)
User_save.save()
return HttpResponseRedirect('/theweber.in/')
else:
return render(request,'register.html')
def google_login_success( request ):
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
values = { p.split('.')[-1] : params[p] for p in params.keys() if 'value' in p }
mode = params['openid.mode']
if mode != 'id_res':
# The user declined to sign in at Google
return _fail_login( request, 'could not verify your credentials' )
email = values['email']
firstname = values['firstname']
lastname = values['lastname']
handle = params['openid.claimed_id']
# Break apart the handle to find the user's ID
# Assumes there are no other parameters attached to URL in 'openid.claimed_id'
userid = handle.split("?")[-1].split("=")[-1]
association = params['openid.assoc_handle']
# Use the information from Google to retrieve this user's profile,
# or create a new user and profile.
# 1) Try to retrieve this user's profile by openid handle
try:
profile = UserProfile.objects.get( openid_auth_stub__claimed_id = userid )
except UserProfile.DoesNotExist:
# 2) Try to retrieve the user's profile by email address (username)
try:
user = User.objects.get( username=email )
profile = UserProfile.objects.get( user=user )
except User.DoesNotExist:
# 3) This person has never logged in before
user=User.create_user(email, random_string())
user.first_name = firstname
user.last_name = lastname
user.save()
profile = UserProfile( user=user )
# Save openid information when this user has never used openid before
# This should happen even if the user's profile already exists
profile.openid_auth_stub = OpenidAuthStub(association=association, claimed_id=userid)
profile.save()
# Store the profile in the session
request.session['profile'] = profile
# Get the user's phone number if they do not have one already registered
if not profile.phone_number:
return HttpResponseRedirect( reverse('google_register') )
profile.user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login( request, profile.user )
return HttpResponseRedirect( reverse('user_landing' ) )
def create_user(data):
"""
Add new User
Keyword arguments:
@param data: data whose user details need to be extracted
"""
user = User.create_user(data["username"], data["password"], data["email"])
profile = Profile(user=user)
profile.save()
return user
def register(request):
error = False
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
email = request.POST.get('email')
user = User.objects(username=username)
if not username or not password or not email or not len(user) == 0:
error = True
return render_to_response("registration/register.html",
{'error': error},
context_instance=RequestContext(request))
else:
User.create_user(username=username, password=password, email=email)
newuser = auth.authenticate(username=username, password=password)
auth.login(request, newuser)
return HttpResponseRedirect("/")
else:
return render_to_response("registration/register.html",
{'error': error},
context_instance=RequestContext(request))
def register(request):
# Cannot register if logged in already
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('login'))
# The registration form
form = None
# Form has been submitted
if request.method == 'POST':
form = RegisterForm(request.POST)
# Validate the registration form
if form.is_valid():
user = User.create_user(form.cleaned_data['username'],
form.cleaned_data['password1'])
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.is_active = False
user.save()
profile = UserProfile.objects.create(
phone_number=form.cleaned_data['phone'], user=user)
stub = RegistrationStub.objects.create(user=user)
# Send confirmation email
hostname = _hostname(protocol="")
activate_uri = reverse('activate')
activate_link = '{}{}?key={}'.format(hostname, activate_uri,
stub.activationCode)
email_subject = "Welcome to Obietaxi!"
email_to = [form.cleaned_data['username']]
msg_body = "Welcome to Obietaxi! Your account has already been created with this email address, now all you need to do is confirm your accout by clicking on the link below. If there is no link, you should copy & paste the address into your browser's address bar and navigate there.\n\n{}".format(
activate_link)
send_email(email_to=email_to,
email_subject=email_subject,
email_body=msg_body)
messages.add_message(
request, messages.SUCCESS,
"Your account has been created. Check your email for a confirmation link to complete the registration process."
)
return HttpResponseRedirect(reverse('login'))
# Form needs to be rendered
else:
form = RegisterForm()
# Render the form (possibly with errors if form did not validate)
return render_to_response('register.html',
locals(),
context_instance=RequestContext(request))
def signup(request):
if request.method == 'POST':
name = request.POST.get('name','')
pw = request.POST.get('password','')
email = request.POST.get('email','')
if not verifyCaptcha(request.POST.get('g-recaptcha-response','')):
messages.error(request, "Captcha could not be validated")
return redirect('website:index')
#check if either is only whitespace
if isNoneOrEmptyOrBlankString(name) or isNoneOrEmptyOrBlankString(pw) or isNoneOrEmptyOrBlankString(email):
return HttpResponseBadRequest('username and/or password is empty')
if len(User.objects(username=name)) != 0:
messages.error(request, "Username" + name + "already taken")
return redirect('website:index')
if len(User.objects(email=email)) != 0:
messages.error(request, "Email" + email + "already taken")
return redirect('website:index')
maxLength = len("IraklisDimitriadis") #this should be a good maxLength
if len(name) > maxLength:
messages.error(request, "Your name is too long. Use less than "+maxLength+" letters.")
return redirect('website:index')
user = User.create_user(name,pw,email)
user.save()
UserExtension(user=user,karma=0).save()
#log user in after registrartion
user = authenticate(username=name,password=pw)
if user is not None:
if user.is_active:
login(request, user)
messages.success(request, 'Your account was created. Click OK to begin using Lemur.')
return redirect('website:catalogue')
elif request.method == 'GET':
return redirect('website:index')
messages.error(request, "The server let's you know, that something unexpected happened.")
return redirect('website:index')
def google_login_success( request ):
if request.method == 'GET':
params = request.GET
elif request.method == 'POST':
params = request.POST
values = { p.split('.')[-1] : params[p] for p in params.keys() if 'value' in p }
mode = params['openid.mode']
if mode != 'id_res':
# The user declined to sign in at Google
return _fail_login( request, 'could not verify your credentials' )
email = values['email']
firstname = values['firstname']
lastname = values['lastname']
handle = params['openid.claimed_id']
# Break apart the handle to find the user's ID
# Assumes there are no other parameters attached to URL in 'openid.claimed_id'
userid = handle.split("?")[-1].split("=")[-1]
association = params['openid.assoc_handle']
# Use the information from Google to retrieve this user's profile,
# or create a new user and profile.
# 1) Try to retrieve this user's profile by openid handle
try:
profile = UserProfile.objects.get( openid_auth_stub__claimed_id = userid )
except UserProfile.DoesNotExist:
# 2) Try to retrieve the user's profile by email address (username)
try:
user = User.objects.get( username=email )
profile = UserProfile.objects.get( user=user )
except User.DoesNotExist:
# 3) This person has never logged in before
random_password = lambda : ''.join( (choice('ABCDEFabcdef1234567890)(*&^%$#@!') for i in xrange(10)) )
user=User.create_user(email, random_password())
user.first_name = firstname
user.last_name = lastname
user.save()
profile = UserProfile( user=user )
# Save openid information when this user has never used openid before
# This should happen even if the user's profile already exists
profile.openid_auth_stub = OpenidAuthStub(association=association, claimed_id=userid)
profile.save()
profile.user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login( request, profile.user )
return render_to_response( 'google_login_success.html',
locals(),
context_instance=RequestContext(request) )
def register(request):
# errors = []
# if(request.POST.get('password','1') != request.POST.get('confirm_password','1')):
# errors.append('wrong_password')
# if(request.POST.get('username', "field is empty") == "" or request.POST.get('email', "field is empty") == "" or request.POST.get('password',"field is empty") == ""):
# errors.append('empty_field')
# if(len(errors) != 0):
# return render_to_response('profile/register.html', {'errors': errors}, RequestContext(request))
# else:
if request.user.is_authenticated():
my_user = MyUser.objects.get(user=User.objects.get(id=request.user.id))
return render_to_response('profile/profile.html', {'my_user': my_user},
RequestContext(request))
users_from_database = User.objects.all()
if request.POST:
User.create_user(username=request.POST['username'],
email=request.POST['email'],
password=request.POST['password'])
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
my_user = MyUser(point=0.0,
comment_count=0,
disease_added_count=0,
article_added_count=0,
discussion_added_count=0,
forum_present_count=0)
my_user.user = user
my_user.save()
login(request, user)
return render_to_response('profile/account.html',
{'users': users_from_database},
RequestContext(request))
else:
return render_to_response('profile/register.html',
{'users': users_from_database},
RequestContext(request))
def register( request ):
# Cannot register if logged in already
if request.user.is_authenticated():
return HttpResponseRedirect( reverse('login') )
# The registration form
form = None
# Form has been submitted
if request.method == 'POST':
form = RegisterForm( request.POST )
# Validate the registration form
if form.is_valid():
user = User.create_user( form.cleaned_data['username'],
form.cleaned_data['password1'] )
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.is_active = False
user.save()
stub = RegistrationStub.objects.create( user=user )
# Send confirmation email
hostname = _hostname( protocol="" )
activate_uri = reverse( 'activate' )
activate_link = '{}{}?key={}'.format( hostname, activate_uri, stub.activationCode )
email_subject = "Welcome to Obietaxi!"
email_from = 'noreply@{}'.format( hostname )
email_to = form.cleaned_data['username']
msg_body = "Welcome to Obietaxi! Your account has already been created with this email address, now all you need to do is confirm your accout by clicking on the link below. If there is no link, you should copy & paste the address into your browser's address bar and navigate there.\n\n{}".format( activate_link )
email_message = "\r\n".join( ["From: {}".format(email_from),
"To: {}".format(email_to),
"Subject: {}".format(email_subject),
"",
msg_body] )
server = smtplib.SMTP( 'localhost' )
server.sendmail( email_from, [email_to], email_message )
server.quit()
messages.add_message( request, messages.SUCCESS, "Your account has been created. Check your email for a confirmation link to complete the registration process." )
return HttpResponseRedirect( reverse('login') )
# Form needs to be rendered
else:
form = RegisterForm()
# Render the form (possibly with errors if form did not validate)
return render_to_response( 'register.html', locals(), context_instance=RequestContext(request) )
def test_search_form_return_correct_event(self):
user=User.create_user('john','john')
request = HttpRequest()
user=User.objects(username='******')
self.client.login(username='******',password='******')
response = self.client.post('/eventslist/addevent',data={'title': 'Concierto','description': 'Es un concierto','category': 'Musica','lat':'49.8','lng':'4.7'})
self.assertEqual(Event.objects(title='Concierto').count(),1)
self.assertEqual(str(Event.objects(title='Concierto')),'[<Event: Concierto-49.84.7-Es un concierto-Musica>]')
response = self.client.post('/',data={'title': 'Concierto','category': 'Musica','lat':'49.8','lng':'4.7','distance':'4'})
self.assertContains(response,'<td>Concierto</td>')
self.assertContains(response,'<td>Es un concierto</td>')
self.assertContains(response,'<td>Musica</td>')
User.objects(username='******').delete()
def createUser(request):
logger.debug(request.POST)
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
new_user = User.create_user(form.username, form.password)
return HttpResponseRedirect('/')
else:
return render(request, 'registration/createUser.html', {
'form': UserForm(),
'error': form.error
})
else:
form = UserForm()
return render(request, 'registration/createUser.html', {'form': form})
def register(request):
form = UserCreationForm(request.POST or None)
data = {'title': 'Kolabria - Registration Page',
'form': form,}
if form.is_valid():
username = request.POST['username']
email = request.POST['email']
password = request.POST['password2']
new_user = User.create_user(username=username, email=email,
password=password)
new_user.save()
auth_user = authenticate(username=username, password=password)
login(request=request, user=auth_user)
return render_to_response('login/register-success.html',
context_instance=RequestContext(request))
return render_to_response('login/register.html', data,
context_instance=RequestContext(request))
def create(request):
form = NewAccountForm(request.POST or None)
if form.is_valid():
# create the account instance
new_account = Account()
new_account.name = request.POST['company_name']
new_account.phone = request.POST['phone']
new_account.address1 = request.POST['address1']
new_account.address2 = request.POST['address2']
new_account.city = request.POST['city']
new_account.state = request.POST['state']
new_account.postal_zip = request.POST['postal_zip']
new_account.country = request.POST['country']
new_account.save()
messages.success(request, new_account)
# create new user and save profile details; save new user
username = request.POST['username']
email = request.POST['email']
password = request.POST['password2']
new_user = User.create_user(username=username, email=email,
password=password)
new_user.first_name = request.POST['first_name']
new_user.last_name = request.POST['last_name']
new_user.save()
# set new user as admin for account instance; save account
new_account.admin = new_user
new_account.save()
# authenticate and log in user
auth_user = authenticate(username=username, password=password)
login(request=request, user=auth_user)
messages.success(request, 'Successfully logged in as %s' % \
auth_user.username)
slug = slugify(new_account.name)
return HttpResponseRedirect('/%s/welcome/' % slug)
data = {'title': 'Kolabria - Create a new Account ', 'form': form, }
return render_to_response('account/create.html', data,
context_instance=RequestContext(request))
def RegView(request):
if request.method == 'GET':
return render(request, 'reg.html')
if request.method == 'POST':
try:
username = request.POST['username']
password = request.POST['password']
passwordrepeat = request.POST['password-repeat']
if User.objects(username=username).first():
messages.error(request, "user exists")
return redirect("reg.html")
elif password != passwordrepeat:
messages.error(request, "please enter same password")
return redirect("reg.html")
else:
user = User.create_user(username=username, password=password)
messages.success(request, "user register successfully")
return render(reqeuest, 'user.html')
except:
messages.error(request, "Error, please try again")
return redirect("reg.html")
def dispenser_admin(request):
newID = ""
if request.method == 'POST':
if request.POST['requestType'] == 'newDispenser':
location = request.POST['location'].strip()
user = User.create_user(location, 'password')
user.save()
user = IonUser(user=user,group='dispenser',birthdate=datetime.datetime.now())
user.save()
newDispenser = dispenser(user=user,location=location)
newDispenser.creationTime = datetime.datetime.now()
newDispenser.slots = [ None for i in range(6)];
newDispenser.save()
if request.POST['requestType'] == 'newCompartment':
newCompartment = compartment(loaded = False)
newCompartment.save()
newID = newCompartment.id
if request.POST['requestType'] == 'deleteCompartment':
# TODO: Implement this? Need to remove from dispenser
id = request.POST['id']
compartment.objects(id=id)[0].delete()
return render(request, 'dispenser_admin.html', {'compartments' : compartment.objects(), 'dispensers' : dispenser.objects(), 'newID' : newID})
def RegView(request):
if request.method == 'GET':
return render(request, 'reg.html')
if request.method == 'POST':
try:
username = request.POST['username']
password = request.POST['password']
passwordrepeat = request.POST['password-repeat']
if User.objects(username=username).first():
messages.error(request, "user exists")
return redirect("reg.html")
elif password != passwordrepeat:
messages.error(request, "please enter same password")
return redirect("reg.html")
else:
user = User.create_user(username = username, password = password)
messages.success(request, "user register successfully")
return render(reqeuest, 'user.html')
except:
messages.error(request, "Error, please try again")
return redirect("reg.html")
def setUp(self):
# Create a test user
self.user_data = {
'username': '******',
'password': '******',
}
self.user = User.create_user(*self.user_data.values())
# Create a test entry
self.text_entry = TextEntry(title='Test-Entry', slug='test-entry')
self.text_entry.tags = ['tests']
self.text_entry.published = True
self.text_entry.content = 'some-test-content'
self.text_entry.rendered_content = '<p>some test content</p>'
# Create test comment
self.comment = HtmlComment(
author='Mr Test',
body='test comment',
rendered_content = '<p>test comment</p>',
)
self.text_entry.comments = [self.comment]
self.text_entry.save()
def register(request):
form = UserCreationForm(request.POST or None)
if form.is_valid():
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
password = request.POST['password2']
username = request.POST['username']
new_user = User.create_user(username=username, email=email,
password=password)
new_user.first_name = first_name
new_user.last_name = last_name
new_user.save()
auth_user = authenticate(username=username, password=password)
login(request=request, user=auth_user)
# Create a new account for this user
new_account = Account(admin=new_user, company=request.POST['company'])
new_account.save()
# Create a user profile to link this user to this account
new_profile = UserProfile(username=new_user.username,
user=new_user,
company=new_account)
new_profile.save()
msg = 'Created username: %s and Company: %s' % (new_user.username,
new_account.company)
messages.success(request, msg)
return HttpResponseRedirect('/devices/')
data = {'title': 'Kolabria - Registration Page',
'form': form,}
return render_to_response('account/create.html', data,
context_instance=RequestContext(request))
def setUp(self):
# Create a test user
self.user_data = {
'username': '******',
'password': '******',
}
self.user = User.create_user(*self.user_data.values())
# Create a test entry
self.text_entry = TextEntry(title='Test-Entry', slug='test-entry')
self.text_entry.tags = ['tests']
self.text_entry.published = True
self.text_entry.content = 'some-test-content'
self.text_entry.rendered_content = '<p>some test content</p>'
# Create test comment
self.comment = HtmlComment(
author='Mr Test',
body='test comment',
rendered_content='<p>test comment</p>',
)
self.text_entry.comments = [self.comment]
self.text_entry.save()
def pytest_funcarg__admin(request):
'''Create an admin user with all permissions.'''
admin = User.create_user(username="******", password="******", email="*****@*****.**")
admin.is_superuser = True
admin.save()
return admin
def createuser(request):
connect('reborn')
User.create_user('boba', 'bobpass', '*****@*****.**')
return HttpResponse("SAVED")
import django
import json
import os, sys
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bibstat.settings")
from django.conf import settings
from mongoengine.django.auth import User
user = User.create_user(email='', username='', password='')
user.is_active = True
user.is_staff = True
user.is_superuser = True
user.save()
print(user)
def _fixture_setup(self):
user=User.create_user('john','john')
def createuser(request):
User.create_user(request.POST['username'], request.POST['password'])
return HttpResponseRedirect('/login/')
