def setUp(self):
'''
Stardard init method: runs before each test_* method
'''
server.app.config['TESTING'] = True
server.app.storage_file_path = "test_storage_file"
self.app = server.app.test_client()
self.recording = server.app.blueprints['recording']
# token call to fire configuration logic
self.app.get('/recordings')
print self.recording.record_config.videodir
self.profile_manager = ProfileManager(tempfile.mkdtemp())
self.temp_video_dir = tempfile.mkdtemp()
self.recording.record_config.videodir = self.temp_video_dir
self.recording.record_profile = self.profile_manager.get('testing')
self.recording.record_config = self.recording.record_profile.get_config('freeseer.conf', settings.FreeseerConfig, ['Global'], read_only=True)
self.recording.record_plugin_manager = PluginManager(self.recording.record_profile)
self.recording.media_dict = {}
# mock media
self.mock_media_1 = MockMedia()
self.mock_media_2 = MockMedia()
self.test_media_dict_1 = {}
filepath1 = os.path.join(self.recording.record_config.videodir, 'mock_media_1')
filepath2 = os.path.join(self.recording.record_config.videodir, 'mock_media_1')
self.test_media_dict_1[1] = {'media': self.mock_media_1, 'filename': 'mock_media_1', 'filepath': filepath1}
self.test_media_dict_1[2] = {'media': self.mock_media_2, 'filename': 'mock_media_2', 'filepath': filepath2}
def configure_recording():
"""Configures freeseer to record via REST server.
Gets recording profiles and configuration and instantiates recording plugins. Then it restores any stored talks.
Runs upon first call to REST server.
"""
# setup the application so it exits gracefully
signal.signal(signal.SIGINT, teardown_recording)
recording.record_profile = settings.profile_manager.get()
recording.record_config = recording.record_profile.get_config(
'freeseer.conf',
settings.FreeseerConfig,
storage_args=['Global'],
read_only=True)
recording.record_plugin_manager = PluginManager(recording.record_profile)
recording.storage_file = os.path.join(settings.configdir,
app.storage_file_path)
recording.next_id = 1
# restore talks from storage
if os.path.isfile(recording.storage_file):
with open(recording.storage_file) as fd:
persistent = json.loads(fd.read())
recording.media_dict = {}
for key in persistent:
new_media = Multimedia(recording.record_config,
recording.record_plugin_manager)
new_media.current_state = persistent[key]['status']
media_id = int(key)
if new_media.current_state == Multimedia.NULL:
filename = persistent[key]['filename'].split(".ogg")[0]
success, filename = new_media.load_backend(None, filename)
if success:
filepath = new_media.plugman.get_plugin_by_name(
new_media.config.record_to_file_plugin,
"Output").plugin_object.location
recording.media_dict[media_id] = {
'media': new_media,
'filename': filename,
'filepath': filepath
}
else:
raise ServerError('Could not load multimedia backend')
else:
recording.media_dict[media_id] = {
'media': new_media,
'filename': persistent[key]['filename'],
'filepath': persistent[key]['filepath']
}
# sets next_id to last index of persistent + 1
recording.next_id = len(persistent)
else:
# if no talks to restore, make empty media_dict, set next_id to 1
recording.media_dict = {}
recording.next_id = 1
def setUp(self):
self.profile_manager = ProfileManager(tempfile.mkdtemp())
profile = self.profile_manager.get('testing')
config = profile.get_config('freeseer.conf',
settings.FreeseerConfig, ['Global'],
read_only=True)
plugin_manager = PluginManager(profile)
self.multimedia = Multimedia(config, plugin_manager)
def get_database(self, name='presentations.db'):
"""Returns an instance of QtDBConnector for a specific database file.
It is also cached for future gets.
"""
if name not in self._databases:
self._databases[name] = QtDBConnector(self.get_filepath(name),
PluginManager(self))
return self._databases[name]
def setUp(self):
'''
Stardard init method: runs before each test_* method
Initializes a PluginManager
'''
self.configdir = tempfile.mkdtemp()
self.manager = PluginManager(self.configdir)
def setUp(self):
'''
Stardard init method: runs before each test_* method
Initializes a PluginManager
'''
self.profile_manager = ProfileManager(tempfile.mkdtemp())
profile = self.profile_manager.get('testing')
self.plugman = PluginManager(profile)
def setUp(self):
'''
Stardard init method: runs before each test_* method
Initializes a PluginManager
'''
self.profile_path = tempfile.mkdtemp()
profile = Profile(self.profile_path, 'testing')
dirname = os.path.dirname(__file__)
self._csvfile = os.path.join(dirname, 'sample_talks.csv')
db_file = os.path.join(self.profile_path, 'presentations.db')
self.db = QtDBConnector(db_file, PluginManager(profile))
def configure_recording():
"""Configures freeseer to record via REST server.
Gets recording profiles and configuration and instantiates recording plugins. Then it restores any stored talks.
Runs upon first call to REST server.
"""
recording.profile = settings.profile_manager.get()
recording.config = recording.profile.get_config('freeseer.conf',
settings.FreeseerConfig,
storage_args=['Global'],
read_only=True)
recording.plugin_manager = PluginManager(recording.profile)
recording.storage_file = os.path.join(settings.configdir,
app.storage_file_path)
media_info = shelve.open(recording.storage_file, writeback=True)
recording.next_id = 1
recording.media_dict = {}
for key, value in media_info.iteritems():
new_media = Multimedia(recording.config, recording.plugin_manager)
if value['null_multimeda']:
new_media.current_state = Multimedia.NULL
else:
# if null_multimeda is False, a video exists, set current_state to Multimedia.STOP
new_media.current_state = Multimedia.STOP
media_id = int(key)
if media_id >= recording.next_id:
recording.next_id = media_id + 1
if new_media.current_state == Multimedia.NULL:
filename = value['filename'].split('.ogg')[0]
success, filename = new_media.load_backend(None, filename)
if not success:
raise ServerError('Could not load multimedia backend')
value['filename'] = filename
value['filepath'] = new_media.plugman.get_plugin_by_name(
new_media.config.record_to_file_plugin,
"Output").plugin_object.location
recording.media_dict[media_id] = new_media
recording.media_info = media_info
recording.media_info.sync()
def recording(self, request, test_client, monkeypatch, tmpdir):
recording = server.app.blueprints['recording']
monkeypatch.setattr(settings, 'configdir',
str(tmpdir.mkdir('configdir')))
test_client.get('/recordings')
profile_manager = ProfileManager(str(tmpdir.mkdir('profile')))
recording.profile = profile_manager.get('testing')
recording.config = recording.profile.get_config(
'freeseer.conf',
settings.FreeseerConfig, ['Global'],
read_only=True)
recording.config.videodir = str(tmpdir.mkdir('Videos'))
recording.plugin_manager = PluginManager(recording.profile)
return recording
def __init__(self, profile, config):
FreeseerApp.__init__(self)
# Load Config Stuff
self.profile = profile
self.config = config
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/freeseer/logo.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
# Initialize geometry, to be used for restoring window positioning.
self.geometry = None
self.mainWidget = ConfigToolWidget()
self.setCentralWidget(self.mainWidget)
self.currentWidget = None
self.mainWidgetLayout = QtGui.QVBoxLayout()
self.mainWidget.rightPanelWidget.setLayout(self.mainWidgetLayout)
# Load all ConfigTool Widgets
self.generalWidget = GeneralWidget()
self.avWidget = AVWidget()
self.pluginloaderWidget = PluginLoaderWidget()
self.plugman = PluginManager(profile)
# Custom Menu Items
self.actionSaveProfile = QtGui.QAction(self)
self.menuFile.insertAction(self.actionExit, self.actionSaveProfile)
#
# --- Language Related
#
# Fill in the langauges combobox and load the default language
for language in self.languages:
translator = QtCore.QTranslator(
) # Create a translator to translate Language Display Text
translator.load(":/languages/%s" % language)
language_display_text = translator.translate(
"Translation", "Language Display Text")
self.generalWidget.languageComboBox.addItem(
language_display_text, language)
# Load default language.
actions = self.menuLanguage.actions()
for action in actions:
if action.data().toString() == self.config.default_language:
action.setChecked(True)
self.translate(action)
break
# --- End Language Related
# connections
self.connect(self.actionSaveProfile, QtCore.SIGNAL('triggered()'),
self.show_save_profile_dialog)
self.connect(self.mainWidget.closePushButton,
QtCore.SIGNAL('clicked()'), self.close)
self.connect(self.mainWidget.optionsTreeWidget,
QtCore.SIGNAL('itemSelectionChanged()'),
self.change_option)
#
# general tab connections
#
self.connect(self.generalWidget.languageComboBox,
QtCore.SIGNAL('currentIndexChanged(int)'),
self.set_default_language)
self.connect(self.generalWidget.recordDirPushButton,
QtCore.SIGNAL('clicked()'), self.browse_video_directory)
self.connect(self.generalWidget.recordDirLineEdit,
QtCore.SIGNAL('editingFinished()'),
self.update_record_directory)
self.connect(self.generalWidget.autoHideCheckBox,
QtCore.SIGNAL('toggled(bool)'), self.toggle_autohide)
#
# AV tab connections
#
self.connect(self.avWidget.audioGroupBox,
QtCore.SIGNAL('toggled(bool)'),
self.toggle_audiomixer_state)
self.connect(self.avWidget.audioMixerComboBox,
QtCore.SIGNAL('activated(const QString&)'),
self.change_audiomixer)
self.connect(self.avWidget.audioMixerSetupPushButton,
QtCore.SIGNAL('clicked()'), self.setup_audio_mixer)
self.connect(self.avWidget.videoGroupBox,
QtCore.SIGNAL('toggled(bool)'),
self.toggle_videomixer_state)
self.connect(self.avWidget.videoMixerComboBox,
QtCore.SIGNAL('activated(const QString&)'),
self.change_videomixer)
self.connect(self.avWidget.videoMixerSetupPushButton,
QtCore.SIGNAL('clicked()'), self.setup_video_mixer)
self.connect(self.avWidget.fileGroupBox,
QtCore.SIGNAL('toggled(bool)'),
self.toggle_record_to_file)
self.connect(self.avWidget.fileComboBox,
QtCore.SIGNAL('activated(const QString&)'),
self.change_file_format)
self.connect(self.avWidget.fileSetupPushButton,
QtCore.SIGNAL('clicked()'), self.setup_file_format)
self.connect(self.avWidget.streamGroupBox,
QtCore.SIGNAL('toggled(bool)'),
self.toggle_record_to_stream)
self.connect(self.avWidget.streamComboBox,
QtCore.SIGNAL('activated(const QString&)'),
self.change_stream_format)
self.connect(self.avWidget.streamSetupPushButton,
QtCore.SIGNAL('clicked()'), self.setup_stream_format)
# GUI Disabling/Enabling Connections
self.connect(self.avWidget.audioGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.audioMixerLabel.setEnabled)
self.connect(self.avWidget.audioGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.audioMixerComboBox.setEnabled)
self.connect(self.avWidget.audioGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.audioMixerSetupPushButton.setEnabled)
self.connect(self.avWidget.videoGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.videoMixerLabel.setEnabled)
self.connect(self.avWidget.videoGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.videoMixerComboBox.setEnabled)
self.connect(self.avWidget.videoGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.videoMixerSetupPushButton.setEnabled)
self.connect(self.avWidget.fileGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.fileLabel.setEnabled)
self.connect(self.avWidget.fileGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.fileComboBox.setEnabled)
self.connect(self.avWidget.fileGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.fileSetupPushButton.setEnabled)
self.connect(self.avWidget.streamGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.streamLabel.setEnabled)
self.connect(self.avWidget.streamGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.streamComboBox.setEnabled)
self.connect(self.avWidget.streamGroupBox,
QtCore.SIGNAL("toggled(bool)"),
self.avWidget.streamSetupPushButton.setEnabled)
self.retranslate()
# load active plugin widgets
self.load_plugin_widgets()
# Start off with displaying the General Settings
items = self.mainWidget.optionsTreeWidget.findItems(
self.generalString, QtCore.Qt.MatchExactly)
if len(items) > 0:
item = items[0]
self.mainWidget.optionsTreeWidget.setCurrentItem(item)
def __init__(self, profile, db, config, cli=False):
self.config = config
self.db = db
self.plugman = PluginManager(profile)
self.media = Multimedia(self.config, self.plugman, cli=cli)
def setUp(self):
settings.configdir = tempfile.mkdtemp()
self.config = Config(settings.configdir)
self.manager = PluginManager(settings.configdir)
self.multimedia = Multimedia(self.config, self.manager)
def plugin_manager(tmpdir):
"""Constructs a plugin manager using a fake profile with a temporary directory."""
profile_manager = ProfileManager(str(tmpdir))
profile = profile_manager.get('testing')
return PluginManager(profile)
def __init__(self, cli=False, profile=None):
self.config = Config(settings.configdir, profile=profile)
self.db = QtDBConnector(settings.configdir)
self.plugman = PluginManager(settings.configdir, profile=profile)
self.media = Multimedia(self.config, self.plugman, cli=cli)
