def ready(self):
# Connections may already exist before we are called.
for conn in connections.all():
if conn.connection is not None:
register_type_handlers(conn)
connection_created.connect(register_type_handlers)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
def ready(self):
for conn in connections.all():
if conn.connection is not None:
register_hstore_handler(conn)
connection_created.connect(connection_handler,
weak=CONNECTION_CREATED_SIGNAL_WEAKREF,
dispatch_uid="_connection_create_handler")
def ready(self):
sys.stdout.write(f"Loading {self.verbose_name} ...\n")
connection_created.connect(activate_foreign_keys)
sys.stdout.write(f" * default TIME_ZONE {settings.TIME_ZONE}.\n")
if not settings.USE_TZ:
raise ImproperlyConfigured("EDC requires settings.USE_TZ = True")
sys.stdout.write(f" Done loading {self.verbose_name}.\n")
def ready(self):
# Connections may already exist before we are called.
for conn in connections.all():
if conn.vendor == 'postgresql':
conn.introspection.data_types_reverse.update({
3802:
'django.contrib.postgres.fields.JSONField',
3904:
'django.contrib.postgres.fields.IntegerRangeField',
3906:
'django.contrib.postgres.fields.DecimalRangeField',
3910:
'django.contrib.postgres.fields.DateTimeRangeField',
3912:
'django.contrib.postgres.fields.DateRangeField',
3926:
'django.contrib.postgres.fields.BigIntegerRangeField',
})
if conn.connection is not None:
register_type_handlers(conn)
connection_created.connect(register_type_handlers)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
def ready(self):
setting_changed.connect(uninstall_if_needed)
# Connections may already exist before we are called.
for conn in connections.all():
if conn.vendor == 'postgresql':
conn.introspection.data_types_reverse.update({
3904:
'django.contrib.postgres.fields.IntegerRangeField',
3906:
'django.contrib.postgres.fields.DecimalRangeField',
3910:
'django.contrib.postgres.fields.DateTimeRangeField',
3912:
'django.contrib.postgres.fields.DateRangeField',
3926:
'django.contrib.postgres.fields.BigIntegerRangeField',
})
if conn.connection is not None:
register_type_handlers(conn)
connection_created.connect(register_type_handlers)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
CharField.register_lookup(TrigramWordSimilar)
TextField.register_lookup(TrigramWordSimilar)
MigrationWriter.register_serializer(RANGE_TYPES, RangeSerializer)
IndexExpression.register_wrappers(OrderBy, OpClass, Collate)
def config():
service_name = os.getenv('DATABASE_SERVICE_NAME',
'').upper().replace('-', '_')
if service_name:
engine = engines.get(os.getenv('DATABASE_ENGINE'), engines['sqlite'])
else:
engine = engines['sqlite']
name = os.getenv('DATABASE_NAME')
if not name and engine == engines['sqlite']:
name = os.path.join(settings.BASE_DIR, 'db.sqlite3')
if bool(os.getenv('FIX_BROKEN_SQLITE', 'False').lower() in ['true', 1]):
connection_created.connect(activate_legacy_table_fix)
return {
'ENGINE': engine,
'NAME': name,
'USER': os.getenv('DATABASE_USER'),
'PASSWORD': os.getenv('DATABASE_PASSWORD'),
'HOST': os.getenv('{}_SERVICE_HOST'.format(service_name)),
'PORT': os.getenv('{}_SERVICE_PORT'.format(service_name)),
'ATOMIC_REQUESTS': True
}
def ready(self) -> None:
# from . import receivers # NOQA
from django.db.backends.signals import connection_created
connection_created.connect(set_dummy_active_tenant)
from occupation.admin import patch_admin
patch_admin()
def ready(self):
# Register DB credential fetching code so that we can fetch credentials from Vault before
# attempting to connect to the database.
if common.VaultAuthenticator.has_envconfig():
from django.conf import settings
found = False
for k, db in settings.DATABASES.items():
if isinstance(db, database.DjangoAutoRefreshDBCredentialsDict):
found = True
if found:
database.monkeypatch_django()
# Register SET_ROLE signal handler for the standard PostgreSQL database wrapper
from django.db.backends.postgresql.base import DatabaseWrapper as PostgreSQLDatabaseWrapper
connection_created.connect(database.set_role_connection,
sender=PostgreSQLDatabaseWrapper)
# Register SET_ROLE signal handler for the PostGIS database wrapper
try:
from django.contrib.gis.db.backends.postgis.base import DatabaseWrapper as PostGISDatabaseWrapper
connection_created.connect(database.set_role_connection,
sender=PostGISDatabaseWrapper)
except (
ImportError, ImproperlyConfigured
): # This exception will get thrown if the GDAL C libraries aren't installed.
pass
def add_database_instrumentation(self):
if not getattr(settings, "DJANGO_MYSQL_REWRITE_QUERIES",
False): # pragma: no cover
return
for _alias, connection in mysql_connections():
install_rewrite_hook(connection)
connection_created.connect(install_rewrite_hook)
def __init__(cls, name, bases, attrs):
super().__init__(name, bases, attrs)
if name == 'CompositeType':
return
# Register the type on the first database connection
connection_created.connect(receiver=cls.database_connected,
dispatch_uid=cls._meta.db_type)
def ready(self):
connection_created.connect(register_hstore_handler)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
def ready(self):
from .signals import update_user_profile_on_post_save
register(edc_base_check)
sys.stdout.write(f'Loading {self.verbose_name} ...\n')
connection_created.connect(activate_foreign_keys)
sys.stdout.write(f' * default TIME_ZONE {settings.TIME_ZONE}.\n')
if not settings.USE_TZ:
raise ImproperlyConfigured('EDC requires settings.USE_TZ = True')
sys.stdout.write(f' Done loading {self.verbose_name}.\n')
def test_connections(self):
connection_created.connect(self.count_conn)
self.connections = 0
# Checking if DatabaseWrapper object creates a connection by default
conn = DatabaseWrapper(settings.DATABASES['default'])
dbo = DatabaseOperations(conn)
dbo.adapt_timefield_value(datetime.time(3, 3, 3))
self.assertEqual(self.connections, 0)
def test_connections(self):
connection_created.connect(self.count_conn)
self.connections = 0
# Checking if DatabaseWrapper object creates a connection by default
conn = DatabaseWrapper(settings.DATABASES['default'])
dbo = DatabaseOperations(conn)
dbo.value_to_db_time(datetime.time(3, 3, 3))
self.assertEqual(self.connections, 0)
def ready(self):
set_read_only()
for alias in connections:
connection = connections[alias]
install_hook(connection)
connection_created.connect(install_hook)
setting_changed.connect(reset_read_only)
def __init__(cls, name, bases, attrs):
super().__init__(name, bases, attrs)
if name == 'CompositeType':
return
cls._capture_descriptors() # pylint:disable=no-value-for-parameter
# Register the type on the first database connection
connection_created.connect(receiver=cls.database_connected,
dispatch_uid=cls._meta.db_type)
def ready(self):
from .signals import update_user_profile_on_post_save
register(edc_base_check)
sys.stdout.write(f'Loading {self.verbose_name} ...\n')
connection_created.connect(activate_foreign_keys)
sys.stdout.write(
f' * default TIME_ZONE {settings.TIME_ZONE}.\n')
if not settings.USE_TZ:
raise ImproperlyConfigured('EDC requires settings.USE_TZ = True')
sys.stdout.write(f' Done loading {self.verbose_name}.\n')
def set_autocommit():
"""
example:
from pyutil.program.db import set_autocommit
set_autocommit()
"""
from django.db.backends.signals import connection_created
connection_created.connect(__autocommit_on)
def __init__(cls, name, bases, attrs):
super().__init__(name, bases, attrs)
if name == 'CompositeType':
return
cls._capture_descriptors() # pylint:disable=no-value-for-parameter
# Register the type on the first database connection
connection_created.connect(receiver=cls.database_connected,
dispatch_uid=cls._meta.db_type)
def ready(self):
db_conn = connections[DEFAULT_DB_ALIAS]
try:
c = db_conn.cursor()
except OperationalError:
pass
else:
db_conn.close()
connection_created.connect(connection_handler,
weak=CONNECTION_CREATED_SIGNAL_WEAKREF,
dispatch_uid="_connection_create_handler")
def ready(self):
"""
Sets up PRAGMAs.
"""
connection_created.connect(self.activate_pragmas_per_connection)
self.activate_pragmas_on_start()
# Log the settings file that we are running Kolibri with.
# Do this logging here, as this will be after Django has done its processing of
# Any environment variables or --settings command line arguments.
logger.info("Running Kolibri with the following settings: {settings}".format(
settings=os.environ["DJANGO_SETTINGS_MODULE"]))
def ready(self):
# Connections may already exist before we are called.
for conn in connections.all():
if conn.connection is not None:
register_hstore_handler(conn)
connection_created.connect(register_hstore_handler)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
def attach_signals():
if not DJANGO_ENABLED:
return
global link
connection_created.connect(link)
# Link all connections that might have popped up while we were
# loading. This will happen for sure if django-livesettings is installed as
# importing settings will automagically open a connection to the default
# database.
for conn in connections.all():
if conn.connection is not None:
link(conn.__class__, conn)
def test_signal(self):
data = {}
def receiver(sender, connection, **kwargs):
data["connection"] = connection
connection_created.connect(receiver)
connection.close()
cursor = connection.cursor()
self.assertTrue(data["connection"] is connection)
connection_created.disconnect(receiver)
data.clear()
cursor = connection.cursor()
self.assertTrue(data == {})
def ready(self):
from application import settings
if not settings.TESTING:
from django.db.backends.signals import connection_created
def register_achievements(*args, **kwargs):
try:
from django.utils.module_loading import autodiscover_modules
autodiscover_modules('achievements')
except Exception as e:
print e
print "Maybe, you need to run migrations first"
connection_created.connect(register_achievements, weak=False)
def customize_sqlite(sender, **kw):
"""
Here is how we install case-insensitive sorting in sqlite3.
Note that this caused noticeable performance degradation...
Thanks to
- http://efreedom.com/Question/1-3763838/Sort-Order-SQLite3-Umlauts
- http://docs.python.org/library/sqlite3.html#sqlite3.Connection.create_collation
- http://www.sqlite.org/lang_createindex.html
"""
from django.db.backends.signals import connection_created
def belgian(s):
s = s.decode('utf-8').lower()
s = s.replace(u'ä', u'a')
s = s.replace(u'à', u'a')
s = s.replace(u'â', u'a')
s = s.replace(u'ç', u'c')
s = s.replace(u'é', u'e')
s = s.replace(u'è', u'e')
s = s.replace(u'ê', u'e')
s = s.replace(u'ë', u'e')
s = s.replace(u'ö', u'o')
s = s.replace(u'õ', u'o')
s = s.replace(u'ô', u'o')
s = s.replace(u'ß', u'ss')
s = s.replace(u'ù', u'u')
s = s.replace(u'ü', u'u')
s = s.replace(u'û', u'u')
return s
def stricmp(str1, str2):
return cmp(belgian(str1), belgian(str2))
def my_callback(sender, **kw):
from django.db.backends.sqlite3.base import DatabaseWrapper
if sender is DatabaseWrapper:
db = kw['connection']
db.connection.create_collation('BINARY', stricmp)
connection_created.connect(my_callback)
def test_signal(self):
from django.db import connection
def conn_setup(*args, **kwargs):
conn = kwargs['connection']
cur = conn.cursor()
cur.execute("SET @xyz=10")
cur.close()
connection_created.connect(conn_setup)
cursor = connection.cursor()
cursor.execute("SELECT @xyz")
self.assertEqual((10, ), cursor.fetchone())
cursor.close()
self.cnx.close()
def test_signal(self):
from django.db import connection
def conn_setup(*args, **kwargs):
conn = kwargs['connection']
cur = conn.cursor()
cur.execute("SET @xyz=10")
cur.close()
connection_created.connect(conn_setup)
cursor = connection.cursor()
cursor.execute("SELECT @xyz")
self.assertEqual((10,), cursor.fetchone())
cursor.close()
self.cnx.close()
def ensure_sql_instrumented():
global sql_instrumented
if sql_instrumented:
return
sql_instrumented = True
if django.VERSION >= (2, 0):
for connection in connections.all():
install_db_execute_hook(connection=connection)
connection_created.connect(install_db_execute_hook)
logger.debug("Installed DB connection created signal handler")
else:
CursorWrapper.execute = execute_wrapper(CursorWrapper.execute)
CursorWrapper.executemany = executemany_wrapper(CursorWrapper.executemany)
logger.debug("Monkey patched SQL")
def test_signal(self):
data = {}
def receiver(sender, connection, **kwargs):
data["connection"] = connection
connection_created.connect(receiver)
connection.close()
with connection.cursor():
pass
self.assertIs(data["connection"].connection, connection.connection)
connection_created.disconnect(receiver)
data.clear()
with connection.cursor():
pass
self.assertEqual(data, {})
def ready(self):
from django.conf import settings
if not getattr(settings, "PARLER_DEFAULT_LANGUAGE_CODE", None):
raise MissingSettingException("PARLER_DEFAULT_LANGUAGE_CODE must be set.")
if not getattr(settings, "PARLER_LANGUAGES", None):
raise MissingSettingException("PARLER_LANGUAGES must be set.")
# set money precision provider function
from .models import get_currency_precision
money.set_precision_provider(get_currency_precision)
if django.conf.settings.SHUUP_ERROR_PAGE_HANDLERS_SPEC:
from .error_handling import install_error_handlers
install_error_handlers()
from shuup.core.utils.context_cache import (
bump_product_signal_handler, bump_shop_product_signal_handler
)
from shuup.core.models import Product, ShopProduct
from django.db.models.signals import m2m_changed
m2m_changed.connect(
bump_shop_product_signal_handler,
sender=ShopProduct.categories.through,
dispatch_uid="shop_product:clear_shop_product_cache"
)
from django.db.models.signals import post_save
post_save.connect(
bump_product_signal_handler,
sender=Product,
dispatch_uid="product:bump_product_cache"
)
post_save.connect(
bump_shop_product_signal_handler,
sender=ShopProduct,
dispatch_uid="shop_product:bump_shop_product_cache"
)
# extends SQLite with necessary functions
from django.db.backends.signals import connection_created
from shuup.core.utils.db import extend_sqlite_functions
connection_created.connect(extend_sqlite_functions)
def ready(self):
# Connections may already exist before we are called.
for conn in connections.all():
if conn.vendor == 'postgresql':
conn.introspection.data_types_reverse.update({
3802: 'django.contrib.postgres.fields.JSONField',
3904: 'django.contrib.postgres.fields.IntegerRangeField',
3906: 'django.contrib.postgres.fields.DecimalRangeField',
3910: 'django.contrib.postgres.fields.DateTimeRangeField',
3912: 'django.contrib.postgres.fields.DateRangeField',
3926: 'django.contrib.postgres.fields.BigIntegerRangeField',
})
if conn.connection is not None:
register_type_handlers(conn)
connection_created.connect(register_type_handlers)
CharField.register_lookup(Unaccent)
TextField.register_lookup(Unaccent)
CharField.register_lookup(SearchLookup)
TextField.register_lookup(SearchLookup)
CharField.register_lookup(TrigramSimilar)
TextField.register_lookup(TrigramSimilar)
def patch():
if not ConfigProvider.get(
config_names.THUNDRA_TRACE_INTEGRATIONS_DJANGO_DISABLE) and (
not utils.get_env_variable(
constants.AWS_LAMBDA_FUNCTION_NAME)):
wrapt.wrap_function_wrapper('django.core.handlers.base',
'BaseHandler.load_middleware', _wrapper)
if not ConfigProvider.get(
config_names.THUNDRA_TRACE_INTEGRATIONS_DJANGO_ORM_DISABLE):
try:
from django import VERSION
from django.db import connections
from django.db.backends.signals import connection_created
if VERSION >= (2, 0):
for connection in connections.all():
install_db_execute_wrapper(connection)
connection_created.connect(install_db_execute_wrapper)
except:
pass
def ready(self):
from django.conf import settings
if not getattr(settings, "PARLER_DEFAULT_LANGUAGE_CODE", None):
raise MissingSettingException(
"PARLER_DEFAULT_LANGUAGE_CODE must be set.")
if not getattr(settings, "PARLER_LANGUAGES", None):
raise MissingSettingException("PARLER_LANGUAGES must be set.")
# set money precision provider function
from .models import get_currency_precision
money.set_precision_provider(get_currency_precision)
if django.conf.settings.SHUUP_ERROR_PAGE_HANDLERS_SPEC:
from .error_handling import install_error_handlers
install_error_handlers()
from shuup.core.utils.context_cache import (
bump_product_signal_handler, bump_shop_product_signal_handler)
from shuup.core.models import Product, ShopProduct
from django.db.models.signals import m2m_changed
m2m_changed.connect(
bump_shop_product_signal_handler,
sender=ShopProduct.categories.through,
dispatch_uid="shop_product:clear_shop_product_cache")
from django.db.models.signals import post_save
post_save.connect(bump_product_signal_handler,
sender=Product,
dispatch_uid="product:bump_product_cache")
post_save.connect(bump_shop_product_signal_handler,
sender=ShopProduct,
dispatch_uid="shop_product:bump_shop_product_cache")
# extends SQLite with necessary functions
from django.db.backends.signals import connection_created
from shuup.core.utils.db import extend_sqlite_functions
connection_created.connect(extend_sqlite_functions)
from django.db.backends.signals import connection_created
from django.utils.importlib import import_module
from multischema import settings
from multischema.handlers import create_namespace_if_not_exist, switch_to_namespace_on_connect
backends = [getattr(import_module('.base', package=backend), 'DatabaseWrapper') for backend in settings.MULTISCHEMA_SUPPORTED_BACKENDS]
if settings.MULTISCHEMA_CREATE_IF_NOT_EXIST:
for backend in backends:
connection_created.connect(create_namespace_if_not_exist, sender=backend)
for backend in backends:
connection_created.connect(switch_to_namespace_on_connect, sender=backend)
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse'
}
},
'handlers': {
'mail_admins': {
'level': 'ERROR',
'filters': ['require_debug_false'],
'class': 'django.utils.log.AdminEmailHandler'
}
},
'loggers': {
'django.request': {
'handlers': ['mail_admins'],
'level': 'ERROR',
'propagate': True,
},
}
}
# If we're using sqlite, we need to tweak the performance a bit
from django.db.backends.signals import connection_created
def activate_synchronous_off(sender, connection, **kwargs):
if connection.vendor == 'sqlite':
cursor = connection.cursor()
cursor.execute('PRAGMA synchronous = 0;')
connection_created.connect(activate_synchronous_off)
#
def ready(self):
connection_created.connect(connection_handler,
weak=CONNECTION_CREATED_SIGNAL_WEAKREF,
dispatch_uid="_connection_create_handler")
from django.db.backends.signals import connection_created
try:
from django.db.backends.postgresql_psycopg2.base import DatabaseWrapper
from .util import register_hstore
def register_hstore_extension(sender, connection, *args, **kwargs):
cursor = connection.cursor()
cursor.execute("CREATE EXTENSION IF NOT EXISTS hstore")
connection.commit_unless_managed()
register_hstore(connection.connection, globally=True, unicode=True)
connection_created.connect(register_hstore_extension, sender=DatabaseWrapper)
except ImportError:
pass
def ready(self):
connection_created.connect(connection_handler,
dispatch_uid="_connection_create_handler")
from django.db.backends.signals import connection_created
def activate_foreign_keys(sender, connection, **kwargs):
"""Enable integrity constraint with sqlite."""
if connection.vendor == "sqlite":
cursor = connection.cursor()
cursor.execute("PRAGMA foreign_keys = ON;")
connection_created.connect(activate_foreign_keys)
from django.conf import settings
from django.db.backends.signals import connection_created
def set_schema_search_path(sender, **kwargs):
from django.db import connection, transaction
cursor = connection.cursor()
cursor.execute('SET search_path TO %s' % ', '.join(settings.DATABASES['default']['SCHEMA_SEARCH_PATH']))
transaction.commit_unless_managed()
if 'postgresql' in settings.DATABASES['default']['ENGINE'] and settings.DATABASES['default'].get('SCHEMA_SEARCH_PATH'):
connection_created.connect(set_schema_search_path)
"""Patches to apply to django."""
from django.db.backends.signals import connection_created
from django.db.backends.sqlite3 import base
def get_new_connection(sender=None, connection=None, **kwargs):
"""Assign correct text factory when database backend is sqlite3"""
if sender is base.DatabaseWrapper:
connection.connection.text_factory = str
# Connect to django signal
connection_created.connect(get_new_connection)
from django import VERSION
import psycopg2.extras
sitename = 'hiking'
def set_schema(sender, connection, **kwargs):
cursor = connection.cursor()
cursor.execute("SET search_path TO %s,public;" % sitename)
psycopg2.extras.register_hstore(cursor, globally=True, unicode=True)
if __name__ == "__main__":
from django.core.management import execute_from_command_line
sys.path.append(os.path.normpath(os.path.join(os.path.realpath(__file__), '../..')))
sys.path.append(os.path.normpath(os.path.join(os.path.realpath(__file__), '../../../../config')))
if len(sys.argv) > 1 and sys.argv[-1] in ('hiking', 'cycling', 'skating', 'mtbmap'):
sitename = sys.argv[-1]
args = sys.argv[:-1]
else:
args = sys.argv
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "routemap.sites.settings." + sitename )
if VERSION >= (1,1):
from django.db.backends.signals import connection_created
connection_created.connect(set_schema)
execute_from_command_line(args)
pg_config = subprocess.Popen(["pg_config", "--sharedir"], stdout=subprocess.PIPE)
share_dir = pg_config.communicate()[0].strip('\r\n ')
hstore_sql = os.path.join(share_dir, 'contrib', 'hstore.sql')
statements = re.compile(r";[ \t]*$", re.M)
cursor = connection.cursor()
with open(hstore_sql, 'U') as fp:
for statement in statements.split(fp.read().decode(settings.FILE_CHARSET)):
statement = re.sub(ur"--.*([\n\Z]|$)", "", statement).strip()
if statement:
cursor.execute(statement + u";")
else:
cursor = connection.cursor()
cursor.execute("CREATE EXTENSION hstore;")
register_hstore(connection.connection, globally=True)
connection_created.connect(register_hstore_on_connection_creation, dispatch_uid='hstore_field.register_hstore_on_connection_creation')
class HStoreDictionary(dict):
def __init__(self, value=None, field=None, instance=None, **params):
super(HStoreDictionary, self).__init__(value, **params)
self.field = field
self.instance = instance
class HStoreDescriptor(object):
def __init__(self, field):
self.field = field
#
# You should have received a copy of the GNU Affero General Public License
# along with LAVA. If not, see <http://www.gnu.org/licenses/>.
import os
from django.core.wsgi import get_wsgi_application
from django.db.backends.signals import connection_created
# Set the environment variables for Django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "lava_server.settings.distro")
os.environ.setdefault("DJANGO_DEBIAN_SETTINGS_TEMPLATE",
"/etc/lava-server/{filename}.conf")
# Set the postgresql connection timeout
# The timeout is only used when running through wsgi. This way, command line
# commands are not affected by the timeout.
def setup_postgres(connection, **kwargs):
if connection.vendor != 'postgresql':
return
with connection.cursor() as cursor:
cursor.execute("SET statement_timeout TO 30000")
connection_created.connect(setup_postgres, dispatch_uid="setup_postgres")
# Create the application
application = get_wsgi_application()
m2m_changed.connect(handle_shop_product_post_save,
sender=ShopProduct.categories.through,
dispatch_uid="shop_product:change_categories")
post_save.connect(handle_product_post_save,
sender=Product,
dispatch_uid="product:bump_product_cache")
post_save.connect(handle_shop_product_post_save,
sender=ShopProduct,
dispatch_uid="shop_product:bump_shop_product_cache")
# connect signals to bump price caches on Tax and TaxClass change
post_save.connect(handle_post_save_bump_all_prices_caches,
sender=Tax,
dispatch_uid="tax_class:bump_prices_cache")
post_save.connect(handle_post_save_bump_all_prices_caches,
sender=TaxClass,
dispatch_uid="tax_class:bump_prices_cache")
# connect signals to bump context cache internal cache for contacts
post_save.connect(handle_contact_post_save,
sender=PersonContact,
dispatch_uid="person_contact:bump_context_cache")
post_save.connect(handle_contact_post_save,
sender=CompanyContact,
dispatch_uid="company_contact:bump_context_cache")
m2m_changed.connect(handle_contact_post_save,
sender=ContactGroup.members.through,
dispatch_uid="contact_group:change_members")
connection_created.connect(extend_sqlite_functions)
else:
# We are running in debug
SECRET_KEY = 'my debug secret key is not a secret'
from django.db.backends.signals import connection_created
def speed_up_writes_by_20_percent(sender, connection, **kwargs):
"""Truncate, don't delete, sqlite3 journal.
This is faster because every write no longer needs to create and
delete a file (which would mean two directory writes).
"""
cursor = connection.cursor()
cursor.execute('PRAGMA journal_mode=TRUNCATE')
connection_created.connect(speed_up_writes_by_20_percent)
DATABASES = {
'default': {
'ENGINE': 'cjworkbench.sqlite3withbeginimmediate',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
'OPTIONS': {
'timeout': 30,
'isolation_level': 'IMMEDIATE',
},
},
}
EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
EMAIL_FILE_PATH = os.path.join(BASE_DIR, 'local_mail')
cur.execute("SELECT NULL::BIT")
bit_oid = cur.description[0].type_code
cur.execute("SELECT NULL::VARBIT")
varbit_oid = cur.description[0].type_code
bit_caster = ext.new_type((bit_oid, varbit_oid), 'BIT', cast_bits)
# There are conflict with `django-postgrespool`.
# From this app we use just `View` and we no need this functionality.
# ext.register_type(bit_caster, connection)
def register_types_on_connection_creation(connection, sender, *args, **kwargs):
if not issubclass(sender, PGDatabaseWrapper):
return
register_bitstring_types(connection.connection)
connection_created.connect(register_types_on_connection_creation)
class BitStringField(models.Field):
"""A Postgres bit string."""
def __init__(self, *args, **kwargs):
self.max_length = kwargs.setdefault('max_length', 1)
self.varying = kwargs.pop('varying', False)
if 'default' in kwargs:
default = kwargs.pop('default')
elif kwargs.get('null', False):
default = None
elif self.max_length is not None and not self.varying:
'toaster': {
'handlers': ['console'],
'level': 'DEBUG',
},
'django.request': {
'handlers': ['console'],
'level': 'WARN',
'propagate': True,
},
}
}
if DEBUG and SQL_DEBUG:
LOGGING['loggers']['django.db.backends'] = {
'level': 'DEBUG',
'handlers': ['console'],
}
# If we're using sqlite, we need to tweak the performance a bit
from django.db.backends.signals import connection_created
def activate_synchronous_off(sender, connection, **kwargs):
if connection.vendor == 'sqlite':
cursor = connection.cursor()
cursor.execute('PRAGMA synchronous = 0;')
connection_created.connect(activate_synchronous_off)
#
@staticmethod
def update_timestamp_for_string(s, override_time=None):
timestamp, _ = Timestamp.objects.get_or_create(key=Timestamp.hash(s), defaults={
'timestamp': datetime.datetime.utcnow()})
timestamp.timestamp = override_time or datetime.datetime.utcnow()
timestamp.save() # definitely!
return timestamp
# Adjustments to default Django sqlite3 behavior
def activate_foreign_keys(sender, connection, **kwargs):
"""Enable integrity constraint with sqlite."""
if connection.vendor == 'sqlite':
cursor = connection.cursor()
cursor.execute('PRAGMA foreign_keys = ON;')
def set_asynchronous_for_sqlite(sender, connection, **kwargs):
"""Make sqlite3 be asynchronous. This is risky in case your
machine crashes, but comes at such a performance boost that
we do it anyway.
More info: http://www.sqlite.org/pragma.html#pragma_synchronous """
if connection.vendor == 'sqlite':
cursor = connection.cursor()
cursor.execute('PRAGMA synchronous=OFF;')
from django.db.backends.signals import connection_created
connection_created.connect(activate_foreign_keys)
connection_created.connect(set_asynchronous_for_sqlite)
def app_options(): # 配置数据容器
'''
系统全局配置参数
'''
from base.options import SYSPARAM, PERSONAL
import dict4ini # 读取配置文件appconfig.ini
appconf=dict4ini.DictIni(settings.APP_HOME+"/appconfig.ini")
language=appconf["language"]["language"] # 设置语言
return (
#参数名称, 参数默认值，参数显示名称，解释,参数类别,是否可见
('date_format', '%Y-%m-%d', u"%s" % _(u'日期格式'), '', PERSONAL, True),
('time_format', '%H:%M:%S', u"%s" % _(u'时间格式'), '', PERSONAL, True),
('datetime_format', '%Y-%m-%d %H:%M:%S', u"%s" % _(u'时间日期格式'), '', PERSONAL, True),
('shortdate_format', '%y-%m-%d', u"%s" % _(u'短日期格式'), '', PERSONAL, True),
('shortdatetime_format', '%y-%m-%d %H:%M', u"%s" % _(u'短日期时间格式'), '', PERSONAL, True),
('language', language, u'语言', '', PERSONAL, True),
('base_default_page', 'data/auth/User/', u"%s" % _(u'系统默认页面'), '', PERSONAL, False),
('site_default_page', 'data/worktable/', u"%s" % _(u'整个系统默认页面'), "", PERSONAL, False),
('backup_sched', '', u'备份时间', "", SYSPARAM, True),
)
def database_init(sender, **kwargs):
from django.db import connection
if 'mysql' in connection.__module__: #设置mysql数据库的提交属性
connection.cursor().execute('set autocommit=1')
from django.db.backends.signals import connection_created
connection_created.connect(database_init) # 加入 connection_created 信号处理函数
sender=Product,
dispatch_uid="product:bump_product_cache"
)
post_save.connect(
handle_shop_product_post_save,
sender=ShopProduct,
dispatch_uid="shop_product:bump_shop_product_cache"
)
# connect signals to bump caches on Supplier change
post_save.connect(
handle_supplier_post_save,
sender=Supplier,
dispatch_uid="supplier:bump_supplier_cache"
)
# connect signals to bump price caches on Tax and TaxClass change
post_save.connect(handle_post_save_bump_all_prices_caches, sender=Tax, dispatch_uid="tax_class:bump_prices_cache")
post_save.connect(handle_post_save_bump_all_prices_caches, sender=TaxClass, dispatch_uid="tax_class:bump_prices_cache")
# connect signals to bump context cache internal cache for contacts
post_save.connect(handle_contact_post_save, sender=PersonContact, dispatch_uid="person_contact:bump_context_cache")
post_save.connect(handle_contact_post_save, sender=CompanyContact, dispatch_uid="company_contact:bump_context_cache")
m2m_changed.connect(
handle_contact_post_save,
sender=ContactGroup.members.through,
dispatch_uid="contact_group:change_members"
)
connection_created.connect(extend_sqlite_functions)
from django.db.backends.signals import connection_created
def activate_foreign_keys(sender, connection, **kwargs):
if connection.vendor == 'sqlite':
cursor = connection.cursor()
cursor.execute('PRAGMA foreign_keys = ON;')
connection_created.connect(activate_foreign_keys)
if len(self.unique_handlers) > 0:
handlers.update(self.unique_handlers)
self.unique_handlers = []
handlers.update(self.generic_handlers)
# List comprension is used instead of for statement
# only for performance.
[x(connection) for x in handlers]
def attach_handler(self, func, vendor=None, unique=False):
if unique:
self.unique_handlers.append(func)
else:
self.generic_handlers.append(func)
connection_handler = ConnectionCreateHandler()
connection_created.connect(connection_handler, dispatch_uid="_connection_create_handler")
def register_hstore_handler(connection, **kwargs):
if not connection.settings_dict.get('HAS_HSTORE', True):
return
if sys.version_info[0] < 3:
register_hstore(connection.connection, globally=True, unicode=True)
else:
register_hstore(connection.connection, globally=True)
connection_handler.attach_handler(register_hstore_handler, vendor="postgresql", unique=True)
def ready(self):
connection_created.connect(activate_foreign_keys)
def setup():
connection_created.connect(sqlite_set_pragma)
