def get_vendor_settings(self):
# Container for vendor settings
vendor_settings = Munch({
'vendors': [],
'vendor': Munch(),
})
# Read vendor settings from configuration
try:
vendor_settings.vendors = read_list(self.application_settings.ip_navigator.vendors)
assert vendor_settings.vendors
except:
raise ConfigurationError('No vendor configured in "{configfile}"'.format(configfile=self.configfile))
for vendor in vendor_settings.vendors:
settings_key = 'vendor:{name}'.format(name=vendor)
if settings_key not in self.application_settings:
raise ConfigurationError('Vendor "{vendor}" not configured in "{configfile}"'.format(
vendor=vendor, configfile=self.configfile))
vendor_info = self.application_settings.get(settings_key, {})
for key, value in vendor_info.items():
vendor_info[key] = value
if 'hostname_matches' in vendor_info:
vendor_info.hostname_matches = read_list(vendor_info.hostname_matches)
vendor_info.email = self.get_email_settings(vendor)
vendor_settings.vendor[vendor] = munchify(vendor_info)
return vendor_settings
def get_datasource_settings(self):
# Container for datasource settings
datasource_settings = Munch({
'datasources': [],
'datasource': Munch(),
'total': munchify({'fulltext_countries': [], 'details_countries': []}),
})
# Read datasource settings from configuration
datasource_settings.datasources = read_list(self.application_settings.get('ip_navigator', {}).get('datasources'))
datasource_settings.protected_fields = read_list(self.application_settings.get('ip_navigator', {}).get('datasources_protected_fields'))
for datasource in datasource_settings.datasources:
settings_key = 'datasource:{name}'.format(name=datasource)
datasource_info = self.application_settings.get(settings_key, {})
datasource_info['fulltext_enabled'] = asbool(datasource_info.get('fulltext_enabled', False))
datasource_info['fulltext_countries'] = read_list(datasource_info.get('fulltext_countries', ''))
datasource_info['details_enabled'] = asbool(datasource_info.get('details_enabled', False))
datasource_info['details_countries'] = read_list(datasource_info.get('details_countries', ''))
datasource_settings.datasource[datasource] = munchify(datasource_info)
# Aggregate data for all countries
datasource_settings.total.fulltext_countries += datasource_info['fulltext_countries']
return datasource_settings
def get_datasource_settings(self, vendor=None):
# Container for datasource settings.
datasource_settings = SmartBunch({
'datasources': [],
'datasource': SmartBunch(),
'total': SmartBunch.bunchify({'fulltext_countries': [], 'details_countries': []}),
})
# Read datasource settings from configuration.
datasource_settings.datasources = read_list(self.application_settings.get('ip_navigator', {}).get('datasources'))
datasource_settings.protected_fields = read_list(self.application_settings.get('ip_navigator', {}).get('datasources_protected_fields'))
for datasource in datasource_settings.datasources:
datasource_info = SmartBunch()
if vendor is None:
settings_key = 'datasource:{name}'.format(name=datasource)
else:
settings_key = 'datasource:{name}:{vendor}'.format(name=datasource, vendor=vendor)
ds_settings = self.application_settings.get(settings_key, {})
datasource_info.setdefault('fulltext_enabled', asbool(ds_settings.get('fulltext_enabled', False)))
datasource_info.setdefault('fulltext_countries', read_list(ds_settings.get('fulltext_countries', '')))
datasource_info.setdefault('details_enabled', asbool(ds_settings.get('details_enabled', False)))
datasource_info.setdefault('details_countries', read_list(ds_settings.get('details_countries', '')))
for key, value in ds_settings.iteritems():
datasource_info.setdefault(key, value)
datasource_settings.datasource[datasource] = SmartBunch.bunchify(datasource_info)
# Aggregate data for all countries.
datasource_settings.total.fulltext_countries += datasource_info['fulltext_countries']
return datasource_settings
def message_factory(**kwargs):
request = get_current_request()
application_settings = request.registry.application_settings
settings = request.runtime_settings
# EmailMessage builder
message = EmailMessage(application_settings.smtp, settings.vendor.email)
if 'reply' in settings.vendor.email.addressbook:
message.add_reply(read_list(settings.vendor.email.addressbook.reply))
is_support_email = False
if 'recipients' in kwargs:
for recipient in kwargs['recipients']:
if recipient == 'support':
is_support_email = True
if recipient in settings.vendor.email.addressbook:
message.add_recipient(
read_list(settings.vendor.email.addressbook[recipient]))
else:
log.warning('Could not add recipient {}'.format(recipient))
# Extend "To" and "Reply-To" addresses by email address of user
#request.user.username = '******'; request.user.fullname = 'Hello World' # debugging
if request.user.username:
username = request.user.username
if validate_email(username):
if request.user.fullname:
pair = (request.user.fullname, username)
else:
pair = (None, username)
try:
user_email = formataddr(pair)
except Exception as ex:
log.warning(
'Computing "user_email" failed: Could not decode email address from "{}": {}'
.format(username, ex))
return message
# Add user email as "Reply-To" address
message.add_reply(user_email)
# If it's a support email, also add user herself as a recipient
if is_support_email:
message.add_recipient(user_email)
else:
log.warning(
'Computing "user_email" failed: Email address "{}" is invalid'.
format(username))
return message
def issue_reporter_handler(request):
targets = request.params.get('targets')
report_data = request.json
report_data.setdefault('application', {})
report = SmartBunch.bunchify(report_data)
# Add user information to issue report
user = request.user
if user:
# Anonymize sensitive user data
user.password = None
user.upstream_credentials = None
# Serialize user object and attach to report
report.application.user = SmartBunch(json.loads(user.to_json()))
# Send the whole beast to the standard application log
log.error('Issue report [{targets}]:\n{report}'.format(
report=report.pretty(),
targets=targets
))
# TODO: Store the issue report into database
# TODO: What about other targets like "log:error", "log:warning", "human:support", "human:user"?
# Send email report
for target in read_list(targets):
if target.startswith('email:'):
recipient = target.replace('email:', '')
email_issue_report(report, recipient)
def create_user(data):
# Decode values with comma-separated lists
for name in ['tags', 'modules']:
data[name] = read_list(data[name])
# Create user object
user = UserManager.add_user(**data)
if user:
msg = 'Successfully created user "{}".\n{}'.format(
data['username'], user.to_json(indent=4))
logger.info(msg)
return user
