Console interface to Storyboard
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 

583 lines
21 KiB

# Copyright 2014 OpenStack Foundation
# Copyright 2014 Hewlett-Packard Development Company, L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import logging
import urwid
from boartty import keymap
from boartty import mywid
from boartty import sync
from boartty.view import story_list as view_story_list
from boartty.view import mouse_scroll_decorator
ACTIVE_COL_WIDTH = 7
class TopicSelectDialog(urwid.WidgetWrap):
signals = ['ok', 'cancel']
def __init__(self, title, topics):
button_widgets = []
ok_button = mywid.FixedButton('OK')
cancel_button = mywid.FixedButton('Cancel')
urwid.connect_signal(ok_button, 'click',
lambda button:self._emit('ok'))
urwid.connect_signal(cancel_button, 'click',
lambda button:self._emit('cancel'))
button_widgets.append(('pack', ok_button))
button_widgets.append(('pack', cancel_button))
button_columns = urwid.Columns(button_widgets, dividechars=2)
self.topic_buttons = []
self.topic_keys = {}
rows = []
for key, name in topics:
button = mywid.FixedRadioButton(self.topic_buttons, name)
self.topic_keys[button] = key
rows.append(button)
rows.append(urwid.Divider())
rows.append(button_columns)
pile = urwid.Pile(rows)
fill = urwid.Filler(pile, valign='top')
super(TopicSelectDialog, self).__init__(urwid.LineBox(fill, title))
def getSelected(self):
for b in self.topic_buttons:
if b.state:
return self.topic_keys[b]
return None
class ProjectRow(urwid.Button):
project_focus_map = {None: 'focused',
'active-project': 'focused-active-project',
'subscribed-project': 'focused-subscribed-project',
'unsubscribed-project': 'focused-unsubscribed-project',
'marked-project': 'focused-marked-project',
}
def selectable(self):
return True
def _setName(self, name, indent):
self.project_name = name
name = indent+name
if self.mark:
name = '%'+name
else:
name = ' '+name
self.name.set_text(name)
def __init__(self, app, project, topic, callback=None):
super(ProjectRow, self).__init__('', on_press=callback,
user_data=(project.key, project.name))
self.app = app
self.mark = False
self._style = None
self.project_key = project.key
if topic:
self.topic_key = topic.key
self.indent = ' '
else:
self.topic_key = None
self.indent = ''
self.project_name = project.name
self.name = mywid.SearchableText('')
self._setName(project.name, self.indent)
self.name.set_wrap_mode('clip')
self.active_stories = urwid.Text(u'', align=urwid.RIGHT)
col = urwid.Columns([
self.name,
('fixed', ACTIVE_COL_WIDTH, self.active_stories),
])
self.row_style = urwid.AttrMap(col, '')
self._w = urwid.AttrMap(self.row_style, None, focus_map=self.project_focus_map)
self.update(project)
def search(self, search, attribute):
return self.name.search(search, attribute)
def update(self, project):
cache = self.app.project_cache.get(project)
if project.subscribed:
style = 'subscribed-project'
else:
style = 'unsubscribed-project'
self._style = style
if self.mark:
style = 'marked-project'
self.row_style.set_attr_map({None: style})
self.active_stories.set_text('%i ' % cache['active_stories'])
def toggleMark(self):
self.mark = not self.mark
if self.mark:
style = 'marked-project'
else:
style = self._style
self.row_style.set_attr_map({None: style})
self._setName(self.project_name, self.indent)
class TopicRow(urwid.Button):
project_focus_map = {None: 'focused',
'subscribed-project': 'focused-subscribed-project',
'marked-project': 'focused-marked-project',
}
def selectable(self):
return True
def _setName(self, name):
self.topic_name = name
name = '[[ '+name+' ]]'
if self.mark:
name = '%'+name
else:
name = ' '+name
self.name.set_text(name)
def __init__(self, topic, callback=None):
super(TopicRow, self).__init__('', on_press=callback,
user_data=(topic.key, topic.name))
self.mark = False
self._style = None
self.topic_key = topic.key
self.name = urwid.Text('')
self._setName(topic.name)
self.name.set_wrap_mode('clip')
self.active_stories = urwid.Text(u'', align=urwid.RIGHT)
col = urwid.Columns([
self.name,
('fixed', ACTIVE_COL_WIDTH, self.active_stories),
])
self.row_style = urwid.AttrMap(col, '')
self._w = urwid.AttrMap(self.row_style, None, focus_map=self.project_focus_map)
self._style = 'subscribed-project'
self.row_style.set_attr_map({None: self._style})
self.update(topic)
def update(self, topic, active_stories=None):
self._setName(topic.name)
if active_stories is None:
self.active_stories.set_text('')
else:
self.active_stories.set_text('%i ' % active_stories)
def toggleMark(self):
self.mark = not self.mark
if self.mark:
style = 'marked-project'
else:
style = self._style
self.row_style.set_attr_map({None: style})
self._setName(self.topic_name)
class ProjectListHeader(urwid.WidgetWrap):
def __init__(self):
cols = [urwid.Text(u' Project'),
(ACTIVE_COL_WIDTH, urwid.Text(u'Active'))]
super(ProjectListHeader, self).__init__(urwid.Columns(cols))
@mouse_scroll_decorator.ScrollByWheel
class ProjectListView(urwid.WidgetWrap, mywid.Searchable):
def getCommands(self):
return [
(keymap.TOGGLE_LIST_SUBSCRIBED,
"Toggle whether only subscribed projects or all projects are listed"),
(keymap.TOGGLE_LIST_ACTIVE,
"Toggle listing of projects with active changes"),
(keymap.TOGGLE_SUBSCRIBED,
"Toggle the subscription flag for the selected project"),
(keymap.REFRESH,
"Sync subscribed projects"),
(keymap.TOGGLE_MARK,
"Toggle the process mark for the selected project"),
(keymap.NEW_PROJECT_TOPIC,
"Create project topic"),
(keymap.DELETE_PROJECT_TOPIC,
"Delete selected project topic"),
(keymap.MOVE_PROJECT_TOPIC,
"Move selected project to topic"),
(keymap.COPY_PROJECT_TOPIC,
"Copy selected project to topic"),
(keymap.REMOVE_PROJECT_TOPIC,
"Remove selected project from topic"),
(keymap.RENAME_PROJECT_TOPIC,
"Rename selected project topic"),
(keymap.INTERACTIVE_SEARCH,
"Interactive search"),
]
def help(self):
key = self.app.config.keymap.formatKeys
commands = self.getCommands()
return [(c[0], key(c[0]), c[1]) for c in commands]
def __init__(self, app):
super(ProjectListView, self).__init__(urwid.Pile([]))
self.log = logging.getLogger('boartty.view.project_list')
self.searchInit()
self.app = app
self.active = True
self.subscribed = True
self.project_rows = {}
self.topic_rows = {}
self.open_topics = set()
self.listbox = urwid.ListBox(urwid.SimpleFocusListWalker([]))
self.header = ProjectListHeader()
self.refresh()
self._w.contents.append((app.header, ('pack', 1)))
self._w.contents.append((urwid.Divider(),('pack', 1)))
self._w.contents.append((urwid.AttrWrap(self.header, 'table-header'), ('pack', 1)))
self._w.contents.append((self.listbox, ('weight', 1)))
self._w.set_focus(3)
def interested(self, event):
if not (isinstance(event, sync.ProjectAddedEvent)
or
isinstance(event, sync.StoryAddedEvent)
or
(isinstance(event, sync.StoryUpdatedEvent) and
event.status_changed)):
self.log.debug("Ignoring refresh project list due to event %s" % (event,))
return False
self.log.debug("Refreshing project list due to event %s" % (event,))
return True
def advance(self):
pos = self.listbox.focus_position
if pos < len(self.listbox.body)-1:
pos += 1
self.listbox.focus_position = pos
def _deleteRow(self, row):
if row in self.listbox.body:
self.listbox.body.remove(row)
if isinstance(row, ProjectRow):
del self.project_rows[(row.topic_key, row.project_key)]
else:
del self.topic_rows[row.topic_key]
def _projectRow(self, i, project, topic):
# Ensure that the row at i is the given project. If the row
# already exists somewhere in the list, delete all rows
# between i and the row and then update the row. If the row
# does not exist, insert the row at position i.
topic_key = topic and topic.key or None
key = (topic_key, project.key)
row = self.project_rows.get(key)
while row: # This is "if row: while True:".
if i >= len(self.listbox.body):
break
current_row = self.listbox.body[i]
if (isinstance(current_row, ProjectRow) and
current_row.project_key == project.key):
break
self._deleteRow(current_row)
if not row:
row = ProjectRow(self.app, project, topic, self.onSelect)
self.listbox.body.insert(i, row)
self.project_rows[key] = row
else:
row.update(project)
return i+1
def _topicRow(self, i, topic):
row = self.topic_rows.get(topic.key)
while row: # This is "if row: while True:".
if i >= len(self.listbox.body):
break
current_row = self.listbox.body[i]
if (isinstance(current_row, TopicRow) and
current_row.topic_key == topic.key):
break
self._deleteRow(current_row)
if not row:
row = TopicRow(topic, self.onSelectTopic)
self.listbox.body.insert(i, row)
self.topic_rows[topic.key] = row
else:
row.update(topic)
return i + 1
def refresh(self):
if self.subscribed:
self.title = u'Subscribed projects'
self.short_title = self.title[:]
if self.active:
self.title += u' with active stories'
else:
self.title = u'All projects'
self.short_title = self.title[:]
self.app.status.update(title=self.title)
with self.app.db.getSession() as session:
i = 0
for project in session.getProjects(topicless=True,
subscribed=self.subscribed, active=self.active):
#self.log.debug("project: %s" % project.name)
i = self._projectRow(i, project, None)
for topic in session.getTopics():
#self.log.debug("topic: %s" % topic.name)
i = self._topicRow(i, topic)
topic_active = 0
for project in topic.projects:
#self.log.debug(" project: %s" % project.name)
cache = self.app.project_cache.get(project)
topic_active += cache['active_stories']
if self.subscribed:
if not project.subscribed:
continue
if topic.key in self.open_topics:
i = self._projectRow(i, project, topic)
topic_row = self.topic_rows.get(topic.key)
topic_row.update(topic, topic_active)
while i < len(self.listbox.body):
current_row = self.listbox.body[i]
self._deleteRow(current_row)
def toggleSubscribed(self, project_key):
with self.app.db.getSession() as session:
project = session.getProject(project_key)
project.subscribed = not project.subscribed
ret = project.subscribed
return ret
def onSelect(self, button, data):
project_key, project_name = data
self.app.changeScreen(view_story_list.StoryListView(
self.app,
"_project_key:%s %s" % (project_key,
self.app.config.project_story_list_query),
project_name, project_key=project_key, active=True))
def onSelectTopic(self, button, data):
topic_key = data[0]
self.open_topics ^= set([topic_key])
self.refresh()
def toggleMark(self):
if not len(self.listbox.body):
return
pos = self.listbox.focus_position
row = self.listbox.body[pos]
row.toggleMark()
self.advance()
def createTopic(self):
dialog = mywid.LineEditDialog(self.app, 'Topic', 'Create a new topic.',
'Topic: ', '', self.app.ring)
urwid.connect_signal(dialog, 'save',
lambda button: self.closeCreateTopic(dialog, True))
urwid.connect_signal(dialog, 'cancel',
lambda button: self.closeCreateTopic(dialog, False))
self.app.popup(dialog)
def closeCreateTopic(self, dialog, save):
if save:
last_topic_key = None
for row in self.listbox.body:
if isinstance(row, TopicRow):
last_topic_key = row.topic_key
with self.app.db.getSession() as session:
if last_topic_key:
last_topic = session.getTopic(last_topic_key)
seq = last_topic.sequence + 1
else:
seq = 0
t = session.createTopic(dialog.entry.edit_text, seq)
self.app.backScreen()
def deleteTopic(self):
rows = self.getSelectedRows(TopicRow)
if not rows:
return
with self.app.db.getSession() as session:
for row in rows:
topic = session.getTopic(row.topic_key)
session.delete(topic)
self.refresh()
def renameTopic(self):
pos = self.listbox.focus_position
row = self.listbox.body[pos]
if not isinstance(row, TopicRow):
return
with self.app.db.getSession() as session:
topic = session.getTopic(row.topic_key)
name = topic.name
key = topic.key
dialog = mywid.LineEditDialog(self.app, 'Topic', 'Rename a new topic.',
'Topic: ', name, self.app.ring)
urwid.connect_signal(dialog, 'save',
lambda button: self.closeRenameTopic(dialog, True, key))
urwid.connect_signal(dialog, 'cancel',
lambda button: self.closeRenameTopic(dialog, False, key))
self.app.popup(dialog)
def closeRenameTopic(self, dialog, save, key):
if save:
with self.app.db.getSession() as session:
topic = session.getTopic(key)
topic.name = dialog.entry.edit_text
self.app.backScreen()
def getSelectedRows(self, cls):
ret = []
for row in self.listbox.body:
if isinstance(row, cls) and row.mark:
ret.append(row)
if ret:
return ret
pos = self.listbox.focus_position
row = self.listbox.body[pos]
if isinstance(row, cls):
return [row]
return []
def copyMoveToTopic(self, move):
if move:
verb = 'Move'
else:
verb = 'Copy'
rows = self.getSelectedRows(ProjectRow)
if not rows:
return
with self.app.db.getSession() as session:
topics = [(t.key, t.name) for t in session.getTopics()]
dialog = TopicSelectDialog('%s to Topic' % verb, topics)
urwid.connect_signal(dialog, 'ok',
lambda button: self.closeCopyMoveToTopic(dialog, True, rows, move))
urwid.connect_signal(dialog, 'cancel',
lambda button: self.closeCopyMoveToTopic(dialog, False, rows, move))
self.app.popup(dialog)
def closeCopyMoveToTopic(self, dialog, save, rows, move):
error = None
if save:
with self.app.db.getSession() as session:
key = dialog.getSelected()
new_topic = session.getTopic(key)
if not new_topic:
error = "Unable to find topic %s" % topic_name
else:
for row in rows:
project = session.getProject(row.project_key)
if move and row.topic_key:
old_topic = session.getTopic(row.topic_key)
self.log.debug("Remove %s from %s" % (project, old_topic))
old_topic.removeProject(project)
self.log.debug("Add %s to %s" % (project, new_topic))
new_topic.addProject(project)
self.app.backScreen()
if error:
self.app.error(error)
def moveToTopic(self):
self.copyMoveToTopic(True)
def copyToTopic(self):
self.copyMoveToTopic(False)
def removeFromTopic(self):
rows = self.getSelectedRows(ProjectRow)
rows = [r for r in rows if r.topic_key]
if not rows:
return
with self.app.db.getSession() as session:
for row in rows:
project = session.getProject(row.project_key)
topic = session.getTopic(row.topic_key)
self.log.debug("Remove %s from %s" % (project, topic))
topic.removeProject(project)
self.refresh()
def toggleSubscribed(self):
rows = self.getSelectedRows(ProjectRow)
if not rows:
return
keys = [row.project_key for row in rows]
subscribed_keys = []
with self.app.db.getSession() as session:
for key in keys:
project = session.getProject(key)
project.subscribed = not project.subscribed
if project.subscribed:
subscribed_keys.append(key)
for row in rows:
if row.mark:
row.toggleMark()
for key in subscribed_keys:
self.app.sync.submitTask(sync.SyncProjectTask(key))
self.refresh()
def keypress(self, size, key):
if self.searchKeypress(size, key):
return None
if not self.app.input_buffer:
key = super(ProjectListView, self).keypress(size, key)
keys = self.app.input_buffer + [key]
commands = self.app.config.keymap.getCommands(keys)
ret = self.handleCommands(commands)
if ret is True:
if keymap.FURTHER_INPUT not in commands:
self.app.clearInputBuffer()
return None
return key
def handleCommands(self, commands):
if keymap.TOGGLE_LIST_ACTIVE in commands:
self.active = not self.active
self.refresh()
return True
if keymap.TOGGLE_LIST_SUBSCRIBED in commands:
self.subscribed = not self.subscribed
self.refresh()
return True
if keymap.TOGGLE_SUBSCRIBED in commands:
self.toggleSubscribed()
return True
if keymap.TOGGLE_MARK in commands:
self.toggleMark()
return True
if keymap.NEW_PROJECT_TOPIC in commands:
self.createTopic()
return True
if keymap.DELETE_PROJECT_TOPIC in commands:
self.deleteTopic()
return True
if keymap.COPY_PROJECT_TOPIC in commands:
self.copyToTopic()
return True
if keymap.MOVE_PROJECT_TOPIC in commands:
self.moveToTopic()
return True
if keymap.REMOVE_PROJECT_TOPIC in commands:
self.removeFromTopic()
return True
if keymap.RENAME_PROJECT_TOPIC in commands:
self.renameTopic()
return True
if keymap.REFRESH in commands:
self.app.sync.submitTask(
sync.SyncSubscribedProjectsTask(sync.HIGH_PRIORITY))
self.app.status.update()
self.refresh()
return True
if keymap.INTERACTIVE_SEARCH in commands:
self.searchStart()
return True
return False