def logout(self, targetURL=h.encodeURL("/")):
"Logout"
# If the person is logged in,
if h.isPerson():
del session["minutesOffset"]
del session["personID"]
del session["nickname"]
session.save()
# Redirect
return redirect(url(h.decodeURL(targetURL)))
def logout(self, targetURL=h.encodeURL('/')):
'Logout'
# If the person is logged in,
if h.isPerson():
del session['minutesOffset']
del session['personID']
del session['nickname']
session.save()
# Redirect
return redirect(url(h.decodeURL(targetURL)))
def confirm(self, ticket):
"Confirm changes"
# Send feedback
candidate = confirmPersonCandidate(ticket)
# If the candidate exists,
if candidate:
messageCode = "updated" if candidate.person_id else "created"
else:
messageCode = "expired"
# Return
return redirect(url("person_login", targetURL=h.encodeURL("/"), messageCode=messageCode))
def confirm(self, ticket):
'Confirm changes'
# Send feedback
candidate = confirmPersonCandidate(ticket)
# If the candidate exists,
if candidate:
messageCode = 'updated' if candidate.person_id else 'created'
else:
messageCode = 'expired'
# Return
return redirect(url('person_login', targetURL=h.encodeURL('/'), messageCode=messageCode))
def test_logout(self):
"""
Make sure that logging out works
If the person is logged in, make sure the person gets logged out
and is redirected properly. If the person is already logged out,
return the user to the page before the user tried to log out.
"""
# Initialize
url_test = url("person_index")
# Add person
meta.Session.add(model.Person(username, model.hashString(password), nickname, email))
meta.Session.commit()
# Logging out should redirect back
self.assert_(url_test in self.app.get(url("person_logout", targetURL=h.encodeURL(url_test))))
# Log in
self.assert_("Login" in self.app.get(url("person_login", targetURL=h.encodeURL(url_test))))
self.assertEqual(
simplejson.dumps({"isOk": 1}),
self.app.post(url("person_login_"), dict(username=username, password=password)).body,
)
# Logging out should redirect back
self.assert_(url_test in self.app.get(url("person_logout", targetURL=h.encodeURL(url_test))))
def update(self):
'Show account update page'
# Load
personID = h.getPersonID()
# If the person is not logged in,
if not personID:
# Return
return redirect(url('person_login', targetURL=h.encodeURL('/')))
# Render
c.isNew = False
person = Session.query(model.Person).get(personID)
# Return
return formencode.htmlfill.render(render('/people/change.mako'), {
'username': person.username,
'nickname': person.nickname,
'email': person.email,
'email_sms': person.email_sms,
})
def clone(self, scenarioID):
'Show form to create a new item based on datasets and parameters from existing scenario'
# Make sure the user is logged in
personID = h.getPersonID()
if not personID:
return redirect(url('person_login', targetURL=h.encodeURL(request.path)))
# Make sure the user has access to the scenario
scenario = Session.query(model.Scenario).filter(model.getScopeFilter(personID)).filter(model.Scenario.id==scenarioID).first()
if not scenario:
return redirect(url('new_scenario'))
# Load
scenarioInput = scenario.input
# Prepare
c.scenario = scenario
c.metricModel = metric.getModel(request.GET.get('metricModel', scenarioInput['metric model name']))
c.metricConfiguration = scenarioInput['metric configuration']
c.networkModel = network.getModel(request.GET.get('networkModel', scenarioInput['network model name']))
c.networkConfiguration = scenarioInput['network configuration']
# Return
return render('/scenarios/new.mako')
def update(self):
"Show account update page"
# Load
personID = h.getPersonID()
# If the person is not logged in,
if not personID:
# Return
return redirect(url("person_login", targetURL=h.encodeURL("/")))
# Render
c.isNew = False
person = Session.query(model.Person).get(personID)
# Return
return formencode.htmlfill.render(
render("/people/change.mako"),
{
"username": person.username,
"nickname": person.nickname,
"email": person.email,
"email_sms": person.email_sms,
},
)
def new(self, format='html'):
'GET /scenarios/new: Show form to create a new item'
# If the user is not logged in,
if not h.isPerson():
# Redirect to login
return redirect(url('person_login', targetURL=h.encodeURL(h.url('new_scenario'))))
# Make sure that the requested metric model exists
metricModelNames = metric.getModelNames()
metricModelName = request.GET.get('metricModel')
if metricModelName not in metricModelNames:
metricModelName = metricModelNames[0]
c.metricModel = metric.getModel(metricModelName)
c.metricConfiguration = {}
# Make sure that the requested network model exists
networkModelNames = network.getModelNames()
networkModelName = request.GET.get('networkModel')
if networkModelName not in networkModelNames:
networkModelName = networkModelNames[0]
c.networkModel = network.getModel(networkModelName)
c.networkConfiguration = {}
# Render form
c.scenario = None
return render('/scenarios/new.mako')
def test_login(self):
"""
Make sure that logging in works
Ensure that the login page shows
Ensure that bad credentials result in an error message
Ensure that good credentials result in a proper redirect
"""
# Initialize
url_test = url("person_update")
# Assert that the login page shows and stores url
self.assert_("Login" in self.app.get(url("person_login", targetURL=h.encodeURL(url_test))))
# Add person
meta.Session.add(model.Person(username, model.hashString(password), nickname, email))
meta.Session.commit()
# Log in using bad credentials
self.assertEqual(
simplejson.dumps({"rejection_count": 1, "isOk": 0}),
self.app.post(url("person_login_"), dict(username=username, password=password + "x")).body,
)
# Log in using good credentials
self.assertEqual(
simplejson.dumps({"isOk": 1}),
self.app.post(url("person_login_"), dict(username=username, password=password)).body,
)
def create(self):
'POST /scenarios: Create a new item'
# Initialize
personID = h.getPersonID()
if not personID:
return redirect(url('person_login', targetURL=h.encodeURL(h.url('new_scenario'))))
# Load
try:
demographicDatabase_h = int(request.POST.get('demographicDatabase_h', 0))
except ValueError:
demographicDatabase_h = 0
if not demographicDatabase_h and 'demographicDatabase' not in request.POST:
return cjson.encode(dict(isOk=0, message='The demographicDatabase field is required'))
scenarioName = request.POST.get('scenarioName') or 'Untitled'
try:
scenarioScope = int(request.POST.get('scenarioScope', model.scopePrivate))
except ValueError:
scenarioScope = model.scopePrivate
metricModelName = request.POST.get('metricModelName', metric.getModelNames()[0])
networkModelName = request.POST.get('networkModelName', network.getModelNames()[0])
callbackURL = request.POST.get('callbackURL')
# Create scenario
scenario = model.Scenario(personID, scenarioName, scenarioScope)
Session.add(scenario)
Session.commit()
scenarioFolder = scenario.getFolder()
if os.path.exists(scenarioFolder):
shutil.rmtree(scenarioFolder)
store.makeFolderSafely(scenarioFolder)
# If the user is using an existing demographicDatabase,
if demographicDatabase_h:
# Copy source in case it is deleted
sourceScenario = Session.query(model.Scenario).get(demographicDatabase_h)
sourceScenarioFolder = sourceScenario.getFolder()
demographicFileName = sourceScenario.input['demographic file name']
demographicPath = os.path.join(scenarioFolder, demographicFileName)
shutil.copyfile(os.path.join(sourceScenarioFolder, demographicFileName), demographicPath)
# If the user is uploading a new demographicDatabase,
else:
# Save original demographicDatabase in case the user wants it later
demographicDatabase = request.POST['demographicDatabase']
demographicFileExtension = os.path.splitext(demographicDatabase.filename)[1]
demographicFileName = 'demographics' + demographicFileExtension
demographicPath = os.path.join(scenarioFolder, demographicFileName)
shutil.copyfileobj(demographicDatabase.file, open(demographicPath, 'wb'))
demographicDatabase.file.close()
# Store input
configurationByName = extractConfigurationByName(request.POST, scenarioFolder)
scenario.input = {
'demographic file name': str(demographicFileName),
'metric model name': metricModelName,
'metric configuration': configurationByName.get('metric', {}),
'network model name': networkModelName,
'network configuration': configurationByName.get('network', {}),
'callback url': callbackURL,
'host url': request.host_url,
}
Session.commit()
store.zipFolder(scenarioFolder + '.zip', scenarioFolder)
# Redirect
redirect(url('scenario', id=scenario.id))
def test_update(self):
"""
Make sure that updating credentials works
Make sure the update page only appears when the user is logged in
Make sure the update form is filled with the user's credentials
Make sure that update_ only works when the user is logged in
Make sure that update confirmation works
"""
# Assert that we are redirected to the login page if the person is not logged in
response = self.app.get(url("person_update"))
self.assertEqual(
urlparse.urlparse(response.response.location).path, url("person_login", targetURL=h.encodeURL("/"))
)
# Assert that we get rejected if we try to post without logging in
self.assertEqual(simplejson.dumps({"isOk": 0}), self.app.post(url("person_update_")).body)
# Add person
meta.Session.add(model.Person(username, model.hashString(password), nickname, email, email_sms))
meta.Session.commit()
# Log in
self.app.post(url("person_login_"), dict(username=username, password=password))
# Assert that the update form is filled with the user's credentials
responseBody = self.app.get(url("person_update")).body
self.assert_(username in responseBody)
self.assert_(nickname in responseBody)
self.assert_(email in responseBody)
self.assert_(email_sms in responseBody)
# Update credentials
newUsername = store.makeRandomString(16)
newPassword = store.makeRandomAlphaNumericString(parameter.PASSWORD_LENGTH_AVERAGE)
newNickname = unicode(store.makeRandomString(16))
newEmail = re.sub(r".*@", store.makeRandomString(16) + "@", email)
newEmailSMS = re.sub(r".*@", store.makeRandomString(16) + "@", email)
self.assertEqual(
simplejson.dumps({"isOk": 1}),
self.app.post(
url("person_update_"),
dict(
username=newUsername,
password=newPassword,
nickname=newNickname,
email=newEmail,
email_sms=newEmailSMS,
),
).body,
)
# Make sure the credentials have not changed yet
self.assertEqual(
meta.Session.query(model.Person)
.filter_by(
username=newUsername,
password_hash=model.hashString(newPassword),
nickname=newNickname,
email=newEmail,
email_sms=newEmailSMS,
)
.count(),
0,
)
# Activate candidate
self.app.get(
url(
"person_confirm",
ticket=meta.Session.query(model.PersonCandidate.ticket).filter_by(username=newUsername).first()[0],
)
)
# Make sure the credentials have changed
self.assertEqual(
meta.Session.query(model.Person)
.filter_by(
username=newUsername,
password_hash=model.hashString(newPassword),
nickname=newNickname,
email=newEmail,
email_sms=newEmailSMS,
)
.count(),
1,
)
def login(self, targetURL=h.encodeURL("/")):
"Show login form"
c.messageCode = request.GET.get("messageCode")
c.targetURL = h.decodeURL(targetURL)
c.publicKey = config["safe"]["recaptcha"]["public"]
return render("/people/login.mako")
def login(self, targetURL=h.encodeURL('/')):
'Show login form'
c.messageCode = request.GET.get('messageCode')
c.targetURL = h.decodeURL(targetURL)
c.publicKey = config['safe']['recaptcha']['public']
return render('/people/login.mako')
