def add_module(request, js_target, tab_name, module_type, context=None):
"""
Create a new tabulation in a project
"""
from django.db.models import Max
from django.db.models.loading import get_app
from djity.utils.security import db_table_exists
tables = [
module_type.lower() + '_' + module_type.lower(),
'djity_' + module_type.lower() + '_' + module_type.lower()
]
if not db_table_exists(tables):
js_target.message(
_("Tab creation failed. There is no table %s in the database, contact the administrator."
% module_type))
return
try:
model = get_app(module_type.lower()).__getattribute__(module_type)
except:
model = get_app('djity_' +
module_type.lower()).__getattribute__(module_type)
project = context['project']
i = project.modules.aggregate(Max('tab_position'))['tab_position__max'] + 1
if module_type == 'SimplePage':
name = None
else:
name = module_type.lower()
module = model(project=project, name=name, label=tab_name, tab_position=i)
module.save()
js_target.redirect(module.djity_url(context))
def yumlfy(self, applications):
F = YUMLFormatter()
model_list = []
arrow_list = []
external_model = set()
for app_module in applications:
models = get_models(app_module)
if not models:
continue
for m in models:
string = F.label(m) + F.PIPE
fields = [f for f in m._meta.fields if not f.auto_created]
for field in fields:
string += F.field(field)
if field.rel:
arrow_list.append(F.relation(m, field.rel))
if get_app(field.rel.to._meta.app_label) not in applications:
external_model.add(field.rel.to)
fields = [f for f in m._meta.many_to_many]
for field in fields:
string += F.field(field)
if field.rel.through._meta.auto_created:
arrow_list.append(F.relation(m, field.rel))
else:
arrow_list.append(F.through(m, field.rel))
if get_app(field.rel.to._meta.app_label) not in applications:
external_model.add(field.rel.to)
model_list.append(F.wrap(string))
for parent in m._meta.parents:
arrow_list.append(F.inherit(m, parent))
if get_app(parent._meta.app_label) not in applications:
external_model.add(parent)
for ext in external_model:
model_list.append(F.external(ext))
return model_list + arrow_list
def add_module(request, js_target, tab_name, module_type, context=None):
"""
Create a new tabulation in a project
"""
from django.db.models import Max
from django.db.models.loading import get_app
from djity.utils.security import db_table_exists
tables = [module_type.lower()+'_'+module_type.lower(),'djity_'+module_type.lower()+'_'+module_type.lower()]
if not db_table_exists(tables):
js_target.message(_("Tab creation failed. There is no table %s in the database, contact the administrator." % module_type))
return
try:
model = get_app(module_type.lower()).__getattribute__(module_type)
except:
model = get_app('djity_'+module_type.lower()).__getattribute__(module_type)
project=context['project']
i = project.modules.aggregate(Max('tab_position'))['tab_position__max'] + 1
if module_type == 'SimplePage':
name = None
else:
name = module_type.lower()
module = model(
project=project,
name=name,
label=tab_name,
tab_position=i
)
module.save()
js_target.redirect(module.djity_url(context))
def _validate_rules(rules):
project_name = _get_project_name()
for app in rules.iterkeys():
try:
get_app(app, emptyOK=True)
except ImproperlyConfigured:
if app != project_name:
raise
def haystack_load_apps():
# Do all, in an INSTALLED_APPS sorted order.
items = []
for app in settings.INSTALLED_APPS:
app_label = app.split('.')[-1]
try:
get_app(app_label)
except ImproperlyConfigured:
continue # Intentionally allow e.g. apps without models.py
items.append(app_label)
return items
def haystack_load_apps():
# Do all, in an INSTALLED_APPS sorted order.
items = []
for app in settings.INSTALLED_APPS:
app_label = app.split('.')[-1]
try:
get_app(app_label)
except ImproperlyConfigured:
continue # Intentionally allow e.g. apps without models.py
items.append(app_label)
return items
def dump(request):
response = HttpResponse(mimetype="application/ms-excel")
response["Content-Disposition"] = "attachment; filename=PennCycle-Database-Dump-%s.xls" % (
str(datetime.datetime.today())
)
wb = xlwt.Workbook()
excel_date_fmt = "M/D/YY h:mm"
datestyle = xlwt.XFStyle()
datestyle.num_format_str = excel_date_fmt
plainstyle = xlwt.XFStyle()
app = get_app("app")
models = get_models(app)
for model in models:
name = model.__name__
print name
if name == "Plan":
break
ws = wb.add_sheet(slugify(name))
xl_export(model, ws, datestyle, plainstyle)
wb.save(response)
return response
def model_tree(app_label_or_app):
'''
Get model order by their relations
'''
from django.db.models import Model
from django.db.models.loading import get_app, get_models
if isinstance(app_label_or_app, basestring):
app = get_app(app_label_or_app)
else:
app = app_label_or_app
assert isinstance(app, Model)
models = get_models(app)
tree = modeldict()
for model in models:
meta = model._meta
#model_name = '.'.join( [ meta.app_label, meta.module_name ] )
deps = []
tree[model] = deps
for rel_model in meta.many_to_many:
deps.append(rel_model.rel.to)
#import ipdb; ipdb.set_trace()
return tree
def svn_app_version(appname=None, fail_silently=bool(not settings.DEBUG)):
"""
foo.app {% svn_app_version "foo.app" %}
project {% svn_app_version %}
"""
cname = 'svn_app_version'
if appname: cname += '.' + appname
version = cache.get(cname)
if not version:
if not appname:
## RED_FLAG: hard coded relative root!
version = get_svn_revision(dn(dn(dn(abspath(__file__)))))
elif appname == 'django':
version = get_svn_revision()
elif appname not in settings.INSTALLED_APPS:
version = 'SVN-None'
else:
try:
module = get_app(appname)
except:
if not fail_silently: raise
version = 'SVN-Error'
else:
version = get_svn_revision(dn(abspath(module.__file__)))
cache.set(cname, version, 60*60*24*30)
return version
def get_view_names(seo_views):
output = []
for name in seo_views:
try:
app = get_app(name)
except:
output.append(name)
else:
app_name = app.__name__.split(".")[:-1]
app_name.append("urls")
try:
urls = __import__(".".join(app_name)).urls
except (ImportError, AttributeError):
output.append(name)
else:
for url in urls.urlpatterns:
if support_transurlvania:
if isinstance(url, LangSelectionRegexURLResolver):
for url_trans in url.url_patterns:
if url_trans.name:
output.append(url_trans.name)
else:
if hasattr(url, 'name') and url.name:
output.append(url.name)
else:
if hasattr(url, 'name') and url.name:
output.append(url.name)
output = list(set(output))
output.sort()
return output
def project_entity_content():
from django.conf import settings
from base.translation import DataTranslation, _ugettext_ as _
from django.contrib.contenttypes.models import ContentType
from django.db.models.loading import get_app
from django.db import models
from django.core.urlresolvers import reverse
model_list=[]
relations=[]
apps=[]
for application in settings.INSTALLED_APPS:
app_label=application.split(".")[-1]
if app_label in ("admin","sessions"): continue
app=get_app(app_label)
ms=[]
for i in dir(app):
try:
model=app.__getattribute__(i)
if issubclass(model, models.Model) and not model._meta.abstract and model._meta.app_label==app_label:
model_list.append(model)
for f in model._meta.fields:
if isinstance(f, models.ForeignKey):
relations.append((f, model._meta, f.rel.to._meta))
ms.append(model._meta)
except: pass
apps.append((app_label,ms))
t=Context({"entities": [entity_diagram(model) for model in model_list],
"relations":[render_relation(relation) for relation in relations],
"applications": [render_application(app) for app in apps],
})
return t
def get(self, request, *args, **kwargs):
app = get_app('app')
models = [{'name': model.__name__, 'title': model._meta.verbose_name}
for model in get_models(app)
if not model._meta.abstract
]
return self.render_to_response(models)
def test_model_requests(self):
"""
Создаем запись POST-ом, потом читаем GET-ом и убеждаемся, что получили то, что сохранили
"""
models = get_models(get_app('dynamic_models'))
post_data = {}
for model in models:
post_data[model.__name__] = {}
for field in model._meta.fields:
if field.get_internal_type() == "IntegerField":
post_data[model.__name__][field.name] = randrange(10000)
elif field.get_internal_type() == "DateField":
post_data[model.__name__][field.name] = rnd_date().strftime("%d.%m.%Y")
if field.get_internal_type() == "CharField":
post_data[model.__name__][field.name] = rnd_str()
# POST
for model_name in post_data:
query = {'model': model_name}
query.update(post_data[model_name])
resp = self.client.post('/model/', query)
self.assertEqual(resp.status_code, 200)
# GET
for model_name in post_data:
url = '/model/?model=%s' % model_name
resp = self.client.get(url)
json_response = json.loads(resp.content)
self.assertEqual(resp.status_code, 200)
for value in post_data[model_name].values():
self.assertIn(value, json_response['values'][0])
def get_objects(self):
objects = list()
app = get_app(self.application)
models = get_models(app)
for model in models:
objects.extend(model.objects.all())
return objects
def get_profile(self):
"""
Returns site-specific profile for this user. Raises
SiteProfileNotAvailable if this site does not allow profiles.
"""
if not hasattr(self, '_profile_cache'):
from django.conf import settings
if not getattr(settings, 'AUTH_PROFILE_MODULE', False):
raise SiteProfileNotAvailable('You need to set AUTH_PROFILE_MO'
'DULE in your project settings')
try:
app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.')
except ValueError:
raise SiteProfileNotAvailable('app_label and model_name should'
' be separated by a dot in the AUTH_PROFILE_MODULE set'
'ting')
try:
### model = models.get_model(app_label, model_name)
from django.db.models.loading import get_app
app = get_app(app_label)
model = getattr(app, model_name, None)
if model is None:
raise SiteProfileNotAvailable('Unable to load the profile '
'model, check AUTH_PROFILE_MODULE in your project sett'
'ings')
### self._profile_cache = model._default_manager.using(self._state.db).get(user__id__exact=self.id)
self._profile_cache = model.get_userprofile(self.get_id)
### self._profile_cache.user = self
except (ImportError, ImproperlyConfigured):
raise SiteProfileNotAvailable
return self._profile_cache
def get_project_app(app_label):
for app in settings.PROJECT_APPS:
if app_label == app.split('.')[-1]:
break
else:
raise ImproperlyConfigured("App with label %s could not be found" % app_label)
return get_app(app_label)
def handle(self, *args, **options):
if len(args) < 1:
raise CommandError("need at least one unit test TestClass")
verbosity = int(options.get("verbosity", 0))
call_command("zap", noinput=False, verbosity=verbosity, load_initial_data=False)
# for app in get_apps():
# call_command('sqlsequencereset', app)
for test in args:
parts = test.split(".")
if len(parts) != 2:
raise ValueError(
"Test label '%s' should be of the form app.TestCase or app.TestCase.test_method" % test
)
app_module = get_app(parts[0])
test_module = get_tests(app_module)
TestClass = getattr(app_module, parts[1], None)
if TestClass is None:
if test_module:
TestClass = getattr(test_module, parts[1], None)
if issubclass(TestClass, unittest.TestCase):
for f in TestClass.fixtures:
if verbosity > 0:
print "Looking for fixture `%s`" % f
call_command("xloaddata", f, verbosity=verbosity)
def get_project_app(app_label):
for app in settings.PROJECT_APPS:
if app_label == app.split('.')[-1]:
break
else:
raise ImproperlyConfigured("App with label %s could not be found" % app_label)
return get_app(app_label)
def pytest_runtest_call(item):
# HACK: sequences arent reset for postgres
global _HAS_FIXED_SEQUENCES
if not _HAS_FIXED_SEQUENCES:
import os
os.environ['DJANGO_COLORS'] = 'nocolor'
from django.core.management import call_command
from django.conf import settings
from django.db import connection
from django.db.models.loading import get_app
from StringIO import StringIO
commands = StringIO()
cursor = connection.cursor()
for app in settings.INSTALLED_APPS:
label = app.split('.')[-1]
if get_app(label, emptyOK=True):
call_command('sqlsequencereset', label, stdout=commands)
value = commands.getvalue()
if value:
cursor.execute(value)
_HAS_FIXED_SEQUENCES = True
def create_history_model(self, model):
"""
Creates a historical model to associate with the model provided.
"""
attrs = {'__module__': self.module}
app_module = '%s.models' % model._meta.app_label
if model.__module__ != self.module:
# registered under different app
attrs['__module__'] = self.module
elif app_module != self.module:
if apps is None: # Django < 1.7
# has meta options with app_label
app = loading.get_app(model._meta.app_label)
attrs['__module__'] = app.__name__ # full dotted name
else:
# Abuse an internal API because the app registry is loading.
app = apps.app_configs[model._meta.app_label]
attrs['__module__'] = app.name # full dotted name
fields = self.copy_fields(model)
attrs.update(fields)
attrs.update(self.get_extra_fields(model, fields))
# type in python2 wants str as a first argument
attrs.update(Meta=type(str('Meta'), (), self.get_meta_options(model)))
name = 'Historical%s' % model._meta.object_name
registered_models[model._meta.db_table] = model
return python_2_unicode_compatible(type(str(name), self.bases, attrs))
def add_yesno_categories(self):
app = get_app('dms')
ResponseCategoryModel = app.poll_response.ResponseCategory
"""
This creates a generic yes/no poll categories for a particular poll
"""
yes_category = ResponseCategoryModel.objects(**dict(poll=self, name='yes')).first() or \
ResponseCategoryModel(**dict(name='yes', poll=self)).save()
no_category = ResponseCategoryModel.objects(**dict(poll=self, name='no')).first() or \
ResponseCategoryModel(**dict(name='no', poll=self)).save()
unknown_category = ResponseCategoryModel.objects(**dict(poll=self, name='unknown')).first() or \
ResponseCategoryModel(**dict(name='unknown', poll=self, default=True, error_category=True)).save()
# add one rule to yes category per language
no_words = getattr(settings, 'NO_WORDS', NO_WORDS)
yes_words = getattr(settings, 'YES_WORDS', YES_WORDS)
no_rule_string = '|'.join(no_words)
yes_rule_string = '|'.join(yes_words)
startswith_template = getattr(settings, 'STARTSWITH_PATTERN_TEMPLATE', STARTSWITH_PATTERN_TEMPLATE)
Rule(**dict(response_category=yes_category,
regex=(startswith_template % yes_rule_string),
rule_type=Rule.TYPE_REGEX,
rule_string=(startswith_template % yes_rule_string))).save()
Rule(**dict(response_category=no_category,
regex=(startswith_template % no_rule_string),
rule_type=Rule.TYPE_REGEX,
rule_string=(startswith_template % no_rule_string))).save()
def add_yesno_categories(self):
app = get_app('dms')
ResponseCategoryModel = app.poll_response.ResponseCategory
"""
This creates a generic yes/no poll categories for a particular poll
"""
yes_category = ResponseCategoryModel.objects(**dict(poll=self, name='yes')).first() or \
ResponseCategoryModel(**dict(name='yes', poll=self)).save()
no_category = ResponseCategoryModel.objects(**dict(poll=self, name='no')).first() or \
ResponseCategoryModel(**dict(name='no', poll=self)).save()
unknown_category = ResponseCategoryModel.objects(**dict(poll=self, name='unknown')).first() or \
ResponseCategoryModel(**dict(name='unknown', poll=self, default=True, error_category=True)).save()
# add one rule to yes category per language
no_words = getattr(settings, 'NO_WORDS', NO_WORDS)
yes_words = getattr(settings, 'YES_WORDS', YES_WORDS)
no_rule_string = '|'.join(no_words)
yes_rule_string = '|'.join(yes_words)
startswith_template = getattr(settings, 'STARTSWITH_PATTERN_TEMPLATE',
STARTSWITH_PATTERN_TEMPLATE)
Rule(**dict(response_category=yes_category,
regex=(startswith_template % yes_rule_string),
rule_type=Rule.TYPE_REGEX,
rule_string=(startswith_template %
yes_rule_string))).save()
Rule(**dict(response_category=no_category,
regex=(startswith_template % no_rule_string),
rule_type=Rule.TYPE_REGEX,
rule_string=(startswith_template %
no_rule_string))).save()
def test_username_non_unique(self):
"A non-unique USERNAME_FIELD should raise a model validation error."
new_io = StringIO()
get_validation_errors(new_io, get_app('auth'))
self.assertIn(
"The USERNAME_FIELD must be unique. Add unique=True to the field parameters.",
new_io.getvalue())
def test_model_requests(self):
"""
Создаем запись POST-ом, потом читаем GET-ом и убеждаемся, что получили то, что сохранили
"""
models = get_models(get_app('dynamic_models'))
post_data = {}
for model in models:
post_data[model.__name__] = {}
for field in model._meta.fields:
if field.get_internal_type() == "IntegerField":
post_data[model.__name__][field.name] = randrange(10000)
elif field.get_internal_type() == "DateField":
post_data[model.__name__][
field.name] = rnd_date().strftime("%d.%m.%Y")
if field.get_internal_type() == "CharField":
post_data[model.__name__][field.name] = rnd_str()
# POST
for model_name in post_data:
query = {'model': model_name}
query.update(post_data[model_name])
resp = self.client.post('/model/', query)
self.assertEqual(resp.status_code, 200)
# GET
for model_name in post_data:
url = '/model/?model=%s' % model_name
resp = self.client.get(url)
json_response = json.loads(resp.content)
self.assertEqual(resp.status_code, 200)
for value in post_data[model_name].values():
self.assertIn(value, json_response['values'][0])
def project_entity_content():
from django.conf import settings
from base.translation import DataTranslation, _ugettext_ as _
from django.contrib.contenttypes.models import ContentType
from django.db.models.loading import get_app
from django.db import models
from django.core.urlresolvers import reverse
model_list = []
relations = []
apps = []
for application in settings.INSTALLED_APPS:
app_label = application.split(".")[-1]
if app_label in ("admin", "sessions"): continue
app = get_app(app_label)
ms = []
for i in dir(app):
try:
model = app.__getattribute__(i)
if issubclass(
model, models.Model
) and not model._meta.abstract and model._meta.app_label == app_label:
model_list.append(model)
for f in model._meta.fields:
if isinstance(f, models.ForeignKey):
relations.append((f, model._meta, f.rel.to._meta))
ms.append(model._meta)
except:
pass
apps.append((app_label, ms))
t = Context({
"entities": [entity_diagram(model) for model in model_list],
"relations": [render_relation(relation) for relation in relations],
"applications": [render_application(app) for app in apps],
})
return t
def dump(request):
response = HttpResponse(mimetype="application/ms-excel")
response['Content-Disposition'] = 'attachment; filename=PennCycle-Database-Dump-%s.xls' % (str(datetime.datetime.today()))
if not request.user.is_staff:
return HttpResponseForbidden()
wb = xlwt.Workbook()
excel_date_fmt = 'M/D/YY h:mm'
datestyle = xlwt.XFStyle()
datestyle.num_format_str = excel_date_fmt
plainstyle = xlwt.XFStyle()
app = get_app('app')
models = get_models(app)
for model in models:
name = model.__name__
print name
if name == 'Plan':
break
ws = wb.add_sheet(slugify(name))
xl_export(model, ws, datestyle, plainstyle)
wb.save(response)
return response
def is_yesno_poll(self):
app = get_app('dms')
ResponseCategoryModel = app.poll_response.ResponseCategory
return ResponseCategoryModel.objects(poll=self).count() == 3 and \
ResponseCategoryModel.objects(poll=self, name='yes').count() and \
ResponseCategoryModel.objects(poll=self, name='no').count() and \
ResponseCategoryModel.objects(poll=self, name='unknown').count()
def build_suite(self, test_labels, extra_tests=None, **kwargs):
""" Default behaviour is augmented to improve test discovery """
sooper = super(XmlDjangoTestSuiteRunner,self)
suite = sooper.build_suite(test_labels, extra_tests=extra_tests, **kwargs)
## This section finds tests that were skipped due to
## duplicate app names. (code adapted from django.test.simple)
for test_label in test_labels:
all_apps = get_apps(test_label)
if len(all_apps) > 1:
leftover_apps = [ app for app in all_apps if app!=get_app(test_label) ]
for app_module in leftover_apps:
# Check to see if a separate 'tests' module
# exists parallel to the "models" module
test_module = get_tests(app_module)
if test_module:
new_suite = unittest.defaultTestLoader.loadTestsFromModule(test_module)
if new_suite._tests:
suite.addTests(new_suite._tests)
msg = "Discovered {N} extra tests for shadowed appname: {A}"
msg_kargs = dict(N=len(new_suite._tests), A=app_module.__name__)
else:
msg = "Discovered shadowed appname \"{A}\" but no tests were found"
msg_kargs = dict(A=app_module.__name__)
self.report(msg, **msg_kargs)
return suite
def fkeymap(self, obj, row, cols):
"""This method is used to map a foreign key.
This method is responsible for recursively fetching and
returning the necessary foreign key objects to ingest a foreign key
into the database.
:return: A model object.
"""
model = None
app = get_app('datawarehouse')
models = get_models(app)
# attempt to match the specified table to a model and raise an exception if not found
for m in models:
if m._meta.db_table == obj['table']:
model = m
break
if model == None:
raise TableDoesNotExist("The database table " + obj['table'] + " does not exist.")
sql_dict = {}
# loop through the mapping object and create the object using data from the input file
# if the value is an object, recursively call fkeymap.
for key, value in obj.iteritems():
if key != 'table':
if isinstance(value, unicode):
sql_dict[key] = (None if row[cols[value]] is "" else row[cols[value]])
else:
sql_dict[key] = (None if self.fkeymap(value, row, cols) is "" else self.fkeymap(value, row, cols))
m, created = model.objects.get_or_create(**sql_dict)
return m
def test_username_not_in_required_fields(self):
"USERNAME_FIELD should not appear in REQUIRED_FIELDS."
new_io = StringIO()
get_validation_errors(new_io, get_app('auth'))
self.assertIn(
"The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.",
new_io.getvalue())
def is_yesno_poll(self):
app = get_app('dms')
ResponseCategoryModel = app.poll_response.ResponseCategory
return ResponseCategoryModel.objects(poll=self).count() == 3 and \
ResponseCategoryModel.objects(poll=self, name='yes').count() and \
ResponseCategoryModel.objects(poll=self, name='no').count() and \
ResponseCategoryModel.objects(poll=self, name='unknown').count()
def handle(self, **options):
runner = simple.DjangoTestSuiteRunner(verbosity=0)
err_msg = "Failed to migrate %s; see output for hints at missing dependencies:\n"
hacks.patch_flush_during_test_db_creation()
failures = 0
for app_name in settings.INSTALLED_APPS:
app_label = app_name.split(".")[-1]
if app_name == 'south':
continue
try:
Migrations(app_name)
except NoMigrations:
continue
app = loading.get_app(app_label)
verbosity = int(options.get('verbosity', 1))
if verbosity >= 1:
self.stderr.write("processing %s\n" % app_name)
old_config = runner.setup_databases()
try:
call_command('migrate', app_label, noinput=True, verbosity=verbosity)
for model in loading.get_models(app):
dummy = model._default_manager.exists()
except (KeyboardInterrupt, SystemExit):
raise
except Exception, e:
failures += 1
if verbosity >= 1:
self.stderr.write(err_msg % app_name)
self.stderr.write("%s\n" % e)
finally:
def checkAndCreateModelPermissions(appName):
from django.db.models.loading import get_app
from django.db import models
app = get_app(appName)
for i in dir(app):
try:
a = app.__getattribute__(i)
if issubclass(a, models.Model):
checkAndCreateModelPermission(a)
except:
pass
try:
ct = ContentType.objects.get_for_model(Transaction)
Permission(content_type=ct,
codename='init_database',
name='Init database').save()
except:
pass
try:
ct = ContentType.objects.get_for_model(Group)
Permission(content_type=ct,
codename='browse_' + Group.__name__.lower(),
name='Can browse %s' % Group.__name__).save()
except:
pass
def safe_build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
try:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
except Exception:
log.warning("Could not add test for label: %s" %label)
else:
for app in get_apps():
try:
suite.addTest(build_suite(app))
except Exception:
log.warning("Could not add tests for app: %s" %app)
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def create_history_model(self, model):
"""
Creates a historical model to associate with the model provided.
"""
attrs = {'__module__': self.module}
app_module = '%s.models' % model._meta.app_label
if model.__module__ != self.module:
# registered under different app
attrs['__module__'] = self.module
elif app_module != self.module:
if apps is None: # Django < 1.7
# has meta options with app_label
app = loading.get_app(model._meta.app_label)
attrs['__module__'] = app.__name__ # full dotted name
else:
# Abuse an internal API because the app registry is loading.
app = apps.app_configs[model._meta.app_label]
attrs['__module__'] = app.name # full dotted name
fields = self.copy_fields(model)
attrs.update(fields)
attrs.update(self.get_extra_fields(model, fields))
# type in python2 wants str as a first argument
attrs.update(Meta=type(str('Meta'), (), self.get_meta_options(model)))
name = 'Historical%s' % model._meta.object_name
registered_models[model._meta.db_table] = model
return python_2_unicode_compatible(
type(str(name), self.bases, attrs))
def get_schematics_models(app_name):
app = get_app(app_name)
models = get_models(app)
all_models = []
for model in models:
all_models += SchematicsModel.from_django(model)
return all_models
def pytest_runtest_call(item):
# HACK: sequences arent reset for postgres
global _HAS_FIXED_SEQUENCES
if not _HAS_FIXED_SEQUENCES:
import os
os.environ['DJANGO_COLORS'] = 'nocolor'
from django.core.management import call_command
from django.conf import settings
from django.db import connection
from django.db.models.loading import get_app
from StringIO import StringIO
commands = StringIO()
cursor = connection.cursor()
for app in settings.INSTALLED_APPS:
label = app.split('.')[-1]
if get_app(label, emptyOK=True):
call_command('sqlsequencereset', label, stdout=commands)
value = commands.getvalue()
if value:
cursor.execute(value)
_HAS_FIXED_SEQUENCES = True
def add_new_model2(request, model_name):
if (model_name.lower() == model_name):
normal_model_name = model_name.capitalize()
else:
normal_model_name = model_name
# app_list = get_apps()
# for app in app_list:
app = get_app('django_obit_desk2')
for model in get_models(app):
if model.__name__ == normal_model_name:
form = modelform_factory(model)
if normal_model_name == 'Death_notice':
dn_name = model._meta.verbose_name
form = Death_noticeForm
service_form = ServiceFormSet
dn_os_formset = DeathNoticeOtherServicesFormSet
if request.method == 'POST':
form = form(request.POST)
service_form = service_form(request.POST)
dn_os_formset = DeathNoticeOtherServicesFormSet(request.POST)
if form.is_valid() and service_form.is_valid(
) and dn_os_formset.is_valid():
try:
if normal_model_name == 'Death_notice':
new_obj = form.save(commit=False)
new_obj.funeral_home = request.user
new_obj.save()
service_form = ServiceFormSet(request.POST,
instance=new_obj)
service_form.save()
dn_os_formset = DeathNoticeOtherServicesFormSet(
request.POST, instance=new_obj)
dn_os_formset.save()
else:
new_obj = form.save()
except forms.ValidationError, error:
new_obj = None
if new_obj:
return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' % \
(escape(new_obj._get_pk_val()), escape(new_obj)))
else:
form = form()
page_context = {
'form': form,
'service_form': service_form,
'other_services_formset': dn_os_formset,
'field': normal_model_name,
'dn_verbose_name': dn_name,
'dn_app_name': app,
}
return render_to_response('dn_popup2.html',
page_context,
context_instance=RequestContext(request))
def unpatch_models(app_name, unpatch_info):
from django.db.models import Model
funcToMethod(_default_save, Model, method_name='save')
app = get_app(app_name)
for model in get_models(app):
restore_m2m_descriptors(model, unpatch_info[model]['descriptors'])
model.objects = unpatch_info[model]['manager']
def test_username_not_in_required_fields(self):
"USERNAME_FIELD should not appear in REQUIRED_FIELDS."
new_io = StringIO()
get_validation_errors(new_io, get_app("auth"))
self.assertIn(
"The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.",
new_io.getvalue(),
)
def get_discovery_root(self, label):
try:
models_module = get_app(label)
discovery_root = os.path.dirname(models_module.__file__)
except ImproperlyConfigured:
discovery_root = os.path.join(settings.ROOT_DIR, label)
return discovery_root
def unpatch_models(app_name, unpatch_info):
from django.db.models import Model
funcToMethod(_default_save, Model, method_name='save')
app = get_app(app_name)
for model in get_models(app):
restore_m2m_descriptors(model, unpatch_info[model]['descriptors'])
model.objects = unpatch_info[model]['manager']
def __init__(self, admin_site, app_label, model_name, page, **initkwargs):
self.admin_site = admin_site
self.app_label = app_label
self.model_name = model_name
self.page = page
self.app = get_app(self.app_label)
self.model = get_model(self.app_label, self.model_name)
return super(CSVImporter, self).__init__(**initkwargs)
def test_model_registering(self):
test_app = get_app(app_label="tests")
models = get_models(
app_mod=test_app, include_auto_created=False, include_deferred=False, include_swapped=False
)
default_registered = len(reversion.get_registered_models())
custom_registered = len(custom_revision_manager.get_registered_models())
self.assertEqual(default_registered + custom_registered, len(models))
def handle_noargs(self, **options):
app = get_app('services')
try:
boris_config = apps.get_app_config('boris')
except:
raise EnvironmentError(
'Cannot find app `boris`. App configs are: %s' %
apps.get_app_configs())
update_contenttypes(boris_config, 2, interactive=False)
app_models = models.get_models(app)
# This will hold the permissions we're looking for as
# (content_type, (codename, name))
searched_perms = list()
# The codenames and ctypes that should exist.
ctypes = set()
for model in app_models:
opts = model._meta
# We can't use `get_for_model` here since it doesn't return
# the correct `ContentType` for proxy models.
# see https://code.djangoproject.com/ticket/17648
app_label, model = opts.app_label, opts.object_name.lower()
if app_label == 'services' and model == 'encounter':
ctype = ContentType.objects.get_by_natural_key(
app_label, model)
ctypes.add(ctype)
for perm in _get_all_permissions(opts, model):
searched_perms.append((ctype, perm))
# Find all the Permissions that have a content_type for a model we're
# looking for. We don't need to check for codenames since we already have
# a list of the ones we're going to create.
all_perms = set(
Permission.objects.filter(content_type__in=ctypes, ).values_list(
"content_type", "codename"))
group, created = Group.objects.get_or_create(name=u'Terén')
print 'group: %s' % group
if created:
print 'ERROR: skupina Teren neexistovala!'
return
for ctype, (codename, name) in searched_perms:
if (ctype.pk, codename) not in all_perms:
Permission.objects.filter(codename=codename,
name=name).delete()
perm = Permission.objects.create(codename=codename,
name=name,
content_type=ctype)
group.permissions.add(perm)
sys.stdout.write("Adding encounter permission '%s'" % perm)
for perm in Permission.objects.filter(
codename__endswith='_groupcontact'):
group.permissions.add(perm)
sys.stdout.write("Adding group encounter permission '%s'" % perm)
for perm in Permission.objects.filter(codename__endswith='_encounter'):
group.permissions.add(perm)
sys.stdout.write("Adding service permission '%s'" % perm)
def get_app_dict(app_label):
app=get_app(app_label)
dict_data={
"verbose_name":u"%(name)s"%{
'name':hasattr(app, "verbose_name") and app.verbose_name or app_label
},
"models":[]
}
return app,dict_data
def haystack_get_models(label):
app_or_model = is_app_or_model(label)
if app_or_model == APP:
app_mod = get_app(label)
return get_models(app_mod)
else:
app_label, model_name = label.rsplit('.', 1)
return [get_model(app_label, model_name)]
def source(self):
app = get_app('dms')
SettingModel = app.admin_setting.AdminSetting
volunteer_profiles = SettingModel._lookup("enable_volunteer_profiles")
if volunteer_profiles and volunteer_profiles.yes_no:
profile = self._mobile_user()
return profile.name if profile else self.SENDER
else:
return self.SENDER
def get_app_package(app_label):
app_config = loading.get_app(app_label)
if not app_config:
return None
if app_config.__package__ is None:
app_config.__package__ = app_config.__name__.rpartition('.')[0]
if app_config.__package__.endswith('.models'):
return app_config.__package__[0:-len('.models')]
return app_config.__package__
def get_context_data(self, **kwargs):
context = super(HomePageView, self).get_context_data(**kwargs)
models = []
for model in get_models(get_app('dynamic_models')):
models.append([model.__name__, model._meta.verbose_name])
context['models'] = models
return context
def test_model_registering(self):
test_app = get_app(app_label="reversion_compare_test_app")
models = get_models(app_mod=test_app,
include_auto_created=False,
include_deferred=False,
only_installed=True)
default_registered = len(reversion.get_registered_models())
custom_registered = len(
custom_revision_manager.get_registered_models())
self.assertEqual(default_registered + custom_registered, len(models))
def test_model_registering(self):
test_app = get_app(app_label="tests")
models = get_models(app_mod=test_app,
include_auto_created=False,
include_deferred=False,
include_swapped=False)
default_registered = len(reversion.get_registered_models())
custom_registered = len(
custom_revision_manager.get_registered_models())
self.assertEqual(default_registered + custom_registered, len(models))
def handle(self, *args, **options):
if len(args) < 1:
if options['all_applications']:
applications = get_apps()
else:
raise CommandError("need one or more arguments for appname")
else:
try:
applications = [get_app(label) for label in args]
except ImproperlyConfigured, e:
raise CommandError("Specified application not found: %s" % e)
def forwards(self, orm):
contenttypes = orm['contenttypes.ContentType'].objects
removed = set()
for ct in contenttypes.filter(model__endswith='_hist')\
.exclude(name__endswith=' history'):
removed.add(ct.app_label)
Permission.objects.filter(content_type=ct).delete()
ct.delete()
for app_label in removed:
app = get_app(app_label)
update_contenttypes(app, None)
create_permissions(app, None, 2)
def normalize(layout):
try:
app_label, model_name = layout.split(".")
except ValueError:
app_label = self.model._meta.app_label
model_name = layout
except AttributeError:
app_label = layout._meta.app_label
model_name = layout._meta.object_name
# we cannot use models.get_model because this class could be
# abstract.
return getattr(get_app(app_label), model_name)
def haystack_get_models(label):
try:
app_mod = get_app(label)
if app_mod is not None:
return get_models(app_mod=app_mod)
except ImproperlyConfigured:
pass
if '.' not in label:
raise ImproperlyConfigured("No installed application has the label %s" % label)
app_label, model_name = label.rsplit('.', 1)
return [get_model(app_label, model_name)]
def patch_models(app_name):
unpatch_info = {}
app = get_app(app_name)
for model in get_models(app):
unpatch_info[model] = dict(manager=model.objects,
descriptors=extract_m2m_descriptors(model))
memorify_m2m_descriptors(model)
model.objects = MemoryManager(model)
from django.db.models import Model
Model.save = memory_save
return unpatch_info
def load_fixtures_for_app(sender, **kwargs):
app_name = kwargs.get("app")
if not app_name: return
print u"Running autoload fixtures for %s:" % app_name
for model in get_models(get_app(app_name)):
model_name = model.__name__.lower()
print u" > %s:%s" % (app_name, model_name)
fixture_path = "%(app_name)s/fixtures/%(model_name)s.json" % {
"app_name": app_name,
"model_name": model_name
}
call_command("loaddata", fixture_path)
