def populate_dataviz_tables(app_config: AppConfig, **_):
if app_config.name == "aidants_connect_web":
DatavizRegion = app_config.get_model("DatavizRegion")
DatavizDepartment = app_config.get_model("DatavizDepartment")
DatavizDepartmentsToRegion = app_config.get_model(
"DatavizDepartmentsToRegion")
fixture = path_join(
dirname(aidants_connect_web.__file__),
"fixtures",
"departements_region.json",
)
with open(fixture) as f:
json = json_loads(f.read())
regions = sorted(set(item["region_name"] for item in json))
for region in regions:
DatavizRegion.objects.get_or_create(name=region)
for item in json:
department, _ = DatavizDepartment.objects.get_or_create(
zipcode=item["zipcode"],
defaults={"dep_name": item["dep_name"]})
region = DatavizRegion.objects.get(name=item["region_name"])
DatavizDepartmentsToRegion.objects.get_or_create(
department=department, region=region)
def ready(self):
if self.ready_run:
return
self.ready_run = True
try:
functionList = inspect.getmembers(analytics_automated.validators,
inspect.isfunction)
validatorList = [seq[0] for seq in functionList]
validator_types = AppConfig.get_model(self, "ValidatorTypes")
existing_entries = validator_types.objects.all().values_list('name')
existing_types = [seq[0] for seq in existing_entries]
for this_type in existing_types:
print("Existing validator: "+str(this_type))
if this_type not in validatorList:
print("Removing removed validator: "+this_type)
validator_types.objects.filter(name=this_type).delete()
for validator in validatorList:
if validator not in existing_types and \
not validator.startswith("_"):
print("Registering New Validator Type: "+validator)
validator_types.objects.create(name=validator)
except:
print("First time eh?")
def ready(self):
if self.ready_run:
return
self.ready_run = True
try:
functionList = inspect.getmembers(analytics_automated.validators,
inspect.isfunction)
validatorList = [seq[0] for seq in functionList]
validator_types = AppConfig.get_model(self, "ValidatorTypes")
existing_entries = validator_types.objects.all().values_list(
'name')
existing_types = [seq[0] for seq in existing_entries]
for this_type in existing_types:
print("Existing validator: " + str(this_type))
if this_type not in validatorList:
print("Removing removed validator: " + this_type)
validator_types.objects.filter(name=this_type).delete()
for validator in validatorList:
if validator not in existing_types and \
not validator.startswith("_"):
print("Registering New Validator Type: " + validator)
validator_types.objects.create(name=validator)
except:
print("First time eh?")
def populate_organisation_type_table(app_config: AppConfig, **_):
if app_config.name == "aidants_connect_web":
OrganisationType = app_config.get_model("OrganisationType")
for org_type in RequestOriginConstants:
OrganisationType.objects.get_or_create(
id=org_type.value, defaults={"name": org_type.label})
# Resets the starting value for AutoField
# See https://docs.djangoproject.com/en/dev/ref/databases/#manually-specified-autoincrement-pk # noqa
regclass = (
"""pg_get_serial_sequence('"aidants_connect_web_organisationtype"', 'id')"""
)
bigint = 'coalesce(max("id"), 1)'
boolean = 'max("id") IS NOT NULL'
with connection.cursor() as cursor:
cursor.execute(f"""SELECT setval({regclass}, {bigint}, {boolean})
FROM "aidants_connect_web_organisationtype";""")
def ready(self):
'''
Load graph from database. This process can take time,
run manage.py with --noreload to ony run once.
'''
# Call get database
synonym_model = AppConfig.get_model(self, 'Synonym_Relation')
# nodes_model = AppConfig.get_model(self, 'Words')
# Queryset all
relations = synonym_model.objects.all()
# query all values from word_from
relations = relations.select_related('word_from')
# query all values from synonyms
relations = relations.select_related('synonym')
print("Loading Words into graph..")
for relation in relations:
self.synonym_graph.add_edge(relation.word_from, relation.synonym)
print("done")
def load_pages(app_config: AppConfig, model_name: str) -> None:
"""
Load all flatpages for a given model into the database
:param app_config: the AppConfig we're loading a model from
:param model_name: the name of the model, since you can't import from here
"""
log = logging.getLogger(__name__)
# typing added to get IDE autocompletion
# we load the model this way to avoid circular imports
model: models.Model = app_config.get_model(model_name)
flatpage_root = settings.RESOURCEFILES_DIR / app_config.name / 'flatpages'
page_count = 0
for page in flatpage_root.rglob('*.md'):
page_count += 1
f = FlatPage(page, flatpage_root)
try:
model(
date=f.date,
updated=f.meta.get('updated'),
published=f['published'],
file_path=f.file,
url=f.url,
body=f.body,
category=f['category'],
title=f['title'],
).save()
except OperationalError:
log.error(f'The table {model} does not exist!')
log.error(f'Skipping loading pages...')
return
log.info(f'{page_count} {model_name} pages loaded')
username_field = lambda: getattr(get_user_model(), 'USERNAME_FIELD', 'username')
try:
from django.contrib.auth import get_user_model
except ImportError:
from django.contrib.auth.models import User
get_user_model = lambda: User
try:
from django.utils.encoding import smart_text
except ImportError:
from django.utils.encoding import smart_unicode as smart_text
try:
from django.contrib.contenttypes import fields as generic
except ImportError:
from django.contrib.contenttypes import generic
try:
from django.apps import AppConfig
user_model_class = lambda: AppConfig.get_model(*user_model_label.split('.'))
except ImportError:
from django.db import models
user_model_class = lambda: models.get_model(*user_model_label.split('.'))
class AppConfig(object):
name = None
def get_model(self, model_name):
return models.get_model(self.name.split('.')[-1], model_name, only_installed=False)
def get_model(model_name):
try:
return AppConfig.get_model(apps.get_app_config("core"), model_name)
except LookupError:
raise Http404
def populate_id_generator_table(app_config: AppConfig, **_):
if app_config.name == "aidants_connect_web":
IdGenerator = app_config.get_model("IdGenerator")
IdGenerator.objects.get_or_create(
code=settings.DATAPASS_CODE_FOR_ID_GENERATOR,
defaults={"last_id": 10000})
def post_migrate_modules(sender: AppConfig, **kwargs):
if sender.name + "_module" in connection.introspection.table_names():
Module = sender.get_model('Module')
for kw in data:
if not Module.objects.filter(name=kw["name"]).exists():
Module.objects.create(**kw)
def post_migrate_tags(sender: AppConfig, **kwargs):
Tag = sender.get_model("Tag")
for data in TAGS:
if not Tag.objects.filter(color=data['color']).exists():
Tag.objects.create(**data)
def add_post(request):
postInfo = AppConfig.get_model(Posts, required_ready=True)
form = postInfo(request.POST)
print("requestpost", request.POST)
form.save()
