class Development(Base):
"""Settings for local development."""
DOTENV_EXISTS = os.path.exists(os.path.join(Core.BASE_DIR, '.env'))
DOTENV = '.env' if DOTENV_EXISTS else None
SECRET_KEY = values.Value('not a secret')
DEBUG = values.BooleanValue(True)
AUTH_PASSWORD_VALIDATORS = values.ListValue([])
INSTALLED_APPS = Base.INSTALLED_APPS + ['sslserver']
EMAIL_BACKEND = values.Value('django.core.mail.backends.console.EmailBackend')
SECURE_SSL_REDIRECT = values.Value(False)
REQUIRE_RECIPE_AUTH = values.BooleanValue(False)
PEER_APPROVAL_ENFORCED = values.BooleanValue(False)
API_CACHE_ENABLED = values.BooleanValue(False)
API_CACHE_TIME = values.IntegerValue(0)
SWAGGER_SETTINGS = Base.SWAGGER_SETTINGS
SWAGGER_SETTINGS['VALIDATOR_URL'] = None
class Development(Base):
"""Development environment settings.
We set ``DEBUG`` to ``True`` by default, configure the server to respond to all hosts,
and use a local sqlite database by default.
"""
DEBUG = values.BooleanValue(True)
ALLOWED_HOSTS = ["*"]
AWS_SOURCE_BUCKET_NAME = "development-marsha-source"
class Production(Staging):
"""
The in-production settings.
"""
# Email
EMAIL_HOST = values.Value(None)
EMAIL_PORT = values.IntegerValue(456)
EMAIL_HOST_USER = values.Value(None)
EMAILEMAIL_USE_TLS = values.BooleanValue(True)
EMAIL_USE_SSL = values.BooleanValue(False)
SERVER_EMAIL = values.Value(None)
CORS_REPLACE_HTTPS_REFERER = False
HOST_SCHEME = "http://"
SECURE_PROXY_SSL_HEADER = None
SECURE_SSL_REDIRECT = False
SESSION_COOKIE_SECURE = False
CSRF_COOKIE_SECURE = False
SECURE_HSTS_SECONDS = None
SECURE_HSTS_INCLUDE_SUBDOMAINS = False
SECURE_FRAME_DENY = False
class Docker(Common):
# DEBUG
DEBUG = values.BooleanValue(True)
TEMPLATE_DEBUG = DEBUG
# END DEBUG
# INSTALLED_APPS
INSTALLED_APPS = Common.INSTALLED_APPS
# END INSTALLED_APPS
# DATABASE CONFIGURATION
import os
POSTGRES_HOST = os.environ['POSTGRES_PORT_5432_TCP_ADDR']
DATABASES = values.DatabaseURLValue('postgres://postgres@{0}/postgres'.format(POSTGRES_HOST))
# END DATABASE CONFIGURATION
# Mail settings
EMAIL_HOST = "localhost"
EMAIL_PORT = 1025
EMAIL_BACKEND = values.Value('django.core.mail.backends.console.EmailBackend')
# End mail settings
# django-debug-toolbar
MIDDLEWARE_CLASSES = Common.MIDDLEWARE_CLASSES + ('debug_toolbar.middleware.DebugToolbarMiddleware',)
INSTALLED_APPS += ('debug_toolbar', 'gunicorn')
# SITE CONFIGURATION
# Hosts/domain names that are valid for this site
# See https://docs.djangoproject.com/en/1.6/ref/settings/#allowed-hosts
ALLOWED_HOSTS = ["*"]
# END SITE CONFIGURATION
INTERNAL_IPS = ('127.0.0.1',)
DEBUG_TOOLBAR_CONFIG = {
'DISABLE_PANELS': [
'debug_toolbar.panels.redirects.RedirectsPanel',
],
'SHOW_TEMPLATE_CONTEXT': True,
}
# end django-debug-toolbar
MEMCACHED_HOST = os.environ['MEMCACHED_PORT_11211_TCP_ADDR']
# CACHES = values.CacheURLValue(default="memcached://{0}:11211".format(MEMCACHED_HOST))
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '{0}:11211'.format(MEMCACHED_HOST)
}
}
# Your local stuff: Below this line define 3rd party libary settings
class Production(Common):
"""
The in-production settings.
"""
# Security
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31_536_000)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value(None)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(("HTTP_X_FORWARDED_PROTO", "https"))
AWS_REGION = values.Value("us-east-1", environ_prefix=None)
AWS_ACCESS_KEY_ID = values.SecretValue(environ_prefix=None)
AWS_SECRET_ACCESS_KEY = values.SecretValue(environ_prefix=None)
AWS_S3_BUCKET_NAME = values.Value(environ_prefix=None)
CONTRACTS_DOCUMENT_STORAGE = "django_s3_storage.storage.S3Storage"
@property
def CACHES(self):
caches = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": f"{self.REDIS_URL}/1",
"OPTIONS": {"CLIENT_CLASS": "django_redis.client.DefaultClient"},
}
}
if self.AUX_REDIS_URL:
caches["aux"] = {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": f"{self.AUX_REDIS_URL}/1",
"OPTIONS": {"CLIENT_CLASS": "django_redis.client.DefaultClient"},
}
return caches
class Localdev(Base):
"""Configuration to be used during local development and base class
for testing"""
DOTENV = os.path.join(BASE_DIR, ".env")
DEBUG = values.BooleanValue(default=True)
LOGGING_USE_JSON = values.BooleanValue(False)
UNSIGNED_S3_CLIENT = values.BooleanValue(False)
@property
def VERSION(self):
fn = os.path.join(self.BASE_DIR, "version.json")
if os.path.exists(fn):
with open(fn) as fp:
return json.load(fp)
return {}
@property
def LOGGING(self):
LOGGING = super().LOGGING
# Add django.server (useful for local dev) and
# unset the request.summary.
LOGGING["loggers"]["django.server"] = {
"level": "INFO",
"handlers": ["console"],
"propagate": False,
}
LOGGING["loggers"]["request.summary"]["level"] = "ERROR"
return LOGGING
MARKUS_BACKENDS = values.ListValue([{
"class":
"markus.backends.logging.LoggingMetrics"
}])
# When doing local development you don't need to redirect to HTTPS.
SECURE_HSTS_SECONDS = values.IntegerValue(0)
SECURE_HSTS_PRELOAD = values.BooleanValue(False)
class Dev(Base):
"""Base settings for development."""
DEBUG = True
# Required overrides
SITE_URL = values.URLValue('http://*****:*****@example.com',
'password': '******'
})
# Storage
AWS_S3_REGION_NAME = ''
AWS_STORAGE_BUCKET_NAME = values.Value('django')
AWS_S3_ENDPOINT_URL = values.Value('http://minio:9000')
AWS_ACCESS_KEY_ID = values.Value('djangos3')
AWS_SECRET_ACCESS_KEY = values.Value('djangos3')
AWS_S3_SECURE_URLS = values.BooleanValue(True)
@property
def AWS_S3_CUSTOM_DOMAIN(self):
return values.Value(self.URL.netloc)
# Core
@property
def FRONTEND_URL(self):
return values.URLValue(self.SITE_URL)
@property
def INSTALLED_APPS(self):
return super().INSTALLED_APPS + [
'debug_toolbar',
]
# Security
CORS_ORIGIN_ALLOW_ALL = True
SESSION_COOKIE_SECURE = False
CSRF_COOKIE_SECURE = False
AWS_AUTO_CREATE_BUCKET = True
# Email
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# Services
CELERY_BROKER_URL = values.Value('redis://redis',
environ_name='CELERY_BROKER_URL')
DATABASES = values.DatabaseURLValue(
'postgis://*****:*****@db:5432/django')
class Staging(Common):
"""
The in-staging settings.
"""
# Security
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31536000)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value(None)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(
('HTTP_X_FORWARDED_PROTO', 'https')
)
DATABASES = Common.DATABASES
DATABASES = values.DatabaseURLValue(
'postgres://*****:*****@localhost/default'
)
class Production(Base):
DEBUG = False
@property
def TEMPLATES(self):
TEMP = super().TEMPLATES
TEMP[0]['OPTIONS']['debug'] = False
return TEMP
ALLOWED_HOSTS = values.TupleValue(('example.com', ))
CELERY_TASK_ALWAYS_EAGER = values.BooleanValue(False)
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'
class Dev(Base):
API = values.BooleanValue(True, environ_prefix='RICHARD')
DEBUG = True
SECRET_KEY = 'richard-testing'
INSTALLED_APPS = Base.INSTALLED_APPS + ('eadred',)
AUTHENTICATION_BACKENDS = (
'django_browserid.auth.AutoLoginBackend', # DON'T use this in Production!
'django_browserid.auth.BrowserIDBackend',
)
BROWSERID_AUDIENCES = ['http://*****:*****@example.com"
# export BROWSERID_AUTOLOGIN_ENABLED=1
# ./manage.py runserver
BROWSERID_AUTOLOGIN_EMAIL = values.Value('')
BROWSERID_AUTOLOGIN_ENABLED = values.BooleanValue(False)
class Production(Common):
"""
The production settings.
"""
INSTALLED_APPS = Common.INSTALLED_APPS + (
'djangosecure',
'raven.contrib.django.raven_compat',
)
SPEAKER_SUBMISSION = False
ALLOWED_HOSTS = [
'speakers.herokuapp.com',
'calltospeakers.com',
'www.calltospeakers.com',
]
# django-secure
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31536000)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_FRAME_DENY = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(
('HTTP_X_FORWARDED_PROTO', 'https'))
class Development(databases.Databases, common.Common):
"""Settings for development."""
CACHES = values.DictValue({
'default': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
}
})
DEVSERVER_ARGS = values.ListValue([])
@property
def DEVSERVER_DEFAULT_ADDR(self):
"""Return the default address to bind devserver to."""
if 'vagrant' in socket.gethostname():
addr = '0.0.0.0'
else:
addr = '127.0.0.1'
return addr
DEVSERVER_MODULES = values.ListValue([
'devserver.modules.sql.SQLRealTimeModule',
'devserver.modules.sql.SQLSummaryModule',
'devserver.modules.profile.ProfileSummaryModule',
])
DEVSERVER_TRUNCATE_SQL = values.BooleanValue(True)
EMAIL_BACKEND = values.Value(
'django.core.mail.backends.console.EmailBackend')
# devserver must be ahead of django.contrib.staticfiles
INSTALLED_APPS = ('devserver', ) + common.Common.INSTALLED_APPS + (
'debug_toolbar', )
@property
def INTERNAL_IPS(self):
"""Return a tuple of IP addresses, as strings.
Detect a Vagrant box by looking at the hostname. Return the gateway IP
address on a Vagrant box, because this is the IP address the request
will originate from.
"""
if 'vagrant' in socket.gethostname():
addr = [
line.split()[1] for line in subprocess.check_output(
['netstat', '-rn']).splitlines()
if line.startswith('0.0.0.0')
][0] # noqa
else:
addr = '127.0.0.1'
return (addr, )
class Development(BasicConfiguration):
"""
Development CRM configuration, for easy debugging and diagnosing.
"""
DEBUG = values.BooleanValue(True)
# SECURITY WARNING: keep the secret key used in production secret!
# Set in local_settings.py
SECRET_KEY = 'SECRET_SECRET_SECRET'
CELERY_TASK_ALWAYS_EAGER = True
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'krynegger_db_dev',
'USER': '******',
'PASSWORD': '******',
'HOST': 'localhost',
'PORT': '5432',
'TEST': {
'NAME': 'krynegger_db_test',
}
},
}
@classmethod
def pre_setup(cls):
super(Development, cls).pre_setup()
@classmethod
def setup(cls):
super(Development, cls).setup()
logging.info('development settings loaded: %s', cls)
@classmethod
def post_setup(cls):
super(Development, cls).post_setup()
logging.debug("done setting up! \o/")
sentry_sdk.init(
dsn="https://[email protected]/3744204",
integrations=[
DjangoIntegration(),
CeleryIntegration(),
RedisIntegration()
],
# If you wish to associate users to errors (assuming you are using
# django.contrib.auth) you may enable sending PII data.
send_default_pii=True)
class Local(Common):
DEBUG = values.BooleanValue(True)
WEBPACK_DEBUG = values.BooleanValue(False)
INTERNAL_IPS = (
'*',
'127.0.0.1',
)
SECRET_KEY = os.environ.get(
"SECRET_KEY",
get_random_string(
50, ("abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)")))
INSTALLED_APPS = Common.INSTALLED_APPS
INSTALLED_APPS += ('debug_toolbar', )
MIDDLEWARE_CLASSES = Common.MIDDLEWARE_CLASSES
MIDDLEWARE_CLASSES += ('debug_toolbar.middleware.DebugToolbarMiddleware', )
class Base(ConstantSettings):
"""
These settings will likely need to be customized to an environment.
"""
ALLOWED_HOSTS = values.ListValue(['*'])
DEBUG = values.BooleanValue(False)
DATABASES = values.DatabaseURLValue('sqlite:///db.sqlite')
SECRET_KEY = values.SecretValue()
TIME_ZONE = values.Value('UTC')
LANGUAGE_CODE = values.Value('en-us')
STATIC_URL = values.Value('/static/')
STATIC_ROOT = values.Value(path('static'))
STATICFILES_STORAGE = 'pipeline.storage.PipelineCachedStorage'
class Heroku(Production):
ALLOWED_HOSTS = ['*']
SECRET_KEY = values.SecretValue()
CELERY_ALWAYS_EAGER = values.BooleanValue(True)
BROKER_URL = values.Value('amqp://')
@property
def LOGGING(self):
logging = super(Heroku, self).LOGGING
logging['handlers']['console']['stream'] = sys.stdout
logging['loggers']['django.request']['handlers'] = ['console']
return logging
class Staging(Common):
"""
The in-staging settings.
"""
ALLOWED_HOSTS = [
'staging.smartz.io', 'stage.smartz.io', '.stage.smartz.io'
]
# Security
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31536000)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value(None)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(
('HTTP_X_FORWARDED_PROTO', 'https'))
SMARTZ_SHOW_SWAGGER_SCHEMA = True
class ProductionReadOnly(Production):
"""
Settings for a production environment that is read-only. This is
used on public-facing webheads.
"""
EXTRA_MIDDLEWARE = [
# No need for sessions, so removing those middlewares helps us go fast
]
ADMIN_ENABLED = values.BooleanValue(False)
SILENCED_SYSTEM_CHECKS = values.ListValue([
'security.W003', # CSRF middleware check
'security.W017', # Check CSRF cookie http only
])
class Localdev(Base):
"""Configuration to be used during local development and base class
for testing"""
DOTENV = os.path.join(BASE_DIR, '.env')
DEBUG = values.BooleanValue(default=True)
LOGGING_USE_JSON = values.BooleanValue(False)
@property
def VERSION(self):
import subprocess
output = subprocess.check_output(
# Use the absolute path of 'git' here to avoid 'git'
# not being the git we expect in Docker.
['/usr/bin/git', 'describe', '--tags', '--always',
'--abbrev=0']) # nosec
if output:
return {'version': output.decode().strip()}
else:
return {}
class Development(InsecureAuthentication, Base):
"""Settings for local development."""
DOTENV_EXISTS = os.path.exists(os.path.join(Core.BASE_DIR, ".env"))
DOTENV = ".env" if DOTENV_EXISTS else None
SECRET_KEY = values.Value("not a secret")
DEBUG = values.BooleanValue(True)
AUTH_PASSWORD_VALIDATORS = values.ListValue([])
INSTALLED_APPS = Base.INSTALLED_APPS + ["django_extensions"]
EMAIL_BACKEND = values.Value(
"django.core.mail.backends.console.EmailBackend")
SECURE_SSL_REDIRECT = values.Value(False)
REQUIRE_RECIPE_AUTH = values.BooleanValue(False)
PEER_APPROVAL_ENFORCED = values.BooleanValue(False)
CSP_REPORT_URI = values.Value("")
DEFAULT_FILE_STORAGE = values.Value(
"django.core.files.storage.FileSystemStorage")
API_CACHE_ENABLED = values.BooleanValue(False)
API_CACHE_TIME = values.IntegerValue(0)
SILENCED_SYSTEM_CHECKS = values.ListValue(["normandy.recipes.E006"
]) # geoip db not available
METRICS_USE_DEBUG_LOGS = values.Value(True)
def LOGGING(self):
config = super().LOGGING()
config["loggers"]["werkzeug"] = {
"handlers": ["console"],
"level": "DEBUG",
"propagate": False,
}
config["loggers"]["markus"] = {
"handlers": ["console"],
"level": "INFO",
"propagate": False,
}
return config
class DebugMixin:
DEBUG = values.Value(True)
ADMIN_ENABLED = values.BooleanValue(True)
INTERNAL_IPS = values.IPValue('127.0.0.1')
@classmethod
def pre_setup(cls):
super(DebugMixin, cls).pre_setup()
logging.info('\n{} loading!'.format(cls.__str__))
@classmethod
def post_setup(cls):
super(DebugMixin, cls).post_setup()
logging.info('\t\t--> Finished!'.format(cls.__str__))
class Dev(Base):
API = values.BooleanValue(True, environ_prefix='RICHARD')
DEBUG = True
SECRET_KEY = 'richard-testing'
INSTALLED_APPS = tuple(list(Base.INSTALLED_APPS) + ['eadred'])
AUTHENTICATION_BACKENDS = (
'richard.base.auth.AutoLoginBackend', # DON'T use this in Production!
'django_browserid.auth.BrowserIDBackend',
)
BROWSERID_AUTOLOGIN = ''
class ProductionInsecure(Production):
"""
Settings for a production-like environment that lacks many security features.
Useful for testing and setups where security is provided by other means.
Not intended for general use on the public internet.
"""
INSTALLED_APPS = Production.INSTALLED_APPS + ['sslserver']
SECRET_KEY = values.Value('not a secret')
ALLOWED_HOSTS = values.ListValue(['*'])
SECURE_SSL_REDIRECT = values.BooleanValue(False)
CSRF_COOKIE_SECURE = values.BooleanValue(False)
SECURE_HSTS_SECONDS = values.IntegerValue(0)
SESSION_COOKIE_SECURE = values.BooleanValue(False)
# These checks aren't useful for a purposefully insecure environment
SILENCED_SYSTEM_CHECKS = values.ListValue([
'security.W004', # check hsts seconds
'security.W008', # Secure SSL redirect
'security.W009', # Secret key length
'security.W012', # Check session cookie secure
'security.W016', # Check CSRF cookie secure
])
class SSL(object):
"""Default settings for SSL-enabled servers.
Please read Django's SSL/HTTPS documentation and modify this configuration
as needed. Be advised that the default settings will not work with all web
servers.
"""
CSRF_COOKIE_SECURE = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(3600)
SECURE_PROXY_SSL_HEADER = values.TupleValue(None)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value('www.example.com')
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SESSION_COOKIE_SECURE = values.BooleanValue(True)
class Development(Common):
DEBUG = values.BooleanValue(True)
TEMPLATE_DEBUG = DEBUG
# INSTALLED_APPS
INSTALLED_APPS = Common.INSTALLED_APPS
# END INSTALLED_APPS
# DATABASE CONFIGURATION
# See: https://docs.djangoproject.com/en/dev/ref/settings/#databases
# DATABASES = values.DatabaseURLValue('postgres://animate_web@localhost/animate_web')
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
#'NAME': normpath(join(DJANGO_ROOT,'hotelnow')), # for sqllite
'NAME': 'animate',
'USER': '******',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}
# END DATABASE CONFIGURATION
# Mail settings
EMAIL_HOST = "localhost"
EMAIL_PORT = 1025
EMAIL_BACKEND = values.Value('django.core.mail.backends.console.EmailBackend')
# End mail settings
# django-debug-toolbar
MIDDLEWARE_CLASSES = Common.MIDDLEWARE_CLASSES + ('debug_toolbar.middleware.DebugToolbarMiddleware',)
INSTALLED_APPS += ('debug_toolbar',)
INTERNAL_IPS = ('127.0.0.1',)
DEBUG_TOOLBAR_CONFIG = {
'DISABLE_PANELS': ['debug_toolbar.panels.redirects.RedirectsPanel', ],
'SHOW_TEMPLATE_CONTEXT': True,
}
# end django-debug-toolbar
# CACHES
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': ''
}
}
class Development(Common):
"""
The in-development settings and the default configuration.
"""
DEBUG = True
TEMPLATE_DEBUG = True
ALLOWED_HOSTS = []
INSTALLED_APPS = Common.INSTALLED_APPS + ('debug_toolbar', )
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
DEBUG_TOOLBAR_PATCH_SETTINGS = values.BooleanValue(True)
class Staging(Common):
"""
The in-staging settings.
"""
# Security
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31536000)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value(None)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(
('HTTP_X_FORWARDED_PROTO', 'https'))
WEBPACK_LOADER = {
'DEFAULT': {
'BUNDLE_DIR_NAME': 'bundles/',
'STATS_FILE': os.path.join(BASE_DIR, 'webpack-stats.prod.json'),
}
}
class Production(Staging):
"""
The in-production settings.
"""
DEBUG_TOOLBAR = values.BooleanValue(False)
MIDDLEWARE = Common.MIDDLEWARE
ALLOWED_HOSTS = [
'forsa-production.herokuapp.com', 'forsa.om', 'www.forsa.om'
]
GOOGLE_ANALYTICS_KEY = 'UA-145916646-1'
GTM_KEY = 'GTM-M7NRK2P'
class Development(Base):
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'nelly',
'USER': '******',
}
}
DEBUG = values.BooleanValue(True)
STATIC_ROOT = os.path.join(BASE_DIR, 'nellyshulman/static')
STATIC_URL = '/static/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'nellyshulman/media')
MEDIA_URL = '/media/'
class Production(Base):
THUMBNAIL_DEFAULT_STORAGE = '%s.s3.Media' % project
DEBUG = values.BooleanValue(False)
ALLOWED_HOSTS = ['*']
DATABASES['default'] = dj_database_url.config(conn_max_age=600)
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_STORAGE_BUCKET_NAME = os.getenv('AWS_STORAGE_BUCKET_NAME')
AWS_AUTO_CREATE_BUCKET = values.BooleanValue(True)
AWS_QUERYSTRING_AUTH = False
COMPRESS_STORAGE = '%s.s3.Static' % project
DEFAULT_FILE_STORAGE = '%s.s3.Media' % project
STATICFILES_STORAGE = '%s.s3.CachedS3BotoStorage' % project
MEDIA_S3 = 'media'
STATIC_S3 = 'static'
MEDIA_ROOT = '/%s/' % MEDIA_S3
STATIC_ROOT = '/%s/' % STATIC_S3
MEDIA_URL = 'https://%s.s3.amazonaws.com/%s/' % (AWS_STORAGE_BUCKET_NAME, MEDIA_S3)
STATIC_URL = "https://%s.s3.amazonaws.com/%s/" % (AWS_STORAGE_BUCKET_NAME, STATIC_S3)
COMPRESS_URL = STATIC_URL
