RUN set -ex \

    && apt-get update

RUN set -ex \

    && buildDeps=' \

        libffi-dev \

        libfreetype6-dev \

        libjpeg-dev \

        libwebp-dev \

        libpng-dev \

        liblcms2-dev \

        zlib1g-dev \

        libmemcached-dev \

        libsasl2-dev \

        inkscape \

    ' \

    && apt-get install -y git xmlsec1 \

    && apt-get install -y $buildDeps --no-install-recommends \

    && rm -rf /var/lib/apt/lists/*

RUN set -ex \

    && pip install uwsgi

COPY constraints.txt requirements.txt /reqs/

RUN set -ex \

    && pip install --no-cache-dir -r /reqs/requirements.txt -c /reqs/constraints.txt \

    && apt-get purge -y --auto-remove $buildDeps \

    && rm -rf /usr/src/python ~/.cache

COPY . /app/symposion_app

WORKDIR /app/symposion_app

RUN set -x \

    && pip install -r vendored_requirements.txt -c /reqs/constraints.txt

RUN set -x \

    && DJANGO_SECRET_KEY=1234 STRIPE_PUBLIC_KEY=1234 STRIPE_SECRET_KEY=1234 \

       DATABASE_URL="sqlite:////dev/null" python manage.py compilescss

RUN set -x \

    && DJANGO_SECRET_KEY=1234 STRIPE_PUBLIC_KEY=1234 STRIPE_SECRET_KEY=1234 \

       DATABASE_URL="sqlite:////dev/null" \

       python manage.py collectstatic --noinput -l -v 0

RUN set -ex \

    && cp static/build/fonts/*.ttf /usr/local/share/fonts/ \

    && fc-cache \

    && fc-list

FROM symposion_base as symposion_dev

VOLUME /app/symposion_app

CMD ["./manage.py", "runserver", "-v3", "0.0.0.0:8000"]

FROM symposion_base as symposion_prod

CMD ["/usr/local/bin/uwsgi", "--http-socket", "0.0.0.0:8000", "-b", "8192", "--wsgi-file", "pinaxcon/wsgi.py"]

DJANGO_SECRET_KEY=5CEA51A5-A613-4AEF-A9FB-D0A57D77C13B

STRIPE_PUBLIC_KEY=5CEA51A5-A613-4AEF-A9FB-D0A57D77C13B

STRIPE_SECRET_KEY=5CEA51A5-A613-4AEF-A9FB-D0A57D77C13B

GCS_BUCKET=5CEA51A5-A613-4AEF-A9FB-D0A57D77C13B

GOOGLE_APPLICATION_CREDENTIALS=/dev/null

DATABASE_URL=sqlite:////tmp/symposion.sqlite

SYMPOSION_DEV_MODE=LAPTOP

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

AUTHENTICATION_BACKENDS = [

    'symposion.teams.backends.TeamPermissionsBackend',

    'django.contrib.auth.backends.ModelBackend',

]

LOGIN_URL='/accounts/login'

ROOT_URLCONF = "pinaxcon.devmode_urls"

DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage'

from pinaxcon import urls

urlpatterns = [

]

urlpatterns += urls.urlpatterns

from functools import wraps

class MonkeyPatchMiddleware(object):

    ''' Ensures that our monkey patching only gets called after it is safe to do so.'''

        do_monkey_patch()

def do_monkey_patch():

    patch_stripe_payment_form()

    # Remove this function from existence

    global do_monkey_patch

    do_monkey_patch = lambda: None  # noqa: E731

def patch_stripe_payment_form():  # noqa: C901

    import inspect  # Oh no.

    from django.http.request import HttpRequest

    from registripe.forms import CreditCardForm

    from pinaxcon.registrasion import models

    old_init = CreditCardForm.__init__

    @wraps(old_init)

    def new_init(self, *a, **k):

        # Map the names from our attendee profile model

        # To the values expected in the Stripe card model

        mappings = (

            ("address_line_1", "address_line1"),

            ("address_line_2", "address_line2"),

            ("address_suburb", "address_city"),

            ("address_postcode", "address_zip"),

            ("state", "address_state"),

            ("country", "address_country"),

        )

        initial = "initial"

        if initial not in k:

            k[initial] = {}

        initial = k[initial]

        # Find request context maybe?

        frame = inspect.currentframe()

        attendee_profile = None

        if frame:

            context = frame.f_back.f_locals

            for name, value in (context.items() or {}):

                if not isinstance(value, HttpRequest):

                    continue

                user = value.user

                    break

                try:

                    attendee_profile = models.AttendeeProfile.objects.get(

                        attendee__user=user

                    )

                except models.AttendeeProfile.DoesNotExist:

                    # Profile is still none.

                    pass

                break

        if attendee_profile:

            for us, stripe in mappings:

                i = getattr(attendee_profile, us, None)

                if i:

                    initial[stripe] = i

        old_init(self, *a, **k)

    CreditCardForm.__init__ = new_init

from django.db import models

from pinaxcon.raffle.mixins import PrizeMixin, RaffleMixin

class Raffle(RaffleMixin, models.Model):

    """

    Stores a single Raffle object, related to one or many

    :model:`pinaxcon_registrasion.Product`, which  is usually a raffle ticket,

    but can be set to tickets or other products for door prizes.

    """

    description = models.CharField(max_length=255)

    products = models.ManyToManyField('registrasion.Product')

    hidden = models.BooleanField(default=True)

    def __str__(self):

        return self.description

class Prize(PrizeMixin, models.Model):

    """

    Stores a Prize for a given :model:`pinaxcon_raffle.Raffle`.

    Once `winning_ticket` has been set to a :model:`pinaxcon_raffle.DrawnTicket`

    object, no further changes are permitted unless the object is explicitely

    unlocked.

    """

    description = models.CharField(max_length=255)

    order = models.PositiveIntegerField()

    winning_ticket = models.OneToOneField(

    )

    class Meta:

        unique_together = ('raffle', 'order')

    def __str__(self):

        return f"{self.order}. Prize: {self.description}"

class PrizeAudit(models.Model):

    """

    Stores an audit event for changes to a particular :model:`pinaxcon_raffle.Prize`.

    """

    reason = models.CharField(max_length=255)

    timestamp = models.DateTimeField(auto_now_add=True)

    class Meta:

        ordering = ('-timestamp',)

    def __str__(self):

        return self.reason

class Draw(models.Model):

    """

    Stores a draw for a given :model:`pinaxcon_raffle.Raffle`, along with audit fields

    for the creating :model:`auth.User` and the creation timestamp.

    """

    drawn_time = models.DateTimeField(auto_now_add=True)

    def __str__(self):

        return f"{self.raffle}: {self.drawn_time}"

class DrawnTicket(models.Model):

    """

    Stores the result of a ticket draw, along with the corresponding

    :model:`pinaxcon_raffle.Draw`, :model:`pinaxcon_raffle.Prize` and the

    :model:`registrasion.commerce.LineItem` from which it was generated.

    """

    ticket = models.CharField(max_length=255)

    def __str__(self):

from django.core.management.base import BaseCommand

from symposion.conference.models import Section, current_conference

from symposion.speakers.models import Speaker

from symposion.schedule.models import Presentation

from symposion.proposals.models import ProposalKind

from pinaxcon.proposals.models import TalkProposal

class Command(BaseCommand):

    help = "Creates a bunch of dummy presentations to play around with."

    def handle(self, *args, **options):

        conf = current_conference()

        section = Section.objects.filter(conference=conf, slug="main").all().first()

        user = User.objects.first()

        speaker = Speaker.objects.first()

        if not speaker:

            speaker, _ = Speaker.objects.get_or_create(name="Dummy Speaker",

                                                       defaults={"user": user})

        talk_kind = ProposalKind.objects.first()

        target_audience = TalkProposal.TARGET_USER

        for i in range(1000, 1020):

            prop, _created = TalkProposal.objects.get_or_create(

                pk=i, kind=talk_kind, speaker=speaker, target_audience=target_audience,

                title=f"dummy title {i}", abstract=f"dummy abstract {i}")

            pres, _created = Presentation.objects.get_or_create(

                proposal_base=prop, section=section, speaker=speaker,

                title=f"dummy title {i}", abstract=f"dummy abstract {i}")

from decimal import Decimal

import os

import sys

import django

import dj_database_url

import saml2

import saml2.saml

from datetime import date, datetime, timedelta

from dataclasses import dataclass

PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))

PACKAGE_ROOT = os.path.abspath(os.path.dirname(__file__))

DJANGO_ROOT = os.path.abspath(os.path.dirname(django.__file__))

BASE_DIR = PACKAGE_ROOT

sys.path.append(os.path.join(PROJECT_ROOT, 'vendor'))

### USER SETTINGS

DEV_MODE = os.environ.get("SYMPOSION_DEV_MODE", None)

DEBUG = os.environ.get('SYMPOSION_APP_DEBUG', '0')

if isinstance(DEBUG, str):

    try:

        i = int(DEBUG)

        if not i in [0, 1]:

            raise ValueError("not 0 or 1")

        DEBUG = bool(i)

    except ValueError:

        sys.exit('DEBUG env var must be set to string value of a 0 or 1')

else:

    sys.exit('DEBUG env var is in unexpected format.  Should be a string'

             'containing either a 0 or a 1 - Got type %s' % type(DEBUG))

DATABASES = {}

DATABASES['default'] = dj_database_url.config(conn_max_age=600)

if DATABASES['default']['ENGINE'] == 'django.db.backends.mysql':

    DATABASES['default']['OPTIONS'] = {'charset': 'utf8mb4'}

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

EMAIL_HOST = os.environ.get('EMAIL_HOST', None)

EMAIL_PORT = os.environ.get('EMAIL_PORT', 25)

EMAIL_HOST_USER = os.environ.get('EMAIL_HOST_USER', None)

EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_HOST_PASSWORD', None)

DEFAULT_FROM_EMAIL = os.environ.get('DEFAULT_FROM_EMAIL', 'webmaster@localhost')

EMAIL_USE_SSL = False

EMAIL_USE_TLS = False

_EMAIL_SSL_FLAVOR=os.environ.get('EMAIL_SSL_FLAVOR', None)

if _EMAIL_SSL_FLAVOR == "TLS":

    EMAIL_USE_TLS = True

elif _EMAIL_SSL_FLAVOR == "SSL":

    EMAIL_USE_SSL = True

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', None)

PINAX_STRIPE_PUBLIC_KEY = os.environ.get('STRIPE_PUBLIC_KEY', None)

PINAX_STRIPE_SECRET_KEY = os.environ.get('STRIPE_SECRET_KEY', None)

PINAX_STRIPE_SEND_EMAIL_RECEIPTS = False

ANALYTICS_KEY = os.environ.get('ANALYTICS_KEY', None)

saml2_entityid = os.environ.get('SAML2_ENTITYID', None)

saml2_sp_name = os.environ.get('SAML2_SP_NAME', None)

saml2_sp_assertion_service = os.environ.get('SAML2_SP_ASSERTION_SERVICE', None)

saml2_sp_slo_rdir = os.environ.get('SAML2_SP_SLO_RDIR', None)

saml2_sp_slo_post = os.environ.get('SAML2_SP_SLO_POST', None)

saml2_idp_metadata = {

    'local': [os.environ.get('SAML2_IDP_METADATA_FILE', None)],

    }

saml2_signing_key = os.environ.get('SAML2_SIGNING_KEY', None)

saml2_signing_crt = os.environ.get('SAML2_SIGNING_CRT', None)

saml2_encr_key = os.environ.get('SAML2_ENCRYPTION_KEY', None)

saml2_encr_crt = os.environ.get('SAML2_ENCRYPTION_CRT', None)

saml2_contact = {

    'given_name': os.environ.get("META_GIVEN_NAME", 'Bastard'),

    'sur_name': os.environ.get('META_FAM_NAME', 'Operator'),

    'company': os.environ.get('META_COMPANY', 'Corp1'),

    'email_address': os.environ.get('META_EMAIL', 'op@example.com'),

    'contact_type': 'technical'},

fail = False

BADGER_DEFAULT_SVG = 'registrasion/badge.svg'

BADGER_DEFAULT_FORM = "registrasion/badge_form.html"

if SECRET_KEY is None:

    print("FAILURE: You need to supply a DJANGO_SECRET_KEY "

          "environment variable")

    fail = True

if PINAX_STRIPE_PUBLIC_KEY is None:

    print("FAILURE: You need to supply a STRIPE_PUBLIC_KEY "

          "environment variable")

    fail = True

if PINAX_STRIPE_SECRET_KEY is None:

    print("FAILURE: You need to supply a STRIPE_SECRET_KEY "

          "environment variable")

    fail = True

if fail:

    sys.exit('FAILURE: Missing environment variables.')

### Standard settings

ADMIN_USERNAMES = []

if DEV_MODE and DEV_MODE == "LAPTOP":

    CACHES = {

        'default': {

            'BACKEND': 'django.core.cache.backends.dummy.DummyCache',

        }

    }

else:

    CACHES = {

        'default': {

            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',

            'LOCATION': 'unique-snowflake',

        }

    }

ALLOWED_HOSTS = ['127.0.0.1', 'localhost', '*']

DATE_FORMAT = "j F Y"

LANGUAGE_CODE = "en-au"

SITE_ID = int(os.environ.get("SITE_ID", 1))

USE_I18N = True

USE_L10N = True

USE_TZ = True

MEDIA_ROOT = os.environ.get("MEDIA_ROOT", os.path.join(PACKAGE_ROOT, "site_media", "media"))

MEDIA_URL = "/site_media/media/"

STATIC_ROOT = os.path.join(PROJECT_ROOT, 'static', 'build')

STATIC_URL = '/static/build/'

STATICFILES_DIRS = [

    os.path.join(PROJECT_ROOT, 'static', 'src'),

]

STATICFILES_FINDERS = [

    "django.contrib.staticfiles.finders.FileSystemFinder",

    "django.contrib.staticfiles.finders.AppDirectoriesFinder",

    "sass_processor.finders.CssFinder",

]

TEMPLATES = [

    {

        "BACKEND": "django.template.backends.django.DjangoTemplates",

        "DIRS": [

            os.path.join(PACKAGE_ROOT, "templates"),

            os.path.join(DJANGO_ROOT, 'forms/templates')

        ],

        "APP_DIRS": True,

        "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.template.context_processors.request",

                "django.contrib.messages.context_processors.messages",

                "pinax_theme_bootstrap.context_processors.theme",

                "symposion.reviews.context_processors.reviews",

                "django_settings_export.settings_export",

            ],

        },

    },

]

    "django.contrib.sessions.middleware.SessionMiddleware",

    "django.middleware.common.CommonMiddleware",

    "django.middleware.csrf.CsrfViewMiddleware",

    "django.contrib.auth.middleware.AuthenticationMiddleware",

    "django.contrib.messages.middleware.MessageMiddleware",

    "debug_toolbar.middleware.DebugToolbarMiddleware",

    "reversion.middleware.RevisionMiddleware",

    "waffle.middleware.WaffleMiddleware",

    "django.middleware.clickjacking.XFrameOptionsMiddleware",

    "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",

    'pinaxcon.monkey_patch.MonkeyPatchMiddleware',

]

if DEV_MODE and DEV_MODE == "LAPTOP":

    ROOT_URLCONF = "pinaxcon.devmode_urls"

else:

    ROOT_URLCONF = "pinaxcon.urls"

# Python dotted path to the WSGI application used by Django's runserver.

WSGI_APPLICATION = "pinaxcon.wsgi.application"

INSTALLED_APPS = [

    "django.contrib.admin",

    "django.contrib.auth",

    "django.contrib.contenttypes",

    "django.contrib.flatpages",

    "django.contrib.messages",

    "django.contrib.sessions",

    "django.contrib.sites",

    "django.contrib.staticfiles",

    "django.contrib.humanize",

    "debug_toolbar",

    'djangosaml2',

    # theme

    "bootstrapform",

    "pinax_theme_bootstrap",

    "sass_processor",

    "capture_tag",

    # external

    "easy_thumbnails",

    "taggit",

    "reversion",

    "sitetree",

    "pinax.eventlog",

    # symposion

    "symposion",

    "symposion.conference",

    "symposion.proposals",

    "symposion.reviews",

    "symposion.schedule",

    "symposion.speakers",

    "symposion.teams",

    # Registrasion

    "registrasion",

    # Registrasion-stripe

    "pinax.stripe",

    "django_countries",

    "registripe",

    #registrasion-desk

    "regidesk",

    # admin - required by registrasion ??

    "nested_admin",

    # project

    "pinaxcon",

    "pinaxcon.proposals",

    "pinaxcon.registrasion",

    "pinaxcon.raffle",

    "jquery",

    "djangoformsetjs",

    # testing and rollout

    "django_nose",

    "waffle",

    "crispy_forms",

]

CRISPY_TEMPLATE_PACK = "bootstrap4"

DEBUG_TOOLBAR_PANELS = [

    'debug_toolbar.panels.versions.VersionsPanel',

    'debug_toolbar.panels.timer.TimerPanel',

    'debug_toolbar.panels.settings.SettingsPanel',

    'debug_toolbar.panels.headers.HeadersPanel',

    'debug_toolbar.panels.request.RequestPanel',

    'debug_toolbar.panels.sql.SQLPanel',

    'debug_toolbar.panels.staticfiles.StaticFilesPanel',

    'debug_toolbar.panels.cache.CachePanel',

    'debug_toolbar.panels.signals.SignalsPanel',

    'debug_toolbar.panels.logging.LoggingPanel',

    'debug_toolbar.panels.templates.TemplatesPanel',

    'debug_toolbar.panels.redirects.RedirectsPanel',

]

DEBUG_TOOLBAR_CONFIG = {

    'INTERCEPT_REDIRECTS': False,

}

from debug_toolbar.panels.logging import collector

LOGGING = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'verbose': {

            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'

        },

        'simple': {

            'format': '%(asctime)s %(levelname)s $(module)s %(message)s'

        },

    },

    'filters': {

        'require_debug_false': {

            '()': 'django.utils.log.RequireDebugFalse'

        }

    },

    'handlers': {

        'console': {

            'level': 'DEBUG',

            'class': 'logging.StreamHandler',

            'formatter': 'simple'

        },

        'mail_admins': {

            'level': 'ERROR',

            'filters': ['require_debug_false'],

            'class': 'django.utils.log.AdminEmailHandler',

            'include_html': True,

        },

        'djdt_log': {

            'level': 'DEBUG',

            'class': 'debug_toolbar.panels.logging.ThreadTrackingHandler',

            'collector': collector,

        },

    },

    'loggers': {

        'django.request': {

            'handlers': ['mail_admins'],

            'level': 'DEBUG',

            'propagate': True,

        },

        'symposion.request': {

            'handlers': ['mail_admins'],

            'level': 'DEBUG',

            'propagate': True,

        },

    },

    'root': {

        'handlers': ['console', 'djdt_log'],

        'level': 'DEBUG'

    },

}

FIXTURE_DIRS = [

    os.path.join(PROJECT_ROOT, "fixtures"),

]

AUTHENTICATION_BACKENDS = [

    'symposion.teams.backends.TeamPermissionsBackend',

    'django.contrib.auth.backends.ModelBackend',

    'djangosaml2.backends.Saml2Backend',

]

LOGIN_URL = '/saml2/login/'

SESSION_EXPIRE_AT_BROWSER_CLOSE = True

CONFERENCE_ID = 1

PROPOSAL_FORMS = {

    "talk": "pinaxcon.proposals.forms.TalkProposalForm",

    "tutorial": "pinaxcon.proposals.forms.TutorialProposalForm",

    "miniconf": "pinaxcon.proposals.forms.MiniconfProposalForm",

}

MAIN_CONFERENCE_PROPOSAL_KINDS = ("Talk", "Miniconf")

# Registrasion bits:

ATTENDEE_PROFILE_MODEL = "pinaxcon.registrasion.models.AttendeeProfile"

ATTENDEE_PROFILE_FORM = "pinaxcon.registrasion.forms.ProfileForm"

INVOICE_CURRENCY = "AUD"

GST_RATE =  Decimal('0.1')

TICKET_PRODUCT_CATEGORY = 1

TERMS_PRODUCT_CATEGORY = 2

ATTENDEE_PROFILE_FORM = "pinaxcon.registrasion.forms.ProfileForm"

#REGIDESK

REGIDESK_BOARDING_GROUP = "Ready For Boarding"

# CSRF custom error screen

CSRF_FAILURE_VIEW = "pinaxcon.csrf_view.csrf_failure"

# Use nose to run all tests

TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'

# Tell nose to measure coverage on the 'foo' and 'bar' apps

NOSE_ARGS = [

    '--with-coverage',

    '--cover-package=registrasion.controllers,registrasion.models',

]

                'assertion_consumer_service': [

                    saml2_sp_assertion_service,

                    ],

                'single_logout_service': [

                    (saml2_sp_slo_rdir, saml2.BINDING_HTTP_REDIRECT),

                    (saml2_sp_slo_post, saml2.BINDING_HTTP_POST),

                    ],

                },

            'logout_requests_signed': True,

            'required_attributes': ['uid', 'mail', 'givenName', 'sn'],

            },

        },

    'metadata': saml2_idp_metadata,

    'debug': 0,

    'key_file': saml2_signing_key,

    'cert_file': saml2_signing_crt,

    'encryption_keypairs': [{

        'key_file': saml2_encr_key,

        'cert_file': saml2_encr_crt,

    }],

    'contact_person': saml2_contact,

    'valid_for': 10,

}

if 'SAML_CONFIG_LOADER' in os.environ:

    SAML_CONFIG_LOADER = os.environ.get('SAML_CONFIG_LOADER')

DEFAULT_FILE_STORAGE = os.environ.get('DEFAULT_FILE_STORAGE', 'gapc_storage.storage.GoogleCloudStorage')

GAPC_STORAGE = {

    'num_retries': 2,

}

SETTINGS_EXPORT = [

    'DEBUG',

    'ANALYTICS_KEY',

]

if DEV_MODE and DEV_MODE == "LAPTOP":

    print("ENABLING LAPTOP MODE")

    from .devmode_settings import *

class Category(object):

    tickets = []

    @classmethod

    def order(cls, ticket) -> int:

        return (cls.tickets.index(ticket) + 1) * 10

@dataclass(frozen=True)

class Ticket:

    name: str

    regular_price: Decimal

    earlybird_price: Decimal

    def earlybird_discount(self):