def rename(self, request):
nerve.users.require_group('admin')
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
# TODO you totally don't validate these names enough
oldname = request.arg('oldname')
newname = request.arg('newname')
if not oldname or not nerve.has_object(oldname):
raise nerve.ControllerError(
"The directory you've specified is invalid.")
if not newname:
raise nerve.ControllerError("The new name given is invalid.")
if nerve.has_object(newname):
raise nerve.ControllerError(
"An object of that name already exists.")
obj = nerve.get_object(oldname)
if not nerve.del_object(oldname):
raise nerve.ControllerError("Unable to rename this object.")
nerve.set_object(newname, obj)
nerve.save_config()
self.load_json_view({'notice': "Object renamed"})
def add_media_items(self, request):
operation = request.arg('operation')
if not operation:
raise nerve.ControllerError("'operation' field must be set")
if not request.arg('media[]'):
raise nerve.ControllerError("'media[]' field must be set")
count = 0
medialib = nerve.get_object(self.get_setting('device'))
media = medialib.get_media_queries(request.arg('media[]'))
if operation == 'playnow':
player = nerve.get_object(self.get_setting('player'))
if len(media) > 0:
player.play(media[0]['filename'])
for media_item in media[1:]:
player.enqueue(media_item['filename'])
count = len(media)
elif operation in [ 'enqueue', 'replace' ]:
if not request.arg('playlist'):
raise nerve.ControllerError("'playlist' field must be set")
playlist = nerve.medialib.Playlist(request.arg('playlist'))
if operation == 'replace':
count = playlist.set_list(media)
elif operation == 'enqueue':
count = playlist.add_list(media)
if count > 0:
self.load_json_view({ 'notice': str(count) + " track(s) were added to playlist " + request.arg('playlist') })
else:
self.load_json_view({ 'error': "No tracks were added" })
def deletepage(self, request):
pagename = request.arg('name', default=None)
if not pagename:
raise nerve.ControllerError(
'You must provide a page name to delete')
if not self.model.page_exists(pagename):
raise nerve.ControllerError(
'Attempting to delete non-existent page: ' + pagename)
self.model.delete_page(pagename)
self.load_json_view({'notice': 'Page deleted successfully'})
def defaults(self, request):
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
if not request.arg('type'):
raise nerve.ControllerError("You must select a type first")
basename = request.arg('basename', default='')
self.set_view(
FormView(nerve.types.ConfigType.get_type('object'),
{'__type__': request.arg('type')},
basename=basename))
def deleteblock(self, request):
blockname = request.arg('name', default=None)
if not blockname:
raise nerve.ControllerError(
'You must provide a block name to delete')
if not self.model.block_exists(blockname):
raise nerve.ControllerError(
'Attempting to delete non-existent block: ' + blockname)
self.model.delete_block(blockname)
self.load_json_view({'notice': 'Block deleted successfully'})
def delete_code(self, request):
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
code = request.arg('code')
if not code:
raise nerve.ControllerError(
"You must provide the 'code' argument.")
irremote = nerve.get_object('/devices/irremote')
irremote.delete_code(code)
self.load_json_view({'notice': code + ' has been deleted'})
def create(self, name):
for pname in Playlist.listnames():
if name == pname:
raise nerve.ControllerError(
"A playlist by that name already exists")
Playlist.create(name)
return true
def remove_remote(self, request):
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
remote_name = request.arg('remote_name')
if not remote_name:
raise nerve.ControllerError(
"You must provide the 'remote_name' argument.")
irremote = nerve.get_object('/devices/irremote')
irremote.remove_remote(remote_name)
self.load_json_view({
'notice': "Remote " + remote_name + " has been removed.",
'remote_name': remote_name
})
def send_code(self, request):
code = request.arg('code')
if not code:
raise nerve.ControllerError("You must provide an IR code")
#irremote = nerve.get_object('/devices/irremote')
nerve.query('/devices/rgb/ir', code)
self.load_json_view({'notice': "Code sent."})
def saveblock(self, request):
originalname = request.arg('originalname')
blockname = request.arg('blockname')
blocktext = request.arg('blocktext')
if not blockname:
raise nerve.ControllerError(
'You must provide a name for this block')
if originalname and not self.model.block_exists(originalname):
raise nerve.ControllerError(
'Attempting to save non-existent block: ' + originalname)
if not originalname and self.model.block_exists(blockname):
raise nerve.ControllerError(
'A block by that name already exists: ' + blockname)
self.model.save_block(originalname, blockname, blocktext)
self.load_json_view({'notice': 'Block saved successfully'})
def clear(self, request):
if not request.arg('nids[]'):
raise nerve.ControllerError("'nids[]' field must be set")
notify = nerve.get_object(self.get_setting('device'))
for nid in request.arg('nids[]'):
notify.clear(int(nid))
self.load_json_view(True)
def create_playlist(self, request):
playlists = nerve.get_object(self.get_setting('playlists'))
playlist_name = request.args['playlist']
for name in playlists.list():
if name == playlist_name:
raise nerve.ControllerError("A playlist by that name already exists")
playlist = nerve.medialib.Playlist.create(playlist_name)
self.load_json_view({ 'notice' : "Playlist created successfully" })
def savepage(self, request):
originalname = request.arg('originalname')
pagename = request.arg('pagename')
if not pagename:
raise nerve.ControllerError(
'You must provide a name for this page')
if originalname and not self.model.page_exists(originalname):
raise nerve.ControllerError(
'Attempting to save non-existent page: ' + originalname)
if originalname != pagename and self.model.page_exists(pagename):
raise nerve.ControllerError(
'A page by that name already exists: ' + pagename)
pagedata = PageView.get_config_info().validate(request.args)
self.model.save_page_data(originalname, pagename, pagedata)
self.load_json_view({'notice': 'Page saved successfully'})
def delete(self, request):
nerve.users.require_group('admin')
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
objectname = request.args['objectname']
if not objectname or not nerve.has_object(objectname):
raise nerve.ControllerError(
"The object you've specified doesn't exist.")
result = nerve.del_object(objectname)
if not result:
raise nerve.ControllerError("Unable to delete object.")
nerve.save_config()
self.load_json_view({'notice': "Object deleted"})
def index(self, request):
if request.reqtype == 'CONNECT':
self.handle_connection(request)
elif request.reqtype == 'QUERY':
self.load_plaintext_view('')
for query_string in request.args['requests[]']:
self.run_command(query_string)
else:
raise nerve.ControllerError("unexpected request type; received " + request.reqtype)
def save_action(self, request):
nerve.users.require_group('admin')
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
code = request.get_slug()
if not code:
raise nerve.ControllerError("You must provide a valid object name")
irremote = nerve.get_object('/devices/irremote')
defaults = nerve.ObjectNode.get_class_config_info(
'asyncs/PyCodeAsyncTask')
config = defaults.validate(request.args)
config['__type__'] = 'asyncs/PyCodeAsyncTask'
irremote.set_action(code, config)
self.load_json_view({'notice': "Action added"})
def editblock(self, request):
data = {}
data['blockname'] = request.next_segment(default='')
if request.segments_left() > 0:
raise nerve.ControllerError("Too many path segments given")
if data['blockname'] and not self.model.block_exists(
data['blockname']):
raise nerve.ControllerError("Block doesn't exist: " +
data['blockname'])
data['blocktext'] = self.model.get_block(
data['blockname']) if data['blockname'] else ''
self.load_template_view(
'nerve/pages/views/editor/editblock.blk.pyhtml', data, request)
#self.template_add_to_section('sidebar', self.make_html_view('nerve/pages/views/editor/sidebar.blk.pyhtml', data))
self.template_add_to_section('jsfiles', '/pages/assets/js/pages.js')
self.template_add_to_section('cssfiles', '/pages/assets/css/pages.css')
def add_remote(self, request):
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
remote_name = request.arg('remote_name')
if not remote_name:
raise nerve.ControllerError(
"You must provide the 'remote_name' argument.")
irremote = nerve.get_object('/devices/irremote')
if irremote.add_remote(remote_name):
self.load_json_view({
'notice': "Remote " + remote_name + " has been added.",
'remote_name': remote_name
})
else:
self.load_json_view(
{'error': "A remote by that name already exists."})
def save(self, request):
nerve.users.require_group('admin')
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
path = request.get_slug()
if not path:
raise nerve.ControllerError("You must provide a valid object name")
print(path)
print(request.args)
obj = nerve.get_object(path)
config = obj.get_config_info().validate(request.args)
obj.update_config_data(config)
nerve.save_config()
self.load_json_view({'notice': "Saved successfully"})
def dialog(self, request):
#nerve.users.require_group('admin')
(slug, _, idnum) = request.get_slug().partition('/')
if idnum != '':
try:
idnum = int(idnum)
except:
raise nerve.ControllerError("invalid id in request: " +
str(idnum))
if slug not in [
'edituser', 'editgroup', 'deleteuser', 'deletegroup'
]:
raise nerve.ControllerError("invalid operation in request: " +
str(slug))
data = {}
data['idnum'] = idnum
self.load_html_view(
'nerve/base/views/users/{0}.blk.pyhtml'.format(slug), data)
def create(self, request):
nerve.users.require_group('admin')
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
path = request.get_slug()
if not path:
raise nerve.ControllerError("You must provide a valid object name")
(dirname, _, name) = path.rpartition('/')
typeinfo = request.arg('__type__')
if not dirname or not nerve.has_object(dirname):
raise nerve.ControllerError(
"The directory you've specified is invalid.")
if not name:
raise nerve.ControllerError("You must provide a valid name.")
if nerve.has_object(dirname + '/' + name):
raise nerve.ControllerError(
"An object of that name already exists.")
if not typeinfo:
raise nerve.ControllerError("You must select a type.")
defaults = nerve.ObjectNode.get_class_config_info(typeinfo)
config = defaults.validate(request.args)
obj = nerve.ObjectNode.make_object(typeinfo, config)
nerve.set_object(dirname + '/' + name, obj)
nerve.save_config()
self.load_json_view({'notice': "Object created"})
def edit(self, request):
nerve.users.require_group('admin')
path = request.get_slug()
if not path:
raise nerve.ControllerError("You must provide a valid object name")
obj = nerve.get_object(path)
if not obj:
raise nerve.ControllerError("Object not found: " + path)
form = FormView(obj.get_config_info(),
obj.get_config_data(),
'/config/save/' + path,
submitback=True)
if request.arg('dialog'):
self.set_view(form)
else:
self.load_template_view(None, None, request)
self.template_add_to_section('jsfiles', '/assets/js/formview.js')
self.template_add_to_section('content', form)
def modify_tags(self, request):
medialib = nerve.get_object(self.get_setting('device'))
if not request.arg('media[]'):
raise nerve.ControllerError("'media[]' field must be set")
if not request.arg('tags'):
raise nerve.ControllerError("'tags' field must be set")
tags = nerve.medialib.MediaLibDevice.split_tags(request.arg('tags'))
media = medialib.get_media_queries(request.arg('media[]'))
for media_item in media:
for tag in tags:
if tag[0] != '!':
medialib.add_tag(media_item['id'], tag)
else:
medialib.remove_tag(media_item['id'], tag[1:])
if len(media) > 0:
self.load_json_view({ 'notice': str(len(media)) + " track(s) tags modified" })
else:
self.load_json_view({ 'error': "No tags were modified" })
def save_names(self, request):
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
codelist = request.arg('codelist')
if not codelist:
raise nerve.ControllerError(
"You must provide the 'codelist' argument.")
errors = []
irremote = nerve.get_object('/devices/irremote')
for (code, remote_name, button_name) in codelist:
if code:
result = irremote.set_button_name(code, remote_name,
button_name)
if result:
errors.append("Button name " + remote_name + ":" +
button_name +
" is already assigned to code " + result)
if len(errors) > 0:
self.load_json_view({'error': '<br/>\n'.join(errors)})
else:
self.load_json_view({'notice': 'Changes have been saved'})
def get_recent_codes(self, request):
irremote = nerve.get_object('/devices/irremote')
try:
last_update = float(request.args['last_update'])
except:
raise nerve.ControllerError(
"You must provide the 'last_update' argument as a float."
) from None
data = {}
data['remotelist'] = irremote.get_remote_names()
data['codelist'] = irremote.get_recent_codes(last_update, wait=60)
self.load_html_view('nerve/irremote/views/coderows.blk.pyhtml', data)
def add(self, request):
nerve.users.require_group('admin')
path = request.get_slug()
if not path:
raise nerve.ControllerError("You must provide a valid object name")
#self.set_view(FormView(nerve.types.ConfigType.get_type('object'), { '__type__': request.arg('type') }))
form = FormView(nerve.types.ConfigType.get_type('object'),
None,
'/config/create/' + path + '/new',
submitname="Create",
submitback=True)
if request.arg('dialog'):
self.set_view(form)
else:
self.load_template_view(None, None, request)
self.template_add_to_section('jsfiles', '/assets/js/formview.js')
self.template_add_to_section('content', form)
def edit_action(self, request):
code = request.get_slug()
if not code:
raise nerve.ControllerError("You must provide a IR code")
path = '/devices/irremote/' + code
try:
obj = nerve.get_object(path)
except AttributeError:
obj = nerve.ObjectNode.make_object("asyncs/PyCodeAsyncTask", {})
#self.set_view(nerve.base.FormView(obj.get_config_info(), obj.get_config_data(), '/config/save' + path, submitback=True))
#self.load_template_view(None, None, request)
#self.template_add_to_section('jsfiles', '/assets/js/formview.js')
#self.template_add_to_section('content', nerve.base.FormView(obj.get_config_info(), obj.get_config_data(), '/irremote/save_action/' + code, submitback=True))
self.set_view(
nerve.base.FormView(
obj.get_config_info(),
obj.get_config_data(),
'/irremote/save_action/' + code,
textbefore="<h5>Event for {0}</h5>".format(code)))
def login(self, request):
redirect = request.arg('redirect', '')
if redirect and (redirect[0] != '/' or '/..' in redirect):
redirect = ''
if request.reqtype == "GET":
data = {'redirect': redirect}
self.load_template_view('nerve/base/views/users/login.blk.pyhtml',
data)
return
if request.reqtype != "POST":
raise nerve.ControllerError("Unexpected request type: " +
request.reqtype)
try:
with nerve.users.login(request.arg('username'),
request.arg('password')):
# TODO this should store a randomized token instead
self.session['username'] = nerve.users.thread_owner()
self.redirect_to(redirect if redirect else '/home')
except nerve.users.UserLoginError:
self.load_json_view({'notice': "Invalid username or password"})
def editpage(self, request):
data = {}
data['pagename'] = request.next_segment(default='')
if request.segments_left() > 0:
raise nerve.ControllerError("Too many path segments given")
if data['pagename'] and not self.model.page_exists(data['pagename']):
raise nerve.NotFoundError("Page doesn't exist: " +
data['pagename'])
data['sections'] = PageView.get_config_info()
data['pagedata'] = self.model.get_page_data(
data['pagename']) if data['pagename'] else None
data['sections'].add_setting('originalname',
"",
default=data['pagename'],
datatype='hidden',
weight=-11)
data['sections'].add_setting('pagename',
"Page Name",
default=data['pagename'],
weight=-10)
#self.load_template_view('nerve/pages/views/editor/editpage.blk.pyhtml', data, request)
self.load_template_view(None, data, request)
#self.template_add_to_section('sidebar', self.make_html_view('nerve/pages/views/editor/sidebar.blk.pyhtml', data))
self.template_add_to_section(
'content',
nerve.base.FormView(data['sections'],
data['pagedata'],
formid='page-editor',
action='/pages/savepage',
title="Edit Page"))
self.template_add_to_section('jsfiles', '/assets/js/formview.js')
self.template_add_to_section('jsfiles', '/pages/assets/js/pages.js')
self.template_add_to_section('cssfiles', '/pages/assets/css/pages.css')
def connect(self, request):
if request.reqtype != 'CONNECT':
raise nerve.ControllerError(
"expected CONNECT request type; received " + request.reqtype)
self.handle_connection(request)
