def get_content_objects(self, querysets={}, annotate=[], select_related=True):
models = {}
objects = {}
results = []
order_fields = list(self.model._meta.ordering)
annotate_fields = list(annotate)
extras = []
extras.extend(order_fields)
extras.extend(annotate_fields)
values = self.values('pk', 'object_id', 'content_type__app_label',
'content_type__model', *extras)
for item in values:
pk = item.pop('pk')
object_id = item.pop('object_id')
app_label = item.pop('content_type__app_label')
model_name = item.pop('content_type__model')
annotated = dict((k, v) for k, v in item.items() if k in annotate_fields)
ordering = dict((k, v) for k, v in item.items() if k in order_fields)
model = get_model(app_label, model_name)
models.setdefault(model, {}) \
.setdefault(object_id, []).append({
'ordering': ordering,
'annotated': annotated,
})
for model, objs in models.items():
if model in querysets:
qs = querysets[model]
else:
qs = model._default_manager
if select_related:
qs = qs.select_related()
object_list = qs.filter(pk__in=objs.keys())
for obj in object_list:
objects.setdefault(model, {})[obj.pk] = obj
for model, objs in models.items():
for pk, options_list in objs.items():
for options in options_list:
try:
fields = objects[model][pk].__dict__.copy()
private_fields = dict((k, fields.pop(k)) for k in \
fields.keys() if k.startswith('_'))
obj = model(**fields)
obj.__temp_ordering = options['ordering']
for name, annotate in options['annotated'].items():
k, v = convert_lookup_to_dict(name, annotate)
setattr(obj, k, v)
obj.__dict__.update(private_fields)
results.append(obj)
except KeyError:
pass
for order in order_fields:
results.sort(key=lambda i: i.__temp_ordering[order])
for result in results:
del result.__temp_ordering
return results
def forward_transition_from_minus_one_to_zero(apps, schema_editor):
models = {
"AutonomousSystem": {
"filters": {"ipv4_max_prefixes": -1, "ipv6_max_prefixes": -1},
"updates": {"ipv4_max_prefixes": 0, "ipv6_max_prefixes": 0},
},
"DirectPeeringSession": {
"filters": {"advertised_prefix_count": -1, "received_prefix_count": -1},
"updates": {"advertised_prefix_count": 0, "received_prefix_count": 0},
},
"InternetExchange": {
"filters": {"peeringdb_id": -1},
"updates": {"peeringdb_id": 0},
},
"InternetExchangePeeringSession": {
"filters": {"advertised_prefix_count": -1, "received_prefix_count": -1},
"updates": {"advertised_prefix_count": 0, "received_prefix_count": 0},
},
}
db_alias = schema_editor.connection.alias
for key, value in models.items():
model = apps.get_model("peering", key)
model.objects.using(db_alias).filter(**value["filters"]).update(
**value["updates"]
)
def register(self, models={}):
for alias, conf in models.items():
handler = self.supported_content_type.setdefault(alias, PurifyHandler())
handler.model = model = get_model(conf['model'])
handler.manager = model.objects
handler.content_type = get_contenttype(model)
handler.methods = conf.get('methods', {})
def execute(cls, request, params):
search_text = params['kw'].lower()
is_content_search = params.get('is_content_search')
results = []
search_models = params.get('search_models')
if is_content_search:
search_apps = content_search_apps
else:
search_apps = all_apps
if search_models:
for app_name in search_models:
for model_name in search_models[app_name]:
fields = search_apps[app_name][model_name]
kwargs = {}
q_objects = Q()
for field in fields:
q_objects |= Q(**{field + '__contains': params['kw']})
kwargs.update({
'{0}__{1}'.format(field, 'contains'):
search_text
})
model_obj = apps.get_model(app_name, model_name)
search_result = model_obj.objects.filter(q_objects)
if search_result:
search_result = ws_methods.queryset_to_list_search(
search_result)
for result in search_result:
result['model'] = app_name + '.' + model_name
results = results + search_result
return results
else:
for app, models in search_apps.items():
for model, fields in models.items():
kwargs = {}
q_objects = Q()
for field in fields:
q_objects |= Q(**{field + '__contains': params['kw']})
kwargs.update({
'{0}__{1}'.format(field, 'contains'):
search_text
})
model_obj = apps.get_model(app, model)
search_result = model_obj.objects.filter(q_objects)
if search_result:
search_result = ws_methods.queryset_to_list_search(
search_result)
for result in search_result:
result['model'] = app + '.' + model
results = results + search_result
return results
def export_models(self, app_label):
try:
models = export_remotes(self._registry[app_label])
models = map(lambda m: (m[0]._meta.object_name, \
issubclass(self._registry[app_label][m[0]], RemoteModelProxy) and 'RemoteModel' or 'RemoteReadOnlyModel', \
m[1]), models.items())
related_apps = get_related_apps(self._registry[app_label])
related_apps.discard(app_label)
return render_to_response(
'djangoffline/models.js',
{'models': models, 'apps': related_apps, 'app': app_label, 'site': self},
mimetype = 'text/javascript')
except ImproperlyConfigured, e:
return HttpResponseNotFound(str(e))
def populate_tracking_fields(apps, schema_editor):
models = {}
models['Phones'] = apps.get_model('hosting', 'Phone')._default_manager.all()
models['Places'] = apps.get_model('hosting', 'Place')._default_manager.all()
models['Profiles'] = apps.get_model('hosting', 'Profile')._default_manager.all()
models['Websites'] = apps.get_model('hosting', 'Website')._default_manager.all()
for name, objects in models.items():
print(name)
print(' deleted: ', objects.update(
deleted_on=Case(
When(deleted=False, then=None),
default=F('modified'),
output_field=DateTimeField())
))
print(' checked: ', objects.update(
checked_on=Case(
When(checked=False, then=None),
default=F('modified'),
output_field=DateTimeField())
))
def pretty(self, indent=0):
indent_str = ' ' * indent
res = '{indent}{name}:\n{indent} Default:\n{default}\n{indent} Models:'.format(
indent=indent_str,
name=type(self).__name__,
default=self._pretty_builder(self._default_builder,
indent=indent + 4),
)
models = self._builders_4_models
if models:
for model, builder in models.items():
res += '\n{indent} [{module}.{cls}]:\n{builder}'.format(
indent=indent_str,
module=model.__module__,
cls=model.__name__,
builder=self._pretty_builder(builder, indent=indent + 6),
)
else:
res += '\n{} (empty)'.format(indent_str)
return res
def populate_tracking_fields(apps, schema_editor):
models = {}
models['Phones'] = apps.get_model('hosting',
'Phone')._default_manager.all()
models['Places'] = apps.get_model('hosting',
'Place')._default_manager.all()
models['Profiles'] = apps.get_model('hosting',
'Profile')._default_manager.all()
models['Websites'] = apps.get_model('hosting',
'Website')._default_manager.all()
for name, objects in models.items():
print(name)
print(
' deleted: ',
objects.update(deleted_on=Case(When(deleted=False, then=None),
default=F('modified'),
output_field=DateTimeField())))
print(
' checked: ',
objects.update(checked_on=Case(When(checked=False, then=None),
default=F('modified'),
output_field=DateTimeField())))
def pprint_frozen_models(models):
return "{\n %s\n }" % ",\n ".join([
"%r: %s" % (name, pprint_fields(fields))
for name, fields in sorted(models.items())
])
def pprint_frozen_models(models):
return "{\n %s\n }" % ",\n ".join([
"%r: %s" % (name, pprint_fields(fields))
for name, fields in sorted(models.items())
])
def models_list(request):
models = apps.all_models['csvApp']
models_list = []
for key, value in models.items():
models_list.append(key)
return render(request, 'csvApp/models_list.html', {'models': models_list})
def set_app_test_models(models, app_label):
"""Sets the list of models in the Django test models registry."""
register_app_models(app_label, models.items(), reset=True)
def register(self, models):
regs = []
for model_name, model in models.items():
reg = admin.site.register(model, admin.ModelAdmin)
regs.append(reg)
return regs
