def update_fact_count_custom(cls, acceptance, items):
debug(u"Обновление фактического кол-ва по новой `прихода` id = '%s' "
u"начато." % acceptance.id)
from services.mailinvoice import InvoiceService
from applications.good.service import GoodService
invoice = acceptance.invoices[0]
acceptance.items.delete()
invoice.items.delete()
for item in items:
good_id = item[GOOD_OBJ_ATTR][GOOD_ID_ATTR]
fact_count = item[COUNT_ATTR]
price_post = item[PRICE_POST_ATTR]
price_retail = item[PRICE_RETAIL_ATTR]
price_gross = item[PRICE_GROSS_ATTR]
good = GoodService.get_good(good_id)
InvoiceService.handle_invoiceitem(
invoice=invoice, good=good, fact_count=fact_count,
price_with_NDS=price_post, full_name=None, name=None,
number_local=None, number_global=None, count_order=None,
count_postorder=None, count=fact_count,
price_without_NDS=None, sum_NDS=None, sum_with_NDS=None,
thematic=None, count_whole_pack=None, placer=None,
rate_NDS=None, sum_without_NDS=None, price_retail=price_retail,
price_gross=price_gross)
ac_it = AcceptanceItems()
ac_it.good_id = good_id
ac_it.acceptance = acceptance
ac_it.count = fact_count
ac_it.fact_count = fact_count
db.session.add(ac_it)
debug(u"Обновление фактического кол-ва по новой `прихода` id = '%s' "
u"завершено." % acceptance.id)
def initial_acceptance_from_custom(cls, acceptance):
debug(u"Инициализация по новой `прихода` id = '%s' начата."
% acceptance.id)
from services.mailinvoice import InvoiceService
invoice = InvoiceService.create_invoice(
number=InvoiceService.generate_number(acceptance.date),
date=acceptance.date, provider=acceptance.provider
)
acceptance.invoices.append(invoice)
debug(u"Инициализация по новой `прихода` id = '%s' завершена."
% acceptance.id)
def get(self, id):
from services.mailinvoice import InvoiceService
try:
invoice = InvoiceService.get_by_id(id)
return _stub(invoice)
except Exception as exc:
error(unicode(exc))
raise
def handle(self, provider, mail):
from services.mailinvoice import InvoiceService
from db import db
invmodel = InvoiceService.create_invoice(
number=self.number, date=self.date, provider=provider,
sum_without_NDS=self.sum_without_NDS, sum_with_NDS=self.sum_with_NDS,
sum_NDS=self.sum_NDS, weight=self.weight, responsible=self.responsible)
products = self.get_products()
mail.invoice = invmodel
db.session.add(mail)
for product in products:
InvoiceService.handle_invoiceitem(
full_name=product.full_name, name=product.name, number_local=product.number_local,
number_global=product.number_global,
count_order=product.count_order, count_postorder=product.count_postorder,
count=product.count, price_without_NDS=product.price_without_NDS,
price_with_NDS=product.price_with_NDS, sum_without_NDS=product.sum_without_NDS,
sum_NDS=product.sum_NDS, rate_NDS=product.rate_NDS, sum_with_NDS=product.sum_with_NDS,
thematic=product.thematic, count_whole_pack=product.count_whole_pack,
placer=product.placer, invoice=invmodel)
def post(self):
data = request.json['data']
prices = data['items']
invoice_id = data['invoice_id']
invoice = InvoiceService.get_by_id(invoice_id)
try:
PriceService.create_or_update_prices(invoice, prices)
db.session.commit()
except PriceServiceException as err:
debug(unicode(err))
abort(404, message=unicode(err))
except Exception as exc:
error(unicode(exc))
raise
return "ok"
def check_count(cls, invoice_id, good_id, count, waybill_id):
waybill = cls.get_by_id(waybill_id)
from services.mailinvoice import InvoiceService
if waybill.from_type() == FROM_MAIL:
count_item = InvoiceService.get_count_item(invoice_id, good_id)
WayBillItems.query.filter(
WayBillItems.good_id == good_id
)
res = db.session.query(
func.sum(WayBillItems.count).label('sum')).join(WayBill).filter(
WayBill.invoice_id == invoice_id,
WayBillItems.good_id == good_id)
res = res.filter(WayBill.id != waybill_id)
uses_cnt = res.first().sum or 0
return (uses_cnt + count) <= count_item
return True
def create_or_update_prices(cls, invoice_model, data_items):
"""
Создаем или изменяем цены позиций переданной накладной.
"""
invoice_id = invoice_model.id
debug(u"Начало сохранения цен в позициях накладной %d", invoice_id)
from applications.good.service import GoodService
from services.mailinvoice import InvoiceService
try:
for data in data_items:
good_id = data['id_good']
commodity_id = int(data['id_commodity'])
price_retail = float(data['price_retail']) \
if data['price_retail'] else None
price_gross = float(data['price_gross']) \
if data['price_gross'] else None
NDS = float(data['NDS'])
price_prev = float(data['price_prev'])
price_post = float(data['price_post'])
good = GoodService.get_good(good_id)
number_local = data['number_local']
number_global = data['number_global']
item = InvoiceService.get_item_by_invoice_good(invoice_id, good_id)
item.price_retail = price_retail
item.price_gross = price_gross
db.session.add(item)
cls.create_or_update(good, DataToUpdatePrice(
id_commodity=commodity_id, price_retail=price_retail,
price_gross=price_gross, price_prev=price_prev,
price_post=price_post, NDS=NDS, number_local=number_local,
number_global=number_global, invoice=invoice_model))
except Exception as err:
error(
u"Ошибка сохранения цен в позициях накладной %d. %s",
invoice_id, unicode(err))
db.session.rollback()
raise PriceServiceException(err)
else:
db.session.commit()
debug(u"Конец сохранения цен в позициях накладной %d", invoice_id)
def prepared_acceptance(cls, acceptance, date, pointsale_id, type,
provider_id, invoices):
from services.mailinvoice import InvoiceService
from services.helperserv import HelperService
from services.modelhelper import ModelService
if acceptance.id is None or acceptance.status == DRAFT:
if date is None:
raise AcceptanceException(
u"Поле дата - обязательно для заполнения.")
acceptance.date = HelperService.convert_to_pydate(date)
if not ModelService.check_id(
pointsale_id):
raise AcceptanceException(
u"Поле торговая точка - обязательно для заполнения.")
if type is None:
raise AcceptanceException(
u"Нельзя создать приход без типа.")
type = int(type)
if type not in [MAIL, NEW]:
raise AcceptanceException(
u"Передан неверный тип.")
if type == MAIL and not invoices:
raise AcceptanceException(
u"При выбранном типе 'Регулярная накладная' необходимо "
u"указать как минимум одну накладную.")
if type == NEW and not ModelService.check_id(provider_id):
raise AcceptanceException(
u"При выбранном типе 'Новая' необходимо указать "
u"поставщика.")
if type == MAIL:
acceptance.provider_id = None
acceptance.invoices[:] = []
for invoice_id in invoices:
invoice = InvoiceService.get_by_id(invoice_id)
acceptance.invoices.append(invoice)
return acceptance
def get(self, invoice_id):
from services.mailinvoice import InvoiceService
count = InvoiceService.get_count_items(invoice_id)
return {'result': {'count': count}}
def get(self, invoice_id):
from services.mailinvoice import InvoiceService
return {'items': InvoiceService.get_items(invoice_id)}
def get(self, id):
return {"items": InvoiceService.get_items_acceptance(id, remain=False)}
def get(self, id):
return {"items": InvoiceService.get_items_acceptance(id)}
