def db_serialize_node(session, tid, language):
"""
Serialize node info.
"""
# Contexts and Receivers relationship
configured = session.query(models.ReceiverContext).filter(models.ReceiverContext.context_id == models.Context.id,
models.Context.tid == tid).count() > 0
node = ConfigFactory(session, tid, 'public_node').serialize()
misc_dict = {
'languages_enabled': models.EnabledLanguage.list(session, tid) if node['wizard_done'] else list(LANGUAGES_SUPPORTED_CODES),
'languages_supported': LANGUAGES_SUPPORTED,
'configured': configured,
'accept_submissions': State.accept_submissions,
'logo': db_get_file(session, tid, u'logo'),
'favicon': db_get_file(session, tid, u'favicon'),
'css': db_get_file(session, tid, u'css'),
'homepage': db_get_file(session, tid, u'homepage'),
'script': db_get_file(session, tid, u'script')
}
l10n_dict = NodeL10NFactory(session, tid).localized_dict(language)
return merge_dicts(node, l10n_dict, misc_dict)
def db_update_node(store, request, language):
"""
Update and serialize the node infos
:param store: the store on which perform queries.
:param language: the language in which to localize data
:return: a dictionary representing the serialization of the node
"""
enable_disable_languages(store, request)
if language in request['languages_enabled']:
node_l10n = NodeL10NFactory(store)
node_l10n.update(request, language)
node = NodeFactory(store)
node.update(request)
if request[
'basic_auth'] and request['basic_auth_username'] != '' and request[
'basic_auth_password'] != '':
node.set_val('basic_auth', True)
node.set_val('basic_auth_username', request['basic_auth_username'])
node.set_val('basic_auth_password', request['basic_auth_password'])
else:
node.set_val('basic_auth', False)
db_refresh_memory_variables(store)
# TODO pass instance of db_update_node into admin_serialize
return db_admin_serialize_node(store, language)
def db_serialize_node(store, language):
"""
Serialize node info.
"""
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
ro_node = NodeFactory(store).public_export()
misc_dict = {
'languages_enabled': l10n.EnabledLanguage.list(store),
'languages_supported': LANGUAGES_SUPPORTED,
'configured': configured,
'accept_submissions': GLSettings.accept_submissions,
'logo': db_get_file(store, u'logo'),
'favicon': db_get_file(store, u'favicon'),
'css': db_get_file(store, u'css'),
'homepage': db_get_file(store, u'homepage'),
'script': db_get_file(store, u'script')
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
ret = disjoint_union(ro_node, l10n_dict, misc_dict)
return ret
def run_node_mgr(self, store):
# Initialize the Node manager
node_l10n = NodeL10NFactory(store)
# Make a query with the Node manager
ret = node_l10n.retrieve_rows('en')
self.assertTrue(len(ret) == 18)
def db_update_node(session, tid, request, language):
"""
Update and serialize the node infos
:param session: the session on which perform queries.
:param language: the language in which to localize data
:return: a dictionary representing the serialization of the node
"""
node = ConfigFactory(session, tid, 'node')
if tid != 1:
request['enable_signup'] = False
node.update(request)
if request['basic_auth'] and request['basic_auth_username'] and request[
'basic_auth_password']:
node.set_val(u'basic_auth', True)
node.set_val(u'basic_auth_username', request['basic_auth_username'])
node.set_val(u'basic_auth_password', request['basic_auth_password'])
else:
node.set_val(u'basic_auth', False)
db_update_enabled_languages(session, tid, request['languages_enabled'],
request['default_language'])
if language in request['languages_enabled']:
node_l10n = NodeL10NFactory(session, tid)
node_l10n.update(request, language)
db_refresh_memory_variables(session, [tid])
# TODO pass instance of db_update_node into admin_serialize
return db_admin_serialize_node(session, tid, language)
def wizard(store, request, language):
node = NodeFactory(store)
if node.get_val('wizard_done'):
# TODO report as anomaly
log.err("DANGER: Wizard already initialized!")
raise errors.ForbiddenOperation
try:
node._query_group()
node.set_val('name', request['node']['name'])
node.set_val('default_language', language)
node.set_val('wizard_done', True)
if GLSettings.onionservice is not None:
node.set_val('onionservice', GLSettings.onionservice)
node_l10n = NodeL10NFactory(store)
node_l10n.set_val('description', language,
request['node']['description'])
node_l10n.set_val('header_title_homepage', language,
request['node']['name'])
context = db_create_context(store, request['context'], language)
langs_to_drop = EnabledLanguage.list(store)
langs_to_drop.remove(language)
if len(langs_to_drop):
EnabledLanguage.remove_old_langs(store, langs_to_drop)
request['receiver']['contexts'] = [context.id]
request['receiver']['language'] = language
db_create_receiver(store, request['receiver'], language)
admin_dict = {
'username': u'admin',
'password': request['admin']['password'],
'role': u'admin',
'state': u'enabled',
'deletable': False,
'name': u'Admin',
'public_name': u'Admin',
'description': u'',
'mail_address': request['admin']['mail_address'],
'language': language,
'password_change_needed': False,
'pgp_key_remove': False,
'pgp_key_fingerprint': '',
'pgp_key_public': '',
'pgp_key_expiration': datetime_null()
}
db_create_admin_user(store, admin_dict, language)
except Exception as excep:
log.err("Failed wizard initialization %s" % excep)
raise excep
def run_node_mgr(self, store):
# Initialize the Node manager
node_l10n = NodeL10NFactory(store)
num_trans = len(NodeL10NFactory.localized_keys)
# Make a query with the Node manager
ret = node_l10n.retrieve_rows(u'en')
self.assertTrue(len(ret) == num_trans)
def serialize_ahmia(store, language):
"""
Serialize Ahmia.fi descriptor.
"""
ret_dict = NodeFactory(store).public_export()
return {
'title': ret_dict['name'],
'description': NodeL10NFactory(store).get_val(language, 'description'),
'keywords': '%s (GlobaLeaks instance)' % ret_dict['name'],
'relation': ret_dict['public_site'],
'language': ret_dict['default_language'],
'contactInformation': u'',
'type': 'GlobaLeaks'
}
def db_admin_serialize_node(store, language):
node_dict = NodeFactory(store).admin_export()
priv_dict = PrivateFactory(store)
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
misc_dict = {
'version': priv_dict.get_val(u'version'),
'latest_version': priv_dict.get_val(u'latest_version'),
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': EnabledLanguage.list(store),
'configured': configured
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
return utils.sets.merge_dicts(node_dict, misc_dict, l10n_dict)
def db_admin_serialize_node(store, language):
node_dict = NodeFactory(store).admin_export()
# Contexts and Receivers relationship
configured = store.find(models.ReceiverContext).count() > 0
custom_homepage = os.path.isfile(os.path.join(GLSettings.static_path, "custom_homepage.html"))
misc_dict = {
'version': PrivateFactory(store).get_val('version'),
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': EnabledLanguage.list(store),
'configured': configured,
'custom_homepage': custom_homepage,
}
l10n_dict = NodeL10NFactory(store).localized_dict(language)
return utils.sets.disjoint_union(node_dict, misc_dict, l10n_dict)
def db_admin_serialize_node(session, tid, language):
config = ConfigFactory(session, tid, 'admin_node').serialize()
# Contexts and Receivers relationship
configured = session.query(models.ReceiverContext).filter(models.ReceiverContext.context_id == models.Context.id,
models.Context.tid).count() > 0
misc_dict = {
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': models.EnabledLanguage.list(session, tid),
'configured': configured,
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
}
l10n_dict = NodeL10NFactory(session, tid).localized_dict(language)
return utils.sets.merge_dicts(config, misc_dict, l10n_dict)
