class Payment(Domain): """Payment, a transfer of money between a |branch| and |client| or a |supplier|. Payments between: * a client and a branch are :obj:`.TYPE_IN`, has a |sale| associated. * branch and a supplier are :obj:`.TYPE_OUT`, has a |purchase| associated. Payments are sometimes referred to as *installments*. Sales and purchase orders can be accessed via the :obj:`payment group <.group>` +-------------------------+-------------------------+ | **Status** | **Can be set to** | +-------------------------+-------------------------+ | :obj:`STATUS_PREVIEW` | :obj:`STATUS_PENDING` | +-------------------------+-------------------------+ | :obj:`STATUS_PENDING` | :obj:`STATUS_PAID`, | | | :obj:`STATUS_CANCELLED` | +-------------------------+-------------------------+ | :obj:`STATUS_PAID` | :obj:`STATUS_PENDING`, | | | :obj:`STATUS_CANCELLED` | +-------------------------+-------------------------+ | :obj:`STATUS_CANCELLED` | None | +-------------------------+-------------------------+ .. graphviz:: digraph status { STATUS_PREVIEW -> STATUS_PENDING; STATUS_PENDING -> STATUS_PAID; STATUS_PENDING -> STATUS_CANCELLED; STATUS_PAID -> STATUS_PENDING; STATUS_PAID -> STATUS_CANCELLED; } Simple sale workflow: * Creating a sale, status is set to :obj:`STATUS_PREVIEW` * Confirming the sale, status is set to :obj:`STATUS_PENDING` * Paying the installment, status is set to :obj:`STATUS_PAID` * Cancelling the payment, status is set to :obj:`STATUS_CANCELLED` See also: `schema <http://doc.stoq.com.br/schema/tables/payment.html>`__ """ __storm_table__ = 'payment' #: incoming to the company, accounts receivable, payment from #: a |client| to a |branch| TYPE_IN = u'in' #: outgoing from the company, accounts payable, a payment from #: |branch| to a |supplier| TYPE_OUT = u'out' #: payment group this payment belongs to hasn't been confirmed, # should normally be filtered when showing a payment list STATUS_PREVIEW = u'preview' #: payment group has been confirmed and the payment has not been received STATUS_PENDING = u'pending' #: the payment has been received STATUS_PAID = u'paid' # FIXME: Remove these two #: Unused. STATUS_REVIEWING = u'reviewing' #: Unused. STATUS_CONFIRMED = u'confirmed' #: payment was cancelled, for instance the payments of the group was changed, or #: the group was cancelled. STATUS_CANCELLED = u'cancelled' statuses = {STATUS_PREVIEW: _(u'Preview'), STATUS_PENDING: _(u'To Pay'), STATUS_PAID: _(u'Paid'), STATUS_REVIEWING: _(u'Reviewing'), STATUS_CONFIRMED: _(u'Confirmed'), STATUS_CANCELLED: _(u'Cancelled')} #: type of payment :obj:`.TYPE_IN` or :obj:`.TYPE_OUT` payment_type = EnumCol(allow_none=False, default=TYPE_IN) #: A numeric identifier for this object. This value should be used instead of #: :obj:`Domain.id` when displaying a numerical representation of this object to #: the user, in dialogs, lists, reports and such. identifier = IdentifierCol() #: status, see |payment| for more information. status = EnumCol(allow_none=False, default=STATUS_PREVIEW) #: description payment, usually something like "1/3 Money for Sale 1234" description = UnicodeCol(default=None) # FIXME: use TransactionTimestamp() instead to avoid server/client date # inconsistencies #: when this payment was opened open_date = DateTimeCol(default_factory=localnow) #: when this payment is due due_date = DateTimeCol() #: when this payment was paid paid_date = DateTimeCol(default=None) #: when this payment was cancelled cancel_date = DateTimeCol(default=None) # FIXME: Figure out when and why this differs from value #: base value base_value = PriceCol(default=None) #: value of the payment value = PriceCol() #: the actual amount that was paid, including penalties, interest, discount etc. paid_value = PriceCol(default=None) #: interest of this payment interest = PriceCol(default=0) #: discount, an absolute value with the difference between the #: sales price and :obj:`.value` discount = PriceCol(default=0) #: penalty of the payment penalty = PriceCol(default=0) # FIXME: Figure out what this is used for #: number of the payment payment_number = UnicodeCol(default=None) branch_id = IdCol(allow_none=False) #: |branch| associated with this payment. #: For a :obj:`.TYPE_IN` payment, this is the branch that will receive #: the money. For a :obj:`.TYPE_IN` payment, this is the branch that #: will make the payment branch = Reference(branch_id, 'Branch.id') method_id = IdCol() #: |paymentmethod| for this payment #: payment method = Reference(method_id, 'PaymentMethod.id') group_id = IdCol() #: |paymentgroup| for this payment group = Reference(group_id, 'PaymentGroup.id') category_id = IdCol() #: |paymentcategory| this payment belongs to, can be None category = Reference(category_id, 'PaymentCategory.id') #: list of :class:`comments <stoqlib.domain.payment.comments.PaymentComment>` for #: this payment comments = ReferenceSet('id', 'PaymentComment.payment_id') #: :class:`check data <stoqlib.domain.payment.method.CheckData>` for #: this payment check_data = Reference('id', 'CheckData.payment_id', on_remote=True) #: |accounttransaction| for this payment transaction = Reference('id', 'AccountTransaction.payment_id', on_remote=True) #: indicates if a bill has been received. They are usually delivered by #: mail before the due date. This is not indicating whether the payment has #: been paid, just that the receiver has notified the payer somehow. bill_received = BoolCol(default=False) attachment_id = IdCol() #: |attachment| for this payment attachment = Reference(attachment_id, 'Attachment.id') def __init__(self, store=None, **kw): if not 'value' in kw: raise TypeError('You must provide a value argument') if not 'base_value' in kw or not kw['base_value']: kw['base_value'] = kw['value'] Domain.__init__(self, store=store, **kw) def _check_status(self, status, operation_name): fmt = 'Invalid status for %s operation: %s' assert self.status == status, ( fmt % (operation_name, self.statuses[self.status])) # # ORMObject hooks # def delete(self): # First call hooks, do this first so the hook # have access to everything it needs self.method.operation.payment_delete(self) # FIXME: BUG 5581 check if it is really safe to remove the payment # when using with synced databases self.store.remove(self) @classmethod def create_repeated(cls, store, payment, repeat_type, start_date, end_date): """Create a set of repeated payments. Given a type of interval (*repeat_type*), a start date and an end_date, this creates a list of payments for that interval. Note, this will also update the description of the payment that's passed in. :param store: a store :param payment: the payment to repeat :param repeat_type: the kind of repetition (weekly, monthly etc) :param start_date: the date to start this repetition :param end_date: the date to end this repetition :returns: a list of repeated payments """ dates = create_date_interval(interval_type=repeat_type, start_date=start_date, end_date=end_date) n_dates = dates.count() if n_dates == 1: raise AssertionError description = payment.description payment.description = u'1/%d %s' % (n_dates, description) payment.due_date = dates[0] payments = [] for i, date in enumerate(dates[1:]): p = Payment(open_date=payment.open_date, branch=payment.branch, payment_type=payment.payment_type, status=payment.status, description=u'%d/%d %s' % (i + 2, n_dates, description), value=payment.value, base_value=payment.base_value, due_date=date, method=payment.method, group=payment.group, category=payment.category, store=store) payments.append(p) return payments # # Properties # @property def comments_number(self): """The number of |paymentcomments| for this payment""" return self.comments.count() @property def bank_account_number(self): """For check payments, the :class:`bank account <BankAccount>` number""" # This is used by test_payment_method, and is a convenience # property, ideally we should move it to payment operation # somehow if self.method.method_name == u'check': data = self.method.operation.get_check_data_by_payment(self) bank_account = data.bank_account if bank_account: return bank_account.bank_number @property def installment_number(self): payments = self.group.get_valid_payments().order_by( Payment.identifier) for i, payment in enumerate(payments): if self == payment: return i + 1 @property def status_str(self): """The :obj:`Payment.status` as a translated string""" if not self.status in self.statuses: raise DatabaseInconsistency('Invalid status for Payment ' 'instance, got %d' % self.status) return self.statuses[self.status] def get_days_late(self): """For due payments, the number of days late this payment is :returns: the number of days late """ if self.status == Payment.STATUS_PAID: return 0 days_late = localtoday().date() - self.due_date.date() if days_late.days < 0: return 0 return days_late.days def set_pending(self): """Set a :obj:`.STATUS_PREVIEW` payment as :obj:`.STATUS_PENDING`. This also means that this is valid payment and its owner actually can charge it """ self._check_status(self.STATUS_PREVIEW, u'set_pending') self.status = self.STATUS_PENDING def set_not_paid(self, change_entry): """Set a :obj:`.STATUS_PAID` payment as :obj:`.STATUS_PENDING`. This requires clearing paid_date and paid_value :param change_entry: a :class:`PaymentChangeHistory` object, that will hold the changes information """ self._check_status(self.STATUS_PAID, u'set_not_paid') if self.transaction: self.transaction.create_reverse() change_entry.last_status = self.STATUS_PAID change_entry.new_status = self.STATUS_PENDING sale = self.group and self.group.sale if sale and sale.can_set_not_paid(): sale.set_not_paid() self.status = self.STATUS_PENDING self.paid_date = None self.paid_value = None def pay(self, paid_date=None, paid_value=None, source_account=None, destination_account=None, account_transaction_number=None): """Pay the current payment set its status as :obj:`.STATUS_PAID` If this payment belongs to a sale, and all other payments from the sale are paid then the sale will be set as paid. """ if self.status != Payment.STATUS_PENDING: raise ValueError(_(u"This payment is already paid.")) self._check_status(self.STATUS_PENDING, u'pay') paid_value = paid_value or (self.value - self.discount + self.interest) self.paid_value = paid_value self.paid_date = paid_date or TransactionTimestamp() self.status = self.STATUS_PAID if (self.is_separate_payment() or self.method.operation.create_transaction()): AccountTransaction.create_from_payment( self, code=account_transaction_number, source_account=source_account, destination_account=destination_account) sale = self.group and self.group.sale if sale: sale.create_commission(self) # When paying payments of a sale, check if the other payments are # paid. If they are, this means you can change the sale status to # paid as well. if sale.can_set_paid(): sale.set_paid() if self.value == self.paid_value: msg = _(u"{method} payment with value {value:.2f} was paid").format( method=self.method.method_name, value=self.value) else: msg = _(u"{method} payment with value original value " u"{original_value:.2f} was paid with value " u"{value:.2f}").format(method=self.method.method_name, original_value=self.value, value=self.paid_value) Event.log(self.store, Event.TYPE_PAYMENT, msg.capitalize()) def cancel(self, change_entry=None): """Cancel the payment, set it's status to :obj:`.STATUS_CANCELLED` """ # TODO Check for till entries here and call cancel_till_entry if # it's possible. Bug 2598 if not self.can_cancel(): raise StoqlibError(_(u"Invalid status for cancel operation, " u"got %s") % self.status_str) if self.transaction: self.transaction.create_reverse() old_status = self.status self.status = self.STATUS_CANCELLED self.cancel_date = TransactionTimestamp() if change_entry is not None: change_entry.last_status = old_status change_entry.new_status = self.status msg = _(u"{method} payment with value {value:.2f} was cancelled").format( method=self.method.method_name, value=self.value) Event.log(self.store, Event.TYPE_PAYMENT, msg.capitalize()) def change_due_date(self, new_due_date): """Changes the payment due date. :param new_due_date: The new due date for the payment. :rtype: datetime.date """ if self.status in [Payment.STATUS_PAID, Payment.STATUS_CANCELLED]: raise StoqlibError(_(u"Invalid status for change_due_date operation, " u"got %s") % self.status_str) self.due_date = new_due_date def update_value(self, new_value): """Update the payment value. """ self.value = new_value def can_cancel(self): return self.status in (Payment.STATUS_PREVIEW, Payment.STATUS_PENDING, Payment.STATUS_PAID) def get_payable_value(self): """Returns the calculated payment value with the daily interest. Note that the payment group daily_interest must be between 0 and 100. :returns: the payable value """ if self.status in [self.STATUS_PREVIEW, self.STATUS_CANCELLED]: return self.value if self.status in [self.STATUS_PAID, self.STATUS_REVIEWING, self.STATUS_CONFIRMED]: return self.paid_value return self.value + self.get_interest() def get_penalty(self, date=None): """Calculate the penalty in an absolute value :param date: date of payment :returns: penalty :rtype: :class:`kiwi.currency.currency` """ if date is None: date = localtoday().date() elif date < self.open_date.date(): raise ValueError(_(u"Date can not be less then open date")) elif date > localtoday().date(): raise ValueError(_(u"Date can not be greather then future date")) if not self.method.penalty: return currency(0) # Don't add penalty if we pay in time! if self.due_date.date() >= date: return currency(0) return currency(self.method.penalty / 100 * self.value) def get_interest(self, date=None, pay_penalty=True): """Calculate the interest in an absolute value :param date: date of payment :returns: interest :rtype: :class:`kiwi.currency.currency` """ if date is None: date = localtoday().date() elif date < self.open_date.date(): raise ValueError(_(u"Date can not be less then open date")) elif date > localtoday().date(): raise ValueError(_(u"Date can not be greather then future date")) if not self.method.daily_interest: return currency(0) days = (date - self.due_date.date()).days if days <= 0: return currency(0) base_value = self.value + (pay_penalty and self.get_penalty(date=date)) return currency(days * self.method.daily_interest / 100 * base_value) def has_commission(self): """Check if this |payment| already has a |commission|""" from stoqlib.domain.commission import Commission return self.store.find(Commission, payment=self).any() def is_paid(self): """Check if the payment is paid. :returns: ``True`` if the payment is paid """ return self.status == Payment.STATUS_PAID def is_pending(self): """Check if the payment is pending. :returns: ``True`` if the payment is pending """ return self.status == Payment.STATUS_PENDING def is_preview(self): """Check if the payment is in preview state :returns: ``True`` if the payment is paid """ return self.status == Payment.STATUS_PREVIEW def is_cancelled(self): """Check if the payment was cancelled. :returns: ``True`` if the payment was cancelled """ return self.status == Payment.STATUS_CANCELLED def get_paid_date_string(self): """Get a paid date string :returns: the paid date string or PAID DATE if the payment isn't paid """ if self.paid_date: return self.paid_date.date().strftime('%x') return _(u'NOT PAID') def get_open_date_string(self): """Get a open date string :returns: the open date string or empty string """ if self.open_date: return self.open_date.date().strftime('%x') return u"" def is_inpayment(self): """Find out if a payment is :obj:`incoming <.TYPE_IN>` :returns: ``True`` if it's incoming """ return self.payment_type == self.TYPE_IN def is_outpayment(self): """Find out if a payment is :obj:`outgoing <.TYPE_OUT>` :returns: ``True`` if it's outgoing """ return self.payment_type == self.TYPE_OUT def is_separate_payment(self): """Find out if this payment is created separately from a sale, purchase or renegotiation :returns: ``True`` if it's separate. """ # FIXME: This is a hack, we should rather store a flag # in the database that tells us how the payment was # created. group = self.group if not group: # Should never happen return False if group.sale: return False elif group.purchase: return False elif group._renegotiation: return False return True def is_of_method(self, method_name): """Find out if the payment was made with a certain method :returns: ``True`` if it's a payment of that method """ return self.method.method_name == method_name
class OpticalPatientMeasures(Domain): __storm_table__ = 'optical_patient_measures' EYE_LEFT = u'left' EYE_RIGHT = u'right' eye_options = { EYE_LEFT: _('Left Eye'), EYE_RIGHT: _('Right Eye'), } create_date = DateTimeCol(default_factory=StatementTimestamp) client_id = IdCol(allow_none=False) #: The related client client = Reference(client_id, 'Client.id') responsible_id = IdCol(allow_none=False) #: The user that registred this information responsible = Reference(responsible_id, 'LoginUser.id') dominant_eye = EnumCol(allow_none=False, default=EYE_LEFT) le_keratometer_horizontal = UnicodeCol() le_keratometer_vertical = UnicodeCol() le_keratometer_axis = UnicodeCol() re_keratometer_horizontal = UnicodeCol() re_keratometer_vertical = UnicodeCol() re_keratometer_axis = UnicodeCol() le_eyebrown = UnicodeCol() le_eyelash = UnicodeCol() le_conjunctiva = UnicodeCol() le_sclerotic = UnicodeCol() le_iris_diameter = UnicodeCol() le_eyelid = UnicodeCol() le_eyelid_opening = UnicodeCol() le_cornea = UnicodeCol() #: Tear breakup time. How much time the eye takes to produce a tear le_tbut = UnicodeCol() #: test that checks how much tear the eye produces le_schirmer = UnicodeCol() re_eyebrown = UnicodeCol() re_eyelash = UnicodeCol() re_conjunctiva = UnicodeCol() re_sclerotic = UnicodeCol() re_iris_diameter = UnicodeCol() re_eyelid = UnicodeCol() re_eyelid_opening = UnicodeCol() re_cornea = UnicodeCol() #: Tear breakup time. How much time the eye takes to produce a tear re_tbut = UnicodeCol() #: test that checks how much tear the eye produces re_schirmer = UnicodeCol() notes = UnicodeCol() @property def responsible_name(self): return self.responsible.get_description()
class OpticalPatientTest(Domain): __storm_table__ = 'optical_patient_test' create_date = DateTimeCol(default_factory=StatementTimestamp) client_id = IdCol(allow_none=False) #: The related client client = Reference(client_id, 'Client.id') responsible_id = IdCol(allow_none=False) #: The user that registred this information responsible = Reference(responsible_id, 'LoginUser.id') #: The contact lens that is being tested. This could be a reference to a #: |product in the future le_item = UnicodeCol() #: The brand of the tested contact lenses le_brand = UnicodeCol() #: Curva Base - CB le_base_curve = UnicodeCol() le_spherical_degree = UnicodeCol() le_cylindrical = UnicodeCol() le_axis = UnicodeCol() le_diameter = UnicodeCol() le_movement = UnicodeCol() le_centralization = UnicodeCol() le_spin = UnicodeCol() le_fluorescein = UnicodeCol() #: Sobre refração - SRF le_over_refraction = UnicodeCol() le_bichrome = UnicodeCol() #: If the client is satisfied with this product le_client_approved = BoolCol() #: If the client has purchased this product after the test. le_client_purchased = BoolCol() #: If the product being tested was delivered to the client le_delivered = BoolCol() re_item = UnicodeCol() re_brand = UnicodeCol() re_base_curve = UnicodeCol() re_spherical_degree = UnicodeCol() re_cylindrical = UnicodeCol() re_axis = UnicodeCol() re_diameter = UnicodeCol() re_movement = UnicodeCol() re_centralization = UnicodeCol() re_spin = UnicodeCol() re_fluorescein = UnicodeCol() re_over_refraction = UnicodeCol() re_bichrome = UnicodeCol() re_client_approved = BoolCol() re_client_purchased = BoolCol() re_delivered = BoolCol() #: Free notes notes = UnicodeCol() @property def responsible_name(self): return self.responsible.get_description()
class OpticalWorkOrder(Domain): """This holds the necessary information to execute an work order for optical stores. This includes all the details present in the prescription. For reference: http://en.wikipedia.org/wiki/Eyeglass_prescription See http://en.wikipedia.org/wiki/Eyeglass_prescription#Abbreviations_and_terms for reference no the names used here. In some places, RE is used as a short for right eye, and LE for left eye """ __storm_table__ = 'optical_work_order' #: Lens used in glasses LENS_TYPE_OPHTALMIC = u'ophtalmic' #: Contact lenses LENS_TYPE_CONTACT = u'contact' #: The frame for the lens is a closed ring FRAME_TYPE_CLOSED_RING = u'closed-ring' #: The frame uses a nylon string to hold the lenses. FRAME_TYPE_NYLON = u'nylon' #: The frame is made 3 pieces FRAME_TYPE_3_PIECES = u'3-pieces' lens_types = { LENS_TYPE_OPHTALMIC: _('Ophtalmic'), LENS_TYPE_CONTACT: _('Contact'), } frame_types = { # Translators: Aro fechado FRAME_TYPE_3_PIECES: _('Closed ring'), # Translators: Fio de nylon FRAME_TYPE_NYLON: _('Nylon String'), # Translators: 3 preças FRAME_TYPE_CLOSED_RING: _('3 pieces'), } work_order_id = IdCol(allow_none=False) work_order = Reference(work_order_id, 'WorkOrder.id') medic_id = IdCol() medic = Reference(medic_id, 'OpticalMedic.id') prescription_date = DateTimeCol() #: The name of the patient. Note that we already have the client of the work #: order, but the patient may be someone else (like the son, father, #: etc...). Just the name is enough patient = UnicodeCol() #: The type of the lens, Contact or Ophtalmic lens_type = EnumCol(default=LENS_TYPE_OPHTALMIC) # # Frame # #: The type of the frame. One of OpticalWorkOrder.FRAME_TYPE_* frame_type = EnumCol(default=FRAME_TYPE_CLOSED_RING) #: The vertical frame measure frame_mva = DecimalCol(default=decimal.Decimal(0)) #: The horizontal frame measure frame_mha = DecimalCol(default=decimal.Decimal(0)) #: The diagonal frame measure frame_mda = DecimalCol(default=decimal.Decimal(0)) #: The brige is the part of the frame between the two lenses, above the nose. frame_bridge = DecimalCol() # # Left eye distance vision # le_distance_spherical = DecimalCol(default=0) le_distance_cylindrical = DecimalCol(default=0) le_distance_axis = DecimalCol(default=0) le_distance_prism = DecimalCol(default=0) le_distance_base = DecimalCol(default=0) le_distance_height = DecimalCol(default=0) #: Pupil distance (DNP in pt_BR) le_distance_pd = DecimalCol(default=0) le_addition = DecimalCol(default=0) # # Left eye distance vision # le_near_spherical = DecimalCol(default=0) le_near_cylindrical = DecimalCol(default=0) le_near_axis = DecimalCol(default=0) #: Pupil distance (DNP in pt_BR) le_near_pd = DecimalCol(default=0) # # Right eye distance vision # re_distance_spherical = DecimalCol(default=0) re_distance_cylindrical = DecimalCol(default=0) re_distance_axis = DecimalCol(default=0) re_distance_prism = DecimalCol(default=0) re_distance_base = DecimalCol(default=0) re_distance_height = DecimalCol(default=0) #: Pupil distance (DNP in pt_BR) re_distance_pd = DecimalCol(default=0) re_addition = DecimalCol(default=0) # # Right eye near vision # re_near_spherical = DecimalCol(default=0) re_near_cylindrical = DecimalCol(default=0) re_near_axis = DecimalCol(default=0) #: Pupil distance (DNP in pt_BR) re_near_pd = DecimalCol(default=0) # # Class methods # @classmethod def find_by_work_order(cls, store, work_order): return store.find(cls, work_order_id=work_order.id).one() # # Properties # @property def frame_type_str(self): return self.frame_types.get(self.frame_type, '') @property def lens_type_str(self): return self.lens_types.get(self.lens_type, '') # # Public API # def can_create_purchase(self): work_order = self.work_order if work_order.status != WorkOrder.STATUS_WORK_IN_PROGRESS: return False if not work_order.sale: return False purchases = [i.purchase_item for i in work_order.get_items()] # If there are any item in this work order that was not purchased yet, then we # can still create a purchase return None in purchases def create_purchase(self, supplier, work_order_item, is_freebie, branch: Branch, station: BranchStation, user: LoginUser): """Create a purchase :param supplier: the |supplier| of that purchase :param work_order_item: The work order item that a purchase is being created for. :param is_freebie: indicates if the item is a freebie """ sellable = work_order_item.sellable store = self.work_order.store purchase = PurchaseOrder(store=store, branch=branch, station=station, status=PurchaseOrder.ORDER_PENDING, supplier=supplier, responsible=user, work_order=self.work_order) if is_freebie: purchase.notes = _( 'The product %s is a freebie') % sellable.description # FIXME We may want the cost 0, but as it is we wont be able to # receive this purchase without changing the receiving. We must # evaluate the consequences of changing the receiving a little bit # further in order to change that behavior. cost = decimal.Decimal('0.01') else: psi = ProductSupplierInfo.find_by_product_supplier( store, sellable.product, supplier, branch) cost = psi.base_cost if psi else sellable.cost # Add the sellable to the purchase purchase_item = purchase.add_item(sellable, quantity=work_order_item.quantity, cost=cost) work_order_item.purchase_item = purchase_item purchase.confirm(user) return purchase def can_receive_purchase(self, purchase): work_order = self.work_order if not work_order.status == WorkOrder.STATUS_WORK_FINISHED: return False # XXX Lets assume that there is only on purchase return purchase and purchase.status == PurchaseOrder.ORDER_CONFIRMED def receive_purchase(self, purchase_order: PurchaseOrder, station: BranchStation, user: LoginUser, reserve=False): receiving = purchase_order.create_receiving_order(station) receiving.confirm(user) if reserve: self.reserve_products(purchase_order, user) def reserve_products(self, purchase_order, user: LoginUser): for item in self.work_order.get_items(): if not item.purchase_item: continue sale_item = item.sale_item to_reserve = sale_item.quantity - sale_item.quantity_decreased if to_reserve > 0: sale_item.reserve(user, quantize(to_reserve)) def copy(self, target): """Make a copy of self into a target |work_order| :param target: a |work_order| """ props = [ 'lens_type', 'le_distance_spherical', 'le_distance_cylindrical', 'le_distance_axis', 'le_distance_prism', 'le_distance_base', 'le_distance_height', 'le_distance_pd', 'le_addition', 'le_near_spherical', 'le_near_cylindrical', 'le_near_axis', 'le_near_pd', 're_distance_spherical', 're_distance_cylindrical', 're_distance_axis', 're_distance_prism', 're_distance_base', 're_distance_height', 're_distance_pd', 're_addition', 're_near_spherical', 're_near_cylindrical', 're_near_axis', 're_near_pd' ] for prop in props: value = getattr(self, prop) setattr(target, prop, value)
class OpticalPatientHistory(Domain): __storm_table__ = 'optical_patient_history' #: Never used lenses before TYPE_FIRST_USER = u'first-user' #: Is currently a user TYPE_SECOND_USER = u'second-user' #: Has used lenses before, but stopped TYPE_EX_USER = u'ex-user' user_types = collections.OrderedDict([ (TYPE_FIRST_USER, _('First User')), (TYPE_SECOND_USER, _('Second User')), (TYPE_EX_USER, _('Ex-User')), ]) create_date = DateTimeCol(default_factory=StatementTimestamp) client_id = IdCol(allow_none=False) #: The related client client = Reference(client_id, 'Client.id') responsible_id = IdCol(allow_none=False) #: The user that registred this information responsible = Reference(responsible_id, 'LoginUser.id') # # Section 1: General questions # #: If the patient is a first time user for contact lenses or not. user_type = EnumCol(allow_none=False, default=TYPE_FIRST_USER) #: What is the occupation of the patient occupation = UnicodeCol() #: Details about the work environment (if it as air conditioning, dust, #: chemical products) work_environment = UnicodeCol() # # First time user # #: If the patient has ever tested any contact lenses has_tested = UnicodeCol() #: What brands the patient has tested tested_brand = UnicodeCol() #: If previous tests irritated the eye eye_irritation = UnicodeCol() #: What is the main purpose for using contact lenses? purpose_of_use = UnicodeCol() #: How many hours per day the patient intends to use the contact lenses intended_hour_usage = UnicodeCol() # # Second time / ex user # #: Previous brand of the client. previous_brand = UnicodeCol() #: What the previous brand felt like previous_feeling = UnicodeCol() #: Have ever had any cornea issues cornea_issues = UnicodeCol() #: How many hours per day the client used the lenses hours_per_day_usage = UnicodeCol() # # Second time user # #: For how long is a user user_since = UnicodeCol() #: Bring the previous lenses? has_previous_lenses = UnicodeCol() #: Previous lenses observations previous_lenses_notes = UnicodeCol() # # Ex User # #: How long since the last use. last_use = UnicodeCol() #: why stopped using stop_reason = UnicodeCol() #: Did frequent removal of proteins? protein_removal = UnicodeCol() #: What cleaning product used? cleaning_product = UnicodeCol() #: Free notes. history_notes = UnicodeCol() # # Section 2: Adaptation test # #: If the patient ever had eye injuries eye_injury = UnicodeCol() #: Any kind of recent pathology, like pink-eye recent_pathology = UnicodeCol() #: Is currently using eye drops using_eye_drops = UnicodeCol() #: Does the patient have health problems health_problems = UnicodeCol() #: Is the patient is using any kind of medicament using_medicament = UnicodeCol() #: Does the patient family has any health problems family_health_problems = UnicodeCol() #: How the eyes feel at the end of the day (burn, itch, etc...) end_of_day_feeling = UnicodeCol() #: Free notes. adaptation_notes = UnicodeCol() @property def responsible_name(self): return self.responsible.get_description()
class StockDecreaseItem(Domain): """An item in a stock decrease object. Note that objects of this type should not be created manually, only by calling :meth:`StockDecrease.add_sellable` """ __storm_table__ = 'stock_decrease_item' stock_decrease_id = IdCol(default=None) #: The stock decrease this item belongs to stock_decrease = Reference(stock_decrease_id, 'StockDecrease.id') sellable_id = IdCol() #: the |sellable| for this decrease sellable = Reference(sellable_id, 'Sellable.id') batch_id = IdCol() #: If the sellable is a storable, the |batch| that it was removed from batch = Reference(batch_id, 'StorableBatch.id') #: the cost of the |sellable| on the moment this decrease was created cost = PriceCol(default=0) #: the quantity decreased for this item quantity = QuantityCol() #: Id of ICMS tax in product tax template icms_info_id = IdCol() #:the :class:`stoqlib.domain.taxes.InvoiceItemIcms` tax for *self* icms_info = Reference(icms_info_id, 'InvoiceItemIcms.id') #: Id of IPI tax in product tax template ipi_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemIpi` tax for *self* ipi_info = Reference(ipi_info_id, 'InvoiceItemIpi.id') #: Id of PIS tax in product tax template pis_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemPis` tax for *self* pis_info = Reference(pis_info_id, 'InvoiceItemPis.id') #: Id of COFINS tax in product tax template cofins_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemCofins` tax for *self* cofins_info = Reference(cofins_info_id, 'InvoiceItemCofins.id') item_discount = Decimal('0') def __init__(self, store=None, sellable=None, **kwargs): if sellable is None: raise TypeError('You must provide a sellable argument') check_tax_info_presence(kwargs, store) super(StockDecreaseItem, self).__init__(store=store, sellable=sellable, **kwargs) product = self.sellable.product if product: self.ipi_info.set_item_tax(self) self.icms_info.set_item_tax(self) self.pis_info.set_item_tax(self) self.cofins_info.set_item_tax(self) # # Properties # @property def total_cost(self): return currency(self.cost * self.quantity) # # IInvoiceItem implementation # @property def parent(self): return self.stock_decrease @property def base_price(self): return self.cost @property def price(self): return self.cost @property def nfe_cfop_code(self): cfop = self.stock_decrease.cfop.code return cfop.replace('.', '') # # Public API # def decrease(self, branch): # FIXME: We should not be receiving a branch here. We should be using # self.stock_decrease.branch for that. assert branch storable = self.sellable.product_storable if storable: storable.decrease_stock( self.quantity, branch, StockTransactionHistory.TYPE_STOCK_DECREASE, self.id, cost_center=self.stock_decrease.cost_center, batch=self.batch) # # Accessors # def get_total(self): return currency(self.cost * self.quantity) def get_quantity_unit_string(self): unit = self.sellable.unit_description if unit: return u"%s %s" % (self.quantity, unit) return unicode(self.quantity) def get_description(self): return self.sellable.get_description()
class OpticalProduct(Domain): """Stores information about products sold by optical stores. There are 3 main types of products sold by optical stores: - Glass frames (without lenses) - Glass lenses - Contact lenses """ __storm_table__ = 'optical_product' #: The frame of the glases (without lenses) TYPE_GLASS_FRAME = u'glass-frame' #: The glasses to be used with a frame TYPE_GLASS_LENSES = u'glass-lenses' #: Contact lenses TYPE_CONTACT_LENSES = u'contact-lenses' product_id = IdCol(allow_none=False) product = Reference(product_id, 'Product.id') # The type indicates what of the following fields should be edited. optical_type = EnumCol() #: If this product should be reserved automatically when added to the sale #: with work order auto_reserve = BoolCol(default=True) # # Glass frame details # #: The type of the frame (prescription or sunglasses) gf_glass_type = UnicodeCol() #: Size of the frame, accordingly to the manufacturer (may also be a string, #: for instance Large, one size fits all, etc..) gf_size = UnicodeCol() # The type of the lenses used in this frame. (for isntance: demo lens, # solar, polarized, mirrored) gf_lens_type = UnicodeCol() # Color of the frame, accordingly to the manufacturer specification gf_color = UnicodeCol() # # Glass lenses details # # Fotossensivel #: Type of the lenses photosensitivity (for instance: tints, sunsensors, #: transitions, etc...) gl_photosensitive = UnicodeCol() # Anti reflexo #: A description of the anti glare treatment the lenses have. gl_anti_glare = UnicodeCol() # Índice refração #: Decimal value describing the refraction index gl_refraction_index = DecimalCol() # Classificação #: lenses may be monofocal, bifocal or multifocal gl_classification = UnicodeCol() # Adição #: Free text describing the range of the possible additions. gl_addition = UnicodeCol() # Diametro # Free text describing the range of the possible diameters for the lens gl_diameter = UnicodeCol() # Altura #: Free text describing the height of the lens gl_height = UnicodeCol() # Disponibilidade #: Free text describint the avaiability of the lens (in what possible #: parameters they are avaiable. For instance: "-10,00 a -2,25 Cil -2,00" gl_availability = UnicodeCol() # # Contact lenses details # # Grau #: Degree of the lenses, a decimal from -30 to +30, in steps of +- 0.25 cl_degree = DecimalCol() # Classificação #: Free text describing the classification of the lenses (solid, gel, etc..) cl_classification = UnicodeCol() # tipo lente #: The type of the lenses (monofocal, toric, etc..) cl_lens_type = UnicodeCol() # Descarte #: How often the lens should be discarded (anually, daily, etc..) cl_discard = UnicodeCol() # Adição #: Free text describing the addition of the lenses. cl_addition = UnicodeCol() # Cilindrico # XXX: I still need to verify if a decimal column is ok, or if there are # possible text values. #: Cylindrical value of the lenses. cl_cylindrical = DecimalCol() # Eixo # XXX: I still need to verify if a decimal column is ok, or if there are # possible text values. #: Axix of the lenses. cl_axis = DecimalCol() #: Free text color description of the lens (for cosmetic use) cl_color = UnicodeCol() # Curvatura #: Free text description of the curvature. normaly a decimal, but may have #: textual descriptions cl_curvature = UnicodeCol() # # Class methods # @classmethod def get_from_product(cls, product): return product.store.find(cls, product=product).one()
class Loan(Domain): """ A loan is a collection of |sellable| that is being loaned to a |client|, the items are expected to be either be returned to stock or sold via a |sale|. A loan that can hold a set of :class:`loan items <LoanItem>` See also: `schema <http://doc.stoq.com.br/schema/tables/loan.html>`__ `manual <http://doc.stoq.com.br/manual/loan.html>`__ """ __storm_table__ = 'loan' #: The request for a loan has been added to the system, #: we know which of the items the client wishes to loan, #: it's not defined if the client has actually picked up #: the items. STATUS_OPEN = u'open' #: All the products or other sellable items have been #: returned and are available in stock. STATUS_CLOSED = u'closed' #: The loan is cancelled and all the products or other sellable items have #: been returned and are available in stock. STATUS_CANCELLED = u'cancelled' # FIXME: This is missing a few states, # STATUS_LOANED: stock is completely synchronized statuses = collections.OrderedDict([ (STATUS_OPEN, _(u'Opened')), (STATUS_CLOSED, _(u'Closed')), (STATUS_CANCELLED, _(u'Cancelled')), ]) #: A numeric identifier for this object. This value should be used instead of #: :obj:`Domain.id` when displaying a numerical representation of this object to #: the user, in dialogs, lists, reports and such. identifier = IdentifierCol() #: status of the loan status = EnumCol(allow_none=False, default=STATUS_OPEN) #: notes related to this loan. notes = UnicodeCol(default=u'') #: date loan was opened open_date = DateTimeCol(default_factory=localnow) #: date loan was closed close_date = DateTimeCol(default=None) #: loan expires on this date, we expect the items to #: to be returned by this date expire_date = DateTimeCol(default=None) #: the date the loan was cancelled cancel_date = DateTimeCol(default=None) removed_by = UnicodeCol(default=u'') #: the reason the loan was cancelled cancel_reason = UnicodeCol() #: branch where the loan was done branch_id = IdCol() branch = Reference(branch_id, 'Branch.id') #: :class:`user <stoqlib.domain.person.LoginUser>` of the system #: that made the loan # FIXME: Should probably be a SalesPerson, we can find the # LoginUser via te.user_id responsible_id = IdCol() responsible = Reference(responsible_id, 'LoginUser.id') #: client that loaned the items client_id = IdCol(default=None) client = Reference(client_id, 'Client.id') client_category_id = IdCol(default=None) #: the |clientcategory| used for price determination. client_category = Reference(client_category_id, 'ClientCategory.id') #: a list of all items loaned in this loan loaned_items = ReferenceSet('id', 'LoanItem.loan_id') #: |payments| generated by this loan payments = None #: |transporter| used in loan transporter = None invoice_id = IdCol() #: The |invoice| generated by the loan invoice = Reference(invoice_id, 'Invoice.id') #: The responsible for cancelling the loan. At the moment, the #: |loginuser| that cancelled the loan cancel_responsible_id = IdCol() cancel_responsible = Reference(cancel_responsible_id, 'LoginUser.id') def __init__(self, store=None, **kwargs): kwargs['invoice'] = Invoice(store=store, invoice_type=Invoice.TYPE_OUT) super(Loan, self).__init__(store=store, **kwargs) # # Classmethods # @classmethod def get_status_name(cls, status): if not status in cls.statuses: raise DatabaseInconsistency(_("Invalid status %d") % status) return cls.statuses[status] # # IContainer implementation # def add_item(self, loan_item): assert not loan_item.loan loan_item.loan = self def get_items(self): return self.store.find(LoanItem, loan=self) def remove_item(self, loan_item): loan_item.loan = None self.store.maybe_remove(loan_item) # # IInvoice implementation # @property def comments(self): return [Settable(comment=self.notes)] @property def discount_value(self): discount = currency(0) for item in self.get_items(): if item.price > item.sellable.base_price: continue discount += item.sellable.base_price - item.price return discount @property def invoice_subtotal(self): return self.get_sale_base_subtotal() @property def invoice_total(self): return self.get_total_amount() @property def recipient(self): return self.client.person @property def operation_nature(self): # TODO: Save the operation nature in new loan table field. return _(u"Loan") # # Public API # def add_sellable(self, sellable, quantity=1, price=None, batch=None): """Adds a new sellable item to a loan :param sellable: the |sellable| :param quantity: quantity to add, defaults to 1 :param price: optional, the price, it not set the price from the sellable will be used :param batch: the |batch| this sellable comes from if the sellable is a storable. Should be ``None`` if it is not a storable or if the storable does not have batches. """ self.validate_batch(batch, sellable=sellable) price = price or sellable.price base_price = sellable.price return LoanItem(store=self.store, quantity=quantity, loan=self, sellable=sellable, batch=batch, price=price, base_price=base_price) def get_available_discount_for_items(self, user=None, exclude_item=None): """Get available discount for items in this loan The available items discount is the total discount not used by items in this sale. For instance, if we have 2 products with a price of 100 and they can have 10% of discount, we have 20 of discount available. If one of those products price is set to 98, that is, using 2 of it's discount, the available discount is now 18. :param user: passed to :meth:`stoqlib.domain.sellable.Sellable.get_maximum_discount` together with :obj:`.client_category` to check for the max discount for sellables on this sale :param exclude_item: a |saleitem| to exclude from the calculations. Useful if you are trying to get some extra discount for that item and you don't want it's discount to be considered here :returns: the available discount """ available_discount = currency(0) used_discount = currency(0) for item in self.get_items(): if item == exclude_item: continue # Don't put surcharges on the discount, or it can end up negative if item.price > item.sellable.base_price: continue used_discount += item.sellable.base_price - item.price max_discount = item.sellable.get_maximum_discount( category=self.client_category, user=user) / 100 available_discount += item.base_price * max_discount return available_discount - used_discount def set_items_discount(self, discount): """Apply discount on this sale's items :param decimal.Decimal discount: the discount to be applied as a percentage, e.g. 10.0, 22.5 """ new_total = currency(0) item = None candidate = None for item in self.get_items(): item.set_discount(discount) new_total += quantize(item.price * item.quantity) if item.quantity == 1: candidate = item # Since we apply the discount percentage above, items can generate a # 3rd decimal place, that will be rounded to the 2nd, making the value # differ. Find that difference and apply it to a sale item, preferable # to one with a quantity of 1 since, for instance, applying +0,1 to an # item with a quantity of 4 would make it's total +0,4 (+0,3 extra than # we are trying to adjust here). discount_value = (self.get_sale_base_subtotal() * discount) / 100 diff = new_total - self.get_sale_base_subtotal() + discount_value if diff: item = candidate or item item.price -= diff # # Accessors # def get_total_amount(self): """ Fetches the total value of the loan, that is to be paid by the client. It can be calculated as:: Sale total = Sum(product and service prices) + surcharge + interest - discount :returns: the total value """ return currency(self.get_items().sum( Round(LoanItem.price * LoanItem.quantity, DECIMAL_PRECISION)) or 0) def get_client_name(self): if self.client: return self.client.person.name return u'' def get_branch_name(self): if self.branch: return self.branch.get_description() return u'' def get_responsible_name(self): return self.responsible.person.name # # Public API # def sync_stock(self): """Synchronizes the stock of *self*'s :class:`loan items <LoanItem>` Just a shortcut to call :meth:`LoanItem.sync_stock` of all of *self*'s :class:`loan items <LoanItem>` instead of having to do that one by one. """ for loan_item in self.get_items(): # No need to sync stock for products that dont need. if not loan_item.sellable.product.manage_stock: continue loan_item.sync_stock() def can_close(self): """Checks if the loan can be closed. A loan can be closed if it is opened and all the items have been returned or sold. :returns: True if the loan can be closed, False otherwise. """ if self.status != Loan.STATUS_OPEN: return False for item in self.get_items(): if item.sale_quantity + item.return_quantity != item.quantity: return False return True def get_sale_base_subtotal(self): """Get the base subtotal of items Just a helper that, unlike :meth:`.get_sale_subtotal`, will return the total based on item's base price. :returns: the base subtotal """ subtotal = self.get_items().sum( Round(LoanItem.quantity * LoanItem.base_price, DECIMAL_PRECISION)) return currency(subtotal) def close(self): """Closes the loan. At this point, all the loan items have been returned to stock or sold.""" assert self.can_close() self.close_date = localnow() self.status = Loan.STATUS_CLOSED def confirm(self): # Save the operation nature and branch in Invoice table. self.invoice.operation_nature = self.operation_nature self.invoice.branch = self.branch # Since there is no status change here and the event requires # the parameter, we use None old_status = None StockOperationConfirmedEvent.emit(self, old_status)
class LoanItem(Domain): """An item in a :class:`loan <Loan>` Note that when changing :obj:`~.quantity`, :obj:`~.return_quantity` or :obj:`~.sale_quantity` you will need to call :meth:`.sync_stock` to synchronize the stock (increase or decrease it). Also note that objects of this type should never be created manually, only by calling :meth:`Loan.add_sellable` See also: `schema <http://doc.stoq.com.br/schema/tables/loan_item.html>`__ """ __storm_table__ = 'loan_item' #: The total quantity that was loaned. The product stock for this #: will be decreased when the loan stock is synchonized quantity = QuantityCol() #: The loadned quantity that was sold. Will increase stock so #: it's decreased correctly when the #: :class:`sale <stoqlib.domain.sale.Sale>` is confirmed sale_quantity = QuantityCol(default=Decimal(0)) #: The loaned quantity that was returned. Will increase stock return_quantity = QuantityCol(default=Decimal(0)) #: price to use for this :obj:`~.sellable` when creating #: a :class:`sale <stoqlib.domain.sale.Sale>` price = PriceCol() #: original price of a sellable base_price = PriceCol() sellable_id = IdCol(allow_none=False) #: :class:`sellable <stoqlib.domain.sellable.Sellable>` that is loaned #: cannot be *None* sellable = Reference(sellable_id, 'Sellable.id') batch_id = IdCol() #: If the sellable is a storable, the |batch| that it was returned in batch = Reference(batch_id, 'StorableBatch.id') loan_id = IdCol() #: :class:`loan <Loan>` this item belongs to loan = Reference(loan_id, 'Loan.id') icms_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemIcms` tax for *self* icms_info = Reference(icms_info_id, 'InvoiceItemIcms.id') ipi_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemIpi` tax for *self* ipi_info = Reference(ipi_info_id, 'InvoiceItemIpi.id') pis_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemPis` tax for *self* pis_info = Reference(pis_info_id, 'InvoiceItemPis.id') cofins_info_id = IdCol() #: the :class:`stoqlib.domain.taxes.InvoiceItemCofins` tax for *self* cofins_info = Reference(cofins_info_id, 'InvoiceItemCofins.id') def __init__(self, *args, **kwargs): # stores the total quantity that was loaned before synching stock self._original_quantity = 0 # stores the loaned quantity that was returned before synching stock self._original_return_quantity = self.return_quantity check_tax_info_presence(kwargs, kwargs.get('store')) super(LoanItem, self).__init__(*args, **kwargs) product = self.sellable.product if product: self.ipi_info.set_item_tax(self) self.icms_info.set_item_tax(self) self.pis_info.set_item_tax(self) self.cofins_info.set_item_tax(self) def __storm_loaded__(self): super(LoanItem, self).__storm_loaded__() self._original_quantity = self.quantity self._original_return_quantity = self.return_quantity @property def branch(self): return self.loan.branch @property def storable(self): return self.sellable.product_storable # # IInvoiceItem implementation # @property def parent(self): return self.loan @property def item_discount(self): if self.price < self.base_price: return self.base_price - self.price return Decimal('0') @property def cfop_code(self): return u'5917' def sync_stock(self): """Synchronizes the stock, increasing/decreasing it accordingly. Using the stored values when this object is created/loaded, compute how much we should increase or decrease the stock quantity. When setting :obj:`~.quantity`, :obj:`~.return_quantity` or :obj:`~.sale_quantity` be sure to call this to properly synchronize the stock (increase or decrease it). That counts for object creation too. """ loaned = self._original_quantity - self.quantity returned = self.return_quantity - self._original_return_quantity diff_quantity = loaned + returned if diff_quantity > 0: self.storable.increase_stock( diff_quantity, self.branch, StockTransactionHistory.TYPE_RETURNED_LOAN, self.id, batch=self.batch) elif diff_quantity < 0: diff_quantity = -diff_quantity self.storable.decrease_stock(diff_quantity, self.branch, StockTransactionHistory.TYPE_LOANED, self.id, batch=self.batch) # Reset the values used to calculate the stock quantity, just like # when the object as loaded from the database again. self._original_quantity = self.quantity self._original_return_quantity = self.return_quantity def get_remaining_quantity(self): """The remaining quantity that wasn't returned/sold yet This is the same as :obj:`.quantity` - :obj:`.sale_quantity` - :obj:`.return_quantity` """ return self.quantity - self.sale_quantity - self.return_quantity def get_quantity_unit_string(self): return u"%s %s" % (self.quantity, self.sellable.unit_description) def get_total(self): return currency(self.price * self.quantity) def set_discount(self, discount): """Apply *discount* on this item Note that the discount will be applied based on :obj:`.base_price` and then substitute :obj:`.price`, making any previous discount/surcharge being lost :param decimal.Decimal discount: the discount to be applied as a percentage, e.g. 10.0, 22.5 """ self.price = quantize(self.base_price * (1 - Decimal(discount) / 100))
class SellableCategory(Domain): """ A Sellable category. A way to group several |sellables| together, like "Shoes", "Consumer goods", "Services". A category can define markup, tax and commission, the values of the category will only be used when the sellable itself lacks a value. Sellable categories can be grouped recursively. See also: `schema <http://doc.stoq.com.br/schema/tables/sellable_category.html>`__ """ __storm_table__ = 'sellable_category' #: The category description description = UnicodeCol() #: Define the suggested markup when calculating the sellable's price. suggested_markup = PercentCol(default=0) #: A percentage comission suggested for all the sales which products #: belongs to this category. salesperson_commission = PercentCol(default=0) category_id = IdCol(default=None) #: base category of this category, ``None`` for base categories themselves category = Reference(category_id, 'SellableCategory.id') tax_constant_id = IdCol(default=None) #: the |sellabletaxconstant| for this sellable category tax_constant = Reference(tax_constant_id, 'SellableTaxConstant.id') #: the children of this category children = ReferenceSet('id', 'SellableCategory.category_id') # # Properties # @property def full_description(self): """The full description of the category, including its parents, for instance: u"Clothes:Shoes:Black Shoe 14 SL" """ descriptions = [self.description] parent = self.category while parent: descriptions.append(parent.description) parent = parent.category return u':'.join(reversed(descriptions)) # # Public API # def get_children_recursively(self): """Return all the children from this category, recursively This will return all children recursively, e.g.:: A / \ B C / \ D E In this example, calling this from A will return ``set([B, C, D, E])`` """ children = set(self.children) if not len(children): # Base case for the leafs return set() for child in list(children): children |= child.get_children_recursively() return children def get_commission(self): """Returns the commission for this category. If it's unset, return the value of the base category, if any :returns: the commission """ if self.category: return (self.salesperson_commission or self.category.get_commission()) return self.salesperson_commission def get_markup(self): """Returns the markup for this category. If it's unset, return the value of the base category, if any :returns: the markup """ if self.category: # Compare to None as markup can be '0' if self.suggested_markup is not None: return self.suggested_markup return self.category.get_markup() return self.suggested_markup def get_tax_constant(self): """Returns the tax constant for this category. If it's unset, return the value of the base category, if any :returns: the tax constant """ if self.category: return self.tax_constant or self.category.get_tax_constant() return self.tax_constant # # IDescribable # def get_description(self): return self.description # # Classmethods # @classmethod def get_base_categories(cls, store): """Returns all available base categories :param store: a store :returns: categories """ return store.find(cls, category_id=None) # # Domain hooks # def on_create(self): CategoryCreateEvent.emit(self) def on_update(self): CategoryEditEvent.emit(self)
class Sellable(Domain): """ Sellable information of a certain item such a |product| or a |service|. See also: `schema <http://doc.stoq.com.br/schema/tables/sellable.html>`__ """ __storm_table__ = 'sellable' #: the sellable is available and can be used on a |purchase|/|sale| STATUS_AVAILABLE = u'available' #: the sellable is closed, that is, it still exists for references, #: but it should not be possible to create a |purchase|/|sale| with it STATUS_CLOSED = u'closed' statuses = collections.OrderedDict([ (STATUS_AVAILABLE, _(u'Available')), (STATUS_CLOSED, _(u'Closed')), ]) #: a code used internally by the shop to reference this sellable. #: It is usually not printed and displayed to |clients|, barcode is for that. #: It may be used as an shorter alternative to the barcode. code = UnicodeCol(default=u'', validator=_validate_code) #: barcode, mostly for products, usually printed and attached to the #: package. barcode = UnicodeCol(default=u'', validator=_validate_barcode) #: status the sellable is in status = EnumCol(allow_none=False, default=STATUS_AVAILABLE) #: cost of the sellable, this is not tied to a specific |supplier|, #: which may have a different cost. This can also be the production cost of #: manufactured item by the company. cost = PriceCol(default=0) #: price of sellable, how much the |client| paid. base_price = PriceCol(default=0) #: the last time the cost was updated cost_last_updated = DateTimeCol(default_factory=localnow) #: the last time the price was updated price_last_updated = DateTimeCol(default_factory=localnow) #: full description of sellable description = UnicodeCol(default=u'') #: maximum discount allowed max_discount = PercentCol(default=0) #: commission to pay after selling this sellable commission = PercentCol(default=0) #: notes for the sellable notes = UnicodeCol(default=u'') unit_id = IdCol(default=None) #: the |sellableunit|, quantities of this sellable are in this unit. unit = Reference(unit_id, 'SellableUnit.id') category_id = IdCol(default=None) #: a reference to category table category = Reference(category_id, 'SellableCategory.id') tax_constant_id = IdCol(default=None) #: the |sellabletaxconstant|, this controls how this sellable is taxed tax_constant = Reference(tax_constant_id, 'SellableTaxConstant.id') #: the |product| for this sellable or ``None`` product = Reference('id', 'Product.id', on_remote=True) #: the |service| for this sellable or ``None`` service = Reference('id', 'Service.id', on_remote=True) #: the |storable| for this |product|'s sellable product_storable = Reference('id', 'Storable.id', on_remote=True) default_sale_cfop_id = IdCol(default=None) #: the default |cfop| that will be used when selling this sellable default_sale_cfop = Reference(default_sale_cfop_id, 'CfopData.id') #: A special price used when we have a "on sale" state, this #: can be used for promotions on_sale_price = PriceCol(default=0) #: When the promotional/special price starts to apply on_sale_start_date = DateTimeCol(default=None) #: When the promotional/special price ends on_sale_end_date = DateTimeCol(default=None) #: This sellable's images images = ReferenceSet('id', 'Image.sellable_id') def __init__(self, store=None, category=None, cost=None, commission=None, description=None, price=None): """Creates a new sellable :param store: a store :param category: category of this sellable :param cost: the cost, defaults to 0 :param commission: commission for this sellable :param description: readable description of the sellable :param price: the price, defaults to 0 """ Domain.__init__(self, store=store) if category: if commission is None: commission = category.get_commission() if price is None and cost is not None: markup = category.get_markup() price = self._get_price_by_markup(markup, cost=cost) self.category = category self.commission = commission or currency(0) self.cost = cost or currency(0) self.description = description self.price = price or currency(0) # # Helper methods # def _get_price_by_markup(self, markup, cost=None): if cost is None: cost = self.cost return currency(quantize(cost + (cost * (markup / currency(100))))) # # Properties # @property def status_str(self): """The sellable status as a string""" return self.statuses[self.status] @property def unit_description(self): """Returns the description of the |sellableunit| of this sellable :returns: the unit description or an empty string if no |sellableunit| was set. :rtype: unicode """ return self.unit and self.unit.description or u"" @property def image(self): """This sellable's main image.""" # FIXME: Should we use .first() here? What will happen if there are # more than one image with "is_main" flag set to True? There's no way # to prevent that in the database return self.images.find(is_main=True).one() @property def markup(self): """Markup, the opposite of discount, a value added on top of the sale. It's calculated as:: ((cost/price)-1)*100 """ if self.cost == 0: return Decimal(0) return ((self.price / self.cost) - 1) * 100 @markup.setter def markup(self, markup): self.price = self._get_price_by_markup(markup) @property def price(self): if self.is_on_sale(): return self.on_sale_price else: return self.base_price @price.setter def price(self, price): if price < 0: # Just a precaution for gui validation fails. price = 0 if self.is_on_sale(): self.on_sale_price = price else: self.base_price = price # # Accessors # def is_available(self): """Whether the sellable is available and can be sold. :returns: ``True`` if the item can be sold, ``False`` otherwise. """ # FIXME: Perhaps this should be done elsewhere. Johan 2008-09-26 if sysparam.compare_object('DELIVERY_SERVICE', self.service): return True return self.status == self.STATUS_AVAILABLE def set_available(self): """Mark the sellable as available Being available means that it can be ordered or sold. :raises: :exc:`ValueError`: if the sellable is already available """ if self.is_available(): raise ValueError('This sellable is already available') self.status = self.STATUS_AVAILABLE def is_closed(self): """Whether the sellable is closed or not. :returns: ``True`` if closed, ``False`` otherwise. """ return self.status == Sellable.STATUS_CLOSED def close(self): """Mark the sellable as closed. After the sellable is closed, this will call the close method of the service or product related to this sellable. :raises: :exc:`ValueError`: if the sellable is already closed """ if self.is_closed(): raise ValueError('This sellable is already closed') assert self.can_close() self.status = Sellable.STATUS_CLOSED obj = self.service or self.product obj.close() def can_remove(self): """Whether we can delete this sellable from the database. ``False`` if the product/service was used in some cases below:: - Sold or received - The |product| is in a |purchase| """ if self.product and not self.product.can_remove(): return False if self.service and not self.service.can_remove(): return False return super(Sellable, self).can_remove( skip=[('product', 'id'), ('service', 'id'), ('image', 'sellable_id'), ('client_category_price', 'sellable_id')]) def can_close(self): """Whether we can close this sellable. :returns: ``True`` if the product has no stock left or the service is not required by the system (i.e. Delivery service is required). ``False`` otherwise. """ obj = self.service or self.product return obj.can_close() def get_commission(self): return self.commission def get_suggested_markup(self): """Returns the suggested markup for the sellable :returns: suggested markup :rtype: decimal """ return self.category and self.category.get_markup() def get_category_description(self): """Returns the description of this sellables category If it's unset, return the constant from the category, if any :returns: sellable category description or an empty string if no |sellablecategory| was set. :rtype: unicode """ category = self.category return category and category.description or u"" def get_tax_constant(self): """Returns the |sellabletaxconstant| for this sellable. If it's unset, return the constant from the category, if any :returns: the |sellabletaxconstant| or ``None`` if unset """ if self.tax_constant: return self.tax_constant if self.category: return self.category.get_tax_constant() def get_category_prices(self): """Returns all client category prices associated with this sellable. :returns: the client category prices """ return self.store.find(ClientCategoryPrice, sellable=self) def get_category_price_info(self, category): """Returns the :class:`ClientCategoryPrice` information for the given :class:`ClientCategory` and this |sellable|. :returns: the :class:`ClientCategoryPrice` or ``None`` """ info = self.store.find(ClientCategoryPrice, sellable=self, category=category).one() return info def get_price_for_category(self, category): """Given the |clientcategory|, returns the price for that category or the default sellable price. :param category: a |clientcategory| :returns: The value that should be used as a price for this sellable. """ info = self.get_category_price_info(category) if info: return info.price return self.price def get_maximum_discount(self, category=None, user=None): user_discount = user.profile.max_discount if user else 0 if category is not None: info = self.get_category_price_info(category) or self else: info = self return Decimal(max(user_discount, info.max_discount)) def check_code_exists(self, code): """Check if there is another sellable with the same code. :returns: ``True`` if we already have a sellable with the given code ``False`` otherwise. """ return self.check_unique_value_exists(Sellable.code, code) def check_barcode_exists(self, barcode): """Check if there is another sellable with the same barcode. :returns: ``True`` if we already have a sellable with the given barcode ``False`` otherwise. """ return self.check_unique_value_exists(Sellable.barcode, barcode) def check_taxes_validity(self): """Check if icms taxes are valid. This check is done because some icms taxes (such as CSOSN 101) have a 'valid until' field on it. If these taxes has expired, we cannot sell the sellable. Check this method using assert inside a try clause. :raises: :exc:`TaxError` if there are any issues with the sellable taxes. """ icms_template = self.product and self.product.icms_template SellableCheckTaxesEvent.emit(self) if not icms_template: return elif not icms_template.p_cred_sn: return elif not icms_template.is_p_cred_sn_valid(): # Translators: ICMS tax rate credit = Alíquota de crédito do ICMS raise TaxError(_("You cannot sell this item before updating " "the 'ICMS tax rate credit' field on '%s' " "Tax Class.\n" "If you don't know what this means, contact " "the system administrator.") % icms_template.product_tax_template.name) def is_on_sale(self): """Check if the price is currently on sale. :return: ``True`` if it is on sale, ``False`` otherwise """ if not self.on_sale_price: return False return is_date_in_interval( localnow(), self.on_sale_start_date, self.on_sale_end_date) def is_valid_quantity(self, new_quantity): """Whether the new quantity is valid for this sellable or not. If the new quantity is fractioned, check on this sellable unit if it allows fractioned quantities. If not, this new quantity cannot be used. Note that, if the sellable lacks a unit, we will not allow fractions either. :returns: ``True`` if new quantity is Ok, ``False`` otherwise. """ if self.unit and not self.unit.allow_fraction: return not bool(new_quantity % 1) return True def is_valid_price(self, newprice, category=None, user=None, extra_discount=None): """Checks if *newprice* is valid for this sellable Returns a dict indicating whether the new price is a valid price as allowed by the discount by the user, by the category or by the sellable maximum discount :param newprice: The new price that we are trying to sell this sellable for :param category: Optionally define a |clientcategory| that we will get the price info from :param user: The user role may allow a different discount percentage. :param extra_discount: some extra discount for the sellable to be considered for the min_price :returns: A dict with the following keys: * is_valid: ``True`` if the price is valid, else ``False`` * min_price: The minimum price for this sellable. * max_discount: The maximum discount for this sellable. """ if category is not None: info = self.get_category_price_info(category) or self else: info = self max_discount = self.get_maximum_discount(category=category, user=user) min_price = info.price * (1 - max_discount / 100) if extra_discount is not None: # The extra discount can be greater than the min_price, and # a negative min_price doesn't make sense min_price = max(currency(0), min_price - extra_discount) return { 'is_valid': newprice >= min_price, 'min_price': min_price, 'max_discount': max_discount, } def copy_sellable(self, target=None): """This method copies self to another sellable If the |sellable| target is None, a new sellable is created. :param target: The |sellable| target for the copy returns: a |sellable| identical to self """ if target is None: target = Sellable(store=self.store) props = ['base_price', 'category_id', 'cost', 'max_discount', 'commission', 'notes', 'unit_id', 'tax_constant_id', 'default_sale_cfop_id', 'on_sale_price', 'on_sale_start_date', 'on_sale_end_date'] for prop in props: value = getattr(self, prop) setattr(target, prop, value) return target # # IDescribable implementation # def get_description(self, full_description=False): desc = self.description if full_description and self.get_category_description(): desc = u"[%s] %s" % (self.get_category_description(), desc) return desc # # Domain hooks # def on_update(self): obj = self.product or self.service obj.on_update() 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() # # Classmethods # def remove(self): """ Remove this sellable. This will also remove the |product| or |sellable| and |categoryprice| """ assert self.can_remove() # Remove category price before delete the sellable. category_prices = self.get_category_prices() for category_price in category_prices: category_price.remove() for image in self.images: self.store.remove(image) if self.product: self.product.remove() elif self.service: self.service.remove() self.store.remove(self) @classmethod def get_available_sellables_query(cls, store): """Get the sellables that are available and can be sold. For instance, this will filter out the internal sellable used by a |delivery|. This is similar to `.get_available_sellables`, but it returns a query instead of the actual results. :param store: a store :returns: a query expression """ delivery = sysparam.get_object(store, 'DELIVERY_SERVICE') return And(cls.id != delivery.sellable.id, cls.status == cls.STATUS_AVAILABLE) @classmethod def get_available_sellables(cls, store): """Get the sellables that are available and can be sold. For instance, this will filter out the internal sellable used by a |delivery|. :param store: a store :returns: a resultset with the available sellables """ query = cls.get_available_sellables_query(store) return store.find(cls, query) @classmethod def get_unblocked_sellables_query(cls, store, storable=False, supplier=None, consigned=False): """Helper method for get_unblocked_sellables When supplier is not ```None``, you should use this query only with Viewables that join with supplier, like ProductFullStockSupplierView. :param store: a store :param storable: if ``True``, we should filter only the sellables that are also a |storable|. :param supplier: |supplier| to filter on or ``None`` :param consigned: if the sellables are consigned :returns: a query expression """ from stoqlib.domain.product import Product, ProductSupplierInfo query = And(cls.get_available_sellables_query(store), cls.id == Product.id, Product.consignment == consigned) if storable: from stoqlib.domain.product import Storable query = And(query, Sellable.id == Product.id, Storable.id == Product.id) if supplier: query = And(query, Sellable.id == Product.id, Product.id == ProductSupplierInfo.product_id, ProductSupplierInfo.supplier_id == supplier.id) return query @classmethod def get_unblocked_sellables(cls, store, storable=False, supplier=None, consigned=False): """ Returns unblocked sellable objects, which means the available sellables plus the sold ones. :param store: a store :param storable: if `True`, only return sellables that also are |storable| :param supplier: a |supplier| or ``None``, if set limit the returned object to this |supplier| :rtype: queryset of sellables """ query = cls.get_unblocked_sellables_query(store, storable, supplier, consigned) return store.find(cls, query) @classmethod def get_unblocked_by_categories_query(cls, store, categories, include_uncategorized=True): """Returns the available sellables by a list of categories. :param store: a store :param categories: a list of SellableCategory instances :param include_uncategorized: whether or not include the sellables without a category :rtype: generator of sellables """ queries = [] if len(categories): queries.append(In(Sellable.category_id, [c.id for c in categories])) if include_uncategorized: queries.append(Eq(Sellable.category_id, None)) query = cls.get_unblocked_sellables_query(store) return And(query, Or(*queries))
class FiscalBookEntry(Domain): __storm_table__ = 'fiscal_book_entry' (TYPE_PRODUCT, TYPE_SERVICE, TYPE_INVENTORY) = range(3) date = DateTimeCol(default_factory=localnow) is_reversal = BoolCol(default=False) invoice_number = IntCol() cfop_id = IdCol() cfop = Reference(cfop_id, 'CfopData.id') branch_id = IdCol() branch = Reference(branch_id, 'Branch.id') drawee_id = IdCol(default=None) drawee = Reference(drawee_id, 'Person.id') payment_group_id = IdCol(default=None) payment_group = Reference(payment_group_id, 'PaymentGroup.id') iss_value = PriceCol(default=None) icms_value = PriceCol(default=None) ipi_value = PriceCol(default=None) entry_type = IntCol(default=None) @classmethod def has_entry_by_payment_group(cls, store, payment_group, entry_type): return bool( cls.get_entry_by_payment_group(store, payment_group, entry_type)) @classmethod def get_entry_by_payment_group(cls, store, payment_group, entry_type): return store.find(cls, payment_group=payment_group, is_reversal=False, entry_type=entry_type).one() @classmethod def _create_fiscal_entry(cls, store, entry_type, group, cfop, invoice_number, iss_value=0, icms_value=0, ipi_value=0): return FiscalBookEntry(entry_type=entry_type, iss_value=iss_value, ipi_value=ipi_value, icms_value=icms_value, invoice_number=invoice_number, cfop=cfop, drawee=group.recipient, branch=get_current_branch(store), date=TransactionTimestamp(), payment_group=group, store=store) @classmethod def create_product_entry(cls, store, group, cfop, invoice_number, value, ipi_value=0): """Creates a new product entry in the fiscal book :param store: a store :param group: payment group :type group: :class:`PaymentGroup` :param cfop: cfop for the entry :type cfop: :class:`CfopData` :param invoice_number: payment invoice number :param value: value of the payment :param ipi_value: ipi value of the payment :returns: a fiscal book entry :rtype: :class:`FiscalBookEntry` """ return cls._create_fiscal_entry( store, FiscalBookEntry.TYPE_PRODUCT, group, cfop, invoice_number, icms_value=value, ipi_value=ipi_value, ) @classmethod def create_service_entry(cls, store, group, cfop, invoice_number, value): """Creates a new service entry in the fiscal book :param store: a store :param group: payment group :type group: :class:`PaymentGroup` :param cfop: cfop for the entry :type cfop: :class:`CfopData` :param invoice_number: payment invoice number :param value: value of the payment :returns: a fiscal book entry :rtype: :class:`FiscalBookEntry` """ return cls._create_fiscal_entry( store, FiscalBookEntry.TYPE_SERVICE, group, cfop, invoice_number, iss_value=value, ) def reverse_entry(self, invoice_number, iss_value=None, icms_value=None, ipi_value=None): store = self.store icms_value = icms_value if icms_value is not None else self.icms_value iss_value = iss_value if iss_value is not None else self.iss_value ipi_value = ipi_value if ipi_value is not None else self.ipi_value return FiscalBookEntry( entry_type=self.entry_type, iss_value=iss_value, icms_value=icms_value, ipi_value=ipi_value, cfop_id=sysparam.get_object_id('DEFAULT_SALES_CFOP'), branch=self.branch, invoice_number=invoice_number, drawee=self.drawee, is_reversal=True, payment_group=self.payment_group, store=store)
class Invoice(Domain): """Stores information about invoices""" __storm_table__ = 'invoice' TYPE_IN = u'in' TYPE_OUT = u'out' LEGACY_MODE = u'legacy' NFE_MODE = u'nfe' NFCE_MODE = u'nfce' MODES = {55: NFE_MODE, 65: NFCE_MODE} MODE_NAMES = {NFE_MODE: _('NF-e'), NFCE_MODE: _('NFC-e')} #: the invoice number invoice_number = IntCol() #: the operation nature operation_nature = UnicodeCol() #: the invoice type, representing an IN/OUT operation invoice_type = EnumCol(allow_none=False) #: the invoice series series = IntCol(default=None) #: the invoice mode mode = EnumCol(default=None) #: the key generated by NF-e plugin key = UnicodeCol() #: numeric code randomly generated for each NF-e cnf = UnicodeCol() branch_id = IdCol() #: the |branch| where this invoice was generated branch = Reference(branch_id, 'Branch.id') def __init__(self, **kw): if not 'branch' in kw: kw['branch'] = get_current_branch(kw.get('store')) super(Invoice, self).__init__(**kw) @classmethod def get_next_invoice_number(cls, store, mode=None, series=None): return Invoice.get_last_invoice_number(store, series, mode) + 1 @classmethod def get_last_invoice_number(cls, store, series=None, mode=None): """Returns the last invoice number. If there is not an invoice number used, the returned value will be zero. :param store: a store :returns: an integer representing the last sale invoice number """ current_branch = get_current_branch(store) last = store.find(cls, branch=current_branch, series=series, mode=mode).max(cls.invoice_number) return last or 0 def save_nfe_info(self, cnf, key): """ Save the CNF and KEY generated in NF-e. """ self.cnf = cnf self.key = key def check_unique_invoice_number_by_branch(self, invoice_number, branch, mode, series=None): """Check if the invoice_number is used in determined branch :param invoice_number: the invoice number we want to check :param branch: the |branch| of the invoice :param mode: one of the Invoice.mode :param series: the series of the invoice """ queries = { Invoice.invoice_number: invoice_number, Invoice.branch_id: branch.id, Invoice.mode: mode, Invoice.series: series } return self.check_unique_tuple_exists(queries) def check_invoice_info_consistency(self): """If the invoice number is set, series and mode should also be. We should have a database constraint for this, but since these three data isn't saved at once, the constraint would brake every time. """ # FIXME: The nfce plugin is responsible for generating those # information now, but that broke our nfe plugin since it # needs an invoice number, but not the mode an the series. # We should find a better way of handling this since we don't # want to polute the nfe/nfce invoice number namespace. pg = get_plugin_manager() if pg.is_active('nfe'): # pragma nocoverage return # FIXME: We should not use assert in this kind of code since # there's an optimization flag on python that removes all the asserts assert ((self.invoice_number and self.series and self.mode) or (not self.invoice_number and not self.series and not self.mode)) def on_create(self): self.check_invoice_info_consistency() def on_update(self): self.check_invoice_info_consistency()
class DeviceSettings(Domain): __storm_table__ = 'device_settings' type = IntCol() brand = UnicodeCol() model = UnicodeCol() device_name = UnicodeCol() station_id = IdCol() station = Reference(station_id, 'BranchStation.id') is_active = BoolCol(default=True) (SCALE_DEVICE, _UNUSED, CHEQUE_PRINTER_DEVICE) = range(1, 4) device_types = { SCALE_DEVICE: _(u'Scale'), CHEQUE_PRINTER_DEVICE: _(u'Cheque Printer') } # # Domain # def get_printer_description(self): return u"%s %s" % (self.brand.capitalize(), self.model) def get_device_type_name(self, type=None): return DeviceSettings.device_types[type or self.type] # XXX: Maybe stoqdrivers can implement a generic way to do this? def get_interface(self): """ Based on the column values instantiate the stoqdrivers interface for the device itself. """ port = SerialPort(device=self.device_name) if self.type == DeviceSettings.CHEQUE_PRINTER_DEVICE: return ChequePrinter(brand=self.brand, model=self.model, port=port) elif self.type == DeviceSettings.SCALE_DEVICE: return Scale(brand=self.brand, model=self.model, device=self.device_name) raise DatabaseInconsistency("The device type referred by this " "record (%r) is invalid, given %r." % (self, self.type)) def is_a_printer(self): return self.type == DeviceSettings.CHEQUE_PRINTER_DEVICE def is_valid(self): return (all((self.model, self.device_name, self.brand, self.station)) and self.type in DeviceSettings.device_types) @classmethod def get_by_station_and_type(cls, store, station, type): """Fetch all settings for a specific station and type. :param store: a store :param station: a BranchStation instance :param type: device type """ return store.find(cls, station=station, type=type) @classmethod def get_scale_settings(cls, store): """ Get the scale device settings for the current station :param store: a store :returns: a :class:`DeviceSettings` object or None if there is none """ station = get_current_station(store) return store.find(cls, station=station, type=cls.SCALE_DEVICE).one() # # IActive implementation # def inactivate(self): self.is_active = False def activate(self): self.is_active = True def get_status_string(self): if self.is_active: return _(u'Active') return _(u'Inactive') # # IDescribable implementation # def get_description(self): return self.get_printer_description()
class PurchaseOrder(Domain): """Purchase and order definition.""" __storm_table__ = 'purchase_order' ORDER_QUOTING = u'quoting' ORDER_PENDING = u'pending' ORDER_CONFIRMED = u'confirmed' ORDER_CONSIGNED = u'consigned' ORDER_CANCELLED = u'cancelled' ORDER_CLOSED = u'closed' statuses = collections.OrderedDict([ (ORDER_QUOTING, _(u'Quoting')), (ORDER_PENDING, _(u'Pending')), (ORDER_CONFIRMED, _(u'Confirmed')), (ORDER_CONSIGNED, _(u'Consigned')), (ORDER_CANCELLED, _(u'Cancelled')), (ORDER_CLOSED, _(u'Closed')), ]) FREIGHT_FOB = u'fob' FREIGHT_CIF = u'cif' freight_types = {FREIGHT_FOB: _(u'FOB'), FREIGHT_CIF: _(u'CIF')} #: A numeric identifier for this object. This value should be used instead of #: :obj:`Domain.id` when displaying a numerical representation of this object to #: the user, in dialogs, lists, reports and such. identifier = IdentifierCol() status = EnumCol(allow_none=False, default=ORDER_QUOTING) open_date = DateTimeCol(default_factory=localnow, allow_none=False) quote_deadline = DateTimeCol(default=None) expected_receival_date = DateTimeCol(default_factory=localnow) expected_pay_date = DateTimeCol(default_factory=localnow) receival_date = DateTimeCol(default=None) confirm_date = DateTimeCol(default=None) notes = UnicodeCol(default=u'') salesperson_name = UnicodeCol(default=u'') freight_type = EnumCol(allow_none=False, default=FREIGHT_FOB) expected_freight = PriceCol(default=0) surcharge_value = PriceCol(default=0) discount_value = PriceCol(default=0) consigned = BoolCol(default=False) supplier_id = IdCol() supplier = Reference(supplier_id, 'Supplier.id') branch_id = IdCol() branch = Reference(branch_id, 'Branch.id') transporter_id = IdCol(default=None) transporter = Reference(transporter_id, 'Transporter.id') responsible_id = IdCol() responsible = Reference(responsible_id, 'LoginUser.id') group_id = IdCol() group = Reference(group_id, 'PaymentGroup.id') # # IContainer Implementation # def get_items(self, with_children=True): """Get the items of the purchase order :param with_children: indicate if we should fetch children_items or not """ query = PurchaseItem.order == self if not with_children: query = And(query, Eq(PurchaseItem.parent_item_id, None)) return self.store.find(PurchaseItem, query) def remove_item(self, item): if item.order is not self: raise ValueError( _(u'Argument item must have an order attribute ' 'associated with the current purchase instance')) item.order = None self.store.maybe_remove(item) def add_item(self, sellable, quantity=Decimal(1), parent=None): store = self.store return PurchaseItem(store=store, order=self, sellable=sellable, quantity=quantity, parent_item=parent) # # Properties # @property def discount_percentage(self): """Discount by percentage. Note that percentage must be added as an absolute value not as a factor like 1.05 = 5 % of surcharge The correct form is 'percentage = 3' for a discount of 3 %""" discount_value = self.discount_value if not discount_value: return currency(0) subtotal = self.purchase_subtotal assert subtotal > 0, (u'the subtotal should not be zero ' u'at this point') total = subtotal - discount_value percentage = (1 - total / subtotal) * 100 return quantize(percentage) @discount_percentage.setter def discount_percentage(self, value): self.discount_value = self._get_percentage_value(value) @property def surcharge_percentage(self): """Surcharge by percentage. Note that surcharge must be added as an absolute value not as a factor like 0.97 = 3 % of discount. The correct form is 'percentage = 3' for a surcharge of 3 %""" surcharge_value = self.surcharge_value if not surcharge_value: return currency(0) subtotal = self.purchase_subtotal assert subtotal > 0, (u'the subtotal should not be zero ' u'at this point') total = subtotal + surcharge_value percentage = ((total / subtotal) - 1) * 100 return quantize(percentage) @surcharge_percentage.setter def surcharge_percentage(self, value): self.surcharge_value = self._get_percentage_value(value) @property def payments(self): """Returns all valid payments for this purchase This will return a list of valid payments for this purchase, that is, all payments on the payment group that were not cancelled. If you need to get the cancelled too, use self.group.payments. :returns: a list of |payment| """ return self.group.get_valid_payments() # # Private # def _get_percentage_value(self, percentage): if not percentage: return currency(0) subtotal = self.purchase_subtotal percentage = Decimal(percentage) return subtotal * (percentage / 100) def _payback_paid_payments(self): paid_value = self.group.get_total_paid() # If we didn't pay anything yet, there is no need to create a payback. if not paid_value: return money = PaymentMethod.get_by_name(self.store, u'money') payment = money.create_payment( Payment.TYPE_IN, self.group, self.branch, paid_value, description=_(u'%s Money Returned for Purchase %s') % (u'1/1', self.identifier)) payment.set_pending() payment.pay() # # Public API # def is_paid(self): for payment in self.payments: if not payment.is_paid(): return False return True def can_cancel(self): """Find out if it's possible to cancel the order :returns: True if it's possible to cancel the order, otherwise False """ # FIXME: Canceling partial orders disabled until we fix bug 3282 for item in self.get_items(): if item.has_partial_received(): return False return self.status in [ self.ORDER_QUOTING, self.ORDER_PENDING, self.ORDER_CONFIRMED ] def can_close(self): """Find out if it's possible to close the order :returns: True if it's possible to close the order, otherwise False """ # Consigned orders can be closed only after being confirmed if self.status == self.ORDER_CONSIGNED: return False for item in self.get_items(): if not item.has_been_received(): return False return True def confirm(self, confirm_date=None): """Confirms the purchase order :param confirm_data: optional, datetime """ if confirm_date is None: confirm_date = TransactionTimestamp() if self.status not in [ PurchaseOrder.ORDER_PENDING, PurchaseOrder.ORDER_CONSIGNED ]: fmt = _(u'Invalid order status, it should be ' u'ORDER_PENDING or ORDER_CONSIGNED, got %s') raise ValueError(fmt % (self.status_str, )) # In consigned purchases there is no payments at this point. if self.status != PurchaseOrder.ORDER_CONSIGNED: for payment in self.payments: payment.set_pending() if self.supplier: self.group.recipient = self.supplier.person self.responsible = get_current_user(self.store) self.status = PurchaseOrder.ORDER_CONFIRMED self.confirm_date = confirm_date Event.log( self.store, Event.TYPE_ORDER, _(u"Order %s, total value %2.2f, supplier '%s' " u"is now confirmed") % (self.identifier, self.purchase_total, self.supplier.person.name)) def set_consigned(self): if self.status != PurchaseOrder.ORDER_PENDING: raise ValueError( _(u'Invalid order status, it should be ' u'ORDER_PENDING, got %s') % (self.status_str, )) self.responsible = get_current_user(self.store) self.status = PurchaseOrder.ORDER_CONSIGNED def close(self): """Closes the purchase order """ if self.status != PurchaseOrder.ORDER_CONFIRMED: raise ValueError( _(u'Invalid status, it should be confirmed ' u'got %s instead') % self.status_str) self.status = self.ORDER_CLOSED Event.log( self.store, Event.TYPE_ORDER, _(u"Order %s, total value %2.2f, supplier '%s' " u"is now closed") % (self.identifier, self.purchase_total, self.supplier.person.name)) def cancel(self): """Cancels the purchase order """ assert self.can_cancel() # we have to cancel the payments too self._payback_paid_payments() self.group.cancel() self.status = self.ORDER_CANCELLED def receive_item(self, item, quantity_to_receive): if not item in self.get_pending_items(): raise StoqlibError( _(u'This item is not pending, hence ' u'cannot be received')) quantity = item.quantity - item.quantity_received if quantity < quantity_to_receive: raise StoqlibError( _(u'The quantity that you want to receive ' u'is greater than the total quantity of ' u'this item %r') % item) self.increase_quantity_received(item, quantity_to_receive) def increase_quantity_received(self, purchase_item, quantity_received): sellable = purchase_item.sellable items = [ item for item in self.get_items() if item.sellable.id == sellable.id ] qty = len(items) if not qty: raise ValueError( _(u'There is no purchase item for ' u'sellable %r') % sellable) purchase_item.quantity_received += quantity_received def update_products_cost(self): """Update purchase's items cost Update the costs of all products on this purchase to the costs specified in the order. """ for item in self.get_items(): item.sellable.cost = item.cost product = item.sellable.product product_supplier = product.get_product_supplier_info(self.supplier) product_supplier.base_cost = item.cost @property def status_str(self): return PurchaseOrder.translate_status(self.status) @property def freight_type_name(self): if not self.freight_type in self.freight_types.keys(): raise DatabaseInconsistency( _(u'Invalid freight_type, got %d') % self.freight_type) return self.freight_types[self.freight_type] @property def branch_name(self): return self.branch.get_description() @property def supplier_name(self): return self.supplier.get_description() @property def transporter_name(self): if not self.transporter: return u"" return self.transporter.get_description() @property def responsible_name(self): return self.responsible.get_description() @property def purchase_subtotal(self): """Get the subtotal of the purchase. The sum of all the items cost * items quantity """ return currency( self.get_items().sum(PurchaseItem.cost * PurchaseItem.quantity) or 0) @property def purchase_total(self): subtotal = self.purchase_subtotal total = subtotal - self.discount_value + self.surcharge_value if total < 0: raise ValueError(_(u'Purchase total can not be lesser than zero')) # XXX: Since the purchase_total value must have two digits # (at the moment) we need to format the value to a 2-digit number and # then convert it to currency data type, because the subtotal value # may return a 3-or-more-digit value, depending on COST_PRECISION_DIGITS # parameters. return currency(get_formatted_price(total)) @property def received_total(self): """Like {purchase_subtotal} but only takes into account the received items """ return currency(self.get_items().sum( PurchaseItem.cost * PurchaseItem.quantity_received) or 0) def get_remaining_total(self): """The total value to be paid for the items not received yet """ return self.purchase_total - self.received_total def get_pending_items(self, with_children=True): """ Returns a sequence of all items which we haven't received yet. """ return self.get_items(with_children=with_children).find( PurchaseItem.quantity_received < PurchaseItem.quantity) def get_partially_received_items(self): """ Returns a sequence of all items which are partially received. """ return self.get_items().find(PurchaseItem.quantity_received > 0) def get_open_date_as_string(self): return self.open_date and self.open_date.strftime("%x") or u"" def get_quote_deadline_as_string(self): return self.quote_deadline and self.quote_deadline.strftime( "%x") or u"" def get_receiving_orders(self): """Returns all ReceivingOrder related to this purchase order """ from stoqlib.domain.receiving import PurchaseReceivingMap, ReceivingOrder tables = [PurchaseReceivingMap, ReceivingOrder] query = And(PurchaseReceivingMap.purchase_id == self.id, PurchaseReceivingMap.receiving_id == ReceivingOrder.id) return self.store.using(*tables).find(ReceivingOrder, query) def get_data_for_labels(self): """ This function returns some necessary data to print the purchase's items labels """ for purchase_item in self.get_items(): sellable = purchase_item.sellable label_data = Settable(barcode=sellable.barcode, code=sellable.code, description=sellable.description, price=sellable.price, quantity=purchase_item.quantity) yield label_data def has_batch_item(self): """Fetch the storables from this purchase order and returns ``True`` if any of them is a batch storable. :returns: ``True`` if this purchase order has batch items, ``False`` if it doesn't. """ return not self.store.find( Storable, And(self.id == PurchaseOrder.id, PurchaseOrder.id == PurchaseItem.order_id, PurchaseItem.sellable_id == Sellable.id, Sellable.id == Storable.id, Eq(Storable.is_batch, True))).is_empty() # # Classmethods # @classmethod def translate_status(cls, status): if not status in cls.statuses: raise DatabaseInconsistency( _(u'Got an unexpected status value: ' u'%s') % status) return cls.statuses[status]
class Domain(ORMObject): """The base domain for Stoq. This builds on top of :class:`stoqlib.database.properties.ORMObject` and adds: * created and modified |transactionentry|, a log which is mainly used by database synchonization, it allows us to find out what has been modified and created within a specific time frame. * create/update/modify hooks, which some domain objects implement to fire of events that can be used to find out when a specific domain event is triggered, eg a |sale| is created, a |product| is modified. etc. * cloning of domains, when you want to create a new similar domain * function to check if an value of a column is unique within a domain. Not all domain objects need to subclass Domain, some, such as :class:`stoqlib.domain.system.SystemTable` inherit from ORMObject. """ # FIXME: this is only used by pylint __storm_table__ = 'invalid' #: A list of fields from this object that should de added on the #: representation of this object (when calling repr()) repr_fields = [] #: id of this domain class, it's usually the primary key. #: it will automatically update when a new insert is created. #: Note that there might be holes in the sequence numbers, which happens #: due to aborted transactions id = IdCol(primary=True, default=AutoReload) te_id = IntCol(default=AutoReload) #: a |transactionentry| for when the domain object was created and last #: modified te = Reference(te_id, TransactionEntry.id) def __init__(self, *args, **kwargs): self._listen_to_events() ORMObject.__init__(self, *args, **kwargs) def __repr__(self): parts = ['%r' % self.id] for field in self.repr_fields: parts.append('%s=%r' % (field, getattr(self, field))) desc = ' '.join(parts) return '<%s %s>' % (self.__class__.__name__, desc) def __storm_loaded__(self): self._listen_to_events() def __storm_pre_flush__(self): obj_info = get_obj_info(self) pending = obj_info.get("pending") stoq_pending = obj_info.get('stoq-status') store = obj_info.get("store") if pending is PENDING_ADD: obj_info['stoq-status'] = _OBJ_CREATED elif pending is PENDING_REMOVE: obj_info['stoq-status'] = _OBJ_DELETED else: # This is storm's approach to check if the obj has pending changes, # but only makes sense if the obj is not being created/deleted. if (store._get_changes_map(obj_info, True) and stoq_pending not in [_OBJ_CREATED, _OBJ_DELETED]): obj_info['stoq-status'] = _OBJ_UPDATED # # Private # def _listen_to_events(self): event = get_obj_info(self).event event.hook('changed', self._on_object_changed) event.hook('before-removed', self._on_object_before_removed) event.hook('before-commited', self._on_object_before_commited) def _on_object_changed(self, obj_info, variable, old_value, value, from_db): # Only call the hook if the value is coming from python, and is a valid # value (not auto reload) and the value actually changed. if from_db or value is AutoReload or old_value == value: return self.on_object_changed(variable.column.name, old_value, value) def _on_object_before_removed(self, obj_info): # If the obj was created and them removed, nothing needs to be done. # It never really got into the database. if obj_info.get('stoq-status') == _OBJ_CREATED: obj_info['stoq-status'] = None else: self.on_delete() # This is emited right before the object is removed from the store. # We must also remove the transaction entry, but the entry should be # deleted *after* the object is deleted, thats why we need to specify # the flush order. store = obj_info.get("store") store.remove(self.te) store.add_flush_order(self, self.te) def _on_object_before_commited(self, obj_info): # on_create/on_update hooks can modify the object and make it be # flushed again, so lets reset pending before calling them stoq_pending = obj_info.get('stoq-status') obj_info['stoq-status'] = None if stoq_pending == _OBJ_CREATED: self.on_create() elif stoq_pending == _OBJ_UPDATED: self.on_update() # # Public API # def serialize(self): """Returns the object as a dictionary""" dictionary = {} for cls in self.__class__.__mro__: for key, value in cls.__dict__.items(): if isinstance(value, Property): attribute = getattr(self, key) # Handle Identifier Columns as string instead of int if type(attribute) == Identifier: attribute = str(attribute) dictionary[key] = attribute return dictionary def on_create(self): """Called when *self* is about to be created on the database This hook can be overridden on child classes for improved functionality. A trick you may want to use: Use :meth:`ORMObject.get_store` to get the :class:`store <stoqlib.database.runtime.StoqlibStore>` in which *self* lives and do your modifications in it. """ def on_update(self): """Called when *self* is about to be updated on the database This hook can be overridden on child classes for improved functionality. A trick you may want to use: Use :meth:`ORMObject.get_store` to get the :class:`store <stoqlib.database.runtime.StoqlibStore>` in which *self* lives and do your modifications in it. """ def on_delete(self): """Called when *self* is about to be removed from the database This hook can be overridden on child classes for improved functionality. A trick you may want to use: Use :meth:`ORMObject.get_store` to get the :class:`store <stoqlib.database.runtime.StoqlibStore>` in which *self* lives and use it to do a cleanup in other objects for instance, so if the store is rolled back, your cleanup will be rolled back too. Note that modifying *self* doesn't make sense since it will soon be removed from the database. """ def on_object_changed(self, attr, old_value, value): """Hook for when an attribute of this object changes. This is called when any property of the object has the value changed. This will only be called when the value is known (ie, not AutoReload) and the value comes from python, not from the database, and the value has actually changed from the previous value. """ pass def clone(self): """Get a persistent copy of an existent object. Remember that we can not use copy because this approach will not activate ORMObject methods which allow creating persitent objects. We also always need a new id for each copied object. :returns: the copy of ourselves """ warnings.warn("don't use this", DeprecationWarning, stacklevel=2) kwargs = {} for column in get_cls_info(self.__class__).columns: # FIXME: Make sure this is cloning correctly name = column.name if name in ['id', 'identifier', 'te_id']: continue if name.endswith('_id'): name = name[:-3] kwargs[name] = getattr(self, name) klass = type(self) return klass(store=self.store, **kwargs) def check_unique_value_exists(self, attribute, value, case_sensitive=True): """Check database for attribute/value precense Check if we already the given attribute/value pair in the database, but ignoring this object's ones. :param attribute: the attribute that should be unique :param value: value that we will check if exists in the database :param case_sensitive: If the checking should be case sensitive or not. :returns: the existing object or ``None`` """ return self.check_unique_tuple_exists({attribute: value}, case_sensitive) def check_unique_tuple_exists(self, values, case_sensitive=True): """Check database for values presence Check if we already the given attributes and values in the database, but ignoring this object's ones. :param values: dictionary of attributes:values that we will check if exists in the database. :param case_sensitive: If the checking should be case sensitive or not. :returns: the existing object or ``None`` """ if all([value in ['', None] for value in values.values()]): return None clauses = [] for attr, value, in values.items(): self.__class__.validate_attr(attr) if not isinstance(value, unicode) or case_sensitive: clauses.append(attr == value) else: clauses.append(Like(attr, value, case_sensitive=False)) cls = type(self) # Remove myself from the results. if hasattr(self, 'id'): clauses.append(cls.id != self.id) query = And(*clauses) try: return self.store.find(cls, query).one() except NotOneError: # FIXME: Instead of breaking stoq if more than one tuple exists, # simply return the first object, but log a warning about the # database issue. We should have UNIQUE constraints in more places # to be sure that this would never happen values_str = ["%s => %s" % (k.name, v) for k, v in values.items()] log.warning( "more than one result found when trying to " "check_unique_tuple_exists on table '%s' for values: %r" % (self.__class__.__name__, ', '.join(sorted(values_str)))) return self.store.find(cls, query).any() def merge_with(self, other, skip=None, copy_empty_values=True): """Does automatic references updating when merging two objects. This will update all tables that reference the `other` object and make them reference `self` instead. After this it should be safe to remove the `other` object. Since there is no one referencing it anymore. :param skip: A set of (table, column) that should be skiped by the automatic update. This are normally tables that require a special treatment, like when there are constraints. :param copy_empty_values: If True, attributes that are either null or an empty string in self will be updated with the value from the other object (given that the other attribute is not empty as well) """ skip = skip or set() event_skip = DomainMergeEvent.emit(self, other) if event_skip: skip = skip.union(event_skip) if copy_empty_values: self.copy_empty_values(other) refs = self.store.list_references(type(self).id) for (table, column, other_table, other_column, u, d) in refs: if (table, column) in skip: continue clause = Field(table, column) == other.id self.store.execute(Update({column: self.id}, clause, table)) def copy_empty_values(self, other): """Copies the values from other object if missing in self This will copy all values from the other object that are missing from this one. """ empty_values = [None, u''] for attr_property, column in self._storm_columns.items(): self_value = getattr(self, column.name) other_value = getattr(other, column.name) if self_value in empty_values and other_value not in empty_values: setattr(self, column.name, other_value) def can_remove(self, skip=None): """Check if this object can be removed from the database This will check if there's any object referencing self :param skip: an itarable containing the (table, column) to skip the check. Use this to avoid false positives when you will delete those skipped by hand before self. """ skip = skip or set() selects = [] refs = self.store.list_references(self.__class__.id) for t_name, c_name, ot_name, oc_name, u, d in refs: if (t_name, c_name) in skip: continue column = Field(t_name, c_name) selects.append( Select(columns=[1], tables=[t_name], where=column == self.id, limit=1)) # If everything was skipped, there's no query to execute if not len(selects): return True # We can only pass limit=1 to UnionAll if there's more than one select. # If not, storm will put the limit anyway and it will join with the # select's limit producing an error: multiple LIMIT clauses not allowed if len(selects) > 1: extra = {'limit': 1} else: extra = {} return not any(self.store.execute(UnionAll(*selects, **extra))) # # Classmethods # @classmethod def get_temporary_identifier(cls, store): """Returns a temporary negative identifier This should be used when working with syncronized databases and a purchase order is being created in a branch different than the destination branch. The sincronizer will be responsible for setting the definitive identifier once the order arives at the destination """ lower_value = store.find(cls).min(cls.identifier) return min(lower_value or 0, 0) - 1 @classmethod def find_distinct_values(cls, store, attr, exclude_empty=True): """Find distinct values for a given attr :param store: a store :param attr: the attr we are going to get distinct values for :param exclude_empty: if ``True``, empty results (``None`` or empty strings) will be removed from the results :returns: an iterator of the results """ cls.validate_attr(attr) results = store.find(cls) results.config(distinct=True) for value in results.values(attr): if exclude_empty and not value: continue yield value @classmethod def get_max_value(cls, store, attr, validate_attr=True, query=Undef): """Get the maximum value for a given attr On text columns, trying to find the max value for them using MAX() on postgres would result in some problems, like '9' being considered greater than '10' (because the comparison is done from left to right). This will 0-"pad" the values for the comparison, making it compare the way we want. Note that because of that, in the example above, it would return '09' instead of '9' :para store: a store :param attr: the attribute to find the max value for :returns: the maximum value for the attr """ if validate_attr: cls.validate_attr(attr, expected_type=UnicodeCol) max_length = Alias( Select(columns=[Alias(Max(CharLength(attr)), 'max_length')], tables=[cls], where=query), '_max_length') # Using LPad with max_length will workaround most of the cases where # the string comparison fails. For example, the common case would # consider '9' to be greater than '10'. We could test just strings # with length equal to max_length, but than '010' would be greater # than '001' would be greater than '10' (that would be excluded from # the comparison). By doing lpad, '09' is lesser than '10' and '001' # is lesser than '010', working around those cases if query is not Undef and query is not None: data = store.using(cls, max_length).find(cls, query) else: data = store.using(cls, max_length).find(cls) max_batch = data.max( LPad(attr, Field('_max_length', 'max_length'), u'0')) # Make the api consistent and return an ampty string instead of None # if there's no batch registered on the database return max_batch or u'' @classmethod def get_or_create(cls, store, **kwargs): """Get the object from the database that matches the given criteria, and if it doesn't exist, create a new object, with the properties given already set. The properties given ideally should be the primary key, or a candidate key (unique values). :returns: an object matching the query or a newly created one if a matching one couldn't be found. """ obj = store.find(cls, **kwargs).one() if obj is not None: return obj obj = cls(store=store) # Use setattr instead of passing it to the constructor, since not all # constructors accept all properties. There is no check if the # properties are valid since it will fail in the store.find() call above. for key, value in kwargs.items(): setattr(obj, key, value) return obj @classmethod def validate_attr(cls, attr, expected_type=None): """Make sure attr belongs to cls and has the expected type :param attr: the attr we will check if it is on cls :param expected_type: the expected type for the attr to be an instance of. If ``None`` will default to Property :raises: :exc:`TypeError` if the attr is not an instance of expected_type :raises: :exc:`ValueError` if the attr does not belong to this class """ expected_type = expected_type or Property if not issubclass(expected_type, Property): raise TypeError("expected_type %s needs to be a %s subclass" % (expected_type, Property)) # We need to iterate over cls._storm_columns to find the # attr's property because there's no reference to that property # (the descriptor) on the attr for attr_property, column in cls._storm_columns.items(): if column is attr: break else: attr_property = None # pylint raise ValueError("Domain %s does not have a column %s" % (cls.__name__, attr.name)) if not isinstance(attr_property, expected_type): raise TypeError("attr %s needs to be a %s instance" % (attr.name, expected_type)) @classmethod def validate_batch(cls, batch, sellable, storable=None): """Verifies if the given |batch| is valid for the given |sellable|. :param batch: A |storablebatch| that is being validated :param sellable: A |sellable| that we should use to validate against the batch :param storable: If provided, the corresponding |storable| for the given batch, to avoid unecessary queries. """ if not storable: product = sellable.product storable = product and product.storable or None if not batch: # When batch is not given, the only accepted scenarios are that storable is # None or the storable does not require batches if not storable or not storable.is_batch: return raise ValueError('Batch should not be None for %r' % sellable) # From now on, batch is not None if not storable: raise ValueError('Batches should only be used with storables, ' 'but %r is not one' % sellable) if not storable.is_batch: raise ValueError('This storable %r does not require a batch' % storable) if batch.storable != storable: raise ValueError('Given batch %r and storable %r are not related' % (batch, storable))
class PurchaseItem(Domain): """This class stores information of the purchased items. """ __storm_table__ = 'purchase_item' quantity = QuantityCol(default=1) quantity_received = QuantityCol(default=0) quantity_sold = QuantityCol(default=0) quantity_returned = QuantityCol(default=0) #: the cost which helps the purchaser to define the #: main cost of a certain product. base_cost = PriceCol() cost = PriceCol() expected_receival_date = DateTimeCol(default=None) sellable_id = IdCol() #: the |sellable| sellable = Reference(sellable_id, 'Sellable.id') order_id = IdCol() #: the |purchase| order = Reference(order_id, 'PurchaseOrder.id') parent_item_id = IdCol() parent_item = Reference(parent_item_id, 'PurchaseItem.id') children_items = ReferenceSet('id', 'PurchaseItem.parent_item_id') def __init__(self, store=None, **kw): if not 'sellable' in kw: raise TypeError('You must provide a sellable argument') if not 'order' in kw: raise TypeError('You must provide a order argument') # FIXME: Avoding shadowing sellable.cost kw['base_cost'] = kw['sellable'].cost if not 'cost' in kw: kw['cost'] = kw['sellable'].cost Domain.__init__(self, store=store, **kw) # # Accessors # def get_total(self): return currency(self.quantity * self.cost) def get_total_sold(self): return currency(self.quantity_sold * self.cost) def get_received_total(self): return currency(self.quantity_received * self.cost) def has_been_received(self): return self.quantity_received >= self.quantity def has_partial_received(self): return self.quantity_received > 0 def get_pending_quantity(self): return self.quantity - self.quantity_received def get_quantity_as_string(self): unit = self.sellable.unit return u"%s %s" % (format_quantity( self.quantity), unit and unit.description or u"") def get_quantity_received_as_string(self): unit = self.sellable.unit return u"%s %s" % (format_quantity( self.quantity_received), unit and unit.description or u"") @classmethod def get_ordered_quantity(cls, store, sellable): """Returns the quantity already ordered of a given sellable. :param store: a store :param sellable: the sellable we want to know the quantity ordered. :returns: the quantity already ordered of a given sellable or zero if no quantity have been ordered. """ query = And(PurchaseItem.sellable_id == sellable.id, PurchaseOrder.id == PurchaseItem.order_id, PurchaseOrder.status == PurchaseOrder.ORDER_CONFIRMED) ordered_items = store.find(PurchaseItem, query) return ordered_items.sum(PurchaseItem.quantity) or Decimal(0) def return_consignment(self, quantity): """ Return this as a consignment item :param quantity: the quantity to return """ storable = self.sellable.product_storable assert storable storable.decrease_stock( quantity=quantity, branch=self.order.branch, type=StockTransactionHistory.TYPE_CONSIGNMENT_RETURNED, object_id=self.id) def get_component_quantity(self, parent): """Get the quantity of a component. :param parent: the |purchase_item| parent_item of self :returns: the quantity of the component """ for component in parent.sellable.product.get_components(): if self.sellable.product == component.component: return component.quantity
class StockDecrease(Domain): """Stock Decrease object implementation. Stock Decrease is when the user need to manually decrease the stock quantity, for some reason that is not a sale, transfer or other cases already covered in stoqlib. """ __storm_table__ = 'stock_decrease' #: Stock Decrease is still being edited STATUS_INITIAL = u'initial' #: Stock Decrease is confirmed and stock items have been decreased. STATUS_CONFIRMED = u'confirmed' statuses = { STATUS_INITIAL: _(u'Opened'), STATUS_CONFIRMED: _(u'Confirmed') } #: A numeric identifier for this object. This value should be used instead of #: :obj:`Domain.id` when displaying a numerical representation of this object to #: the user, in dialogs, lists, reports and such. identifier = IdentifierCol() #: status of the sale status = EnumCol(allow_none=False, default=STATUS_INITIAL) reason = UnicodeCol(default=u'') #: Some optional additional information related to this sale. notes = UnicodeCol(default=u'') #: the date sale was created confirm_date = DateTimeCol(default_factory=localnow) responsible_id = IdCol() #: who should be blamed for this responsible = Reference(responsible_id, 'LoginUser.id') removed_by_id = IdCol() removed_by = Reference(removed_by_id, 'Employee.id') branch_id = IdCol() #: branch where the sale was done branch = Reference(branch_id, 'Branch.id') #: person who is receiving person_id = IdCol() person = Reference(person_id, 'Person.id') #: the choosen CFOP cfop_id = IdCol() cfop = Reference(cfop_id, 'CfopData.id') # FIXME: Duplicated from Invoice. Remove it #: The invoice number of the stock decrease invoice_number = IntCol() #: the payment group related to this stock decrease group_id = IdCol() group = Reference(group_id, 'PaymentGroup.id') cost_center_id = IdCol() #: the |costcenter| that the cost of the products decreased in this stock #: decrease should be accounted for. When confirming a stock decrease with #: a |costcenter| set, a |costcenterentry| will be created for each product #: decreased. cost_center = Reference(cost_center_id, 'CostCenter.id') #: |transporter| used in stock decrease transporter = None invoice_id = IdCol() #: The |invoice| generated by the stock decrease invoice = Reference(invoice_id, 'Invoice.id') def __init__(self, store=None, **kwargs): kwargs['invoice'] = Invoice(store=store, invoice_type=Invoice.TYPE_OUT) super(StockDecrease, self).__init__(store=store, **kwargs) # # IInvoice implementation # @property def comments(self): return self.reason @property def discount_value(self): return currency(0) @property def invoice_subtotal(self): return currency(self.get_total_cost()) @property def invoice_total(self): return currency(self.get_total_cost()) @property def payments(self): if self.group: return self.group.get_valid_payments().order_by(Payment.open_date) return None @property def recipient(self): return self.person @property def operation_nature(self): # TODO: Save the operation nature in new loan table field. return _(u"Stock decrease") # # Classmethods # @classmethod def get_status_name(cls, status): if not status in cls.statuses: raise DatabaseInconsistency(_(u"Invalid status %d") % status) return cls.statuses[status] def add_item(self, item): assert not item.stock_decrease item.stock_decrease = self def get_items(self): return self.store.find(StockDecreaseItem, stock_decrease=self) def remove_item(self, item): item.stock_decrease = None self.store.maybe_remove(item) # Status def can_confirm(self): """Only stock decreases with status equal to INITIAL can be confirmed :returns: ``True`` if the stock decrease can be confirmed, otherwise ``False`` """ return self.status == StockDecrease.STATUS_INITIAL def confirm(self): """Confirms the stock decrease """ assert self.can_confirm() assert self.branch store = self.store branch = self.branch for item in self.get_items(): if item.sellable.product: ProductHistory.add_decreased_item(store, branch, item) item.decrease(branch) self.status = StockDecrease.STATUS_CONFIRMED # Save the invoice number, operation_nature and branch in Invoice Table self.invoice.invoice_number = self.invoice_number self.invoice.operation_nature = self.operation_nature self.invoice.branch = branch if self.group: self.group.confirm() # # Accessors # def get_branch_name(self): return self.branch.get_description() def get_responsible_name(self): return self.responsible.get_description() def get_removed_by_name(self): if not self.removed_by: return u'' return self.removed_by.get_description() def get_total_items_removed(self): return sum([item.quantity for item in self.get_items()], 0) def get_cfop_description(self): return self.cfop.get_description() def get_total_cost(self): return self.get_items().sum(StockDecreaseItem.cost * StockDecreaseItem.quantity) # Other methods def add_sellable(self, sellable, cost=None, quantity=1, batch=None): """Adds a new sellable item to a stock decrease :param sellable: the |sellable| :param cost: the cost for the decrease. If ``None``, sellable.cost will be used instead :param quantity: quantity to add, defaults to ``1`` :param batch: the |batch| this sellable comes from, if the sellable is a storable. Should be ``None`` if it is not a storable or if the storable does not have batches. """ self.validate_batch(batch, sellable=sellable) if cost is None: cost = sellable.cost return StockDecreaseItem(store=self.store, quantity=quantity, stock_decrease=self, sellable=sellable, batch=batch, cost=cost)