# -*- encoding: utf-8 -*- 
# ============LICENSE_START======================================================= 
# org.onap.vvp/engagementmgr
# ===================================================================
# Copyright © 2017 AT&T Intellectual Property. All rights reserved.
# ===================================================================
#
# Unless otherwise specified, all software contained herein is licensed
# under the Apache License, Version 2.0 (the “License”);
# you may not use this software except in compliance with the License.
# You may obtain a copy of the License at
#
#             http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
#
# Unless otherwise specified, all documentation contained herein is licensed
# under the Creative Commons License, Attribution 4.0 Intl. (the “License”);
# you may not use this documentation except in compliance with the License.
# You may obtain a copy of the License at
#
#             https://creativecommons.org/licenses/by/4.0/
#
# Unless required by applicable law or agreed to in writing, documentation
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# ============LICENSE_END============================================
#
# ECOMP is a trademark and service mark of AT&T Intellectual Property.
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: cms-settings
  namespace: default
data:
  gunicorn.ini: |
    bind = ":80"
    chdir = '/srv'
    pidfile = '/tmp/ice-project-master.pid'
    backlog = '5000'
    errorlog = '-'
    loglevel = 'info'
  __init__.py: |
    from __future__ import absolute_import, unicode_literals
    import os
    from cms.envbool import envbool

    from django import VERSION as DJANGO_VERSION
    from django.utils.translation import ugettext_lazy as _
    from boto.s3.connection import OrdinaryCallingFormat


    ######################
    # MEZZANINE SETTINGS #
    ######################

    # The following settings are already defined with default values in
    # the ``defaults.py`` module within each of Mezzanine's apps, but are
    # common enough to be put here, commented out, for conveniently
    # overriding. Please consult the settings documentation for a full list
    # of settings Mezzanine implements:
    # http://mezzanine.jupo.org/docs/configuration.html#default-settings

    # Controls the ordering and grouping of the admin menu.
    #
    # ADMIN_MENU_ORDER = (
    #     ("Content", ("pages.Page", "blog.BlogPost",
    #        "generic.ThreadedComment", (_("Media Library"), "media-library"),)),
    #     ("Site", ("sites.Site", "redirects.Redirect", "conf.Setting")),
    #     ("Users", ("auth.User", "auth.Group",)),
    # )

    # A three item sequence, each containing a sequence of template tags
    # used to render the admin dashboard.
    #
    # DASHBOARD_TAGS = (
    #     ("blog_tags.quick_blog", "mezzanine_tags.app_list"),
    #     ("comment_tags.recent_comments",),
    #     ("mezzanine_tags.recent_actions",),
    # )

    # A sequence of templates used by the ``page_menu`` template tag. Each
    # item in the sequence is a three item sequence, containing a unique ID
    # for the template, a label for the template, and the template path.
    # These templates are then available for selection when editing which
    # menus a page should appear in. Note that if a menu template is used
    # that doesn't appear in this setting, all pages will appear in it.

    # PAGE_MENU_TEMPLATES = (
    #     (1, _("Top navigation bar"), "pages/menus/dropdown.html"),
    #     (2, _("Left-hand tree"), "pages/menus/tree.html"),
    #     (3, _("Footer"), "pages/menus/footer.html"),
    # )

    # A sequence of fields that will be injected into Mezzanine's (or any
    # library's) models. Each item in the sequence is a four item sequence.
    # The first two items are the dotted path to the model and its field
    # name to be added, and the dotted path to the field class to use for
    # the field. The third and fourth items are a sequence of positional
    # args and a dictionary of keyword args, to use when creating the
    # field instance. When specifying the field class, the path
    # ``django.models.db.`` can be omitted for regular Django model fields.
    #
    # EXTRA_MODEL_FIELDS = (
    #     (
    #         # Dotted path to field.
    #         "mezzanine.blog.models.BlogPost.image",
    #         # Dotted path to field class.
    #         "somelib.fields.ImageField",
    #         # Positional args for field class.
    #         (_("Image"),),
    #         # Keyword args for field class.
    #         {"blank": True, "upload_to": "blog"},
    #     ),
    #     # Example of adding a field to *all* of Mezzanine's content types:
    #     (
    #         "mezzanine.pages.models.Page.another_field",
    #         "IntegerField", # 'django.db.models.' is implied if path is omitted.
    #         (_("Another name"),),
    #         {"blank": True, "default": 1},
    #     ),
    # )

    # Setting to turn on featured images for blog posts. Defaults to False.
    #
    # BLOG_USE_FEATURED_IMAGE = True

    # If True, the django-modeltranslation will be added to the
    # INSTALLED_APPS setting.
    USE_MODELTRANSLATION = False


    ########################
    # MAIN DJANGO SETTINGS #
    ########################

    # Hosts/domain names that are valid for this site; required if DEBUG is False
    # See https://docs.djangoproject.com/en/dev/ref/settings/#allowed-hosts
    ALLOWED_HOSTS = ['*']

    # Set UTC time zone:
    TIME_ZONE = 'UTC'
    USE_TZ = True

    # Local time zone for this installation. Choices can be found here:
    # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
    # although not all choices may be available on all operating systems.
    # On Unix systems, a value of None will cause Django to use the same
    # timezone as the operating system.
    # If running in a Windows environment this must be set to the same as your
    # system time zone.
    TIME_ZONE = 'UTC'

    # If you set this to True, Django will use timezone-aware datetimes.
    USE_TZ = True

    # Language code for this installation. All choices can be found here:
    # http://www.i18nguy.com/unicode/language-identifiers.html
    LANGUAGE_CODE = "en"

    # Supported languages
    LANGUAGES = (
        ('en', _('English')),
    )

    ENVIRONMENT = os.environ['ENVIRONMENT']

    # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/
    SECRET_KEY = os.environ["SECRET_KEY"]

    # A boolean that turns on/off debug mode. When set to ``True``, stack traces
    # are displayed for error pages. Should always be set to ``False`` in
    # production. Best set to ``True`` in local_settings.py
    DEBUG = envbool('DJANGO_DEBUG_MODE', False)

    # Note: Only SSL email backends are allowed
    EMAIL_USE_SSL = True

    # Whether a user's session cookie expires when the Web browser is closed.
    SESSION_EXPIRE_AT_BROWSER_CLOSE = True

    SITE_ID = 1

    # If you set this to False, Django will make some optimizations so as not
    # to load the internationalization machinery.
    USE_I18N = False

    AUTHENTICATION_BACKENDS = ("mezzanine.core.auth_backends.MezzanineBackend",)

    # The numeric mode to set newly-uploaded files to. The value should be
    # a mode you'd pass directly to os.chmod.
    FILE_UPLOAD_PERMISSIONS = 0o644


    #############
    # DATABASES #
    #############

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql',
            'NAME': os.environ['PGDATABASE'],
            'USER': os.environ['PGUSER'],
            'PASSWORD': os.environ['PGPASSWORD'],
            'HOST': os.environ['PGHOST'],
            'PORT': os.environ['PGPORT'],
        }
    }


    #########
    # PATHS #
    #########

    # Full filesystem path to the project.
    PROJECT_APP_PATH = os.path.dirname(os.path.abspath(__file__))
    PROJECT_APP = os.path.basename(PROJECT_APP_PATH)
    PROJECT_ROOT = BASE_DIR = os.path.dirname(PROJECT_APP_PATH)

    # Every cache key will get prefixed with this value - here we set it to
    # the name of the directory the project is in to try and use something
    # project specific.
    CACHE_MIDDLEWARE_KEY_PREFIX = PROJECT_APP

    # Package/module name to import the root urlpatterns from for the project.
    ROOT_URLCONF = 'cms.urls' 

    TEMPLATES = [
        {
            "BACKEND": "django.template.backends.django.DjangoTemplates",
            "DIRS": [
                os.path.join(PROJECT_ROOT, "templates")
            ],
            "APP_DIRS": True,
            "OPTIONS": {
                "context_processors": [
                    "django.contrib.auth.context_processors.auth",
                    "django.contrib.messages.context_processors.messages",
                    "django.template.context_processors.debug",
                    "django.template.context_processors.i18n",
                    "django.template.context_processors.static",
                    "django.template.context_processors.media",
                    "django.template.context_processors.request",
                    "django.template.context_processors.tz",
                    "mezzanine.conf.context_processors.settings",
                    "mezzanine.pages.context_processors.page",
                ],
                "builtins": [
                    "mezzanine.template.loader_tags",
                ],
            },
        },
    ]

    if DJANGO_VERSION < (1, 9):
        del TEMPLATES[0]["OPTIONS"]["builtins"]


    ################
    # APPLICATIONS #
    ################

    INSTALLED_APPS = (
        "mezzanine_api",
        "rest_framework",
        "rest_framework_swagger",
        "oauth2_provider",
        "django.contrib.admin",
        "django.contrib.auth",
        "django.contrib.contenttypes",
        "django.contrib.redirects",
        "django.contrib.sessions",
        "django.contrib.sites",
        "django.contrib.sitemaps",
        "django.contrib.staticfiles",
        "mezzanine.boot",
        "mezzanine.conf",
        "mezzanine.core",
        "mezzanine.generic",
        "mezzanine.pages",
        "mezzanine.blog",
        "mezzanine.forms",
        "mezzanine.galleries",
        "mezzanine.twitter",
        # "mezzanine.accounts",
        # "mezzanine.mobile",
        "cms" ,
        "storages",
    )

    # List of middleware classes to use. Order is important; in the request phase,
    # these middleware classes will be applied in the order given, and in the
    # response phase the middleware will be applied in reverse order.
    MIDDLEWARE_CLASSES = (
        "mezzanine.core.middleware.UpdateCacheMiddleware",
        "mezzanine_api.middleware.ApiMiddleware",
        'django.contrib.sessions.middleware.SessionMiddleware',
        # Uncomment if using internationalisation or localisation
        # 'django.middleware.locale.LocaleMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',

        "mezzanine.core.request.CurrentRequestMiddleware",
        "mezzanine.core.middleware.RedirectFallbackMiddleware",
        "mezzanine.core.middleware.TemplateForDeviceMiddleware",
        "mezzanine.core.middleware.TemplateForHostMiddleware",
        "mezzanine.core.middleware.AdminLoginInterfaceSelectorMiddleware",
        "mezzanine.core.middleware.SitePermissionMiddleware",
        "mezzanine.pages.middleware.PageMiddleware",
        "mezzanine.core.middleware.FetchFromCacheMiddleware",
    )

    # Store these package names here as they may change in the future since
    # at the moment we are using custom forks of them.
    PACKAGE_NAME_FILEBROWSER = "filebrowser_safe"
    PACKAGE_NAME_GRAPPELLI = "grappelli_safe"

    #########################
    # OPTIONAL APPLICATIONS #
    #########################

    # These will be added to ``INSTALLED_APPS``, only if available.
    OPTIONAL_APPS = (
        "debug_toolbar",
        "django_extensions",
        "compressor",
        PACKAGE_NAME_FILEBROWSER,
        PACKAGE_NAME_GRAPPELLI,
    )

    #####################
    # REST API SETTINGS #
    #####################
    try:
        from mezzanine_api.settings import *
    except ImportError:
        pass


    ##################
    # LOCAL SETTINGS #
    ##################

    # Allow any settings to be defined in local_settings.py which should be
    # ignored in your version control system allowing for settings to be
    # defined per ma    chine.

    # Instead of doing "from .local_settings import *", we use exec so that
    # local_settings has full access to everything defined in this module.
    # Also force into sys.modules so it's visible to Django's autoreload.

    f = os.path.join(PROJECT_APP_PATH, "local_settings/__init__.py")
    if os.path.exists(f):
        import sys
        import imp
        module_name = "%s.local_settings" % PROJECT_APP
        module = imp.new_module(module_name)
        module.__file__ = f
        sys.modules[module_name] = module
        exec(open(f, "rb").read())


    ####################
    # DYNAMIC SETTINGS #
    ####################

    # set_dynamic_settings() will rewrite globals based on what has been
    # defined so far, in order to provide some better defaults where
    # applicable. We also allow this settings module to be imported
    # without Mezzanine installed, as the case may be when using the
    # fabfile, where setting the dynamic settings below isn't strictly
    # required.
    try:
        from mezzanine.utils.conf import set_dynamic_settings
    except ImportError:
        pass
    else:
        set_dynamic_settings(globals())

    # default settings for mezzanine    
    NEVERCACHE_KEY = os.getenv('CMS_NEVERCACHE_KEY', ''),
    # Application User
    CMS_APP_USER = os.getenv('CMS_APP_USER')
    CMS_APP_USER_PASSWORD = os.getenv('CMS_APP_USER_PASSWORD')
    CMS_APP_USER_MAIL = os.getenv('CMS_APP_USER_MAIL')
    # Client App (EM)
    CMS_APP_CLIENT_ID = os.getenv('CMS_APP_CLIENT_ID')
    CMS_APP_CLIENT_SECRET = os.getenv('CMS_APP_CLIENT_SECRET')
    CMS_APP_NAME = 'Engagement_Manager_App'
    REST_FRAMEWORK['DEFAULT_RENDERER_CLASSES'] = (
        'rest_framework.renderers.JSONRenderer',
    )

    # S3 configuration for static resources storage and media upload
 
    # used by our custom storage.py
    MEDIA_BUCKET = "cms-media"
    STATIC_BUCKET = "cms-static"

    # django-storages configuration
    AWS_S3_HOST = os.environ['S3_HOST']
    AWS_S3_PORT = int(os.environ['S3_PORT'])
    AWS_S3_CUSTOM_DOMAIN = os.environ['S3_HOST']
    AWS_ACCESS_KEY_ID = os.environ['AWS_ACCESS_KEY_ID']
    AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_ACCESS_KEY']
    AWS_AUTO_CREATE_BUCKET = True
    AWS_PRELOAD_METADATA = True

    # Set by custom subclass.
    # AWS_STORAGE_BUCKET_NAME = "em-static"
    AWS_S3_CALLING_FORMAT = OrdinaryCallingFormat()
    DEFAULT_FILE_STORAGE = 'cms.settings.storage.S3MediaStorage'
    STATICFILES_STORAGE = 'cms.settings.storage.S3StaticStorage'
    
    # These seem to have no effect even when we don't override with custom_domain?
    STATIC_URL = 'https://%s/%s/' % (AWS_S3_CUSTOM_DOMAIN, STATIC_BUCKET)
    MEDIA_URL = 'https://%s/%s/' % (AWS_S3_CUSTOM_DOMAIN, MEDIA_BUCKET)

    STATIC_ROOT = os.environ['STATIC_ROOT']

  storage.py: |
    """
    storage.py

    In order to make Django store trusted static files and untrusted media
    (user-uploaded) files in separate s3 buckets, we must create two different
    storage classes.

    https://www.caktusgroup.com/blog/2014/11/10/Using-Amazon-S3-to-store-your-Django-sites-static-and-media-files/
    http://www.leehodgkinson.com/blog/my-mezzanine-s3-setup/

    """

    # FIXME this module never changes so might not need not be kept in a
    # configmap. Also it is (almost) the same as what we use in em; that does
    # not use S3BotoStorageMixin.

    # There is a newer storage based on boto3 but that doesn't support changing
    # the HOST, as we need to for non-amazon s3 services. It does support an
    # "endpoint"; setting AWS_S3_ENDPOINT_URL may cause it to work.
    from storages.backends.s3boto import S3BotoStorage
    from filebrowser_safe.storage import S3BotoStorageMixin
    from django.conf import settings


    # NOTE for some reason, collectstatic uploads to bucket/location but the
    # urls constructed are domain/location
    class S3StaticStorage(S3BotoStorage, S3BotoStorageMixin):
        custom_domain = '%s/%s' % (settings.AWS_S3_HOST, settings.STATIC_BUCKET)
        bucket_name = settings.STATIC_BUCKET
        # location = ...


    class S3MediaStorage(S3BotoStorage, S3BotoStorageMixin):
        custom_domain = '%s/%s' % (settings.AWS_S3_HOST, settings.MEDIA_BUCKET)
        bucket_name = settings.MEDIA_BUCKET
        # location = ...
