Handler for all "customer order" batches, regardless of "mode".  The

    handler must inspect the

    :attr:`~rattail.db.model.batch.custorder.CustomerOrderBatch.mode` attribute

    of each batch it deals with, in order to determine which logic to apply.

    """

    batch_model_class = model.CustomerOrderBatch

    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:

        # 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',