def handle(self, *args, **options):
app_configs = [
a for a in apps.get_app_configs() if a.name.startswith('apps.')
]
for app_config in app_configs:
dirname = os.path.join(os.path.dirname(app_config.module.__file__),
'fixtures')
filename = os.path.join(
dirname, '{name}_data.json'.format(name=app_config.label))
if not list(app_config.get_models()):
continue
models = [
'{}.{}'.format(app_config.label, m._meta.object_name.lower())
for m in app_config.get_models() if m._meta.proxy is False
]
self.write_fixtures(filename, *models)
self.write_fixtures(
os.path.join(settings.BASE_DIR,
'apps/user/fixtures/user_data.json'),
*['auth.user', 'auth.group', 'account'])
self.write_fixtures(
os.path.join(settings.BASE_DIR,
'apps/core/fixtures/initial_data.json'), *['sites'])
def get_apps():
"""Get list of all authentik apps"""
from django.apps.registry import apps
for _app in apps.get_app_configs():
if _app.name.startswith("authentik"):
yield _app
def synchronize_client(client):
"""
Synchronize all models as resources for a client.
:type client: django_keycloak.models.Client
"""
for app_config in apps.get_app_configs():
synchronize_resources(client=client, app_config=app_config)
def count_registers(self, full=True):
print('--------- CountRegisters ----------')
for app in apps.get_app_configs():
for m in app.get_models():
count = m.objects.all().count()
if full or count > 100000:
print(count, m, app)
def get_all_app_models():
r = {}
for app in apps.get_app_configs():
model_names = app.models.keys()
if not model_names:
continue
m = r[app.label] = {}
for model_name in model_names:
m[model_name] = dict(full={}, part={})
return r
def search(request):
"""
Search rules (Scripts and Signatures) from all the probes.
"""
if request.GET.get("pattern"):
pattern = request.GET.get("pattern")
if pattern != "" and pattern != " ":
data = list()
for app in apps.get_app_configs():
first = True
for model in app.get_models():
if issubclass(model, Rule):
if app.verbose_name != "Rules":
if first:
first = False
probe_data = dict()
try:
my_class = getattr(
importlib.import_module(app.label +
".models"),
'Signature' + app.verbose_name)
signatures = my_class.find(pattern)
probe_data.update(
{'signatures': signatures})
my_class = getattr(
importlib.import_module(app.label +
".models"),
'Script' + app.verbose_name)
scripts = my_class.find(pattern)
probe_data.update({'scripts': scripts})
my_class = getattr(
importlib.import_module(app.label +
".models"),
'Rule' + app.verbose_name)
rules = my_class.find(pattern)
probe_data.update({'rules': rules})
except AttributeError:
pass
probe_data.update({'name': app.label})
data.append(probe_data)
return render(request, 'rules/search.html', {
'data': data,
'pattern': pattern
})
else:
return render(request, 'rules/search.html',
{'message': 'Pattern ' + pattern + ' not found'})
else:
return render(request, 'rules/search.html',
{'message': 'Pattern not found'})
def ready(self):
# Find all schema.graphql and resolver modules and load them
self.type_defs = list()
self.types = list()
self.resolvers = list()
logger.debug("Trying to load resolvers and schemas:")
for config in apps.get_app_configs():
self.load_schema(config)
self.load_resolvers(config)
self.load_custom_types(config)
logger.debug("Types: %s",
", ".join([_type.name for _type in self.types]))
def index(request):
"""
Display all probes instances.
"""
instances = dict()
for app in apps.get_app_configs():
for model in app.get_models():
if issubclass(model, Probe):
if app.verbose_name != "Home":
my_class = getattr(
importlib.import_module(app.label + ".models"),
app.verbose_name)
instances[app.label] = my_class.get_all()
return render(request, 'home/index.html', {'instances': instances})
def get_models(app_mod=None, include_auto_created=False):
"""Return the models belonging to an app.
Args:
app_mod (module, optional):
The application module.
include_auto_created (bool, optional):
Whether to return auto-created models (such as many-to-many
models) in the results.
Returns:
list:
The list of modules belonging to the app.
"""
if apps:
# Django >= 1.7
if app_mod is None:
return apps.get_models(include_auto_created=include_auto_created)
for app_config in apps.get_app_configs():
if app_config.models_module is app_mod:
return [
model for model in app_config.get_models(
include_auto_created=include_auto_created)
if not model._meta.abstract
]
return []
else:
# Django < 1.7
models = _get_models(app_mod,
include_auto_created=include_auto_created)
if app_mod is not None:
# Avoids a circular import.
from django_evolution.utils.apps import get_app_name
app_mod_name = get_app_name(app_mod)
models = [
model for model in models
if model.__module__.startswith(app_mod_name)
]
return models
def get_apps():
"""Return the list of all installed apps with models.
This returns the apps from the app registry on Django >= 1.7, and from
the old-style cache on Django < 1.7.
Returns:
list: A list of all the modules containing model classes.
"""
if apps:
# Django >= 1.7
return [
app.models_module for app in apps.get_app_configs()
if app.models_module is not None
]
else:
# Django < 1.7
return cache.get_apps()
def main(options):
verbosity = int(options.get("verbosity"))
exclude_list = options.get("exclude")
if exclude_list is None:
exclude_list = []
results = {}
for app in apps.get_app_configs():
if app.name in exclude_list:
if verbosity > 2:
print("excluding:", app.name)
continue
if verbosity > 2:
print("trying:", app.name)
try:
m = __import__("%s.utils.EMAIL" % app.name)
except ImportError:
pass # no email generator for this app
else:
if verbosity > 1:
print("collecting from:", app.name)
try:
d = m.utils.EMAIL.main()
except:
print("-" * 25)
print("APPLICATION:", app.name)
traceback.print_exc()
print("=" * 50)
else:
for key, data in d.items():
if verbosity > 2:
print("({}, {}) = {}".format(app.name, key, data))
results[(app.name, key)] = data
# Fix 'safe strings' Django-ism.
uni_res = {}
deactivate = []
for key, value in results.items():
if value is None:
if verbosity > 2:
print("flagging", key, "for deativation")
deactivate.append(key)
else:
uni_res[key] = value
return uni_res, deactivate
def get_apps():
"""Return the list of all installed apps with models.
This returns the apps from the app registry on Django >= 1.7, and from
the old-style cache on Django < 1.7.
Returns:
list: A list of all the modules containing model classes.
"""
if apps:
# Django >= 1.7
return [
app.models_module
for app in apps.get_app_configs()
if app.models_module is not None
]
else:
# Django < 1.7
return cache.get_apps()
def run(*args):
if args[0] and args[1]:
source = args[0] + '/probemanager'
dest = args[1].rstrip('/') + '/probemanager'
else:
source = settings.BASE_DIR
dest = settings.BASE_DIR
# en prod git_tag prendre des sources ou copier git_root = settings.BASE_DIR
with open(dest + '/version.txt', 'w') as f:
f.write(git_tag(source))
for app in apps.get_app_configs():
for model in app.get_models():
if issubclass(model, Probe):
if app.verbose_name != "Core":
dest_app = dest + "/" + app.label + '/'
source_app = source + "/" + app.label + '/'
with open(dest_app + 'version.txt', 'w') as f:
f.write(git_tag(source_app))
exit(0)
def add_groups(apps, schema_editor):
# create all ContentTypes premission before this migration
for app_config in apps_alt.get_app_configs():
create_permissions(app_config)
Group = apps.get_model('auth', 'Group')
Permission = apps.get_model('auth', 'Permission')
"""
dividing two groups of user here
- Set it's name
- Clearify it's premission
"""
# bidder group
bidder = Group.objects.create(name="Bidder")
permission_list = \
list(
chain(
Permission.objects.filter(codename__contains = "event"),
Permission.objects.filter(codename__contains = "post"),
Permission.objects.filter(codename__contains = "message")
)
)
# CRUD of post Event Msg
bidder.permissions.set(permission_list)
# save the setting
bidder.save()
# poster group
poster = Group.objects.create(name="Poster")
permission_list = list(
chain(Permission.objects.filter(codename__contains="bid"),
Permission.objects.filter(codename__contains="message")))
# CRUD of post Event Msg
poster.permissions.set(permission_list)
# save the setting
poster.save()
def run(*args):
template = """
{{ name }}
{% for char in range(name|length) -%}
=
{%- endfor %}
.. toctree::
{{ module }}
"""
template_include = """.. include:: ../../probemanager/{{ module }}/README.rst
"""
t = Template(template)
t_include = Template(template_include)
with open(settings.ROOT_DIR + '/docs/modules/index.rst', 'w') as f:
for app in apps.get_app_configs():
for model in app.get_models():
if issubclass(model, Probe):
if app.verbose_name != "Core":
path = settings.BASE_DIR + "/" + app.label + "/README.rst"
if os.path.isfile(path):
template_rendered = t.render(module=app.label,
name=app.verbose_name)
template_include_rendered = t_include.render(
module=app.label)
f_include = open(
settings.ROOT_DIR + '/docs/modules/' +
app.label + '.rst', 'w')
f_include.write(template_include_rendered)
f_include.close()
f.write(template_rendered)
break
exit(0)
from django.conf.urls import url, include
from django.contrib import admin
from rest_framework_swagger.views import get_swagger_view
from django.apps.registry import apps
from home.models import Probe
schema_view = get_swagger_view(title='ProbeManager API', url='/')
urlpatterns_modules = list()
for app in apps.get_app_configs():
for model in app.get_models():
if issubclass(model, Probe):
if app.verbose_name != "Home":
urlpatterns_modules.append(
url(r'^' + app.label + '/', include(app.label + '.urls')))
urlpatterns = [
url(r'^api/v1/doc/$', schema_view),
url(r'^api/v1/', include('api.urls')),
url(r'^admin/', admin.site.urls),
url(r'^select2/', include('select2.urls')),
url(r'^rules/', include('rules.urls')),
url(r'^', include('home.urls')),
]
urlpatterns += urlpatterns_modules
def handle(self, *args, **options):
""""
Obtiene los grupos de usuarios y el codename de sus permisos, elimina todos los permisos registrados
y los regenera, agrega los permisos correspondientes a cada grupo verficando si el permiso existe.
"""
per_laboratory_administrator = None
per_professor = None
per_student = None
laboratory_administrator = Group.objects.filter(
name="Laboratory Administrator").first()
professor = Group.objects.filter(name="Professor").first()
student = Group.objects.filter(name="Student").first()
if laboratory_administrator:
per_laboratory_administrator = list(
Group.objects.filter(
name="Laboratory Administrator").values_list(
'permissions__codename', flat=True))
per_laboratory_administrator += [
'add_organizationusermanagement',
'change_organizationusermanagement',
'delete_organizationusermanagement',
'view_organizationusermanagement'
]
if professor:
per_professor = list(
Group.objects.filter(name="Professor").values_list(
'permissions__codename', flat=True))
if student:
per_student = list(
Group.objects.filter(name="Student").values_list(
'permissions__codename', flat=True))
Permission.objects.all().delete()
for app_config in apps.get_app_configs():
create_permissions(app_config)
if laboratory_administrator and per_laboratory_administrator:
for per in per_laboratory_administrator:
permission = Permission.objects.filter(codename=per).first()
if permission:
laboratory_administrator.permissions.add(permission)
if professor and per_professor:
for per in per_professor:
permission = Permission.objects.filter(codename=per).first()
if permission:
professor.permissions.add(permission)
if student and per_student:
for per in per_student:
permission = Permission.objects.filter(codename=per).first()
if permission:
student.permissions.add(permission)
def handle_django_settings(filename):
'''Attempts to load a Django project and get package dependencies from
settings.
Tested using Django 1.4 and 1.8. Not sure if some nuances are missed in
the other versions.
'''
old_sys_path = sys.path[:]
dirpath = os.path.dirname(filename)
project = os.path.basename(dirpath)
cwd = os.getcwd()
project_path = os.path.normpath(os.path.join(dirpath, '..'))
if project_path not in sys.path:
sys.path.insert(0, project_path)
os.chdir(project_path)
project_settings = '{}.settings'.format(project)
os.environ['DJANGO_SETTINGS_MODULE'] = project_settings
try:
import django
# Sanity
django.setup = lambda: False
except ImportError:
log.error('Found Django settings, but Django is not installed.')
return
log.warn('Loading Django Settings (Using {}): {}'.format(
django.get_version(), filename))
from django.conf import LazySettings
installed_apps = set()
settings_imports = set()
try:
settings = LazySettings()
settings._setup()
for k, v in vars(settings._wrapped).items():
if k not in _excluded_settings and re.match(r'^[A-Z_]+$', k):
# log.debug('Scanning Django setting: %s', k)
scan_django_settings(v, settings_imports)
# Manually scan INSTALLED_APPS since the broad scan won't include
# strings without a period in it .
for app in getattr(settings, 'INSTALLED_APPS', []):
if hasattr(app, '__file__') and getattr(app, '__file__'):
imp, _ = utils.import_path_from_file(getattr(app, '__file__'))
installed_apps.add(imp)
else:
installed_apps.add(app)
except Exception as e:
log.error('Could not load Django settings: %s', e)
log.debug('', exc_info=True)
return
if not installed_apps or not settings_imports:
log.error('Got empty settings values from Django settings.')
try:
from django.apps.registry import apps, Apps, AppRegistryNotReady
# Django doesn't like it when the initial instance of `apps` is reused,
# but it has to be populated before other instances can be created.
if not apps.apps_ready:
apps.populate(installed_apps)
else:
apps = Apps(installed_apps)
start = time.time()
while True:
try:
for app in apps.get_app_configs():
installed_apps.add(app.name)
except AppRegistryNotReady:
if time.time() - start > 10:
raise Exception('Bail out of waiting for Django')
log.debug('Waiting for apps to load...')
continue
break
except Exception as e:
log.debug('Could not use AppConfig: {}'.format(e))
# Restore before sub scans can occur
sys.path[:] = old_sys_path
os.chdir(cwd)
for item in settings_imports:
need_scan = item.startswith(_filescan_modules)
yield ('django', item, project_path if need_scan else None)
for app in installed_apps:
need_scan = app.startswith(project)
yield ('django', app, project_path if need_scan else None)
def get_installed_apps(self):
for app_config in apps.get_app_configs():
yield app_config.name, app_config
def handle_django_settings(filename):
'''Attempts to load a Django project and get package dependencies from
settings.
Tested using Django 1.4 and 1.8. Not sure if some nuances are missed in
the other versions.
'''
old_sys_path = sys.path[:]
dirpath = os.path.dirname(filename)
project = os.path.basename(dirpath)
cwd = os.getcwd()
project_path = os.path.normpath(os.path.join(dirpath, '..'))
if project_path not in sys.path:
sys.path.insert(0, project_path)
os.chdir(project_path)
project_settings = '{}.settings'.format(project)
os.environ['DJANGO_SETTINGS_MODULE'] = project_settings
try:
import django
# Sanity
django.setup = lambda: False
except ImportError:
log.error('Found Django settings, but Django is not installed.')
return
log.warn('Loading Django Settings (Using {}): {}'
.format(django.get_version(), filename))
from django.conf import LazySettings
installed_apps = set()
settings_imports = set()
try:
settings = LazySettings()
settings._setup()
for k, v in vars(settings._wrapped).items():
if k not in _excluded_settings and re.match(r'^[A-Z_]+$', k):
# log.debug('Scanning Django setting: %s', k)
scan_django_settings(v, settings_imports)
# Manually scan INSTALLED_APPS since the broad scan won't include
# strings without a period in it .
for app in getattr(settings, 'INSTALLED_APPS', []):
if hasattr(app, '__file__') and getattr(app, '__file__'):
imp, _ = utils.import_path_from_file(getattr(app, '__file__'))
installed_apps.add(imp)
else:
installed_apps.add(app)
except Exception as e:
log.error('Could not load Django settings: %s', e)
log.debug('', exc_info=True)
return
if not installed_apps or not settings_imports:
log.error('Got empty settings values from Django settings.')
try:
from django.apps.registry import apps, Apps, AppRegistryNotReady
# Django doesn't like it when the initial instance of `apps` is reused,
# but it has to be populated before other instances can be created.
if not apps.apps_ready:
apps.populate(installed_apps)
else:
apps = Apps(installed_apps)
start = time.time()
while True:
try:
for app in apps.get_app_configs():
installed_apps.add(app.name)
except AppRegistryNotReady:
if time.time() - start > 10:
raise Exception('Bail out of waiting for Django')
log.debug('Waiting for apps to load...')
continue
break
except Exception as e:
log.debug('Could not use AppConfig: {}'.format(e))
# Restore before sub scans can occur
sys.path[:] = old_sys_path
os.chdir(cwd)
for item in settings_imports:
need_scan = item.startswith(_filescan_modules)
yield ('django', item, project_path if need_scan else None)
for app in installed_apps:
need_scan = app.startswith(project)
yield ('django', app, project_path if need_scan else None)
def handle_django_settings(filename):
'''Attempts to load a Django project and get package dependencies from
settings.
Tested using Django 1.4 and 1.8. Not sure if some nuances are missed in
the other versions.
'''
dirpath = os.path.dirname(filename)
project = os.path.basename(dirpath)
cwd = os.getcwd()
project_path = os.path.normpath(os.path.join(dirpath, '..'))
remove_path = project_path not in sys.path
if remove_path:
sys.path.insert(0, project_path)
os.chdir(project_path)
os.environ['DJANGO_SETTINGS_MODULE'] = '{}.settings'.format(project)
try:
import django
# Sanity
django.setup = lambda: False
except ImportError:
printer.error('Found Django settings, but Django is not installed.')
return
printer.error('Loading Django Settings (Using {}): {}'
.format(django.get_version(), filename))
from django.conf import LazySettings
installed_apps = None
db_settings = None
cache_settings = None
try:
settings = LazySettings()
installed_apps = getattr(settings, 'INSTALLED_APPS', None)
db_settings = getattr(settings, 'DATABASES', None)
cache_settings = getattr(settings, 'CACHES', None)
except Exception as e:
printer.error(u'Could not load Django settings: {}'.format(e))
return
if not installed_apps or not db_settings:
printer.error(u'Could not load INSTALLED_APPS or DATABASES.')
# Find typical Django modules that rely on packages that the user chooses
# to install.
django_base = os.path.normpath(os.path.join(os.path.dirname(django.__file__), '..'))
django_modules = set()
if db_settings:
for backend, db_conf in db_settings.items():
engine = db_conf.get('ENGINE')
if not engine:
continue
if hasattr(engine, '__file__'):
django_modules.add(engine.__file__)
else:
p = os.path.join(django_base, *engine.split('.'))
django_modules.add(os.path.join(p, 'base.py'))
if cache_settings:
for backend, cache_conf in cache_settings.items():
engine = cache_conf.get('BACKEND')
if hasattr(engine, '__file__'):
django_modules.add(engine.__file__)
else:
p = os.path.join(django_base, *engine.split('.')[:-1])
django_modules.add(p + '.py')
if django_modules:
for mod in django_modules:
if os.path.exists(mod):
for item in _scan_file(mod, 'django'):
yield item
django_installed_apps = []
try:
from django.apps.registry import apps, Apps, AppRegistryNotReady
# Django doesn't like it when the initial instance of `apps` is reused,
# but it has to be populated before other instances can be created.
if not apps.apps_ready:
apps.populate(installed_apps)
else:
apps = Apps(installed_apps)
start = time.time()
while True:
try:
for app in apps.get_app_configs():
django_installed_apps.append(app.name)
except AppRegistryNotReady:
if time.time() - start > 10:
raise Exception('Bail out of waiting for Django')
printer.debug('Waiting for apps to load...')
continue
break
except Exception as e:
django_installed_apps = list(installed_apps)
printer.debug('Could not use AppConfig: {}'.format(e))
for app in django_installed_apps:
import_parts = app.split('.')
# Start with the longest import path and work down
for i in range(len(import_parts), 0, -1):
yield ('django', '.'.join(import_parts[:i]))
os.chdir(cwd)
if remove_path:
sys.path.remove(project_path)
def ajuste_metadata_com_set_values(self):
for app in apps.get_app_configs():
if not app.name.startswith('cmj') and not app.name.startswith(
'sapl'):
continue
print(app)
for m in app.get_models():
model_exec = False
for f in m._meta.get_fields():
dua = f
print(dua)
if hasattr(dua, 'auto_now') and dua.auto_now:
#print(m, 'auto_now deve ser desativado.')
# continue # auto_now deve ser desativado
print(m, 'desativando auto_now')
dua.auto_now = False
if not isinstance(f, FileField):
continue
# se possui FileField, o model então
# deve possuir FIELDFILE_NAME
assert hasattr(m, 'FIELDFILE_NAME'
), '{} não possui FIELDFILE_NAME'.format(
m._meta.label)
# se possui FileField, o model então
# deve possuir metadata
assert hasattr(
m, 'metadata'), '{} não possui metadata'.format(
m._meta.label)
# o campo field deve estar em FIELDFILE_NAME
assert f.name in m.FIELDFILE_NAME, '{} não está no FIELDFILE_NAME de {}'.format(
f.name, m._meta.label)
model_exec = True
if not model_exec:
continue
print(m, m.objects.all().count())
# if m != DocumentoAdministrativo:
# continue
for i in m.objects.all().order_by('-id'): # [:500]:
if not hasattr(i, 'metadata'):
continue
metadata = i.metadata if i.metadata else {}
for fn in i.FIELDFILE_NAME:
ff = getattr(i, fn)
if not ff:
continue
if not os.path.exists(ff.path):
print('Arquivo registrado mas não existe', i.id, i)
continue
if not metadata:
continue
if 'signs' not in metadata:
continue
if fn not in metadata['signs']:
continue
if not metadata['signs'][fn]:
print(i)
i.save()
def get_apps():
for app_config in apps.get_app_configs():
yield app_config.name, app_config
def get_apps_labels():
"""
Get apps list and return tuple of apps labels.
"""
return tuple(app.label for app in apps.get_app_configs())
def get_apps():
for app_config in apps.get_app_configs():
yield app_config.name, app_config
def get_apps():
"""Get list of all p2 apps"""
from django.apps.registry import apps
for _app in apps.get_app_configs():
if _app.name.startswith('p2'):
yield _app
