# accounting/platform.html

class Platform:
    def __init__(self, name, verbose_name):
        self.name = name
        self.verbose_name = verbose_name

    def __str__(self):
        return self.verbose_name


class PlatformRegistry:
    def register(self, platform):
        ...

    def get_by_name(self, platform_name):
        ...

    def all(self):
        ...

# accounting/__init__.py
from django.utils.module_loading import autodiscover_modules


class AppConfig(BaseAppConfig):
    ...
    def ready(self):
        # Autodiscover any app modules named accounting_platforms.py
        autodiscover_modules('accounting_platforms')
...

# accounting/connection.html
from django.conf import settings
from django.utils.module_loading import import_string


class AbstractConnectionService:
    @classmethod
    def get_connected_platform(cls, business):
        """Given a business, returns the platform that the business
        is currently connected to. Otherwise returns None.
        """
        raise NotImplementedError

    @classmethod
    def get_connection_url(cls, business, platform):
        """Get the URL that the business should visit to connect
        to the supplied platform.
        """
        raise NotImplementedError

    @classmethod
    def store_successful_connection(cls, business, params):
        """Stores the connection following a successful connection
        using the connection service.
        """
        raise NotImplementedError


def get_connection_service():
    return import_string(settings.ACCOUNTING_CONNECTION_SERVICE)

# accounting/views.py
from . import platforms
from .connection_service import get_connection_service


class ConnectionsPage(TemplateView):
    """View for the user to view their connected platform,
    or select one to connect to.
    """
    template_name = 'accounting/connections.html'

    def get_context_data(self, *args, **kwargs):
        context_data = super().get_context_data(*args, **kwargs)

        connection_service = get_connection_service()

        # If the business is connected to a platform,
        # include that in the context
        context_data['connected_platform'] = connection_service\
            .get_connected_platform(self.business)

        # Otherwise, include all available platforms
        if not context_data['connected_platform']:
            context_data['available_platforms'] = platforms.all()

        return context_data

# templates/accounting/connections.html

{% load accounting_tags %}
...

{% if connected_platform %}
    {% borrower_connected_platform_block connected_platform %}
{% else %}
    {% for platform in available_platforms %}
        {% borrower_connect_platform_block platform %}
    {% endfor %}
{% endif %}
...

# accounting/templatetags/accounting_tags.html
...

@register.simple_tag
def borrower_connect_platform_block(platform):
    """Display the block to allow the user to connect to a platform.
    """
    template_name = 'accounting/includes/connect_{}_block.html'/
        .format(platform.name)
    template = loader.get_template(template_name)
    return template.render({'platform': platform})

# xero/accounting_platforms.py

from accounting import platforms, Platform

xero = Platform(name='xero', verbose_name='Xero')
platforms.register(xero)

# quickbooks/accounting_platforms.py

from accounting import platforms, Platform

quickbooks = Platform(name='quickbooks', verbose_name='Quickbooks')
platforms.register(quickbooks)

# sage/accounting_platforms.py

from accounting import platforms, Platform

sage = Platform(name='sage', verbose_name='Sage')
platforms.register(sage)

# cloudconnect/connection_service.py

from accounting.connection import AbstractConnectionService
from accounting import platforms
from .models import CloudconnectBusinessConnection


class Cloudconnect(AbstractConnectionService):
    @classmethod
    def get_connected_platform(cls, business):
        try:
            connection = CloudconnectBusinessConnection.objects.filter(
                business=business).exclude(platform_name='').get()
        except CloudconnectBusinessConnection.DoesNotExist:
            return None
        else:
            return platforms.get_by_name(connection.platform_name)

    ...

# settings.py

ACCOUNTING_CONNECTION_SERVICE = \
    'cloudconnect.connection_service.Cloudconnect'