Config

Complexity

Total Complexity

20

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	16	3
A	has_option()	0	2	1
A	get_bool()	0	3	1
F	get()	0	30	15

import os
from configparser import SafeConfigParser

from django.core.exceptions import ImproperlyConfigured

script_dir = os.path.dirname(__file__)
VERSION = open(os.path.join(script_dir, 'VERSION')).read()

NOT_CONFIGURED_VALUE = '***not configured***'


class Config():
    '''
    Custom implementation of INI-file reading with ENV variable
    pverride.
    '''
    config_file = None
    config = None
    is_production = None

    def __init__(self, config_files):
        '''
        Creates a new config object.

        Parameters:
        config_files: Dictionary with file_name: is_production setting
        '''
        for config_file, is_production in config_files:
            if os.path.isfile(config_file):
                self.config_file = config_file
                self.is_production = is_production
                self.config = SafeConfigParser()
                self.config.read([self.config_file], encoding='utf-8')
                return

        raise IOError("No configuration file found.")

    def has_option(self, name, category):
        return self.config.has_option(name, category)

    def get_bool(self, name, category):
        text = self.get(name, category)
        return text.lower() in ['true', 't', 'yes', 'active', 'enabled']

    def get(self, name, category, mandatory=False, expect_leading_slash=None, expect_trailing_slash=None):
        '''
        Get the value for the config variable.
        '''

        # Check environment variables for overrides, otherwise use INI file
        env_name = 'OPENSUBMIT_%s_%s'.format(category.upper(), name.upper())
        text = os.getenv(env_name)
        if text is None:
            text = self.config.get(name, category)
            logtext = "Setting '[%s] %s' in %s has the value '%s'" % (category, name, self.config_file, text)
        else:
            logtext = "Environment variable %s has the value '%s'" % (env_name, text)

        if mandatory and text == NOT_CONFIGURED_VALUE:
            raise ImproperlyConfigured(logtext + ', but must be set.')

        if len(text) == 0:
            if expect_leading_slash or expect_trailing_slash:
                raise ImproperlyConfigured(logtext + ", but should not be empty.")
        else:
            if not text[0] == '/' and expect_leading_slash is True:
                raise ImproperlyConfigured(logtext + ", but should have a leading slash.")
            if not text[-1] == '/' and expect_trailing_slash is True:
                raise ImproperlyConfigured(logtext + ", but should have a trailing slash.")
            if text[0] == '/' and expect_leading_slash is False:
                raise ImproperlyConfigured(logtext + ", but shouldn't have a leading slash.")
            if text[-1] == '/' and expect_trailing_slash is False:
                raise ImproperlyConfigured(logtext + ", but shouldn't have a trailing slash.")
        return text


# Precedence rules are as follows:
# - Developer configuration overrides production configuration on developer machine.
# - Linux production system are more likely to happen than Windows developer machines.
config = Config((
    ('/etc/opensubmit/settings.ini', True),  # Linux production system
    (os.path.dirname(__file__) + '/settings_dev.ini', False),  # Linux / Mac development system
    (os.path.expandvars('$APPDATA') + 'opensubmit/settings.ini', False),  # Windows development system
    ))

################################################################################################################
################################################################################################################
################################################################################################################

# Global settings
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.' + config.get('database', 'DATABASE_ENGINE'),
        'NAME': config.get('database', 'DATABASE_NAME', True),
        'USER': config.get('database', 'DATABASE_USER'),
        'PASSWORD': config.get('database', 'DATABASE_PASSWORD'),
        'HOST': config.get('database', 'DATABASE_HOST'),
        'PORT': config.get('database', 'DATABASE_PORT'),
    }
}

# We have the is_production indicator from above, which could also determine this value.
# But sometimes, you need Django stack traces in your production system for debugging.
DEBUG = config.get_bool('general', 'DEBUG')

# Determine MAIN_URL / FORCE_SCRIPT option
HOST = config.get('server', 'HOST')
HOST_DIR = config.get('server', 'HOST_DIR')
if len(HOST_DIR) > 0:
    MAIN_URL = HOST + '/' + HOST_DIR
    FORCE_SCRIPT_NAME = '/' + HOST_DIR
else:
    MAIN_URL = HOST
    FORCE_SCRIPT_NAME = ''

# Determine some settings based on the MAIN_URL
LOGIN_URL = MAIN_URL
LOGIN_ERROR_URL = MAIN_URL
LOGIN_REDIRECT_URL = MAIN_URL + '/dashboard/'

# Local file system storage for uploads.
# Please note that MEDIA_URL is intentionally not set, since all media
# downloads have to use our download API URL for checking permissions.
MEDIA_ROOT = config.get('server', 'MEDIA_ROOT', True, True, True)

# Root of the installation
# This is normally detected automatically, so the settings.ini template does
# not contain the value. For the test suite, however, we need the override option.
if config.has_option('general', 'SCRIPT_ROOT'):
    SCRIPT_ROOT = config.get('general', 'SCRIPT_ROOT', True, True, False)
else:
    SCRIPT_ROOT = os.path.dirname(os.path.abspath(__file__))

if config.is_production:
    # Root folder for static files
    STATIC_ROOT = SCRIPT_ROOT + '/static-production/'
    STATICFILES_DIRS = (SCRIPT_ROOT + '/static/', )
    # Absolute URL for static files, directly served by Apache on production systems
    STATIC_URL = MAIN_URL + '/static/'
    EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
    ALLOWED_HOSTS = [MAIN_URL.split('/')[2]]
    if ':' in ALLOWED_HOSTS[0]:
        ALLOWED_HOSTS = [ALLOWED_HOSTS[0].split(':')[0]]
    SERVER_EMAIL = config.get('admin', 'ADMIN_EMAIL')
else:
    # Root folder for static files
    STATIC_ROOT = SCRIPT_ROOT + '/static/'
    # Relative URL for static files
    STATIC_URL = '/static/'
    EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
    ALLOWED_HOSTS = ['localhost', '127.0.0.1']

ADMINS = (
    (config.get('admin', 'ADMIN_NAME'), config.get('admin', 'ADMIN_EMAIL'), ),
)
MANAGERS = ADMINS
EMAIL_SUBJECT_PREFIX = '[OpenSubmit] '
TIME_ZONE = config.get("server", "TIME_ZONE")
LANGUAGE_CODE = 'en-en'
USE_I18N = True
USE_L10N = True
USE_TZ = False
STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
    'django.contrib.staticfiles.finders.FileSystemFinder',
)
SECRET_KEY = config.get("server", "SECRET_KEY")

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'OPTIONS': {'debug': DEBUG,
                    'context_processors':
                        ("django.contrib.auth.context_processors.auth",
                         "django.template.context_processors.debug",
                         "django.template.context_processors.i18n",
                         "django.template.context_processors.media",
                         "django.template.context_processors.static",
                         "django.template.context_processors.tz",
                         "django.contrib.messages.context_processors.messages",
                         "opensubmit.contextprocessors.footer",
                         "django.template.context_processors.request",
                         "social_django.context_processors.backends",
                         "social_django.context_processors.login_redirect")
                    },
        'APP_DIRS': True,
    },
]

TEST_RUNNER = 'opensubmit.tests.DiscoverRunner'

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.RemoteUserMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'social_django.middleware.SocialAuthExceptionMiddleware',
    'opensubmit.middleware.CourseRegister'
)
ROOT_URLCONF = 'opensubmit.urls'
WSGI_APPLICATION = 'opensubmit.wsgi.application'
INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'formtools',
    'social_django',
    'bootstrapform',
    'grappelli.dashboard',
    'grappelli',
    'django.contrib.admin',
#    'django.contrib.admin.apps.SimpleAdminConfig',
    'opensubmit.app.OpenSubmitConfig',
)

LOG_FILE = config.get('server', 'LOG_FILE')

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue'
        },
    },
    'formatters': {
        'verbose': {
            'format': "[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s"
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        },
        'console': {
            'level': 'DEBUG',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler'
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'formatter': 'verbose',
            'filename': LOG_FILE
        }
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins', 'file'],
            'level': 'ERROR',
            'propagate': True,
        },
        'OpenSubmit': {
            'handlers': ['console', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'social': {
            'handlers': ['console', 'file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    }
}

LOGIN_GOOGLE = config.get_bool('login', 'LOGIN_GOOGLE')
LOGIN_OPENID = config.get_bool('login', 'LOGIN_OPENID')
LOGIN_GITHUB = config.get_bool('login', 'LOGIN_GITHUB')
LOGIN_TWITTER = config.get_bool('login', 'LOGIN_TWITTER')
LOGIN_SHIB = config.get_bool('login', 'LOGIN_SHIB')

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

if LOGIN_GOOGLE:
    AUTHENTICATION_BACKENDS += ('social_core.backends.google.GoogleOAuth2',)
    SOCIAL_AUTH_GOOGLE_OAUTH2_KEY = config.get("login", "LOGIN_GOOGLE_OAUTH_KEY")
    SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET = config.get("login", "LOGIN_GOOGLE_OAUTH_SECRET")

if LOGIN_TWITTER:
    AUTHENTICATION_BACKENDS += ('social_core.backends.twitter.TwitterOAuth',)
    SOCIAL_AUTH_TWITTER_KEY = config.get("login", "LOGIN_TWITTER_OAUTH_KEY")
    SOCIAL_AUTH_TWITTER_SECRET = config.get("login", "LOGIN_TWITTER_OAUTH_SECRET")

if LOGIN_GITHUB:
    AUTHENTICATION_BACKENDS += ('social_core.backends.github.GithubOAuth2',)
    SOCIAL_AUTH_GITHUB_KEY = config.get("login", "LOGIN_GITHUB_OAUTH_KEY")
    SOCIAL_AUTH_GITHUB_SECRET = config.get("login", "LOGIN_GITHUB_OAUTH_SECRET")

if LOGIN_OPENID:
    AUTHENTICATION_BACKENDS += ('opensubmit.social.open_id.OpenIdAuth',)
    LOGIN_DESCRIPTION = config.get('login', 'LOGIN_DESCRIPTION')
    OPENID_PROVIDER = config.get('login', 'OPENID_PROVIDER')

if LOGIN_SHIB:
    AUTHENTICATION_BACKENDS += ('opensubmit.social.apache.ModShibAuth',)
    LOGIN_SHIB_DESCRIPTION = config.get('login', 'LOGIN_SHIB_DESCRIPTION')

AUTHENTICATION_BACKENDS += ('opensubmit.social.lti.LtiAuth',)

SOCIAL_AUTH_URL_NAMESPACE = 'social'
SOCIAL_AUTH_FIELDS_STORED_IN_SESSION = ['next', ]
SOCIAL_AUTH_PIPELINE = (
    'social_core.pipeline.social_auth.social_details',
    'social_core.pipeline.social_auth.social_uid',
    'social_core.pipeline.social_auth.auth_allowed',
    'social_core.pipeline.social_auth.social_user',
    'social_core.pipeline.user.get_username',
    'social_core.pipeline.social_auth.associate_by_email',  # Transition for existing users
    'social_core.pipeline.user.create_user',
    'social_core.pipeline.social_auth.associate_user',
    'social_core.pipeline.social_auth.load_extra_data',
    'social_core.pipeline.user.user_details'
)

JOB_EXECUTOR_SECRET = config.get("executor", "SHARED_SECRET")
assert(JOB_EXECUTOR_SECRET is not "")

GRAPPELLI_ADMIN_TITLE = "OpenSubmit"
GRAPPELLI_SWITCH_USER = True
GRAPPELLI_INDEX_DASHBOARD = {
    'opensubmit.admin.teacher_backend': 'opensubmit.dashboard.TeacherDashboard'
}