Esempio n. 1
0
 def get_count_remain(remain, item, pointsale_id):
     if remain:
         return PointSaleService.item_to_pointsale_good(
             pointsale.id, item.good_id).count \
             if PointSaleService.item_to_pointsale_good(
             pointsale.id, item.good_id) else ""
     else:
         return item.count
Esempio n. 2
0
 def sync_to_point(cls, obj):
     from applications.point_sale.service import PointSaleService
     try:
         pointsale_id = obj.pointsale_id
         exc_items = []
         if pointsale_id:
             for item in obj.items:
                 pointitem = PointSaleService.sync_good(
                     pointsale_id, item.good_id, item.count_after)
                 exc_items.append(pointitem.id)
         PointSaleService.none_count(pointsale_id, exc_items)
     except Exception as exc:
         raise RevisionService.RevisionServiceException(unicode(exc))
Esempio n. 3
0
    def status(cls, acceptance, status):
        from applications.point_sale.service import PointSaleService
        from applications.price.service import PriceService, DataToUpdatePrice
        debug(u"Смена статуса `прихода` id = '%s' с %s на %s." % (
            acceptance.id, acceptance.status, StatusType[status]))

        if status == DRAFT:
            if acceptance.type == NEW:
                debug(u"Переход `прихода` id = '%s' в статус 'Черновик' и "
                      u"типом 'Новая' сопровождается удалением накладной."
                      % acceptance.id)
                acceptance.items.delete()
                acceptance.invoice.items.delete()
                db.session.delete(acceptance.invoice)

        if status == IN_PROG:
            if acceptance.type == MAIL:
                cls.initial_acceptance_from_mail(acceptance)
            elif acceptance.type == NEW:
                cls.initial_acceptance_from_custom(acceptance)

        if status == VALIDATED:
            if acceptance.type == MAIL:
                for item in acceptance.items:
                    if item.fact_count:
                        PointSaleService.sync_good_increment(
                            acceptance.pointsale_id, item.good_id,
                            item.fact_count)
            elif acceptance.type == NEW:
                invoice = acceptance.invoices[0]
                for item in invoice.items:
                    good = item.good

                    PriceService.create_or_update(good, DataToUpdatePrice(
                        id_commodity=good.commodity_id,
                        price_retail=item.price_retail,
                        price_gross=item.price_gross,
                        price_prev=None,
                        price_post=item.price_with_NDS,
                        NDS=None,
                        number_local=good.number_local,
                        number_global=good.number_global,
                        invoice=invoice))
                    if item.fact_count:
                        PointSaleService.sync_good_increment(
                            acceptance.pointsale_id, item.good_id,
                            item.fact_count)
        old_status = acceptance.status
        acceptance.status = status
        debug(u"Смена статуса `прихода` id = '%s' с %s на %s завершено." % (
            acceptance.id, old_status, StatusType[status]))
Esempio n. 4
0
 def pre_save(self, obj, data):
     try:
         point = PointSaleService.point_save(
             obj=obj, name=obj.name, address=obj.address,
             is_central=obj.is_central)
     except PointSaleService.PointSaleServiceException as exc:
         raise BaseCanoniseResource.CanonException(unicode(exc))
     return point
Esempio n. 5
0
    def status(cls, waybill, status):
        from applications.point_sale.service import PointSaleService
        debug(u"Смена статуса `накладной` id = '%s' с %s на %s." % (
            waybill.id, waybill.status, StatusType[status]))

        if status == FINISH:
            debug(u"Финальный статус `накладной`.")

            from_point = waybill.pointsale_from

            if waybill.receiver:
                debug(u"Пересчет кол-ва товаром на точке "
                      u"отправителе id = '%s'" % from_point.id)
                for item in waybill.items:
                    PointSaleService.sync_good_increment(
                        from_point.id, item.good_id, item.count * -1 if item.count else 0)
            else:
                to_point = waybill.pointsale
                debug(u"Пересчет кол-ва товаров на точке отправителе id = '%s' "
                      u"и точке получаете id = '%s'." % (
                        from_point.id, to_point.id))
                for item in waybill.items:
                    PointSaleService.sync_good_increment(
                        from_point.id, item.good_id, item.count * -1
                        if item.count else 0)
                    PointSaleService.sync_good_increment(
                        to_point.id, item.good_id, item.count if item.count
                        else 0)
            debug(u"Пересчет кол-ва товаров завершен.")
        old_status = waybill.status
        waybill.status = status
        debug(u"Смена статуса `накладной` id = '%s' с %s на %s завершено." % (
            waybill.id, old_status, StatusType[status]))
Esempio n. 6
0
    def get_item_to_acceptance(cls, invoice_id, acceptance_id):
        from applications.point_sale.service import PointSaleService
        from applications.acceptance.service import AcceptanceService
        acceptance = AcceptanceService.get_by_id(acceptance_id)
        pointsale = acceptance.pointsale

        return [{
            "id": item.id,
            "full_name": item.full_name,
            "good_id": item.good_id,
            "price_retail": GoodService.get_price(
                item.good_id).price_retail if GoodService.get_price(
                item.good_id) else "",
            "price_gross": GoodService.get_price(
                item.good_id).price_gross if GoodService.get_price(
                item.good_id) else "",
            "count": PointSaleService.item_to_pointsale_good(
                pointsale.id, item.good_id).count
            if PointSaleService.item_to_pointsale_good(
                pointsale.id, item.good_id) else "",

        } for item in cls.get_items(invoice_id=invoice_id)]
Esempio n. 7
0
 def initial_revision(cls, obj):
     """
     Инициализация ревизии. Если вдруг ревизия не первая, то нужно заполнить
     позиции ревизии пунктами из точки.
     """
     from applications.point_sale.service import PointSaleService
     try:
         pointsale_id = obj.pointsale_id
         if pointsale_id and cls.exists_point(pointsale_id, obj.id):
             items = PointSaleService.items_pointsale(pointsale_id)
             for item in items:
                 rev_item = RevisionService.create_item(
                     obj.id, item.good_id, item.count)
                 db.session.add(rev_item)
     except Exception as exc:
         raise RevisionService.RevisionServiceException(unicode(exc))
Esempio n. 8
0
 def initial_inventory(cls, obj):
     """
     Инициализация ревизии. Если вдруг ревизия не первая, то нужно заполнить
     позиции ревизии пунктами из точки.
     """
     from applications.point_sale.service import PointSaleService
     try:
         location_id = obj.location_id
         if location_id:
             items = PointSaleService.items_pointsale(location_id)
             for item in items:
                 rev_item = cls.create_item(obj.id, item.good_id, item.count,
                                            item.count)
                 db.session.add(rev_item)
     except Exception as exc:
         raise InventoryService.InventoryServiceException(unicode(exc))
Esempio n. 9
0
    def status(cls, waybillreturn, status):
        from applications.point_sale.service import PointSaleService
        from applications.return_app.service import ReturnService
        debug(u"Смена статуса `накладной возврата` %s с %s на %s." % (
            waybillreturn.id, waybillreturn.status, StatusType[status]))

        if status == DRAFT:
            waybillreturn.items.delete()

        if status == IN_PROG:
            waybillreturn.items.delete()
            return_inst = ReturnService.get_by_id(waybillreturn.returninst_id)
            point = waybillreturn.pointsale

            for item in return_inst.items:
                good_id = item.good_id
                res = PointSaleService.item_to_pointsale_good(
                    point.id, good_id)
                if res:
                    itemreturn = WayBillReturnItems()
                    itemreturn.waybill = waybillreturn
                    itemreturn.good_id = good_id
                    itemreturn.count_plan = res.count
                    db.session.add(itemreturn)

        if status == FINISH:
            from_point = waybillreturn.pointsale
            to_point = PointSaleService.get_central()
            for item in waybillreturn.items:
                PointSaleService.sync_good_increment(
                    from_point.id, item.good_id, item.count * -1 if item.count
                    else 0)
                PointSaleService.sync_good_increment(
                    to_point.id, item.good_id, item.count if item.count else 0)

        waybillreturn.status = status
        debug(u"Смена статуса `накладной возврата` %s с %s на %s завершено." % (
            waybillreturn.id, waybillreturn.status, StatusType[status]))
Esempio n. 10
0
    def save_from_json(cls, date, items, provider_id=None, invoice=None):
        """
        Сохраняем накладную с позициями.

        Для редактирования надо передать инстанс накладной в переменную invoice.
        """
        from applications.price.service import DataToUpdatePrice, PriceService
        from applications.point_sale.service import PointSaleService
        try:
            if invoice:
                invmodel = invoice
            else:
                provider = ProviderService.get_by_id(provider_id)

                invmodel = InvoiceService.create_invoice(
                    number=InvoiceService.generate_number(date), date=date,
                    provider=provider, sum_without_NDS=None, sum_with_NDS=None,
                    sum_NDS=None, weight=None, responsible=None)

                db.session.add(invmodel)

            if invoice:
                pointsale = invoice.acceptance.pointsale
                for item in invmodel.items:
                    pointsale_item = PointSaleService.item_to_pointsale_good(
                        pointsale.id, item.good_id)
                    pointsale_item.count -= item.count
                    db.session.add(pointsale_item)
                invmodel.items.delete()
                db.session.add(invmodel)

            for item in items:
                good = GoodService.get_good(item['good_id'])
                name = good.commodity.name
                number_local = good.number_local
                number_global = good.number_global
                full_name = GoodService.generate_name(
                    name, number_local, number_global)

                invoice = invmodel
                count_order= None
                count_postorder = None
                count = item['count_invoice'] if 'count_invoice' in item \
                    else None
                price_without_NDS = item['price_pre'] if 'price_pre' in item \
                    else None
                price_with_NDS = item['price_post'] if 'price_post' in item \
                    else None
                sum_without_NDS = None
                sum_NDS = None
                rate_NDS = item['NDS'] if 'NDS' in item else None
                sum_with_NDS = None
                thematic = None
                count_whole_pack = None
                placer = None
                fact_count = None

                cls.handle_invoiceitem(
                    full_name, name, number_local, number_global, invoice,
                    count_order, count_postorder, count, price_without_NDS,
                    price_with_NDS, sum_without_NDS, sum_NDS, rate_NDS,
                    sum_with_NDS, thematic, count_whole_pack, placer, good,
                    fact_count)

                if 'price_retail' in item or 'price_gross' in item:
                    PriceService.create_or_update(good, DataToUpdatePrice(
                        id_commodity=good.commodity_id,
                        price_retail=item['price_retail'],
                        price_gross=item['price_gross'],
                        price_prev=item['price_prev'] if 'price_prev' in item
                        else None,
                        price_post=item['price_post'],
                        NDS=item['NDS'] if 'NDS' in item else None,
                        number_local=number_local, number_global=number_global,
                        invoice=invmodel))

        except Exception as exc:
            db.session.rollback()
            error(unicode(exc))
            raise InvoiceService.InvoiceServiceException(unicode(exc))
        else:
            db.session.commit()
            return invmodel