def add_map_feature_types(self, types):
"""
add_map_feature_types(self, types)
types is a list of map feature class names.
Add these types to the instance config,
save the instance!!!,
and create udf rows for udfs that have settings defaults,
if they don't already exist.
"""
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self._map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def __init__(self, acl=None, bucket=None, **settings):
# check if some of the settings we've provided as class attributes
# need to be overwritten with values passed in here
for name, value in settings.items():
if name in self.__dict__:
setattr(self, name, value)
# For backward-compatibility of old differing parameter names
if acl is not None:
self.default_acl = acl
if bucket is not None:
self.bucket_name = bucket
self.location = (self.location or '').lstrip('/')
# Backward-compatibility: given the anteriority of the SECURE_URL setting
# we fall back to https if specified in order to avoid the construction
# of unsecure urls.
if self.secure_urls:
self.url_protocol = 'https:'
self._entries = {}
self._bucket = None
self._connection = None
if not self.access_key and not self.secret_key:
self.access_key, self.secret_key = self._get_access_keys()
def __init__(self, settings, *args, **kwargs):
"""
Initialization method.
Args:
settings (dict): subsettings.
name (str): the name of the setting.
default (dict): default value given to the setting.
required (bool): whether the setting is required or not.
prefix (str):
the setting's prefix (overrides ``AppSettings.Meta`` prefix).
call_default (bool): whether to call the default (if callable).
transform_default (bool): whether to transform the default value.
validators (list of callables): list of additional validators to use.
key_type: the type of the dict keys.
value_type (type): the type of dict values.
min_length (int): minimum length of the iterable (included).
max_length (int): maximum length of the iterable (included).
empty (bool): whether empty iterable is allowed. Deprecated in favor of min_length.
"""
super().__init__(*args, **kwargs)
for subname, subsetting in settings.items():
if subsetting.name == "":
subsetting.name = subname
subsetting.parent_setting = self
self.settings = settings
def custom_settings(context):
from custom_settings.models import Setting
settings = {
'headers_excursions': Setting.objects.get_value('headers_excursions'),
'headers_travel': Setting.objects.get_value('headers_travel'),
}
out = {}
for key, value in settings.items():
items = value.split('/')
while len(items) < 5:
items.append('')
out[key] = {
'people': items[0],
'default_price': items[1],
'price_line': {
0: items[4],
1: items[3],
2: items[2],
}
}
out['CUSTOMS'] = out
return out
def __init__(self, **settings):
# check if some of the settings provided as class attributes
# should be overwritten
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
validate_settings(self)
self.last_headers_name = None
self.last_headers_value = None
self.os_options = {
'tenant_id': self.tenant_id,
'tenant_name': self.tenant_name,
'user_domain_id': self.user_domain_id,
'user_domain_name': self.user_domain_name,
'project_domain_id': self.project_domain_id,
'project_domain_name': self.project_domain_name,
'region_name': self.region_name,
}
self.os_options.update(self.os_extra_options)
if not self.lazy_connect:
self.swift_conn
def add_map_feature_types(self, types):
"""
add_map_feature_types(self, types)
types is a list of map feature class names.
Add these types to the instance config,
save the instance!!!,
and create udf rows for udfs that have settings defaults,
if they don't already exist.
"""
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self._map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def get_settings(self):
settings = {
"django.use_l10n": self.use_l10n,
"channels.core.auth": self.auth_settings,
"channels.core.reconnection_policy": self.reconnection_policy,
"channels.core.socket_address": self.socket_address}
return {k: v for k, v in settings.items() if v is not None}
def update_field(settings):
# Identifier is lower-cased above to match the calling convention
# of update endpoints, so we shouldn't overwrite it :(
field.update({
k: v
for k, v in settings.items()
if v is not None and k != 'identifier'
})
def __init__(self, **settings):
# check if some of the settings we've provided as class attributes
# need to be overwritten with values passed in here
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
self._bucket = None
self._client = None
def __init__(self, **settings):
# check if some of the settings we've provided as class attributes
# need to be overwritten with values passed in here
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
self._bucket = None
self._client = None
def __init__(self, **settings):
# check if some of the settings provided as class attributes
# should be overwritten
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
self.last_headers_name = None
self.last_headers_value = None
# Get authentication token
self.storage_url, self.token = swiftclient.get_auth(
self.api_auth_url,
self.api_username,
self.api_key,
auth_version=self.auth_version,
os_options={"tenant_name": self.tenant_name},
)
self.http_conn = swiftclient.http_connection(self.storage_url)
# Check container
try:
swiftclient.head_container(self.storage_url,
self.token,
self.container_name,
http_conn=self.http_conn)
except swiftclient.ClientException:
if self.auto_create_container:
swiftclient.put_container(self.storage_url,
self.token,
self.container_name,
http_conn=self.http_conn)
else:
raise ImproperlyConfigured("Container %s does not exist." %
self.container_name)
if self.auto_base_url:
# Derive a base URL based on the authentication information from
# the server, optionally overriding the protocol, host/port and
# potentially adding a path fragment before the auth information.
self.base_url = self.storage_url + '/'
if self.override_base_url is not None:
# override the protocol and host, append any path fragments
split_derived = urlparse.urlsplit(self.base_url)
split_override = urlparse.urlsplit(self.override_base_url)
split_result = [''] * 5
split_result[0:2] = split_override[0:2]
split_result[2] = (split_override[2] +
split_derived[2]).replace('//', '/')
self.base_url = urlparse.urlunsplit(split_result)
self.base_url = urlparse.urljoin(self.base_url,
self.container_name)
self.base_url += '/'
else:
self.base_url = self.override_base_url
def get_parsed_client_urls(client: Client) -> dict:
"""
Get MB_URLS with inserted the client URL
"""
settings = dict(mb_settings(client))
url = client.url
for key, value in settings.items():
if isinstance(value, str) and '{}' in value:
settings[key] = value.format(url) if url else None
return settings
def __init__(self, **settings):
# check if some of the settings provided as class attributes
# should be overwritten
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
self.last_headers_name = None
self.last_headers_value = None
# Get authentication token
self.storage_url, self.token = swiftclient.get_auth(
self.api_auth_url,
self.api_username,
self.api_key,
auth_version=self.auth_version,
os_options={"tenant_name": self.tenant_name},
)
self.http_conn = swiftclient.http_connection(self.storage_url)
# Check container
try:
swiftclient.head_container(self.storage_url, self.token,
self.container_name,
http_conn=self.http_conn)
except swiftclient.ClientException:
if self.auto_create_container:
swiftclient.put_container(self.storage_url, self.token,
self.container_name,
http_conn=self.http_conn)
else:
raise ImproperlyConfigured(
"Container %s does not exist." % self.container_name)
if self.auto_base_url:
# Derive a base URL based on the authentication information from
# the server, optionally overriding the protocol, host/port and
# potentially adding a path fragment before the auth information.
self.base_url = self.storage_url + '/'
if self.override_base_url is not None:
# override the protocol and host, append any path fragments
split_derived = urlparse.urlsplit(self.base_url)
split_override = urlparse.urlsplit(self.override_base_url)
split_result = [''] * 5
split_result[0:2] = split_override[0:2]
split_result[2] = (split_override[2] +
split_derived[2]).replace('//', '/')
self.base_url = urlparse.urlunsplit(split_result)
self.base_url = urlparse.urljoin(self.base_url,
self.container_name)
self.base_url += '/'
else:
self.base_url = self.override_base_url
def _build_key(cls, urls, timeout, **settings):
# Order the settings by key and then turn it into a string with
# repr. There are a lot of edge cases here, but the worst that
# happens is that the key is different and so you get a new
# Elasticsearch. We'll probably have to tweak this.
settings = sorted(settings.items(), key=lambda item: item[0])
settings = repr([(k, v) for k, v in settings])
# elasticsearch allows URLs to be a string, so we make sure to
# account for that when converting whatever it is into a tuple.
if isinstance(urls, string_types):
urls = (urls,)
else:
urls = tuple(urls)
# Generate a tuple of all the bits and return that as the key
# because that's hashable.
key = (urls, timeout, settings)
return key
def _build_key(cls, urls, timeout, **settings):
# Order the settings by key and then turn it into a string with
# repr. There are a lot of edge cases here, but the worst that
# happens is that the key is different and so you get a new
# Elasticsearch. We'll probably have to tweak this.
settings = sorted(settings.items(), key=lambda item: item[0])
settings = repr([(k, v) for k, v in settings])
# elasticsearch allows URLs to be a string, so we make sure to
# account for that when converting whatever it is into a tuple.
if isinstance(urls, string_types):
urls = (urls, )
else:
urls = tuple(urls)
# Generate a tuple of all the bits and return that as the key
# because that's hashable.
key = (urls, timeout, settings)
return key
def allValues(cls, user=None):
"""
Return a dict of "all" defined global settings.
This performs a single database lookup,
and then any settings which are not *in* the database
are assigned their default values
"""
results = cls.objects.all()
if user is not None:
results = results.filter(user=user)
# Query the database
settings = {}
for setting in results:
if setting.key:
settings[setting.key.upper()] = setting.value
# Specify any "default" values which are not in the database
for key in cls.GLOBAL_SETTINGS.keys():
if key.upper() not in settings:
settings[key.upper()] = cls.get_setting_default(key)
for key, value in settings.items():
validator = cls.get_setting_validator(key)
if cls.validator_is_bool(validator):
value = InvenTree.helpers.str2bool(value)
elif cls.validator_is_int(validator):
try:
value = int(value)
except ValueError:
value = cls.get_setting_default(key)
settings[key] = value
return settings
def add_map_feature_types(self, types):
from treemap.models import MapFeature # prevent circular import
from treemap.audit import add_default_permissions
classes = [MapFeature.get_subclass(type) for type in types]
dups = set(types) & set(self.map_feature_types)
if len(dups) > 0:
raise ValidationError('Map feature types already added: %s' % dups)
self.map_feature_types = list(self.map_feature_types) + list(types)
self.save()
for type, clz in zip(types, classes):
settings = (getattr(clz, 'udf_settings', {}))
for udfc_name, udfc_settings in settings.items():
if udfc_settings.get('defaults'):
get_or_create_udf(self, type, udfc_name)
add_default_permissions(self, models=classes)
def settings_list(request):
"""
Custom admin view that displays the settings for this Django project.
"""
if not request.user.is_superuser:
return HttpResponseRedirect(reverse('admin:index'))
settings = get_safe_settings()
for setting in PRIVATE_SETTINGS:
if setting in settings:
settings[setting] = '********************'
sorted_settings = sorted(settings.items())
return render_to_response('admin/settings_list.html', RequestContext(request, {
'title': 'Django Settings',
'sorted_settings': sorted_settings,
}))
def put(self, request, device_id=None):
# Basic sanity check on the values we're trying to send
for group, settings in request.DATA.items():
if not type(settings) == dict:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
for key, val in settings.items():
if not isinstance(val, (int, float, bool, str, unicode)):
return Response(status=status.HTTP_400_BAD_REQUEST)
username, password, cloud_fqdn = get_credentials(request)
if not username or not password or not cloud_fqdn:
return Response(status=status.HTTP_400_BAD_REQUEST)
conn = DeviceCloudConnector(username, password, cloud_fqdn)
try:
settings = conn.set_device_settings(device_id,
settings=request.DATA)
except HTTPError, e:
return Response(status=e.response.status_code,
data=e.response.text)
def override_api_settings(**settings):
old_settings = {}
for k, v in settings.items():
# Save settings
try:
old_settings[k] = api_settings.user_settings[k]
except KeyError:
pass
# Install temporary settings
api_settings.user_settings[k] = v
# Delete any cached settings
try:
delattr(api_settings, k)
except AttributeError:
pass
yield
for k in settings.keys():
# Delete temporary settings
api_settings.user_settings.pop(k)
# Restore saved settings
try:
api_settings.user_settings[k] = old_settings[k]
except KeyError:
pass
# Delete any cached settings
try:
delattr(api_settings, k)
except AttributeError:
pass
def update_field(settings):
# Identifier is lower-cased above to match the calling convention
# of update endpoints, so we shouldn't overwrite it :(
field.update({k: v for k, v in settings.items()
if v is not None and k != 'identifier'})
def wrapped(self, *args, **kwargs):
self.factory.settings.update(settings)
for key, value in settings.items():
setattr(self.provider, key, value)
fn(self, *args, **kwargs)
def __init__(self, **settings):
# check if some of the settings provided as class attributes
# should be overwritten
for name, value in settings.items():
if hasattr(self, name):
setattr(self, name, value)
validate_settings(self)
self.last_headers_name = None
self.last_headers_value = None
self.os_options = {
'tenant_id': self.tenant_id,
'tenant_name': self.tenant_name,
'user_domain_id': self.user_domain_id,
'user_domain_name': self.user_domain_name,
'project_domain_id': self.project_domain_id,
'project_domain_name': self.project_domain_name
}
self.os_options.update(self.os_extra_options)
# Get authentication token
self.storage_url, self.token = swiftclient.get_auth(
self.api_auth_url,
self.api_username,
self.api_key,
auth_version=self.auth_version,
os_options=self.os_options)
self.http_conn = swiftclient.http_connection(self.storage_url)
# Check container
try:
swiftclient.head_container(self.storage_url,
self.token,
self.container_name,
http_conn=self.http_conn)
except swiftclient.ClientException:
headers = {}
if self.auto_create_container:
if self.auto_create_container_public:
headers['X-Container-Read'] = '.r:*'
if self.auto_create_container_allow_orgin:
headers['X-Container-Meta-Access-Control-Allow-Origin'] = \
self.auto_create_container_allow_orgin
swiftclient.put_container(self.storage_url,
self.token,
self.container_name,
http_conn=self.http_conn,
headers=headers)
else:
raise ImproperlyConfigured(
"Container %s does not exist." % self.container_name)
if self.auto_base_url:
# Derive a base URL based on the authentication information from
# the server, optionally overriding the protocol, host/port and
# potentially adding a path fragment before the auth information.
self.base_url = self.storage_url + '/'
if self.override_base_url is not None:
# override the protocol and host, append any path fragments
split_derived = urlparse.urlsplit(self.base_url)
split_override = urlparse.urlsplit(self.override_base_url)
split_result = [''] * 5
split_result[0:2] = split_override[0:2]
split_result[2] = (split_override[2] + split_derived[2]
).replace('//', '/')
self.base_url = urlparse.urlunsplit(split_result)
self.base_url = urlparse.urljoin(self.base_url,
self.container_name)
self.base_url += '/'
else:
self.base_url = self.override_base_url
