def get_review_request_fieldsets(include_main=False,
include_change_entries_only=False):
"""Returns a list of all registered fieldset classes.
As an internal optimization, the "main" fieldset can be filtered out,
to help with rendering the side of the review request page.
"""
_populate_defaults()
if include_main and include_change_entries_only:
return six.itervalues(_fieldsets)
else:
excluded_ids = []
if not include_main:
excluded_ids.append('main')
if not include_change_entries_only:
excluded_ids.append('_change_entries_only')
return [
fieldset
for fieldset in six.itervalues(_fieldsets)
if fieldset.fieldset_id not in excluded_ids
]
def reset(self):
# Delete temporary files before breaking reference to them.
wizard_files = self.data[self.step_files_key]
for step_files in six.itervalues(wizard_files):
for step_file in six.itervalues(step_files):
self.file_storage.delete(step_file['tmp_name'])
self.init_data()
def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """
multi1 = MultiValueDict({'key1': ['value1'],
'key2': ['value2', 'value3']})
multi2 = MultiValueDict({'key2': ['value4'],
'key4': ['value5', 'value6']})
mm = MergeDict(multi1, multi2)
# Although 'key2' appears in both dictionaries,
# only the first value is used.
self.assertEqual(mm.getlist('key2'), ['value2', 'value3'])
self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
self.assertEqual(mm.getlist('undefined'), [])
self.assertEqual(sorted(six.iterkeys(mm)), ['key1', 'key2', 'key4'])
self.assertEqual(len(list(six.itervalues(mm))), 3)
self.assertTrue('value1' in six.itervalues(mm))
self.assertEqual(sorted(six.iteritems(mm), key=lambda k: k[0]),
[('key1', 'value1'), ('key2', 'value3'),
('key4', 'value6')])
self.assertEqual([(k,mm.getlist(k)) for k in sorted(mm)],
[('key1', ['value1']),
('key2', ['value2', 'value3']),
('key4', ['value5', 'value6'])])
def __init__(self, form, inline_formsets):
if form.is_bound:
self.extend(list(six.itervalues(form.errors)))
for inline_formset in inline_formsets:
self.extend(inline_formset.non_form_errors())
for errors_in_inline_form in inline_formset.errors:
self.extend(list(six.itervalues(errors_in_inline_form)))
def compute_form_list(self, form_list=None, *args, **kwargs):
"""Compute the forms list."""
form_list = form_list or kwargs.pop('form_list',
getattr(self, 'form_list',
None)) or []
computed_form_list = OrderedDict()
# walk through the passed form list
for i, form in enumerate(form_list):
if isinstance(form, (list, tuple)):
# if the element is a tuple, add the tuple to the new created
# sorted dictionary.
computed_form_list[six.text_type(form[0])] = form[1]
else:
# if not, add the form with a zero based counter as unicode
computed_form_list[six.text_type(i)] = form
# walk through the new created list of forms
for form in six.itervalues(computed_form_list):
if issubclass(form, formsets.BaseFormSet):
# if the element is based on BaseFormSet (FormSet/ModelFormSet)
# we need to override the form variable.
form = form.form
# check if any form contains a FileField, if yes, we need a
# file_storage added to the wizardview (by subclassing).
for field in six.itervalues(form.base_fields):
if (isinstance(field, forms.FileField) and
not hasattr(self, 'file_storage')):
raise NoFileStorageConfigured(
"You need to define 'file_storage' in your "
"wizard view in order to handle file uploads.")
return computed_form_list
def test_mergedict_merges_multivaluedict(self):
""" MergeDict can merge MultiValueDicts """
multi1 = MultiValueDict({"key1": ["value1"], "key2": ["value2", "value3"]})
multi2 = MultiValueDict({"key2": ["value4"], "key4": ["value5", "value6"]})
mm = MergeDict(multi1, multi2)
# Although 'key2' appears in both dictionaries,
# only the first value is used.
self.assertEqual(mm.getlist("key2"), ["value2", "value3"])
self.assertEqual(mm.getlist("key4"), ["value5", "value6"])
self.assertEqual(mm.getlist("undefined"), [])
self.assertEqual(sorted(six.iterkeys(mm)), ["key1", "key2", "key4"])
self.assertEqual(len(list(six.itervalues(mm))), 3)
self.assertIn("value1", six.itervalues(mm))
self.assertEqual(
sorted(six.iteritems(mm), key=lambda k: k[0]), [("key1", "value1"), ("key2", "value3"), ("key4", "value6")]
)
self.assertEqual(
[(k, mm.getlist(k)) for k in sorted(mm)],
[("key1", ["value1"]), ("key2", ["value2", "value3"]), ("key4", ["value5", "value6"])],
)
def get_initkwargs(cls, form_list, initial_dict=None,
instance_dict=None, condition_dict=None, *args, **kwargs):
"""
Creates a dict with all needed parameters for the form wizard instances.
* `form_list` - is a list of forms. The list entries can be single form
classes or tuples of (`step_name`, `form_class`). If you pass a list
of forms, the wizardview will convert the class list to
(`zero_based_counter`, `form_class`). This is needed to access the
form for a specific step.
* `initial_dict` - contains a dictionary of initial data dictionaries.
The key should be equal to the `step_name` in the `form_list` (or
the str of the zero based counter - if no step_names added in the
`form_list`)
* `instance_dict` - contains a dictionary whose values are model
instances if the step is based on a ``ModelForm`` and querysets if
the step is based on a ``ModelFormSet``. The key should be equal to
the `step_name` in the `form_list`. Same rules as for `initial_dict`
apply.
* `condition_dict` - contains a dictionary of boolean values or
callables. If the value of for a specific `step_name` is callable it
will be called with the wizardview instance as the only argument.
If the return value is true, the step's form will be used.
"""
kwargs.update({
'initial_dict': initial_dict or {},
'instance_dict': instance_dict or {},
'condition_dict': condition_dict or {},
})
init_form_list = SortedDict()
assert len(form_list) > 0, 'at least one form is needed'
# walk through the passed form list
for i, form in enumerate(form_list):
if isinstance(form, (list, tuple)):
# if the element is a tuple, add the tuple to the new created
# sorted dictionary.
init_form_list[six.text_type(form[0])] = form[1]
else:
# if not, add the form with a zero based counter as unicode
init_form_list[six.text_type(i)] = form
# walk through the new created list of forms
for form in six.itervalues(init_form_list):
if issubclass(form, formsets.BaseFormSet):
# if the element is based on BaseFormSet (FormSet/ModelFormSet)
# we need to override the form variable.
form = form.form
# check if any form contains a FileField, if yes, we need a
# file_storage added to the wizardview (by subclassing).
for field in six.itervalues(form.base_fields):
if (isinstance(field, forms.FileField) and
not hasattr(cls, 'file_storage')):
raise NoFileStorageConfigured
# build the kwargs for the wizardview instances
kwargs['form_list'] = init_form_list
return kwargs
def version_matrix(request):
matrix = defaultdict(partial(defaultdict, LatestList))
latest = defaultdict(list)
groups = defaultdict(list)
judges = {judge.id: judge.name for judge in Judge.objects.filter(online=True)}
languages = Language.objects.all()
for runtime in RuntimeVersion.objects.filter(judge__online=True).order_by('priority'):
if runtime.version:
matrix[runtime.judge_id][runtime.language_id].append(runtime)
for judge, data in six.iteritems(matrix):
name_tuple = judges[judge].rpartition('.')
groups[name_tuple[0] or name_tuple[-1]].append((judges[judge], data))
matrix = {}
for group, data in six.iteritems(groups):
if len(data) == 1:
judge, data = data[0]
matrix[judge] = data
continue
ds = list(range(len(data)))
size = [1] * len(data)
for i, (p, x) in enumerate(data):
if ds[i] != i:
continue
for j, (q, y) in enumerate(data):
if i != j and compare_version_list(x, y):
ds[j] = i
size[i] += 1
size[j] = 0
rep = max(range(len(data)), key=size.__getitem__)
matrix[group] = data[rep][1]
for i, (j, x) in enumerate(data):
if ds[i] != rep:
matrix[j] = x
for data in six.itervalues(matrix):
for language, versions in six.iteritems(data):
versions.versions = [version.parse(runtime.version) for runtime in versions]
if versions.versions > latest[language]:
latest[language] = versions.versions
for data in six.itervalues(matrix):
for language, versions in six.iteritems(data):
versions.is_latest = versions.versions == latest[language]
languages = sorted(languages, key=lambda lang: version.parse(lang.name))
return render(request, 'status/versions.html', {
'title': _('Version matrix'),
'judges': sorted(matrix.keys()),
'languages': languages,
'matrix': matrix,
})
def reset(self):
# Store unused temporary file names in order to delete them
# at the end of the response cycle through a callback attached in
# `update_response`.
wizard_files = self.data[self.step_files_key]
for step_files in six.itervalues(wizard_files):
for step_file in six.itervalues(step_files):
self._tmp_files.append(step_file['tmp_name'])
self.init_data()
def _prepare(self, model):
# 排序的属性
if self.order_with_respect_to:
self.order_with_respect_to = self.get_field(self.order_with_respect_to)
self.ordering = ('_order',)
model.add_to_class('_order', OrderWrt())
else:
self.order_with_respect_to = None
if self.pk is None:
if self.parents:
# Promote 促进, 提升 the first parent link in lieu of adding yet another
# field.
field = next(six.itervalues(self.parents))
# Look for a local field with the same name as the
# first parent link. If a local field has already been
# created, use it instead of promoting the parent
already_created = [fld for fld in self.local_fields if fld.name == field.name]
if already_created:
field = already_created[0]
field.primary_key = True
self.setup_pk(field)
else:
auto = AutoField(verbose_name='ID', primary_key=True,
auto_created=True)
model.add_to_class('id', auto)
# 如果两个属性同时关联两个外部表, 比如两个外键的时候, 需要创建一个集合.
# Determine any sets of fields that are pointing to the same targets
# (e.g. two ForeignKeys to the same remote model). The query
# construction code needs to know this. At the end of this,
# self.duplicate_targets will map each duplicate field column to the
# columns it duplicates.
collections = {}
for column, target in six.iteritems(self.duplicate_targets):
try:
collections[target].add(column)
except KeyError:
collections[target] = set([column])
self.duplicate_targets = {}
for elt in six.itervalues(collections):
if len(elt) == 1:
continue
for column in elt:
# elt_set - set([column])
self.duplicate_targets[column] = elt.difference(set([column]))
def ready(self):
# Models have been imported (these are imported
# reverse order, due to Django loading them.
# We correctly register these calls now.
dummy = params.loader
params.loader = params._loader
del params._loader
# Apply calls in reversed order
for args in reversed(dummy.calls):
params.loader.register(*args[0], **args[1])
# Import .modules and .configure submodules for
# each Sellmo App
imports = ['modules', 'indexes', 'configure']
apps = list(six.itervalues(params.sellmo_apps))
for module_name in imports:
for app in reversed(apps):
app.import_module(module_name)
# At this point Sellmo's loading functionality
# should no longer be used.
loader = params.loader
del params.loader
# Delayed loading is now done. We can now call all
# delayed functions in correct order.
loader.load()
# Initialize Sellmo modules now
modules.init_modules()
# Import extra modules for
# each Sellmo App. Like:
# .views and .links.
apps = list(six.itervalues(params.sellmo_apps))
for module_name in params.extra_imports:
for app in reversed(apps):
app.import_module(module_name)
# Everything has been imported and all chains
# should have been created and linked to by now.
chainer = params.chainer
del params.chainer
# Hookup all chains
chainer.hookup()
# We are done
post_init.send(self)
def __init__(self, form, inline_formsets):
if form.is_bound:
self.extend(list(six.itervalues(form.errors)))
for inline_formset in inline_formsets:
self.extend(inline_formset.non_form_errors())
for errors_in_inline_form in inline_formset.errors:
self.extend(list(six.itervalues(errors_in_inline_form)))
for form in inline_formset:
if hasattr(form, "nested_formsets"):
for nested_formset in form.nested_formsets:
self.extend(nested_formset.formset.non_form_errors())
for errors_in_nested_form in nested_formset.formset.errors:
self.extend(list(six.itervalues(errors_in_nested_form)))
log.info("Errors: %s" % self.as_text())
def sitemap(request, sitemaps, section=None):
"""
This view generates a sitemap with additional geographic
elements defined by Google.
"""
warnings.warn("Geo Sitemaps are deprecated. Use plain sitemaps from "
"django.contrib.sitemaps instead", DeprecationWarning, stacklevel=2)
maps, urls = [], []
if section is not None:
if section not in sitemaps:
raise Http404(_("No sitemap available for section: %r") % section)
maps.append(sitemaps[section])
else:
maps = list(six.itervalues(sitemaps))
page = request.GET.get("p", 1)
current_site = get_current_site(request)
for site in maps:
try:
if callable(site):
urls.extend(site().get_urls(page=page, site=current_site))
else:
urls.extend(site.get_urls(page=page, site=current_site))
except EmptyPage:
raise Http404(_("Page %s empty") % page)
except PageNotAnInteger:
raise Http404(_("No page '%s'") % page)
xml = loader.render_to_string('gis/sitemaps/geo_sitemap.xml', {'urlset': urls})
return HttpResponse(xml, content_type='application/xml')
def sitemap(request, sitemaps, section=None,
template_name='sitemap.xml', content_type='application/xml'):
req_protocol = request.scheme
req_site = get_current_site(request)
if section is not None:
if section not in sitemaps:
raise Http404("No sitemap available for section: %r" % section)
maps = [sitemaps[section]]
else:
maps = list(six.itervalues(sitemaps))
page = request.GET.get("p", 1)
urls = []
for site in maps:
try:
if callable(site):
site = site()
urls.extend(site.get_urls(page=page, site=req_site,
protocol=req_protocol))
except EmptyPage:
raise Http404("Page %s empty" % page)
except PageNotAnInteger:
raise Http404("No page '%s'" % page)
response = TemplateResponse(request, template_name, {'urlset': urls},
content_type=content_type)
if hasattr(site, 'latest_lastmod'):
# if latest_lastmod is defined for site, set header so as
# ConditionalGetMiddleware is able to send 304 NOT MODIFIED
response['Last-Modified'] = http_date(
timegm(site.latest_lastmod.utctimetuple()))
return response
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str('vote=yes&vote=no'))
self.assertEqual(q['vote'], 'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', 'no'])
self.assertEqual(q.getlist('foo'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
if not six.PY3:
self.assertEqual(q.has_key('vote'), True)
self.assertEqual('vote' in q, True)
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
self.assertEqual(list(six.iterkeys(q)), ['vote'])
self.assertEqual(list(six.itervalues(q)), ['no'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertRaises(AttributeError, q.__delitem__, 'vote')
def wrapper(*args, **kwargs):
for arg in list(args) + list(six.itervalues(kwargs)):
if isinstance(arg, Promise):
break
else:
return func(*args, **kwargs)
return lazy(func, *resultclasses)(*args, **kwargs)
def test_get_context_data(self):
"""Testing ConfigPagesView.get_context_data"""
request = RequestFactory().request()
request.user = User.objects.create(username='******')
view = MyConfigPagesView()
view.request = request
view.dispatch(view.request)
self.assertEqual(
view.get_context_data(),
{
'base_template_name': 'base.html',
'page_title': 'My Page Title',
'nav_title': 'My Nav Entry',
'pages_id': 'config_pages',
'pages': view.pages,
'css_bundle_names': ['my-css-bundle'],
'js_bundle_names': ['my-js-bundle'],
'js_model_class': 'MyModel',
'js_view_class': 'MyView',
'js_model_data': {
'my-attr': 'value',
},
'js_view_data': {
'my-option': 'value',
},
'forms': list(six.itervalues(view.forms)),
'render_sidebar': True,
})
def test_multivaluedict(self):
d = MultiValueDict({'name': ['Adrian', 'Simon'],
'position': ['Developer']})
self.assertEqual(d['name'], 'Simon')
self.assertEqual(d.get('name'), 'Simon')
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEqual(sorted(list(six.iteritems(d))),
[('name', 'Simon'), ('position', 'Developer')])
self.assertEqual(sorted(list(six.iterlists(d))),
[('name', ['Adrian', 'Simon']),
('position', ['Developer'])])
six.assertRaisesRegex(self, MultiValueDictKeyError, 'lastname',
d.__getitem__, 'lastname')
self.assertEqual(d.get('lastname'), None)
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEqual(d.getlist('lastname'), [])
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']),
['Adrian', 'Simon'])
d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEqual(sorted(list(six.itervalues(d))),
['Developer', 'Simon', 'Willison'])
def _process_aggregate_args(self, args, kwargs):
"""for aggregate and annotate kwargs: allow ModelX___field syntax for kwargs, forbid it for args.
Modifies kwargs if needed (these are Aggregate objects, we translate the lookup member variable)"""
for a in args:
assert not '___' in a.lookup, 'PolymorphicModel: annotate()/aggregate(): ___ model lookup supported for keyword arguments only'
for a in six.itervalues(kwargs):
a.lookup = translate_polymorphic_field_path(self.model, a.lookup)
def sitemap(request, sitemaps, section=None,
template_name='sitemap.xml', content_type='application/xml',
mimetype=None):
if mimetype:
warnings.warn("The mimetype keyword argument is deprecated, use "
"content_type instead", DeprecationWarning, stacklevel=2)
content_type = mimetype
req_protocol = 'https' if request.is_secure() else 'http'
req_site = get_current_site(request)
req_site = Site(name='movie', domain='movie.' + req_site.domain)
if section is not None:
if section not in sitemaps:
raise Http404("No sitemap available for section: %r" % section)
maps = [sitemaps[section]]
else:
maps = list(six.itervalues(sitemaps))
page = request.GET.get("p", 1)
urls = []
for site in maps:
try:
if callable(site):
site = site()
urls.extend(site.get_urls(page=page, site=req_site,
protocol=req_protocol))
except EmptyPage:
raise Http404("Page %s empty" % page)
except PageNotAnInteger:
raise Http404("No page '%s'" % page)
return TemplateResponse(request, template_name, {'urlset': urls},
content_type=content_type)
def _prepare(self, model):
if self.order_with_respect_to:
# The app registry will not be ready at this point, so we cannot
# use get_field().
query = self.order_with_respect_to
try:
self.order_with_respect_to = next(
f for f in self._get_fields(reverse=False) if f.name == query or f.attname == query
)
except StopIteration:
raise FieldDoesNotExist("%s has no field named %r" % (self.object_name, query))
self.ordering = ("_order",)
if not any(isinstance(field, OrderWrt) for field in model._meta.local_fields):
model.add_to_class("_order", OrderWrt())
else:
self.order_with_respect_to = None
if self.pk is None:
if self.parents:
# Promote the first parent link in lieu of adding yet another
# field.
field = next(six.itervalues(self.parents))
# Look for a local field with the same name as the
# first parent link. If a local field has already been
# created, use it instead of promoting the parent
already_created = [fld for fld in self.local_fields if fld.name == field.name]
if already_created:
field = already_created[0]
field.primary_key = True
self.setup_pk(field)
else:
auto = AutoField(verbose_name="ID", primary_key=True, auto_created=True)
model.add_to_class("id", auto)
def _get_any_translated_model(self):
"""
Return any available translation.
Returns None if there are no translations at all.
"""
if self._translations_cache:
# There is already a language available in the case. No need for queries.
# Give consistent answers if they exist.
try:
return self._translations_cache.get(self._current_language, None) \
or self._translations_cache.get(self.get_fallback_language(), None) \
or next(t for t in six.itervalues(self._translations_cache) if t if not None) # Skip fallback markers.
except StopIteration:
pass
try:
# Use prefetch if available, otherwise perform separate query.
qs = self._get_translated_queryset()
if qs._prefetch_done:
translation = list(qs)[0]
else:
translation = qs[0]
except IndexError:
return None
else:
self._translations_cache[translation.language_code] = translation
_cache_translation(translation)
return translation
def main():
leden = Es.by_name('leden')
lut = {}
id2name = {}
for m in Es.users():
if not m.name:
continue
lut[str(m.name)] = set()
id2name[m._id] = str(m.name)
max_q = Es.date_to_year(Es.now()) * 4
for q in range(1, max_q + 1):
start, end = Es.quarter_to_range(q)
for m in leden.get_rrelated(_from=start, until=end, how=None,
deref_who=False, deref_with=False,
deref_how=False):
lut[id2name[m['who']]].add(q)
for i, name in enumerate(sorted(six.itervalues(id2name))):
if i % 20 == 0:
print()
print('%20s %s' % (
'year',
' '.join([str(((q - 1) / 4) + 1).ljust(7)
for q in range(1, max_q + 1, 4)])
))
print('%20s %s' % (
'quarter',
' '.join([str(((q - 1) % 4) + 1)
for q in range(1, max_q + 1)])
))
print('%-20s %s' % (
name,
' '.join(['*' if q in lut[name] else ' '
for q in range(1, max_q + 1)])
))
def delete(self):
""" deletion for versioned objects means setting the 'ends_at' field
to the current datetime. Applied only for active versions, having
ends_at=NULL """
now = timezone.now()
# sort instance collections
for model, instances in self.data.items():
self.data[model] = sorted(instances, key=attrgetter("pk"))
# if possible, bring the models in an order suitable for databases that
# don't support transactions or cannot defer constraint checks until the
# end of a transaction.
self.sort()
with transaction.commit_on_success_unless_managed(using=self.using):
# send pre_delete signals
for model, obj in self.instances_with_model():
if not model._meta.auto_created:
signals.pre_delete.send(
sender=model, instance=obj, using=self.using
)
# fast deletes - TODO check works correctly with versioned rels
for qs in self.fast_deletes:
query = sql.UpdateQuery(qs.model)
pk_list = [obj.pk for obj in qs.all()]
query.update_batch(pk_list, {'ends_at': now}, self.using)
# update fields - TODO check works correctly with versioned rels
for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
for (field, value), instances in six.iteritems(instances_for_fieldvalues):
for o in instances: # update FK fields
setattr(o, field.name, value)
model.objects.bulk_create(instances)
# reverse instance collections
for instances in six.itervalues(self.data):
instances.reverse()
# delete instances by setting 'ends_at' to 'now'
for model, instances in six.iteritems(self.data):
query = sql.UpdateQuery(model)
pk_list = [obj.pk for obj in instances]
query.update_batch(pk_list, {'ends_at': now}, self.using)
if not model._meta.auto_created:
for obj in instances:
signals.post_delete.send(
sender=model, instance=obj, using=self.using
)
# update collected instances
for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
for (field, value), instances in six.iteritems(instances_for_fieldvalues):
for obj in instances:
setattr(obj, field.attname, value)
for model, instances in six.iteritems(self.data):
for instance in instances:
setattr(instance, model._meta.pk.attname, None)
def __init__(self, *args, **kwargs):
"""Initialize the form.
Args:
limit_to_local_site (reviewboard.site.models.LocalSite, optional):
The Local Site to limit configurations to. If ``None`` (or not
provided), the configuration's Local Site (or lack thereof) can
be specified by the user.
*args (tuple):
Positional arguments to pass to the parent form.
**kwargs (dict):
Keyword arguments to pass to the parent form.
"""
local_site = kwargs.pop('limit_to_local_site', None)
self.limit_to_local_site = local_site
super(IntegrationConfigForm, self).__init__(*args, **kwargs)
if local_site:
self.fields['local_site'].queryset = \
LocalSite.objects.filter(pk=local_site.pk)
# Limit LocalSites for all condition fields.
for field in six.itervalues(self.fields):
if isinstance(field, ConditionsField):
field.choice_kwargs['local_site'] = local_site
def _find_longest_move_range(self, r_move_ranges):
# Go through every range of lines we've found and find the longest.
#
# The longest move range wins. If we find two ranges that are equal,
# though, we'll ignore both. The idea is that if we have two identical
# moves, then it's probably common enough code that we don't want to
# show the move. An example might be some standard part of a comment
# block, with no real changes in content.
#
# Note that with the current approach, finding duplicate moves doesn't
# cause us to reset the winning range to the second-highest identical
# match. We may want to do that down the road, but it means additional
# state, and this is hopefully uncommon enough to not be a real
# problem.
r_move_range = None
for iter_move_range in six.itervalues(r_move_ranges):
if not r_move_range:
r_move_range = iter_move_range
else:
len1 = r_move_range.end - r_move_range.start
len2 = iter_move_range.end - iter_move_range.start
if len1 < len2:
r_move_range = iter_move_range
elif len1 == len2:
# If there are two that are the same, it may be common
# code that we don't want to see moves for. Comments,
# for example.
r_move_range = None
return r_move_range
def index(self, request, extra_context=None):
"""
Displays the main admin index page, which lists all of the installed
apps that have been registered in this site.
"""
app_dict = {}
user = request.user
for model, model_admin in self._registry.items():
app_label = model._meta.app_label
has_module_perms = user.has_module_perms(app_label)
if has_module_perms:
perms = model_admin.get_model_perms(request)
# Check whether user has any perm for this module.
# If so, add the module to the model_list.
if True in perms.values():
info = (app_label, model._meta.model_name)
model_dict = {
'name': capfirst(model._meta.verbose_name_plural),
'object_name': model._meta.object_name,
'perms': perms,
}
if perms.get('change', False):
try:
model_dict['admin_url'] = reverse('admin:%s_%s_changelist' % info, current_app=self.name)
except NoReverseMatch:
pass
if perms.get('add', False):
try:
model_dict['add_url'] = reverse('admin:%s_%s_add' % info, current_app=self.name)
except NoReverseMatch:
pass
if app_label in app_dict:
app_dict[app_label]['models'].append(model_dict)
else:
app_dict[app_label] = {
'name': app_label.title(),
'app_label': app_label,
'app_url': reverse('admin:app_list', kwargs={'app_label': app_label}, current_app=self.name),
'has_module_perms': has_module_perms,
'models': [model_dict],
}
# Sort the apps alphabetically.
app_list = list(six.itervalues(app_dict))
app_list.sort(key=lambda x: x['name'])
# Sort the models alphabetically within each app.
for app in app_list:
app['models'].sort(key=lambda x: x['name'])
context = dict(self.each_context(),
title=self.index_title,
app_list=app_list,
)
context.update(extra_context or {})
return TemplateResponse(request, self.index_template or
'admin/index.html', context,
current_app=self.name)
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str("vote=yes&vote=no"))
self.assertEqual(q["vote"], "no")
self.assertRaises(AttributeError, q.__setitem__, "something", "bar")
self.assertEqual(q.get("vote", "default"), "no")
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.getlist("vote"), ["yes", "no"])
self.assertEqual(q.getlist("foo"), [])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])
if six.PY2:
self.assertEqual(q.has_key("vote"), True)
self.assertEqual("vote" in q, True)
if six.PY2:
self.assertEqual(q.has_key("foo"), False)
self.assertEqual("foo" in q, False)
self.assertEqual(list(six.iteritems(q)), [("vote", "no")])
self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])])
self.assertEqual(list(six.iterkeys(q)), ["vote"])
self.assertEqual(list(six.itervalues(q)), ["no"])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {"foo": "bar"})
self.assertRaises(AttributeError, q.pop, "foo")
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
self.assertRaises(AttributeError, q.__delitem__, "vote")
def get_grouping(self):
"""
Returns a tuple representing the SQL elements in the "group by" clause.
"""
qn = self.quote_name_unless_alias
result, params = [], []
if self.query.group_by is not None:
if (len(self.query.model._meta.fields) == len(self.query.select) and
self.connection.features.allows_group_by_pk):
self.query.group_by = [
(self.query.model._meta.db_table, self.query.model._meta.pk.column)
]
group_by = self.query.group_by or []
extra_selects = []
for extra_select, extra_params in six.itervalues(self.query.extra_select):
extra_selects.append(extra_select)
params.extend(extra_params)
cols = (group_by + self.query.select +
self.query.related_select_cols + extra_selects)
seen = set()
for col in cols:
if col in seen:
continue
seen.add(col)
if isinstance(col, (list, tuple)):
result.append('%s.%s' % (qn(col[0]), qn(col[1])))
elif hasattr(col, 'as_sql'):
result.append(col.as_sql(qn, self.connection))
else:
result.append('(%s)' % str(col))
return result, params
def _prepare(self, model):
if self.order_with_respect_to:
self.order_with_respect_to = self.get_field(self.order_with_respect_to)
self.ordering = ('_order',)
model.add_to_class('_order', OrderWrt())
else:
self.order_with_respect_to = None
if self.pk is None:
if self.parents:
# Promote the first parent link in lieu of adding yet another
# field.
field = next(six.itervalues(self.parents))
# Look for a local field with the same name as the
# first parent link. If a local field has already been
# created, use it instead of promoting the parent
already_created = [fld for fld in self.local_fields if fld.name == field.name]
if already_created:
field = already_created[0]
field.primary_key = True
self.setup_pk(field)
else:
auto = AutoField(verbose_name='ID', primary_key=True,
auto_created=True)
model.add_to_class('id', auto)
def test_immutable_basic_operations(self):
q = QueryDict()
self.assertEqual(q.getlist('foo'), [])
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def to_internal_value(self, data):
if isinstance(data, list):
result = [self.inverted_choices.get(item, None) for item in data]
else:
result = self.inverted_choices.get(data, None)
if result is None:
if not data:
raise ValidationError("This field cannot be blank.")
raise ValidationError(
"'%s' is not a valid choice. Expected one of %s." %
(data, [choice for choice in six.itervalues(self.choices)]))
return result
def __init__(self, *args, **kwargs):
rule_names = kwargs.pop('rules', tuple())
disabled = kwargs.pop('disabled',
False) # in set fields are note editable
super(CodepointForm, self).__init__(*args, **kwargs)
self.fields['when'].choices = rule_names
self.fields['not_when'].choices = rule_names
if disabled:
for field in six.itervalues(self.fields):
# field.disabled = True XXX need django 1.9
field.widget.attrs['disabled'] = True
def test_immutable_basic_operations(self):
q = QueryDict(str(''))
self.assertEqual(q.getlist('foo'), [])
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def delete(self):
# sort instance collections
for model, instances in self.data.items():
self.data[model] = sorted(instances, key=attrgetter("pk"))
# if possible, bring the models in an order suitable for databases that
# don't support transactions or cannot defer constraint checks until the
# end of a transaction.
self.sort()
with transaction.atomic(using=self.using, savepoint=False):
# send pre_delete signals
for model, obj in self.instances_with_model():
if not model._meta.auto_created:
signals.pre_delete.send(
sender=model, instance=obj, using=self.using
)
# fast deletes
for qs in self.fast_deletes:
qs._raw_delete(using=self.using)
# update fields
for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
query = sql.UpdateQuery(model)
for (field, value), instances in six.iteritems(instances_for_fieldvalues):
query.update_batch([obj.pk for obj in instances],
{field.name: value}, self.using)
# reverse instance collections
for instances in six.itervalues(self.data):
instances.reverse()
# delete instances
for model, instances in six.iteritems(self.data):
query = sql.DeleteQuery(model)
pk_list = [obj.pk for obj in instances]
query.delete_batch(pk_list, self.using)
if not model._meta.auto_created:
for obj in instances:
signals.post_delete.send(
sender=model, instance=obj, using=self.using
)
# update collected instances
for model, instances_for_fieldvalues in six.iteritems(self.field_updates):
for (field, value), instances in six.iteritems(instances_for_fieldvalues):
for obj in instances:
setattr(obj, field.attname, value)
for model, instances in six.iteritems(self.data):
for instance in instances:
setattr(instance, model._meta.pk.attname, None)
def get_all_conditions(self):
"""
Returns a generator which yields groups of lists of conditions.
>>> for set_id, label, field in gargoyle.get_all_conditions():
>>> print("%(label)s: %(field)s" % (label, field.label))
"""
for condition_set in sorted(self.get_condition_sets(),
key=lambda x: x.get_group_label()):
group = six.text_type(condition_set.get_group_label())
for field in six.itervalues(condition_set.fields):
yield condition_set.get_id(), group, field
def get_context_data(self, **kwargs):
context = {'base_url': self.get_base_url()}
organization = self.kwargs.get('organization', None)
if organization:
for accessible in self.get_accessibles(self.request):
if accessible['slug'] == organization:
context.update({'organization': accessible})
break
from_root, trail = self.breadcrumbs
root = None
if trail:
root = self._build_tree(trail[-1][0],
from_root,
cut=TransparentCut())
# Flatten icons and practices (i.e. Energy Efficiency) to produce
# the list of charts.
for element in six.itervalues(root[1]):
for chart in self.score_charts:
# We use `score_charts`, not `get_printable_charts` because
# not all top level icons might show up in the benchmark
# graphs, yet we need to display the scores under the icons.
if element[0]['slug'] == chart['slug']:
if 'normalized_score' in chart:
element[0][
'normalized_score'] = "%s%%" % chart.get(
'normalized_score')
else:
element[0]['normalized_score'] = "N/A"
element[0]['score_weight'] = chart.get(
'score_weight', "N/A")
break
charts = self.get_printable_charts()
for chart in charts:
if chart['slug'] == 'totals':
context.update({
'total_chart':
chart,
'nb_respondents':
chart.get('nb_respondents', "N/A")
})
break
context.update({
'charts':
[chart for chart in charts if chart['slug'] != 'totals'],
'breadcrumbs':
trail,
'root':
root,
'at_time':
datetime_or_now()
})
return context
def get_root_entities(cls, containers):
"""Returns a list of entities that aren't contained within others
:type containers: nav.ipdevpoll.storage.ContainerRepository
"""
if cls in containers:
entities = itervalues(containers[cls])
return [
e for e in entities
if e.contained_in is None or e.contained_in == -1
]
else:
return []
def get_chassis_entities(cls, containers):
"""Returns a list of chassis entities in containers
:type containers: nav.ipdevpoll.storage.ContainerRepository
"""
if cls in containers:
entities = itervalues(containers[cls])
return [
e for e in entities
if e.physical_class == manage.NetboxEntity.CLASS_CHASSIS
]
else:
return []
def _get_smoke_alarms_params(self, smoke_alarms):
sensors = []
for smoke_alarm in itervalues(smoke_alarms):
smoke_alarm_avail = smoke_alarm.get('smokeAlarmAvail', None)
if smoke_alarm_avail:
smoke_alarm_oid = smoke_alarm.get(0, None)
serial = smoke_alarm.get('smokeAlarmSerial', None)
name = smoke_alarm.get('smokeAlarmName', None)
sensors.append(self._make_result_dict(
smoke_alarm_oid,
self._get_oid_for_sensor('smokeAlarmStatus'),
serial, 'smokeAlarmStatus', name=name))
return sensors
def _get_analog_sensors_params(self, analog_sensors):
sensors = []
for analog_sensor in itervalues(analog_sensors):
analog_avail = analog_sensor.get('analogSensorAvail', None)
if analog_avail:
analog_sensor_oid = analog_sensor.get(0, None)
serial = analog_sensor.get('analogSensorSerial', None)
name = analog_sensor.get('analogSensorName', None)
sensors.append(self._make_result_dict(
analog_sensor_oid,
self._get_oid_for_sensor('analogSensorAnalog'),
serial, 'analogSensorAnalog', name=name))
return sensors
def _get_digital_sensors_params(self, digital_sensors):
sensors = []
for digital_sensor in itervalues(digital_sensors):
digital_avail = digital_sensor.get('digitalSensorAvail', None)
if digital_avail:
digital_sensor_oid = digital_sensor.get(0, None)
serial = digital_sensor.get('digitalSensorSerial', None)
name = digital_sensor.get('digitalSensorName', None)
sensors.append(self._make_result_dict(
digital_sensor_oid,
self._get_oid_for_sensor('digitalSensorDigital'),
serial, 'digitalSensorDigital', name=name))
return sensors
def _get_cpm_params(self, cpm_sensors):
sensors = []
for cpm_sensor in itervalues(cpm_sensors):
cpm_sensor_avail = cpm_sensor.get('cpmSensorAvail', None)
if cpm_sensor_avail:
cpm_sensor_oid = cpm_sensor.get(0, None)
serial = cpm_sensor.get('cpmSensorSerial', None)
name = cpm_sensor.get('cpmSensorName', None)
sensors.append(self._make_result_dict(
cpm_sensor_oid,
self._get_oid_for_sensor('cpmSensorStatus'),
serial, 'cpmSensorStatus', name=name))
return sensors
def _get_water_sensors_params(self, water_sensors):
sensors = []
for water_sensor in itervalues(water_sensors):
water_sensor_avail = water_sensor.get('waterSensorAvail', None)
if water_sensor_avail:
water_sensor_oid = water_sensor.get(0, None)
serial = water_sensor.get('waterSensorSerial', None)
name = water_sensor.get('waterSensorName', None)
sensors.append(self._make_result_dict(
water_sensor_oid,
self._get_oid_for_sensor('waterSensorDampness'),
serial, 'waterSensorSerial', name=name))
return sensors
def encode_response(self, results):
"""Pack the raw execute response."""
outputs = []
for data, prm, req in itervalues(results):
if prm.identifier in self.resp_form:
outputs.append(_encode_raw_output(data, prm, req))
if len(outputs) == 1:
self.content_type = outputs[0].content_type
else:
self.content_type = "multipart/related"
return outputs
def to_representation(self, instance):
ret = super(HighlighterMixin, self).to_representation(instance)
terms = " ".join(six.itervalues(self.context["request"].GET))
if terms:
highlighter = self.get_highlighter()(terms, **{
"html_tag": self.highlighter_html_tag,
"css_class": self.highlighter_css_class,
"max_length": self.highlighter_max_length
})
document_field = self.get_document_field(instance)
if highlighter and document_field:
ret["highlighted"] = highlighter.highlight(getattr(instance, self.highlighter_field or document_field))
return ret
def _validate_max_depth(self, root_instructions):
max_depth = self.get_max_expand_depth()
for nested_field_names in six.itervalues(root_instructions):
for nested_field_name in nested_field_names:
depth = len(nested_field_name.split(EXPAND_DELIMITER))
if depth > max_depth:
raise ValueError(
'Expansion of "{0}" exceeds max depth of {1}'.format(
nested_field_name, max_depth
)
)
def _process_aggregate_args(self, args, kwargs):
"""for aggregate and annotate kwargs: allow ModelX___field syntax for kwargs, forbid it for args.
Modifies kwargs if needed (these are Aggregate objects, we translate the lookup member variable)"""
___lookup_assert_msg = 'PolymorphicModel: annotate()/aggregate(): ___ model lookup supported for keyword arguments only'
if django.VERSION < (1, 8):
def patch_lookup(a):
a.lookup = translate_polymorphic_field_path(self.model, a.lookup)
def test___lookup(a):
assert '___' not in a.lookup, ___lookup_assert_msg
else:
def patch_lookup(a):
# With Django > 1.8, the field on which the aggregate operates is
# stored inside a complex query expression.
if isinstance(a, Q):
translate_polymorphic_Q_object(self.model, a)
elif hasattr(a, 'get_source_expressions'):
for source_expression in a.get_source_expressions():
if source_expression is not None:
patch_lookup(source_expression)
else:
a.name = translate_polymorphic_field_path(self.model, a.name)
def test___lookup(a):
""" *args might be complex expressions too in django 1.8 so
the testing for a '___' is rather complex on this one """
if isinstance(a, Q):
def tree_node_test___lookup(my_model, node):
" process all children of this Q node "
for i in range(len(node.children)):
child = node.children[i]
if type(child) == tuple:
# this Q object child is a tuple => a kwarg like Q( instance_of=ModelB )
assert '___' not in child[0], ___lookup_assert_msg
else:
# this Q object child is another Q object, recursively process this as well
tree_node_test___lookup(my_model, child)
tree_node_test___lookup(self.model, a)
elif hasattr(a, 'get_source_expressions'):
for source_expression in a.get_source_expressions():
test___lookup(source_expression)
else:
assert '___' not in a.name, ___lookup_assert_msg
for a in args:
test___lookup(a)
for a in six.itervalues(kwargs):
patch_lookup(a)
def _get_dsts_params(self, dsts_sensors):
sensors = []
for dsts_sensor in itervalues(dsts_sensors):
dsts_avail = dsts_sensor.get('dstsAvail', None)
if dsts_avail:
dsts_oid = dsts_sensor.get(0, None)
serial = dsts_sensor.get('dstsSerial', None)
name = dsts_sensor.get('dstsName', None)
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsVoltsA'), serial,
'dstsVoltsA', u_o_m=Sensor.UNIT_VOLTS_DC, name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsAmpsA'), serial,
'dstsAmpsA', u_o_m=Sensor.UNIT_AMPERES, name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsVoltsB'), serial,
'dstsVoltsB', u_o_m=Sensor.UNIT_VOLTS_DC, name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsAmpsB'), serial,
'dstsAmpsB', u_o_m=Sensor.UNIT_AMPERES, name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsSourceAActive'),
serial, 'dstsSourceAActive', name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsSourceBActive'),
serial, 'dstsSourceBActive', name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsPowerStatusA'),
serial, 'dstsPowerStatusA', name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsPowerStatusB'),
serial, 'dstsPowerStatusB', name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsSourceATempC'),
serial, 'dstsSourceATempC', u_o_m=Sensor.UNIT_CELCIUS,
name=name))
sensors.append(self._make_result_dict(
dsts_oid,
self._get_oid_for_sensor('dstsSourceBTempC'),
serial, 'dstsSourceBTempC', u_o_m=Sensor.UNIT_CELCIUS,
name=name))
return sensors
def get_models(self, app_mod=None,
include_auto_created=False, include_deferred=False,
only_installed=True, include_swapped=False):
"""
Given a module containing models, returns a list of the models.
Otherwise returns a list of all installed models.
By default, auto-created models (i.e., m2m models without an
explicit intermediate table) are not included. However, if you
specify include_auto_created=True, they will be.
By default, models created to satisfy deferred attribute
queries are *not* included in the list of models. However, if
you specify include_deferred, they will be.
By default, models that aren't part of installed apps will *not*
be included in the list of models. However, if you specify
only_installed=False, they will be.
By default, models that have been swapped out will *not* be
included in the list of models. However, if you specify
include_swapped, they will be.
"""
cache_key = (app_mod, include_auto_created, include_deferred, only_installed, include_swapped)
try:
return self._get_models_cache[cache_key]
except KeyError:
pass
self._populate()
if app_mod:
if app_mod in self.app_store:
app_list = [self.app_models.get(self._label_for(app_mod),
SortedDict())]
else:
app_list = []
else:
if only_installed:
app_list = [self.app_models.get(app_label, SortedDict())
for app_label in six.iterkeys(self.app_labels)]
else:
app_list = six.itervalues(self.app_models)
model_list = []
for app in app_list:
model_list.extend(
model for model in app.values()
if ((not model._deferred or include_deferred) and
(not model._meta.auto_created or include_auto_created) and
(not model._meta.swapped or include_swapped))
)
self._get_models_cache[cache_key] = model_list
return model_list
def paginate_queryset(self, queryset, request, view=None):
self.nb_organizations = 0
self.reporting_publicly_count = 0
self.no_assessment = 0
self.abandoned = 0
self.expired = 0
self.assessment_phase = 0
self.improvement_phase = 0
self.completed = 0
accounts = {}
for sample in queryset:
slug = sample.get('slug')
reporting_status = sample.get(
'reporting_status', AccountSerializer.REPORTING_NOT_STARTED)
if not slug in accounts:
accounts[slug] = {
'reporting_status': reporting_status,
'reporting_publicly':
bool(sample.get('reporting_publicly')),
'reporting_fines': bool(sample.get('reporting_fines'))
}
continue
if reporting_status > accounts[slug]['reporting_status']:
accounts[slug]['reporting_status'] == reporting_status
if sample.get('reporting_publicly'):
accounts[slug]['reporting_publicly'] = True
if sample.get('reporting_fines'):
accounts[slug]['reporting_fines'] = True
self.nb_organizations = len(accounts)
for account in six.itervalues(accounts):
reporting_status = account.get(
'reporting_status', AccountSerializer.REPORTING_NOT_STARTED)
if reporting_status == AccountSerializer.REPORTING_ABANDONED:
self.abandoned += 1
elif reporting_status == AccountSerializer.REPORTING_EXPIRED:
self.expired += 1
elif (reporting_status ==
AccountSerializer.REPORTING_ASSESSMENT_PHASE):
self.assessment_phase += 1
elif reporting_status == AccountSerializer.REPORTING_PLANNING_PHASE:
self.improvement_phase += 1
elif reporting_status == AccountSerializer.REPORTING_COMPLETED:
self.completed += 1
else:
self.no_assessment += 1
if account.get('reporting_publicly'):
self.reporting_publicly_count += 1
return super(CompletionSummaryPagination,
self).paginate_queryset(queryset, request, view=view)
def get_app_list(self, request, registry, label=''):
#register the explicit app_labels
if label:
self.app_dict = {label: self.app_labels[label]} if label in self.app_labels else {}
else:
self.app_dict = self.app_labels
user = request.user
for model, model_admin in registry.items():
app_label = model._meta.app_label
if label and not label == app_label:
continue
has_module_perms = user.has_module_perms(app_label)
if has_module_perms and not app_label in self.exclude:
perms = model_admin.get_model_perms(request)
# Check whether user has any perm for this module.
# If so, add the module to the model_list.
if True in perms.values():
info = (app_label, model._meta.model_name)
model_dict = {
'classname': model.__name__,
'name': capfirst(model._meta.verbose_name_plural),
'perms': perms,
}
if perms.get('change', False):
try:
model_dict['admin_url'] = reverse('admin:%s_%s_changelist' % info, current_app=self.name)
except NoReverseMatch:
pass
if perms.get('add', False):
try:
model_dict['add_url'] = reverse('admin:%s_%s_add' % info, current_app=self.name)
except NoReverseMatch:
pass
self._check_app_dict(app_label, has_module_perms)
if not 'exclude' in self.app_dict[app_label] or \
model_dict['classname'] not in self.app_dict[app_label]['exclude']:
self.app_dict[app_label]['models'].append(model_dict)
self._app_dict_sets()
if not label:
# Sort the apps by the specified sorter - alphabetically by default.
app_list = list(six.itervalues(self.app_dict))
app_list.sort(key=self.app_sorter)
return app_list
return self.app_dict[label]
def smart_values(self, *fields):
fields = list(fields)
value_field_names = [
typ.get_value_field_name()
for typ in six.itervalues(attribute_types)
]
if 'value' in fields:
fields.remove('value')
fields.extend(value_field_names)
values = self.values(*fields)
values = values._clone(klass=SmartValueValuesQuerySet)
return values.order_by(*fields)
def _get_current_monitors_params(self, current_monitors):
sensors = []
for current_mon in itervalues(current_monitors):
current_mon_avail = current_mon.get('currentMonitorAvail', None)
if current_mon_avail:
current_mon_oid = current_mon.get(0, None)
serial = current_mon.get('currentMonitorSerial', None)
name = current_mon.get('currentMonitorName', None)
sensors.append(self._make_result_dict(
current_mon_oid,
self._get_oid_for_sensor('currentMonitorDeciAmps'),
serial, 'currentMonitorDeciAmps',
u_o_m=Sensor.UNIT_AMPERES, name=name))
return sensors
def validate_unique(self, exclude=None):
"""
Also validate the unique_together of the translated model.
"""
# This is called from ModelForm._post_clean() or Model.full_clean()
errors = {}
try:
super(TranslatableModel, self).validate_unique(exclude=exclude)
except ValidationError as e:
errors = e.message_dict # Django 1.5 + 1.6 compatible
for local_cache in six.itervalues(self._translations_cache):
for translation in six.itervalues(local_cache):
if translation is MISSING: # Skip fallback markers
continue
try:
translation.validate_unique(exclude=exclude)
except ValidationError as e:
errors.update(e.message_dict)
if errors:
raise ValidationError(errors)
def check_generic_foreign_keys(app_configs=None, **kwargs):
from .fields import GenericForeignKey
if app_configs is None:
models = apps.get_models()
else:
models = chain.from_iterable(app_config.get_models()
for app_config in app_configs)
errors = []
fields = (obj for model in models for obj in six.itervalues(vars(model))
if isinstance(obj, GenericForeignKey))
for field in fields:
errors.extend(field.check())
return errors
def _get_temp_sensors_params(self, temp_sensors):
sensors = []
for temp_sensor in itervalues(temp_sensors):
temp_avail = temp_sensor.get('tempSensorAvail', None)
if temp_avail:
temp_oid = temp_sensor.get(0, None)
serial = temp_sensor.get('tempSensorSerial', None)
name = temp_sensor.get('tempSensorName', None)
sensors.append(self._make_result_dict(
temp_oid,
self._get_oid_for_sensor('tempSensorTempC'),
serial, 'tempSensorTempC', u_o_m=Sensor.UNIT_CELSIUS,
name=name))
return sensors
def _add_formset_recursive(self, formset):
#check if it is a wrapped formset
if isinstance(formset, InlineAdminFormSet):
formset = formset.formset
self.extend(formset.non_form_errors())
for errors_in_inline_form in formset.errors:
self.extend(list(six.itervalues(errors_in_inline_form)))
#support for nested formsets
for form in formset:
if hasattr(form, 'nested_formsets'):
for fs in form.nested_formsets:
self._add_formset_recursive(fs)
def _construct_form(self, i, **kwargs):
"""
Called when building "internal" forms.
Hook ourselves into this function to set the required flag on fields
"""
form = super(BaseDisableableFormSet, self)._construct_form(i, **kwargs)
if self.disabled:
for field in six.itervalues(form.fields):
# field.disabled = True XXX need django 1.9
field.widget.attrs['disabled'] = True
return form
def _get_millivolt_monitors_params(self, millivolts_monitors):
sensors = []
for mvolts_mon in itervalues(millivolts_monitors):
mvolts_mon_avail = mvolts_mon.get('millivoltMonitorAvail', None)
if mvolts_mon_avail:
mvolts_mon_oid = mvolts_mon.get(0, None)
serial = mvolts_mon.get('millivoltMonitorSerial', None)
name = mvolts_mon.get('millivoltMonitorName', None)
sensors.append(self._make_result_dict(
mvolts_mon_oid,
self._get_oid_for_sensor('millivoltMonitorMV'),
serial, 'millivoltMonitorMV', u_o_m=Sensor.UNIT_VOLTS_DC,
scale='milli', name=name))
return sensors
