def _add_world_list(template_name, **params):
worlds = runtime.get_available_worlds()
if request.query.get('select_world') and request.query.get('select_world') in worlds:
current_world = request.query.get('select_world')
response.set_cookie('selected_world', current_world)
else:
current_world = request.get_cookie('selected_world')
world_type = ""
world_assets = {}
world_template = ""
if current_world:
world_obj = runtime.load_world(current_world)
world_type = world_obj.__class__.__name__
if hasattr(world_obj, 'assets'):
world_assets = world_obj.assets
if 'template' in world_assets:
import inspect
basedir = os.path.dirname(inspect.getfile(world_obj.__class__))
with open(os.path.join(basedir, world_assets['template'])) as fp:
world_template = template(fp.read(), world_assets=world_assets)
return template(template_name, current=current_world,
mine=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].get('owner') == params['user_id']),
others=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].get('owner') != params['user_id']),
world_type=world_type,
world_assets=world_assets,
world_template=world_template,
**params)
def user_mgt():
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
return template("user_mgt", version=VERSION, permissions=permissions,
user_id=user_id,
userlist=usermanager.list_users())
return template("error", msg="Insufficient rights to access user console")
def login_submit():
params = dict((key, request.forms.getunicode(key)) for key in request.forms)
user_id = params['userid']
password = params['password']
# log in new user
token = usermanager.start_session(user_id, password, params.get("keep_logged_in"))
if token:
response.set_cookie("token", token)
# redirect to start page
return dict(redirect="/")
else:
# login failed, retry
if user_id in usermanager.users:
return template("login", version=VERSION, userid=user_id, password=password,
title="Log in to the %s server" % APPTITLE,
password_error="Re-enter the password",
login_error="User name and password do not match",
cookie_warning=(token is None),
permissions=usermanager.get_permissions_for_session_token(token))
else:
return template("login", version=VERSION, userid=user_id, password=password,
title="Log in to the %s server" % APPTITLE,
userid_error="Re-enter the user name",
login_error="User unknown",
cookie_warning=(token is None),
permissions=usermanager.get_permissions_for_session_token(token))
def set_password(userid):
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
return template("set_password", version=VERSION, permissions=permissions,
title="Change Password",
user_id=user_id,
userid=userid)
return template("error", msg="Insufficient rights to access user console")
def login_as_user(userid):
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
if userid in usermanager.users:
if usermanager.switch_user_for_session_token(userid, token):
# redirect to start page
redirect("/")
return template("error", msg="Could not log in as new user")
return template("error", msg="User does not exist")
return template("error", msg="Insufficient rights to access user console")
def login():
if not usermanager.users: # create first user
return template("signup", version=VERSION, first_user=True, userid="admin",
title="Create the administrator for the %s server" % APPTITLE)
return template("login",
title="Log in to the %s server" % APPTITLE,
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(None),
permissions=usermanager.get_permissions_for_session_token(None))
def nodenet_mgt():
user_id, permissions, token = get_request_data()
if "manage nodenets" in permissions:
notification = None
if request.get_cookie('notification'):
notification = json.loads(request.get_cookie('notification'))
response.set_cookie('notification', '', path='/')
return template("nodenet_mgt", version=VERSION, permissions=permissions,
user_id=user_id,
nodenet_list=runtime.get_available_nodenets(), notification=notification)
return template("error", msg="Insufficient rights to access nodenet console")
def signup():
if request.get_cookie("token"):
token = request.get_cookie("token")
else:
token = None
if not usermanager.users: # create first user
return template("signup", version=VERSION,
title="Create the administrator for the %s server" % APPTITLE,
first_user=True, cookie_warning=(token is None))
return template("signup", version=VERSION,
title="Create a new user for the %s server" % APPTITLE,
permissions=usermanager.get_permissions_for_session_token(token),
cookie_warning=(token is None))
def nodenet_list(current_nodenet=None):
user_id, permissions, token = get_request_data()
nodenets = runtime.get_available_nodenets()
return template("nodenet_list", type="nodenet", user_id=user_id,
current=current_nodenet,
mine=dict((uid, nodenets[uid]) for uid in nodenets if nodenets[uid].owner == user_id),
others=dict((uid, nodenets[uid]) for uid in nodenets if nodenets[uid].owner != user_id))
def world_list(current_world=None):
user_id, permissions, token = get_request_data()
worlds = runtime.get_available_worlds()
return template("nodenet_list", type="world", user_id=user_id,
current=current_world,
mine=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].owner == user_id),
others=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].owner != user_id))
def edit_runner_properties():
user_id, permissions, token = get_request_data()
if len(request.params) > 0:
runtime.set_runner_properties(int(request.params['timestep']), int(request.params['factor']))
return dict(status="success", msg="Settings saved")
else:
return template("runner_form", action="/config/runner", value=runtime.get_runner_properties())
def select_nodenet_from_console(nodenet_uid):
user_id, permissions, token = get_request_data()
result, uid = runtime.load_nodenet(nodenet_uid)
if not result:
return template("error", msg="Could not select nodenet")
response.set_cookie("selected_nodenet", nodenet_uid + "/", path="/")
redirect("/")
def delete_user(userid):
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
if userid in usermanager.users:
usermanager.delete_user(userid)
redirect("/user_mgt")
return template("error", msg="Insufficient rights to access user console")
def set_permissions(user_key, role):
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
if user_key in usermanager.users and role in usermanagement.USER_ROLES:
usermanager.set_user_role(user_key, role)
redirect('/user_mgt')
return template("error", msg="Insufficient rights to access user console")
def create_user_submit():
params = dict((key, request.forms.getunicode(key)) for key in request.forms)
user_id, permissions, token = get_request_data()
userid = params['userid']
password = params['password']
role = params.get('permissions')
(success, result) = micropsi_core.tools.check_for_url_proof_id(userid, existing_ids=usermanager.users.keys())
if success:
# check if permissions in form are consistent with internal permissions
if ((role == "Administrator" and ("create admin" in permissions or not usermanager.users)) or
(role == "Full" and "create full" in permissions) or
(role == "Restricted" and "create restricted" in permissions)):
if usermanager.create_user(userid, password, role, uid=micropsi_core.tools.generate_uid()):
if request.is_xhr:
return dict(status="OK", redirect='/user_mgt')
else:
redirect('/user_mgt')
else:
return dict(status="error", msg="User creation failed for an obscure internal reason.")
else:
return dict(status="error", msg="Permission inconsistency during user creation.")
else:
# something wrong with the user id, retry
return template("create_user", version=VERSION, user_id=user_id,
title="Create a user for the %s server" % APPTITLE,
permissions=permissions, userid_error=result)
return dict(status="error", msg="Insufficient rights to access user console")
def edit_worldrunner():
user_id, permissions, token = get_request_data()
if len(request.params) > 0:
runtime.set_worldrunner_timestep(int(request.params['runner_timestep']))
return dict(status="success", msg="Timestep saved")
else:
return template("runner_form", mode="world", action="/config/world/runner", value=runtime.get_worldrunner_timestep())
def merge_nodenet_form(nodenet_uid):
token = request.get_cookie("token")
return template("upload.tpl", title='Merge Nodenet', message='Select a file to upload and use for merging',
action='/nodenet/merge/%s' % nodenet_uid,
version=VERSION,
userid=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def import_world_form():
token = request.get_cookie("token")
return template("upload.tpl", title='World import', message='Select a file to upload and use for importing',
action='/world/import',
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def signup_submit():
params = dict((key, request.forms.getunicode(key)) for key in request.forms)
user_id, permissions, token = get_request_data()
userid = params['userid']
password = params['password']
role = params.get('permissions')
firstuser = not usermanager.users
(success, result) = micropsi_core.tools.check_for_url_proof_id(userid, existing_ids=usermanager.users.keys())
if success:
# check if permissions in form are consistent with internal permissions
if ((role == "Administrator" and ("create admin" in permissions or not usermanager.users)) or
(role == "Full" and "create full" in permissions) or
(role == "Restricted" and "create restricted" in permissions)):
if usermanager.create_user(userid, password, role, uid=micropsi_core.tools.generate_uid()):
# log in new user
token = usermanager.start_session(userid, password, params.get("keep_logged_in"))
response.set_cookie("token", token)
# redirect to start page
return dict(redirect='/')
else:
return dict(status="error", msg="User creation failed for an obscure internal reason.")
else:
return dict(status="error", msg="Permission inconsistency during user creation.")
else:
# something wrong with the user id, retry
return template("signup", version=VERSION, userid=userid, password=password, userid_error=result,
title="Create a new user for the %s server" % APPTITLE, first_user=firstuser,
user_id=user_id, permissions=permissions, cookie_warning=(token is None))
def signup():
if request.get_cookie("token"):
token = request.get_cookie("token")
else:
token = None
if not usermanager.users: # create first user
return template("signup", version=VERSION,
title="Create the administrator for the %s server" % APPTITLE,
first_user=True, cookie_warning=(token is None))
return template("signup", version=VERSION,
title="Create a new user for the %s server" % APPTITLE,
permissions=usermanager.get_permissions_for_session_token(token),
first_user=False,
cookie_warning=(token is None))
def delete_nodenet_from_console(nodenet_uid):
user_id, permissions, token = get_request_data()
if "manage nodenets" in permissions:
runtime.delete_nodenet(nodenet_uid)
response.set_cookie('notification', '{"msg":"Nodenet deleted", "status":"success"}', path='/')
redirect('/nodenet_mgt')
return template("error", msg="Insufficient rights to access nodenet console")
def edit_world_form():
token = request.get_cookie("token")
id = request.params.get('id', None)
title = 'Edit World' if id is not None else 'New World'
return template("world_form.tpl", title=title, worldtypes=runtime.get_available_world_types(),
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def save_all_nodenets():
user_id, permissions, token = get_request_data()
if "manage nodenets" in permissions:
for uid in runtime.nodenets:
runtime.save_nodenet(uid)
response.set_cookie('notification', '{"msg":"All nodenets saved", "status":"success"}', path='/')
redirect('/nodenet_mgt')
return template("error", msg="Insufficient rights to access nodenet console")
def error_page(error):
if request.is_xhr:
response.content_type = "application/json"
return json.dumps({
"status": "error",
"data": "Function not found"
})
return template("error.tpl", error=error, msg="Page not found.", img="/static/img/brazil.gif")
def error_page_405(error):
if request.is_xhr:
response.content_type = "application/json"
return json.dumps({
"status": "error",
"data": "Method not allowed"
})
return template("error.tpl", error=error, msg="Method not allowed.", img="/static/img/strangelove.gif")
def edit_world_form():
token = request.get_cookie("token")
worldtypes = runtime.get_available_world_types()
world_data = runtime.world_data
return template("world_form.tpl",
worldtypes=worldtypes,
world_data=world_data,
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def edit_device_form():
token = request.get_cookie("token")
device_types = runtime.get_device_types()
device_data = runtime.get_devices()
return template("device_form.tpl",
device_types=device_types,
device_data=device_data,
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def edit_nodenet():
user_id, permissions, token = get_request_data()
# nodenet_id = request.params.get('id', None)
title = 'Edit Nodenet' if id is not None else 'New Nodenet'
return template("nodenet_form.tpl", title=title,
# nodenet_uid=nodenet_uid,
nodenets=runtime.get_available_nodenets(),
templates=runtime.get_available_nodenets(),
worlds=runtime.get_available_worlds(),
version=VERSION, user_id=user_id, permissions=permissions)
def edit_world_form():
token = request.get_cookie("token")
id = request.params.get('id', None)
title = 'Edit World' if id is not None else 'New World'
worldtypes = runtime.get_available_world_types()
return template("world_form.tpl", title=title,
worldtypes=worldtypes,
version=VERSION,
user_id=usermanager.get_user_id_for_session_token(token),
permissions=usermanager.get_permissions_for_session_token(token))
def edit_nodenet():
user_id, permissions, token = get_request_data()
nodenet_uid = request.params.get('id')
title = 'Edit Agent' if nodenet_uid is not None else 'New Agent'
return template("nodenet_form.tpl", title=title,
nodenet=None if not nodenet_uid else runtime.get_nodenet(nodenet_uid).metadata,
devices=runtime.get_devices(),
nodenets=runtime.get_available_nodenets(),
worldtypes=runtime.get_available_world_types(),
templates=runtime.get_available_nodenets(),
worlds=runtime.get_available_worlds(),
version=VERSION, user_id=user_id, permissions=permissions)
def change_password_submit():
user_id, permissions, token = get_request_data()
if token:
old_password = request.forms.old_password
new_password = request.forms.new_password
if usermanager.test_password(user_id, old_password):
usermanager.set_user_password(user_id, new_password)
return dict(msg='New password saved', status="success")
else:
return template("change_password", title="Change password", version=VERSION, user_id=user_id, old_password=old_password,
permissions=permissions, new_password=new_password,
old_password_error="Wrong password, please try again")
else:
return dict(status="error", msg="Cannot change password outside of a session")
def _add_world_list(template_name, **params):
worlds = runtime.get_available_worlds()
if request.query.get('select_world') and request.query.get('select_world') in worlds:
current_world = request.query.get('select_world')
response.set_cookie('selected_world', current_world)
else:
current_world = request.get_cookie('selected_world')
if current_world in worlds and hasattr(worlds[current_world], 'assets'):
world_assets = worlds[current_world].assets
else:
world_assets = {}
return template(template_name, current=current_world,
mine=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].owner == params['user_id']),
others=dict((uid, worlds[uid]) for uid in worlds if worlds[uid].owner != params['user_id']),
world_assets=world_assets, **params)
def change_password_submit():
params = dict((key, request.forms.getunicode(key)) for key in request.forms)
user_id, permissions, token = get_request_data()
if token:
old_password = params['old_password']
new_password = params['new_password']
if usermanager.test_password(user_id, old_password):
usermanager.set_user_password(user_id, new_password)
return dict(msg='New password saved', status="success")
else:
return template("change_password", title="Change password", version=VERSION, user_id=user_id, old_password=old_password,
permissions=permissions, new_password=new_password,
old_password_error="Wrong password, please try again")
else:
return dict(status="error", msg="Cannot change password outside of a session")
def edit_nodenet():
user_id, permissions, token = get_request_data()
# nodenet_id = request.params.get('id', None)
title = 'Edit Nodenet' if id is not None else 'New Nodenet'
theano_available = True
try:
import theano
except ImportError:
theano_available = False
return template("nodenet_form.tpl", title=title,
# nodenet_uid=nodenet_uid,
nodenets=runtime.get_available_nodenets(),
templates=runtime.get_available_nodenets(),
worlds=runtime.get_available_worlds(),
version=VERSION, user_id=user_id, permissions=permissions, theano_available=theano_available)
def show_dashboard():
user_id, permissions, token = get_request_data()
return template("viewer", mode="dashboard", logging_levels=runtime.get_logging_levels(), user_id=user_id, permissions=permissions, token=token, version=VERSION)
def create_worldadapter_selector(world_uid):
nodenets = runtime.get_available_nodenets()
worlds = runtime.get_available_worlds()
return template("worldadapter_selector", world_uid=world_uid,
nodenets=nodenets, worlds=worlds)
def create_new_nodenet_form():
user_id, permissions, token = get_request_data()
nodenets = runtime.get_available_nodenets()
worlds = runtime.get_available_worlds()
return template("nodenet_form", user_id=user_id, template="None",
nodenets=nodenets, worlds=worlds)
def change_password():
user_id, permissions, token = get_request_data()
if token:
return template("change_password", title="Change password", version=VERSION, user_id=user_id, permissions=permissions)
else:
return dict(status="error", msg="Cannot change password outside of a session")
def create_user():
user_id, permissions, token = get_request_data()
if "manage users" in permissions:
return template("create_user", version=VERSION, user_id=user_id,
title="Create a user for the %s server" % APP_PATH, permissions=permissions)
return template("error", msg="Insufficient rights to access user console")
