def on_object_changed(self, attr, old_value, value):
     if attr == 'cost':
         self.cost_last_updated = localnow()
         if self.product:
             self.product.update_product_cost(value)
     elif attr == 'base_price':
         self.price_last_updated = localnow()

    def test_sync(self):
        results = self.store.find(BranchSynchronization,
                                  branch=self.branch)
        self.assertEqual(results.count(), 0)

        t1 = localnow()
        # Datetime columns doesn't store microseconds
        t1 = t1.replace(microsecond=0)
        obj = BranchSynchronization(branch=self.branch,
                                    policy=u"shop",
                                    sync_time=t1,
                                    store=self.store)

        results = self.store.find(BranchSynchronization,
                                  branch=self.branch)
        self.assertEqual(results.count(), 1)
        self.assertEqual(results[0], obj)
        # FIXME: Storm is not using the right resolution
        self.assertEqual(obj.sync_time.date(), t1.date())
        self.assertEqual(obj.policy, u"shop")
        self.assertEqual(obj.branch, self.branch)

        t2 = localnow()
        # Datetime columns doesn't store microseconds
        t2 = t2.replace(microsecond=0)
        obj.sync_time = t2

        results = self.store.find(BranchSynchronization,
                                  branch=self.branch)
        self.assertEqual(results.count(), 1)
        self.assertEqual(results[0], obj)
        # FIXME: Storm is not using the right resolution
        self.assertEqual(obj.sync_time.date(), t2.date())
        self.assertEqual(obj.policy, u"shop")
        self.assertEqual(obj.branch, self.branch)

    def test_new(self):
        with self.assertRaises(TypeError):
            Payment(due_date=localnow(),
                    branch=self.create_branch(),
                    payment_type=Payment.TYPE_OUT,
                    store=self.store)

        payment = Payment(value=currency(10), due_date=localnow(),
                          branch=self.create_branch(),
                          method=None,
                          group=None,
                          category=None,
                          payment_type=Payment.TYPE_OUT,
                          store=self.store)
        self.failUnless(payment.status == Payment.STATUS_PREVIEW)

 def test_get_paid_date_string(self):
     method = PaymentMethod.get_by_name(self.store, u'check')
     payment = Payment(value=currency(100),
                       branch=self.create_branch(),
                       due_date=localnow(),
                       method=method,
                       group=None,
                       category=None,
                       payment_type=Payment.TYPE_OUT,
                       store=self.store)
     today = localnow().strftime(u'%x')
     self.failIf(payment.get_paid_date_string() == today)
     payment.set_pending()
     payment.pay()
     self.failUnless(payment.get_paid_date_string() == today)

    def create_account_transaction(self, account=None, value=1,
                                   source=None, incoming=False):
        from stoqlib.domain.account import AccountTransaction
        if account is None:
            account = self.create_account()

        if source:
            source_id = source.id
        else:
            source_id = sysparam.get_object_id('IMBALANCE_ACCOUNT')

        if incoming:
            operation_type = AccountTransaction.TYPE_IN
        else:
            operation_type = AccountTransaction.TYPE_OUT

        return AccountTransaction(
            description=u"Test Account Transaction",
            code=u"Code",
            date=localnow(),
            value=value,
            account=account,
            source_account_id=source_id,
            operation_type=operation_type,
            store=self.store)

def orm_get_random(column):
    if isinstance(column, Reference):
        return None

    variable = column.variable_factory.func

    if issubclass(variable, UnicodeVariable):
        value = u''
    elif issubclass(variable, RawStrVariable):
        value = ''
    elif issubclass(variable, DateTimeVariable):
        value = localnow()
    elif issubclass(variable, IntVariable):
        value = None
    elif issubclass(variable, PriceVariable):
        value = currency(20)
    elif issubclass(variable, BoolVariable):
        value = False
    elif isinstance(variable, QuantityVariable):
        value = decimal.Decimal(1)
    elif issubclass(variable, DecimalVariable):
        value = decimal.Decimal(1)
    else:
        raise ValueError(column)

    return value

    def on_confirm(self):
        if self._is_default_salesperson_role():
            if self.salesperson:
                if not self.salesperson.is_active:
                    self.salesperson.activate()
            else:
                store = self.store
                self.salesperson = SalesPerson(person=self.person,
                                               store=store)
        elif self.salesperson:
            if self.salesperson.is_active:
                self.salesperson.inactivate()

        old_salary = self.employee.salary
        self.employee.salary = self.model.salary
        if (self.model.role is not self.employee.role
            or old_salary != self.model.salary):
            self.employee.role = self.model.role
            if self.current_role_history:
                self.current_role_history.salary = old_salary
                self.current_role_history.ended = localnow()
                self.current_role_history.is_active = False
        else:
            # XXX This will prevent problems when you can't update
            # the connection.
            self.store.remove(self.model)

    def test_is_p_cred_sn_valid(self):
        icms_template = self.create_product_icms_template()

        self.assertTrue(icms_template.is_p_cred_sn_valid())

        expire_date = localnow()
        icms_template.p_cred_sn_valid_until = expire_date
        self.assertTrue(icms_template.is_p_cred_sn_valid())

        expire_date = localnow() + relativedelta(days=+1)
        icms_template.p_cred_sn_valid_until = expire_date
        self.assertTrue(icms_template.is_p_cred_sn_valid())

        expire_date = localnow() + relativedelta(days=-1)
        icms_template.p_cred_sn_valid_until = expire_date
        self.assertFalse(icms_template.is_p_cred_sn_valid())

    def receive(self):
        """Receive the package on the :attr:`.destination_branch`

        This will mark the package as received in the branch
        to receive it there. Note that it's only possible to call this
        on the same branch as :attr:`.destination_branch`.

        When calling this, the work orders' :attr:`WorkOrder.current_branch`
        will be set to :attr:`.destination_branch`, since receiving means
        they got to their destination.
        """
        assert self.can_receive()

        if self.destination_branch != get_current_branch(self.store):
            raise ValueError(
                _("This package's destination branch is %s and you are in %s. "
                  "It's not possible to receive a package outside the "
                  "destination branch") % (
                      self.destination_branch, get_current_branch(self.store)))

        for order in [item.order for item in self.package_items]:
            assert order.current_branch is None
            # The order is in destination branch now
            order.current_branch = self.destination_branch

        self.receive_date = localnow()
        self.status = self.STATUS_RECEIVED

    def send(self):
        """Send the package to the :attr:`.destination_branch`

        This will mark the package as sent. Note that it's only possible
        to call this on the same branch as :attr:`.source_branch`.

        When calling this, the work orders' :attr:`WorkOrder.current_branch`
        will be ``None``, since they are on a package and not on any branch.
        """
        assert self.can_send()

        if self.source_branch != get_current_branch(self.store):
            raise ValueError(
                _("This package's source branch is %s and you are in %s. "
                  "It's not possible to send a package outside the "
                  "source branch") % (
                      self.source_branch, get_current_branch(self.store)))

        workorders = [item.order for item in self.package_items]
        if not len(workorders):
            raise ValueError(_("There're no orders to send"))

        for order in workorders:
            assert order.current_branch == self.source_branch
            # The order is going to leave the current_branch
            order.current_branch = None

        self.send_date = localnow()
        self.status = self.STATUS_SENT

 def createInPayments(self, no=3):
     sale = self.create_sale()
     d = localnow()
     method = PaymentMethod.get_by_name(self.store, self.method_type)
     payments = method.create_payments(Payment.TYPE_IN, sale.group,
                                       sale.branch, Decimal(100),
                                       [d] * no)
     return payments

 def price(self):
     if self.on_sale_price:
         today = localnow()
         start_date = self.on_sale_start_date
         end_date = self.on_sale_end_date
         if is_date_in_interval(today, start_date, end_date):
             return self.on_sale_price
     return self.base_price

 def __init__(self, store):
     self.open_date = localnow()
     self.branch = api.get_current_branch(store)
     self.branch_name = self.branch.get_description()
     self.user = api.get_current_user(store)
     self.product_manufacturer = None
     self.product_brand = None
     self.product_family = None

 def createOutPayments(self, no=3):
     purchase = self.create_purchase_order()
     d = localnow()
     method = PaymentMethod.get_by_name(self.store, self.method_type)
     payments = method.create_payments(Payment.TYPE_OUT, purchase.group,
                                       purchase.branch, Decimal(100),
                                       [d] * no)
     return payments

 def get_opening_date(self):
     # self.till is None only in the special case that the user added the ECF
     # to Stoq with a pending reduce Z, so we need to close the till on the
     # ECF, but not on Stoq.
     # Return a date in the past
     if not self.till:
         return localnow() - timedelta(1)
     return self.till.opening_date

    def test_calls(self):
        person = self.create_person()
        user = self.create_user()
        self.assertEquals(len(list(person.calls)), 0)

        call = Calls(store=self.store, date=localnow(),
                     description=u'', message=u'', person=person, attendant=user)
        self.assertEquals(len(list(person.calls)), 1)
        self.assertEquals(list(person.calls)[0], call)

    def approve(self):
        """Approves this work order

        Approving means that the |client| has accepted the
        work's quote and it's cost and it can now start.
        """
        assert self.can_approve()
        self.approve_date = localnow()
        self.status = self.STATUS_APPROVED

 def test_needs_closing(self):
     till = Till(station=self.create_station(), store=self.store)
     self.failIf(till.needs_closing())
     till.open_till()
     self.failIf(till.needs_closing())
     till.opening_date = localnow() - datetime.timedelta(1)
     self.failUnless(till.needs_closing())
     till.close_till()
     self.failIf(till.needs_closing())

    def confirm(self, login_user):
        """Receive the returned_sale_items from a pending |returned_sale|

        :param user: the |login_user| that received the pending returned sale
        """
        assert self.status == self.STATUS_PENDING
        self._return_items()
        self.status = self.STATUS_CONFIRMED
        self.confirm_responsible = login_user
        self.confirm_date = localnow()

    def cancel(self, responsible, cancel_date=None):
        """Cancel a transfer order"""
        assert self.can_cancel()

        for item in self.get_items():
            item.cancel()

        self.cancel_date = cancel_date or localnow()
        self.cancel_responsible_id = responsible.id
        self.status = self.STATUS_CANCELLED