if handler:

                return type(handler)

        if not factory:

            return

        if not handler:

            self.stderr.write("no handler configured!\n")

            if self.handler_key:

                self.stderr.write("handler key is: {}\n".format(self.handler_key))

            sys.exit(1)

# -*- coding: utf-8; -*-

"""add custorder_item_xref

Revision ID: c7022b294760

Revises: fae21d8c854a

Create Date: 2022-03-16 22:02:04.370686

"""

from __future__ import unicode_literals, absolute_import

from alembic import op

import sqlalchemy as sa

# revision identifiers, used by Alembic.

revision = 'c7022b294760'

down_revision = 'fae21d8c854a'

branch_labels = None

depends_on = None

def upgrade():

    # transaction_order_marker

    op.create_table('transaction_order_marker',

                    sa.Column('uuid', sa.String(length=32), nullable=False),

                    sa.Column('transaction_uuid', sa.String(length=32), nullable=False),

                    sa.Column('custorder_xref', sa.String(length=50), nullable=True),

                    sa.Column('custorder_item_xref', sa.String(length=50), nullable=True),

                    sa.ForeignKeyConstraint(['transaction_uuid'], ['transaction.uuid'], name='transaction_order_marker_fk_transaction'),

                    sa.PrimaryKeyConstraint('uuid')

    )

    # transaction_item

    op.add_column('transaction_item', sa.Column('custorder_item_xref', sa.String(length=50), nullable=True))

def downgrade():

    # transaction_item

    op.drop_column('transaction_item', 'custorder_item_xref')

    # transaction_order_marker

    op.drop_table('transaction_order_marker')

                   TransactionOrderMarkerBase,

@six.python_2_unicode_compatible

class TransactionOrderMarkerBase(object):

    """

    Represents a "marker" to cross-reference one or more customer

    orders with a given POS transaction.

    """

    __tablename__ = 'transaction_order_marker'

    @declared_attr

    def __table_args__(cls):

        return cls.__txnmarker_table_args__()

    @classmethod

    def __txnmarker_table_args__(cls):

        txn_table = cls.__txn_class__.__tablename__

        marker_table = cls.__tablename__

        return (

            sa.ForeignKeyConstraint(['transaction_uuid'], ['{}.uuid'.format(txn_table)],

                                    name='{}_fk_transaction'.format(marker_table)),

        )

    uuid = uuid_column()

    transaction_uuid = sa.Column(sa.String(length=32), nullable=False)

    @declared_attr

    def transaction(cls):

        txn_class = cls.__txn_class__

        marker_class = cls

        # txn_class.order_xref_marker_class = marker_class

        # Must establish `Transaction.items` here instead of from within

        # Transaction itself, because the item class doesn't yet exist (really,

        # it can't even be "known") when Transaction is being created.

        txn_class.custorder_xref_markers = orm.relationship(

            marker_class,

            cascade='all, delete-orphan',

            doc="""

            Set of "order xref markers" for the transaction.

            """,

            back_populates='transaction')

        # Now, here's the `TransactionOrderMarker.transaction` reference.

        return orm.relationship(

            txn_class,

            back_populates='custorder_xref_markers',

            doc="""

            Reference to the order maker's parent transaction.

            """)

    custorder_xref = sa.Column(sa.String(length=50), nullable=True, doc="""

    Cross-reference identifier for a "customer order" which

    corresponds to this transaction, if applicable.  More than one

    such order xref can exist for a transaction.

    """)

    custorder_item_xref = sa.Column(sa.String(length=50), nullable=True, doc="""

    Cross-reference identifier for a "customer order item" which

    corresponds to this transaction, if applicable.  More than one

    such order xref can exist for a transaction.

    """)

    def __str__(self):

        xref = self.custorder_xref or "??"

        if self.custorder_item_xref:

            xref = "{} / {}".format(xref, self.custorder_item_xref)

        return "{} / {}".format(self.transaction, xref)

    custorder_item_xref = sa.Column(sa.String(length=50), nullable=True, doc="""

    Cross-reference identifier for the "customer order item" which

    corresponds to this line item, if applicable.  Can be useful to

    tie these things together for sake of reporting.

    """)

#  Copyright © 2010-2022 Lance Edgar

class TransactionOrderMarker(model.TransactionOrderMarkerBase, model.Base):

    """

    Represents a "customer order xref" for a transaction.

    """

    __txn_class__ = Transaction

    allow_delete = False

    def normalize_host_object(self, txn):

        """

        This method is defined only as a convenience for the simple

        case where you need to mark a transaction as having been

        updated, along with some other "processing" logic.

        """

        return {

            'uuid': txn.uuid,

            'self_updated': True,

        }

class TransactionOrderMarkerImporter(ToTrainwreck):

    """

    Transaction order marker data importer

    .. attribute:: match_on_time_field

       This time field will be used for the cache query etc.  In

       particular it controls which transactions are deemed to belong

       to a given date, which is needed when restricting the import to

       a particular date range.  Can set this to ``'upload_time'`` or

       ``'start_time'`` if necessary, depending on the nature of

       transaction data coming from the host side.

    """

    match_on_time_field = 'end_time'

    @property

    def importing_from_system(self):

        raise NotImplementedError("TODO: please define this for your subclass")

    def get_model_class(self):

        if hasattr(self, 'model_class') and self.model_class:

            return self.model_class

        trainwreck = self.config.get_trainwreck_model()

        return trainwreck.TransactionOrderMarker

    @property

    def transaction_class(self):

        trainwreck = self.config.get_trainwreck_model()

        return trainwreck.Transaction

    def cache_query(self):

        query = super(TransactionOrderMarkerImporter, self).cache_query()

        trainwreck = self.config.get_trainwreck_model()

        query = query.join(trainwreck.Transaction)

        try:

            system = self.importing_from_system

        except NotImplementedError:

            pass

        else:

            query = query.filter(trainwreck.Transaction.system == system)

        time_field = getattr(trainwreck.Transaction, self.match_on_time_field)

        query = query.filter(time_field >= self.app.make_utc(self.start_time))\

                     .filter(time_field < self.app.make_utc(self.end_time))

        return query

#  Copyright © 2010-2022 Lance Edgar

        importers['TransactionOrderMarker'] = TransactionOrderMarkerImporter

class TransactionOrderMarkerImporter(FromTrainwreck, model.TransactionOrderMarkerImporter):

    """

    Base class for Transaction order marker data importer

    """

    def query(self):

        query = super(TransactionOrderMarkerImporter, self).query()

        query = self.filter_date_range(query)

        return query

    def filter_date_range(self, query):

        time_field = getattr(self.transaction_class, self.match_on_time_field)

        return query.join(self.transaction_class)\

                    .filter(time_field >= self.app.make_utc(self.start_time))\

                    .filter(time_field < self.app.make_utc(self.end_time))