#  Copyright © 2010-2021 Lance Edgar

import six

from sqlalchemy import orm

    def refresh_row(self, row):

        if not row.product:

            if row.item_entry:

                session = orm.object_session(row)

                # TODO: should do more than just query for uuid here

                product = session.query(model.Product).get(row.item_entry)

                if product:

                    row.product = product

            if not row.product:

                row.status_code = row.STATUS_PRODUCT_NOT_FOUND

                return

        product = row.product

        row.product_upc = product.upc

        row.product_brand = six.text_type(product.brand or "")

        row.product_description = product.description

        row.product_size = product.size

        row.product_weighed = product.weighed

        row.case_quantity = product.case_size

        department = product.department

        row.department_number = department.number if department else None

        row.department_name = department.name if department else None

        cost = product.cost

        row.product_unit_cost = cost.unit_cost if cost else None

        regprice = product.regular_price

        row.unit_price = regprice.price if regprice else None

        # we need to know if total price is updated

        old_total = row.total_price

        # maybe update total price

        if row.unit_price is None:

            row.total_price = None

        elif not row.unit_price:

            row.total_price = 0

        else:

            row.total_price = row.unit_price * row.order_quantity

            if row.order_uom == self.enum.UNIT_OF_MEASURE_CASE:

                row.total_price *= row.case_quantity

        # update total price for batch too, if it changed

        if row.total_price != old_total:

            batch = row.batch

            batch.total_price = ((batch.total_price or 0)

                                 + (row.total_price or 0)

                                 - (old_total or 0))

        row.status_code = row.STATUS_OK

    def remove_row(self, row):

        batch = row.batch

        if not row.removed:

            row.removed = True

            if row.total_price:

                batch.total_price = (batch.total_price or 0) - row.total_price

        self.refresh_batch_status(batch)

    def execute(self, batch, user=None, progress=None, **kwargs):

        """

        Default behavior here will simply create a new (proper) Customer Order

        based on the batch contents.  Override as needed.

        """

        batch_fields = [

            'store',

            'id',

            'customer',

            'person',

            'phone_number',

            'email_address',

            'total_price',

        ]

        order = model.CustomerOrder()

        order.created_by = user

        order.status_code = self.enum.CUSTORDER_STATUS_ORDERED

        for field in batch_fields:

            setattr(order, field, getattr(batch, field))

        row_fields = [

            'product',

            'product_upc',

            'product_brand',

            'product_description',

            'product_size',

            'product_weighed',

            'department_number',

            'department_name',

            'case_quantity',

            'order_quantity',

            'order_uom',

            'product_unit_cost',

            'unit_price',

            'discount_percent',

            'total_price',

            'paid_amount',

            'payment_transaction_number',

        ]

        def convert(row, i):

            item = model.CustomerOrderItem()

            item.sequence = i + 1

            item.status_code = self.enum.CUSTORDER_ITEM_STATUS_ORDERED

            for field in row_fields:

                setattr(item, field, getattr(row, field))

            order.items.append(item)

        self.progress_loop(convert, batch.active_rows(), progress,

                           message="Converting batch rows to order items")

        session = orm.object_session(batch)

        session.add(order)

        session.flush()

        return order

            batch.rowcount = (batch.rowcount or 0) + 1

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

"""add custorder_batch_row.product_upc

Revision ID: 2afee42cc24d

Revises: a7b286e87f89

Create Date: 2021-01-25 21:32:00.008209

"""

from __future__ import unicode_literals

# revision identifiers, used by Alembic.

revision = '2afee42cc24d'

down_revision = 'a7b286e87f89'

branch_labels = None

depends_on = None

from alembic import op

import sqlalchemy as sa

import rattail.db.types

def upgrade():

    # custorder

    op.add_column('custorder', sa.Column('total_price', sa.Numeric(precision=10, scale=3), nullable=True))

    # custorder_item

    op.alter_column('custorder_item', 'product_unit_of_measure',

               existing_type=sa.VARCHAR(length=4),

               nullable=True)

    op.add_column('custorder_item', sa.Column('product_upc', rattail.db.types.GPCType(), nullable=True))

    op.add_column('custorder_item', sa.Column('product_weighed', sa.Boolean(), nullable=True))

    op.add_column('custorder_item', sa.Column('order_quantity', sa.Numeric(precision=10, scale=4), nullable=True))

    op.add_column('custorder_item', sa.Column('order_uom', sa.String(length=4), nullable=True))

    # custorder_batch

    op.add_column('custorder_batch', sa.Column('total_price', sa.Numeric(precision=10, scale=3), nullable=True))

    # custorder_batch_row

    op.alter_column('custorder_batch_row', 'product_unit_of_measure',

               existing_type=sa.VARCHAR(length=4),

               nullable=True)

    op.add_column('custorder_batch_row', sa.Column('product_upc', rattail.db.types.GPCType(), nullable=True))

    op.add_column('custorder_batch_row', sa.Column('product_weighed', sa.Boolean(), nullable=True))

    op.add_column('custorder_batch_row', sa.Column('order_quantity', sa.Numeric(precision=10, scale=4), nullable=True))

    op.add_column('custorder_batch_row', sa.Column('order_uom', sa.String(length=4), nullable=True))

def downgrade():

    # custorder_batch_row

    op.drop_column('custorder_batch_row', 'order_uom')

    op.drop_column('custorder_batch_row', 'order_quantity')

    op.drop_column('custorder_batch_row', 'product_weighed')

    op.drop_column('custorder_batch_row', 'product_upc')

    # TODO: this is really a one-way change, cannot be easily undone

    # op.alter_column('custorder_batch_row', 'product_unit_of_measure',

    #            existing_type=sa.VARCHAR(length=4),

    #            nullable=False)

    # custorder_batch

    op.drop_column('custorder_batch', 'total_price')

    # custorder_item

    op.drop_column('custorder_item', 'order_uom')

    op.drop_column('custorder_item', 'order_quantity')

    op.drop_column('custorder_item', 'product_weighed')

    op.drop_column('custorder_item', 'product_upc')

    # TODO: this is really a one-way change, cannot be easily undone

    # op.alter_column('custorder_item', 'product_unit_of_measure',

    #            existing_type=sa.VARCHAR(length=4),

    #            nullable=False)

    # custorder

    op.drop_column('custorder', 'total_price')

#  Copyright © 2010-2021 Lance Edgar

from rattail.db.types import GPCType

    total_price = sa.Column(sa.Numeric(precision=10, scale=3), nullable=True, doc="""

    Full price (not including tax etc.) for all items on the order.

    """)

    product_upc = sa.Column(GPCType(), nullable=True, doc="""

    UPC for the product associated with the row.

    """)

    product_weighed = sa.Column(sa.String(length=4), nullable=True, doc="""

    Flag indicating whether the product is sold by weight.  This should be a

    cache of :attr:`Product.weighed`.

    """)

    # TODO: probably should get rid of this, i can't think of why it's needed.

    # for now we just make sure it is nullable, since that wasn't the case.

    product_unit_of_measure = sa.Column(sa.String(length=4), nullable=True, doc="""

    :attr:`Product.case_size`.

    # TODO: i now think that cases_ordered and units_ordered should go away.

    # but will wait until that idea has proven itself before removing.  am

    # pretty sure they are obviated by order_quantity and order_uom.

    order_quantity = sa.Column(sa.Numeric(precision=10, scale=4), nullable=True, doc="""

    Quantity being ordered by the customer.

    """)

    order_uom = sa.Column(sa.String(length=4), nullable=True, doc="""

    Code indicating the unit of measure for the order itself.  Does not

    directly reflect the :attr:`~rattail.db.model.Product.unit_of_measure`.

    """)

CUSTORDER_STATUS_ORDERED                = 10

# CUSTORDER_STATUS_PAID                   = 20

CUSTORDER_STATUS = {

    CUSTORDER_STATUS_ORDERED            : "ordered",

    # CUSTORDER_STATUS_PAID               : "paid",

}

CUSTORDER_ITEM_STATUS_ORDERED           = 10

# CUSTORDER_ITEM_STATUS_PAID              = 20

CUSTORDER_ITEM_STATUS = {

    CUSTORDER_ITEM_STATUS_ORDERED       : "ordered",

    # CUSTORDER_ITEM_STATUS_PAID          : "paid",

}