def test_unknown_contenttypes(mocker):
ct1 = ContentType(app_label='myapp1', model='mymodel1', id=1)
ct2 = ContentType(app_label='myapp1', model='mymodel2', id=2)
ct3 = ContentType(app_label='myapp2', model='mymodel3', id=3)
app_config1 = CustomAppConfig('myapp1', mocker.Mock())
app_config2 = CustomAppConfig('myapp2', mocker.Mock())
app_config3 = CustomAppConfig('myapp3', mocker.Mock())
mocker.patch(
'django_north.management.commands.showfixtures.apps'
'.get_app_configs',
return_value=[app_config1, app_config2, app_config3])
mock_get_contenttypes = mocker.patch(
'django_north.management.contenttypes'
'.get_unknown_contenttypes_for_app_config')
command = showfixtures.Command()
# unknown contenttypes
mock_get_contenttypes.side_effect = [[ct1, ct2], [ct3], []]
assert command.unknown_contenttypes() == [
"DELETE FROM django_content_type "
"WHERE app_label = 'myapp1' AND model = 'mymodel1';",
"DELETE FROM django_content_type "
"WHERE app_label = 'myapp1' AND model = 'mymodel2';",
"DELETE FROM django_content_type "
"WHERE app_label = 'myapp2' AND model = 'mymodel3';",
]
# no unknown contenttypes
mock_get_contenttypes.side_effect = [[], [], []]
assert command.unknown_contenttypes() == []
def test_missing_contenttypes(mocker):
ct1 = ContentType(app_label='myapp1', model='mymodel1')
ct2 = ContentType(app_label='myapp1', model='mymodel2')
ct3 = ContentType(app_label='myapp2', model='mymodel3')
app_config1 = CustomAppConfig('myapp1', mocker.Mock())
app_config2 = CustomAppConfig('myapp2', mocker.Mock())
app_config3 = CustomAppConfig('myapp3', mocker.Mock())
mocker.patch(
'django_north.management.commands.showfixtures.apps'
'.get_app_configs',
return_value=[app_config1, app_config2, app_config3])
mock_get_contenttypes = mocker.patch(
'django_north.management.contenttypes'
'.get_missing_contenttypes_for_app_config')
command = showfixtures.Command()
# missing contenttypes
mock_get_contenttypes.side_effect = [[ct1, ct2], [ct3], []]
assert command.missing_contenttypes() == [
"INSERT INTO django_content_type(app_label, model) "
"VALUES('myapp1', 'mymodel1');",
"INSERT INTO django_content_type(app_label, model) "
"VALUES('myapp1', 'mymodel2');",
"INSERT INTO django_content_type(app_label, model) "
"VALUES('myapp2', 'mymodel3');"
]
# no missing contenttypes
mock_get_contenttypes.side_effect = [[], [], []]
assert command.missing_contenttypes() == []
def test_get_searched_permissions(mocker):
ct1 = ContentType(app_label='myapp', model='mymodel1')
ct2 = ContentType(app_label='myapp', model='mymodel2')
model1 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel1'))
model2 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel2'))
perms = [[('add_mymodel1', 'Can add Mymodel1'),
('change_mymodel1', 'Can change Mymodel1'),
('delete_mymodel1', 'Can delete Mymodel1')],
[('add_mymodel2', 'Can add Mymodel2'),
('change_mymodel2', 'Can change Mymodel2'),
('delete_mymodel2', 'Can delete Mymodel2'),
('custom', 'Custom')]]
mocker.patch('django_north.management.permissions._get_all_permissions',
side_effect=perms)
result = permissions.get_searched_permissions([(ct1, model1),
(ct2, model2)])
assert result == [
(ct1, perms[0][0]),
(ct1, perms[0][1]),
(ct1, perms[0][2]),
(ct2, perms[1][0]),
(ct2, perms[1][1]),
(ct2, perms[1][2]),
(ct2, perms[1][3]),
]
def test_get_missing_permissions_for_app_config(mocker):
ct1 = ContentType(app_label='myapp', model='mymodel1', id=1)
ct2 = ContentType(app_label='myapp', model='mymodel2', id=2)
model1 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel1'))
model2 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel2'))
app_config = CustomAppConfig('myapp', mocker.Mock())
mock_get_contenttypes = mocker.patch(
'django_north.management.permissions'
'.get_all_contenttypes_for_app_config')
mock_get_searched_perms = mocker.patch(
'django_north.management.permissions'
'.get_searched_permissions')
mock_get_all_perms = mocker.patch(
'django_north.management.permissions.get_all_permissions')
# missing permissions
mock_get_contenttypes.return_value = [(ct1, model1), (ct2, model2)]
mock_get_searched_perms.return_value = [
(ct1, ('perm11', 'Perm11')),
(ct1, ('perm12', 'Perm12')),
(ct2, ('perm2', 'Perm2')),
]
mock_get_all_perms.return_value = [
(1, 'perm11'),
(2, 'perm2'),
]
result = permissions.get_missing_permissions_for_app_config(app_config)
assert len(result) == 1
new_perm = result[0]
assert new_perm.codename == 'perm12'
assert new_perm.name == 'Perm12'
assert new_perm.content_type == ct1
# no existing contenttypes
mock_get_contenttypes.return_value = []
mock_get_searched_perms.return_value = [
(ct1, ('perm11', 'Perm11')),
(ct1, ('perm12', 'Perm12')),
(ct2, ('perm2', 'Perm2')),
]
mock_get_all_perms.return_value = [
(1, 'perm11'),
(2, 'perm2'),
]
result = permissions.get_missing_permissions_for_app_config(app_config)
assert result == []
# no searched perms
mock_get_contenttypes.return_value = [(ct1, model1), (ct2, model2)]
mock_get_searched_perms.return_value = []
mock_get_all_perms.return_value = [
(1, 'perm11'),
(2, 'perm2'),
]
result = permissions.get_missing_permissions_for_app_config(app_config)
assert result == []
def save(self, force_insert=False, force_update=False, using=None,
update_fields=None):
try:
content_type1 = ContentType.objects.get(app_label="frontend", model="Article")
except:
content_type1 = ContentType(app_label="frontend", model="Article", name="文章板块权限")
content_type1.save()
try:
content_type2 = ContentType.objects.get(app_label="frontend", model="Slider")
except:
content_type2 = ContentType(app_label="frontend", model="Slider", name="幻灯片推送权限")
content_type2.save()
try:
content_type3 = ContentType.objects.get(app_label="frontend", model="Activity")
except:
content_type3 = ContentType(app_label="frontend", model="Activity", name="活动发布权限")
content_type3.save()
translate = {"add": "添加", "delete": "删除", "change": "修改"}
for permission in ["add", "delete", "change"]:
try:
codename = permission + "_" + self.codename + "_articles"
Permission.objects.get(codename=codename)
except:
name = "允许" + translate[permission] + " " + self.name + " 内的文章"
codename = permission + "_" + self.codename + "_articles"
p = Permission(name=name, content_type=content_type1, codename=codename)
p.save()
try:
codename = permission + "_" + self.codename + "_sliders"
Permission.objects.get(codename=codename)
except:
name = "允许" + translate[permission] + " " + self.name + " 内的幻灯片"
codename = permission + "_" + self.codename + "_sliders"
p = Permission(name=name, content_type=content_type2, codename=codename)
p.save()
try:
codename = permission + "_" + self.codename + "_activities"
Permission.objects.get(codename=codename)
except:
name = "允许" + translate[permission] + " " + self.name + " 内的活动"
codename = permission + "_" + self.codename + "_activities"
p = Permission(name=name, content_type=content_type3, codename=codename)
p.save()
if self.order == None:
self.order = self.id
result = super(MainMenu, self).save()
return result
class Like(models.Model):
user = models.ForeignKey(get_user_model(),
related_name='likes',
on_delete=models.CASCADE)
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = ContentType('content_type', 'object_id')
def action():
"""Add a test action.
"""
action = Action(
action="test action",
question_text="test question",
co2_formula="0.8 * test_parameter * 0.5",
water_formula="0.8 * test_parameter * 0.5",
waste_formula="0.8 * test_parameter * 0.5",
version="version 1.0",
content_type=ContentType(id=1),
object_id=1,
)
def _action(real_data):
"""Updates test action with realistic data if needed.
"""
if real_data:
action.co2_formula = "0.8 * vegetarian_meals * 0.5"
action.water_formula = "0.4 * current_meals"
action.waste_formula = "0.9 * current_meals * vegetarian_meals"
action.content_type = ContentType(
id=3, app_label="pledges | food pledge", model=FoodPledge)
action.save()
return action
return _action
def create_table(*models):
""" Create all tables for the given models """
cursor = connection.cursor()
def execute(statements):
for statement in statements:
cursor.execute(statement)
STYLE = no_style()
table_names = connection.introspection.get_table_list(cursor)
for model in models:
if not model._meta.db_table in table_names:
execute(connection.creation.sql_create_model(model, STYLE)[0])
execute(connection.creation.sql_indexes_for_model(model, STYLE))
execute(sql.custom_sql_for_model(model, STYLE, connection))
for model in models:
opts = model._meta
try:
ct = ContentType.objects.get(app_label=opts.app_label,
model=opts.object_name.lower())
except ContentType.DoesNotExist:
ct = ContentType(name=smart_unicode(opts.verbose_name_raw),
app_label=opts.app_label,
model=opts.object_name.lower())
ct.save()
def backwards(self, orm):
# Adding model 'Suggestion'
db.create_table('pootle_app_suggestion', (
('translation_project',
self.gf('django.db.models.fields.related.ForeignKey')(
to=orm['pootle_translationproject.TranslationProject'])),
('state', self.gf('django.db.models.fields.CharField')(
default='pending', max_length=16, db_index=True)),
('suggester',
self.gf('django.db.models.fields.related.ForeignKey')(
related_name='suggester', null=True,
to=orm['accounts.User'])),
('review_time', self.gf('django.db.models.fields.DateTimeField')(
null=True, db_index=True)),
('reviewer', self.gf('django.db.models.fields.related.ForeignKey')(
related_name='reviewer', null=True, to=orm['accounts.User'])),
('creation_time', self.gf('django.db.models.fields.DateTimeField')(
auto_now_add=True, blank=True, db_index=True)),
('id',
self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('unit',
self.gf('django.db.models.fields.IntegerField')(db_index=True)),
))
db.send_create_signal('pootle_app', ['Suggestion'])
ct = ContentType(app_label='pootle_app',
model='suggestion',
name='suggestion')
ct.save()
def update_contenttypes(app, created_models, verbosity=2):
"""
Creates content types for models in the given app, removing any model
entries that no longer have a matching model class.
"""
ContentType.objects.clear_cache()
content_types = list(
ContentType.objects.filter(app_label=app.__name__.split('.')[-2]))
app_models = get_models(app)
if not app_models:
return
for klass in app_models:
opts = klass._meta
try:
ct = ContentType.objects.get(app_label=opts.app_label,
model=opts.object_name.lower())
content_types.remove(ct)
except ContentType.DoesNotExist:
ct = ContentType(name=smart_unicode(opts.verbose_name_raw),
app_label=opts.app_label,
model=opts.object_name.lower())
ct.save()
if verbosity >= 2:
print "Adding content type '%s | %s'" % (ct.app_label,
ct.model)
# The presence of any remaining content types means the supplied app has an
# undefined model and can safely be removed, which cascades to also remove
# related permissions.
for ct in content_types:
if verbosity >= 2:
print "Deleting stale content type '%s | %s'" % (ct.app_label,
ct.model)
ct.delete()
def mutate_and_get_payload(self, info, name, object_id, comment, targets):
if not '.' in name:
raise SngyException('Неправильное имя')
app_label, model = name.lower().split('.')
content_type = ContentType(app_label=app_label, model=model)
content_object = content_type.get_object_for_this_type(id=object_id)
Comment.objects.create(content_object=content_object,
user=info.context.user,
comment=comment)
users_id = [u.id for u in User.objects.all()]
if not targets:
targets = list(
set([
c.user_id for c in Comment.objects.filter(
content_type__app_label=app_label,
content_type__model=model,
object_id=object_id)
]))
if info.context.user.id in targets:
targets.remove(info.context.user.id)
for t in targets:
if t in users_id:
text = 'Комментарий: ' + comment
Notification.objects.create(purpose_id=t,
created=info.context.user,
text=text)
return CreateComments(result=True)
def permission_add(module, using=None):
'''
添加自定义权限
'''
content_type = None
try:
if not using:
content_type = ContentType.objects.get(
app_label=settings.PERMISSION_APP, model=module)
else:
content_type = ContentType.objects.using(using).get(
app_label=settings.PERMISSION_APP, model=module)
except:
content_type = ContentType(name=module,
app_label=settings.PERMISSION_APP,
model=module)
content_type.save(using=using)
for op in operations.values():
try:
perm = Permission(codename='%s_%s' % (op, module),
name='can %s %s' % (op, module),
content_type=content_type)
perm.save(using=using)
except:
pass
def create_vote(self, vote):
content_type = ContentType(app_label=self.app, model=self.model)
content_object = content_type.get_object_for_this_type(
id=self.instance.id)
return Vote.objects.create(vote=vote,
content_object=content_object,
user_id=self.user_id)
def register_content_type(apps, schema_editor):
"""Registers AlertSettings if not yet registered"""
try:
ContentType.objects.get(app_label='monitoring', model='alertsettings')
except ObjectDoesNotExist:
ct = ContentType(app_label='monitoring', model='alertsettings')
ct.save()
def get(self, **kwargs):
self._repopulate_if_necessary()
if "pk" in kwargs:
kwargs["id"] = kwargs["pk"]
del kwargs["pk"]
if "id" in kwargs:
dic = self._get_from_store(int(kwargs["id"]))
else:
for ct in self._store.content_types.values():
for k, v in kwargs.items():
if k not in ct:
raise ContentType.DoesNotExist()
if ct[k] != v:
break
else:
dic = ct
break
else:
raise ContentType.DoesNotExist()
def disable_save(*args, **kwargs):
raise NotImplementedError("You can't save simulated content types")
# We do this because some tests to comparisons with 'is' so we store
# constructed ContentTypes in the thread local and return them if possible
if dic["id"] in self._store.constructed_instances:
return self._store.constructed_instances[dic["id"]]
else:
result = ContentType(**dic)
result.save = new.instancemethod(disable_save, ContentType, result)
self._store.constructed_instances[dic["id"]] = result
return result
def setUp(self):
self.field = ContentRelatedField()
self.internal_value = ContentType.objects.create(id=99,
model='model',
app_label='app_label')
self.bad_internal_value = MagicMock(spec=ContentType(), id=100)
self.display_value = 'model'
self.bad_display_value = 'bad-model'
def test_get_queryset_invalid_content_type_raises_404(self):
# Arrange
view = self.setUpView(
content_type=ContentType(pk=1000000, app_label="Test", model="Test")
)
# Act & Assert
with self.assertRaises(Http404):
view.get_queryset()
def gen_content_type():
from django.contrib.contenttypes.models import ContentType
from django.apps import apps
try:
return ContentType.objects.get_for_model(choice(apps.get_models()))
except AssertionError:
warnings.warn('Database access disabled, returning ContentType raw instance')
return ContentType()
def add_app_content_type(sender, **kwargs):
for app in apps.get_app_configs():
appname = app.name
try:
ContentType.objects.get(model='', app_label=appname)
except ContentType.DoesNotExist:
ct = ContentType(model='', app_label=appname)
ct.save()
def clean(self):
su = super(ObjectsFormAdmin, self).clean()
# TODO это просто бомба же
for name in self.foreign_keys:
if self.md_fields.get(name).to.model_class(
) in self.foreign_keys_models_with_magic:
su[name] = ContentType(id=su[name].pk)
return su
def update_contenttypes(app, created_models, verbosity=2, **kwargs):
"""
Creates content types for models in the given app, removing any model
entries that no longer have a matching model class.
"""
# print u"johan-----------------------------: 更新contenttypes 表"
ContentType.objects.clear_cache()
content_types = list(
ContentType.objects.filter(
app_label=app.__name__.split('.')[-2])) # 得到app中的所有ContentType
app_models = get_models(app) # api 应用例子
if not app_models:
return
for klass in app_models: #-----------------------遍历 app 所有 model 添加新模型对应的 ContentType
opts = klass._meta
try:
ct = ContentType.objects.get(app_label=opts.app_label,
model=opts.object_name.lower())
content_types.remove(ct)
except ContentType.DoesNotExist:
ct = ContentType(name=u"%s" % opts.verbose_name,
app_label=opts.app_label,
model=opts.object_name.lower())
ct.save()
if verbosity >= 2: # ------------------------是否显示运行信息
print "Adding content type '%s | %s'......" % (ct.app_label,
ct.model)
# The presence of any remaining content types means the supplied app has an
# undefined model. Confirm that the content type is stale before deletion.
if content_types: # ------------------------------去除已被删除model 对应的 content_type
if kwargs.get('interactive', False):
content_type_display = '\n'.join([
' %s | %s' % (ct.app_label, ct.model)
for ct in content_types
])
ok_to_delete = raw_input(
"""The following content types are stale and need to be deleted:
%s
Any objects related to these content types by a foreign key will also
be deleted. Are you sure you want to delete these content types?
If you're unsure, answer 'no'.
Type 'yes' to continue, or 'no' to cancel: """ % content_type_display)
else:
ok_to_delete = False
if ok_to_delete == 'yes':
for ct in content_types:
if verbosity >= 2:
print "Deleting stale content type '%s | %s'......" % (
ct.app_label, ct.model)
ct.delete()
else:
if verbosity >= 2:
print "Stale content types remain......"
def create_content_type(model):
opts = model._meta
try:
ct = ContentType.objects.get(app_label=opts.app_label,
model=opts.object_name.lower())
except ContentType.DoesNotExist:
ct = ContentType(app_label=opts.app_label,
model=opts.object_name.lower())
ct.save()
def test_stale_model_str(self):
"""
No matter what, the ContentItem.__str__() should work.
This would break the admin delete screen otherwise.
"""
c = ContentType()
c.save()
a = ContentItem(polymorphic_ctype=c)
self.assertEqual(str(a), "'(type deleted) 0' in 'None None'")
def setUp(self):
super(IndexationDjangoContentTypeTestCase, self).setUp()
entry1 = ContentType(model='DjangoContentType')
entry1.save()
entry2 = DjangoContentType(content_type=entry1)
entry2.save()
self.backend.update(self.index, [entry2])
def execute(self):
app_label, model = self.model_name.lower().split('.')
content_type = ContentType(app_label=app_label, model=model)
content_object = content_type.get_object_for_this_type(id=self.instance_id)
return Comment.objects.create(
content_object=content_object,
user_id=self.user_id,
text=self.text,
parent_id=self.parent_id
)
def _ensure_content_type():
""" Add the bulldog content type to the database if it's missing. """
from django.contrib.contenttypes.models import ContentType
try:
row = ContentType.objects.get(app_label=PERM_APP_NAME)
except ContentType.DoesNotExist:
row = ContentType(name=PERM_APP_NAME,
app_label=PERM_APP_NAME,
model=PERM_APP_NAME)
row.save()
return row.id
def setupModels(*models):
"""
:param models:
:return:
"""
with connection.schema_editor(atomic=True) as schema_editor:
for model in models:
schema_editor.create_model(model)
cts = [ContentType(app_label=model._meta.app_label, model=model._meta.model) for model in models]
ContentType.objects.using(DEFAULT_DB_ALIAS).bulk_create(cts)
def test_get_all_contenttypes_for_app_config(mocker):
model1 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel1'))
model2 = mocker.Mock(_meta=mocker.Mock(model_name='mymodel2'))
ct1 = ContentType(app_label='myapp', model='mymodel1')
ct2 = ContentType(app_label='myapp', model='mymodel2')
app_config = CustomAppConfig('myapp', mocker.Mock())
mocker.patch('django.apps.AppConfig.get_models',
return_value=[model1, model2])
mock_get_for_model = mocker.patch(
'django.contrib.contenttypes.models.ContentTypeManager.get')
mock_get_for_model.side_effect = [ct1, ct2]
result = permissions.get_all_contenttypes_for_app_config(app_config)
assert result == [(ct1, model1), (ct2, model2)]
mock_get_for_model.side_effect = [ct1, ContentType.DoesNotExist]
result = permissions.get_all_contenttypes_for_app_config(app_config)
assert result == [(ct1, model1)]
def _action(real_data):
"""Updates test action with realistic data if needed.
"""
if real_data:
action.co2_formula = "0.8 * vegetarian_meals * 0.5"
action.water_formula = "0.4 * current_meals"
action.waste_formula = "0.9 * current_meals * vegetarian_meals"
action.content_type = ContentType(
id=3, app_label="pledges | food pledge", model=FoodPledge)
action.save()
return action
def test_wrong_user_or_group(self):
template = ''.join((
'{% load guardian_tags %}',
'{% get_obj_perms some_obj for contenttype as "obj_perms" %}',
))
context = {'some_obj': ContentType(), 'contenttype': self.ctype}
# This test would raise TemplateSyntaxError instead of NotUserNorGroup
# if TEMPLATE_DEBUG is set to True during tests
tmp = template_debug_getter()
template_debug_setter(False)
self.assertRaises(NotUserNorGroup, render, template, context)
template_debug_setter(tmp)
