base.py

# *-* encoding: utf-8 *-*
"""Common settings and globals."""
from __future__ import unicode_literals
from os.path import abspath, basename, dirname, join, normpath
from sys import path, modules
from django.core.exceptions import ImproperlyConfigured


# ========== PATH CONFIGURATION
#
# Absolute filesystem path to the Django project directory:
DJANGO_ROOT = dirname(dirname(abspath(__file__)))

# Absolute filesystem path to the top-level project folder:
SITE_ROOT = dirname(DJANGO_ROOT)

# Site name:
SITE_NAME = basename(DJANGO_ROOT)

# Add our project to our pythonpath, this way we don't need to type our project
# name in our dotted import paths:
path.append(DJANGO_ROOT)
# ---------- END PATH CONFIGURATION


# ========== LOAD SECRETS
try:
    from .components.private import *
except ImportError:
    raise ImproperlyConfigured("Unable to load private configuration. "
                               "Please add a SECRET_KEY in {}/settings/components/private.py".format(SITE_NAME))


# ========== DJANGO GENERAL CONFIGURATIONS
#
# ..... MANAGEMENT
DEBUG = False
ALLOWED_HOSTS = []
ADMINS = (
    ("Julien Furrer", 'julien.furrer@unil.ch'),
)
MANAGERS = ADMINS

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}


# ..... TEMPLATES CONFIG
TEMPLATES = [{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': (normpath(join(SITE_ROOT, 'templates')), ),
    'OPTIONS': {
        'debug': False,
        'loaders': (
            'django.template.loaders.filesystem.Loader',
            'django.template.loaders.app_directories.Loader'
        ),
        'context_processors': [
            'django.contrib.auth.context_processors.auth',
            'django.core.context_processors.debug',
            'django.core.context_processors.i18n',
            'django.core.context_processors.media',
            'django.core.context_processors.static',
            'django.core.context_processors.request',
            'django.core.context_processors.tz',
            'django.contrib.messages.context_processors.messages',
            'adim_utils.context_processors.default',
        ],
        'string_if_invalid': "",
    }
}]

# backward compatibility
TEMPLATE_DIRS = TEMPLATES[0]['DIRS']
TEMPLATE_CONTEXT_PROCESSORS = TEMPLATES[0]['OPTIONS']['context_processors']
TEMPLATE_DEBUG = TEMPLATES[0]['OPTIONS']['debug']
TEMPLATE_LOADERS = TEMPLATES[0]['OPTIONS']['loaders']
TEMPLATE_STRING_IF_INVALID = TEMPLATES[0]['OPTIONS']['string_if_invalid']


# ..... MEDIA AND STATICS PATHS
MEDIA_ROOT = normpath(join(SITE_ROOT, 'media'))
STATIC_ROOT = normpath(join(SITE_ROOT, 'static'))


# ..... Localization
LANGUAGE_CODE = 'fr-ch'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
SITE_ID = 1


# ..... Application
ROOT_URLCONF = '%s.urls' % SITE_NAME
WSGI_APPLICATION = '%s.wsgi.application' % SITE_NAME

# ---------- END DJANGO GENERAL CONFIGURATION


# ========== URL CONFIGURATION
#
def update_urls(base_url=None, name=__name__):
    this_module = modules[name]
    if base_url is None:
        base_url = getattr(this_module, 'BASE_URL', "/")
    setattr(this_module, 'BASE_URL', base_url)
    setattr(this_module, 'SESSION_COOKIE_PATH', base_url)
    setattr(this_module, 'CSRF_COOKIE_PATH', base_url)
    setattr(this_module, 'MEDIA_URL', '{}media/'.format(base_url))
    setattr(this_module, 'STATIC_URL', '{}static/'.format(base_url))
    setattr(this_module, 'CORS_URLS_REGEX', r'^{}api/.*$'.format(base_url))

update_urls("/")
# ---------- END URL CONFIGURATION


# ========== AUTHENTICATION
#
AUTHENTICATION_BACKENDS = (
    'django.contrib.auth.backends.ModelBackend',
)

LOGIN_REDIRECT_URL = "adim.app:annotate-new"
LOGIN_URL = "adim.app:home"

SESSION_EXPIRE_AT_BROWSER_CLOSE = True
SESSION_COOKIE_NAME = "adim_sessid"

# ---------- END AUTHENTICATION


# ========== LOCAL APPS CONFIGURATION
#
LOCAL_APPS = ('django_extensions',)

# ..... MISC
SENDFILE_BACKEND = 'sendfile.backends.xsendfile'


# ..... REST FRAMEWORK
LOCAL_APPS += ('rest_framework', 'rest_framework.authtoken')
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
        'adim_ttp.authentication.TTPAuthentication',
    ),
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated'
    ]
}


# ..... CORS HEADERS (https://github.com/ottoyiu/django-cors-headers/)
LOCAL_APPS += ('corsheaders',)
MIDDLEWARE_CLASSES = list(MIDDLEWARE_CLASSES)
MIDDLEWARE_CLASSES.insert(
    MIDDLEWARE_CLASSES.index('django.middleware.common.CommonMiddleware'),
    'corsheaders.middleware.CorsMiddleware'
)
MIDDLEWARE_CLASSES += ('corsheaders.middleware.CorsMiddleware', )
CORS_ORIGIN_ALLOW_ALL = True
# CORS_URLS_REGEX = r'^.*/api/.*$'


# ..... ADIM
LOCAL_APPS += ('adim', 'adim_app', 'adim_ttp')
# Max file size in Mb
ADIM_UPLOAD_MAX_FILESIZE = 50

# Size of the Thumbnail
ADIM_THUMB_SIZE = (150, 150)

# When in PROD, DEBUG_JS if False and uses prod ready css too
ADIM_PROD = True

# If True load the non-minified version of adim js
ADIM_DEBUG_JS = False

# If the number of suggested adim-user is less than this value,
# the ldap will be queried too
ADIM_SUGGESTION = {
    'LIMIT': 7,
    'LDAP': {
        'URL': "ldap://ldap.unil.ch:389",
        'BASE': "o=universite de lausanne, c=ch",
        'TIMEOUT': 3
    }
}

ADIM_ENV = {
    'cimaf': {},
    'anodate': {
        'categories': {
            'default': [{
                'id': 'cat_1',
                'label': "Marqueur contextuel",
                'color': "#54848E"
            }, {
                'id': 'cat_3',
                'label': "Marqueur numérique",
                'color': "#6D557F"
            }, {
                'id': 'cat_7',
                'label': "Changement",
                'color': "#FF8B00"
            }, {
                'id': 'cat_4',
                'label': "Cycle",
                'color': "#D80918"
            }, {
                'id': 'cat_5',
                'label': "Chronologie",
                'color': "#71B800"
            }, {
                'id': 'cat_2',
                'label': "Sans catégorie",
                'color': "#D2D29F"
            # }, {
            #     'id': 'cat_6',
            #     'label': "Cycle",
            #     'color': "#EFC300"
            # }, {
            #     'id': 'cat_8',
            #     'label': "Contexte",
            #     'color': "#25BFD1"
            }]
        },
    },
    'geomo': {
        'categories': {
            'default': [{
                'id': 'cat_geo_1',
                'label': "Structural",
                'color': "#E1192E",
                'colorbg': "#ff7676"
            }, {
                'id': 'cat_geo_2',
                'label': "Hydrographie",
                'color': "#009CC4",
                'colorbg': "#87D2E7"
            }, {
                'id': 'cat_geo_3',
                'label': "Gravitaire",
                'color': "#DD9940",
                'colorbg': "#F0CA8F"
            }, {
                'id': 'cat_geo_4',
                'label': "Fluviatile",
                'color': "#00824B",
                'colorbg': "#58A57E"
            }, {
                'id': 'cat_geo_5',
                'label': "Glaciaire",
                'color': "#4B286A",
                'colorbg': "#A597B5"
            }, {
                'id': 'cat_geo_6',
                'label': "Périglaciaire",
                'color': "#BA106E",
                'colorbg': "#D988A9"
            }, {
                'id': 'cat_geo_7',
                'label': "Nival",
                'color': "#B01B21",
                'colorbg': "#C47D76"
            }, {
                'id': 'cat_geo_8',
                'label': "Karstique",
                'color': "#09A092",
                'colorbg': "#56BEB2"
            }, {
                'id': 'cat_geo_9',
                'label': "Organogène",
                'color': "#d1d17f",
                'colorbg': "#EBEBC7"
            }, {
                'id': 'cat_geo_10',
                'label': "Anthropique",
                'color': "#8A8B8A",
                'colorbg': "#BFC0BF"
            }, {
                'id': 'cat_geo_0',
                'label': "Sans catégorie",
                'color': "#c6c6c6",
                'colorbg': "#ededed"
            }]
        }
    }
}

AAI = {
    'SLO': True,
    # Not yet used
    'URLS': {
        'SP_LOGOUT': "https://jabba.unil.ch/Shibboleth.sso/Logout",
        'idp_LOGOUT': "https://aai.unil.ch/idp/logout.jsp"
    }
}


# ATTP = {
#     'OPTIONS': {
#         'CACHE_TIMEOUT': <the time in sec the ttp authorization result is kept in cache>
#     },
#     '<ttp_service_id>': {
#         'CHECK_URL' : <the url for authorization on the ttp>
#         'MODE_ID': <the sharing_mode value for that ttp. this should be a unique int > 15
#     }
# }
#
# CAUTION: when adding a ttp service, update the template (templates/adim/aom-modal.inc.html) with MODE_ID where needed
#
ATTP = {
    'OPTIONS': {
        'CACHE_TIMEOUT': 20,  # 30,
    },
    'moodle': {
        'CHECK_URL': "http://moodle2.unil.ch/mod/adim/checkAccess.php?uuid={uuid}",
        'MODE_ID': 16
    },
    'toto': {
        'CHECK_URL': "http://localhost/tests/phpupload/toto.php?a={uuid}",
        'MODE_ID': 24
    },
    'my_ttp': {
        'CHECK_URL': "http://my-ttp:8001/ttp/check/{uuid}/",
        'MODE_ID': 32
    }
}


# ..... SHIBAUTH
LOCAL_APPS += ('shibauth', )
AUTHENTICATION_BACKENDS = ('shibauth.shibbolethbackends.ShibbolethBackend',) + AUTHENTICATION_BACKENDS

try:
    from .components.shibbauth import *
except ImportError:
    raise ImproperlyConfigured("Unable to import SHIBAUTH configurations")

# ---------- END LOCAL APPS CONFIGURATION


# ========== APPS CONFIGURATION
#
DJANGO_APPS = (
    'django.contrib.sites',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
)
INSTALLED_APPS = DJANGO_APPS + LOCAL_APPS
# ---------- END APPS CONFIGURATION

SERVER_EMAIL = 'julien.furrer@unil.ch'
EMAIL_HOST = "smtp.unil.ch"


# ========== LOGGING CONFIGURATION
#
def add_remote_info(record):
    """
    Pour utiliser, utilisez le logger comme:
        logger.debug("Coucou", extra={'request': request})

    :param record:
    :return:
    """
    req = getattr(record, 'request', None)
    record.remote_addr = req.META.get('REMOTE_ADDR', '-') if req else '-'
    record.forwarded_for = req.META.get('HTTP_X_FORWARDED_FOR', '-') if req else '-'
    return True


LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue'
        },
        'add_remote_info': {
            '()': 'django.utils.log.CallbackFilter',
            'callback': add_remote_info,
        },
        'save_emails_to_disk': {
            '()': 'django.utils.log.CallbackFilter',
            'callback': lambda x: False,
        }

    },
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(name)s.%(funcName)s:%(lineno)d %(message)s',
        },
        'verbose_with_remote': {
            'format': '%(levelname)s %(asctime)s %(name)s.%(funcName)s:%(lineno)d %(remote_addr)s %(forwarded_for)s %(message)s',
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'include_html': False,
            'class': 'django.utils.log.AdminEmailHandler'
        },
        'mail_admins_file': {
            'level': 'ERROR',
            'filters': ['require_debug_false', 'save_emails_to_disk'],
            'include_html': False,
            'class': 'django.utils.log.AdminEmailHandler',
            'email_backend': 'django.core.mail.backends.filebased.EmailBackend'
        },
        'console': {
            'filters': ['require_debug_true', ],
            'class': 'logging.StreamHandler',
        },
        'file_debug': {
            'level': 'DEBUG',
            # 'class': 'logging.FileHandler',
            'class': 'logging.handlers.WatchedFileHandler',
            'filters': ['add_remote_info', ],
            'formatter': 'verbose_with_remote',
            'filename': '{}/log/debug.log'.format(dirname(SITE_ROOT)),
        },
        'file': {
            'level': 'INFO',
            # 'class': 'logging.FileHandler',
            'class': 'logging.handlers.WatchedFileHandler',
            'filters': ['add_remote_info', ],
            'formatter': 'verbose',
            'filename': '{}/log/error.log'.format(dirname(SITE_ROOT)),
        },
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins', 'mail_admins_file', 'file_debug', 'file' ],
            'level': 'WARNING',
            'propagate': True,
        },
        'adim.permissions': {
            'handlers': ['console'],
            'level': 'DEBUG',  # 'NOTSET',
            'propagate': True,
        },
        'adim_app': {
            'handlers': ['console', 'file_debug', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'adim_ttp': {
            'handlers': ['console', 'file_debug', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'shibauth': {
            'handlers': ['console', 'file_debug', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    }
}
########## END LOGGING CONFIGURATION