def post(self):
name = self.args["name"].strip()
code = self.args["code"].strip()
length = self.args.get("length", 0)
width = self.args.get("width", 0)
height = self.args.get("height", 0)
standards_weight = self.args.get("standards_weight", 0)
user = self.current_user
station = self.current_station
valid, message = self.validate_name_and_code(name, code, length, width,
height, standards_weight)
if not valid:
return self.send_fail(message)
new_goods = models.Goods(
name=name,
code=code,
length=check_int(length * 100),
width=check_int(width * 100),
height=check_int(height * 100),
standards_weight=check_int(standards_weight * 100),
creator_id=user.id,
station_id=station.id,
)
self.session.add(new_goods)
self.session.commit()
goods_dict = new_goods.to_dict()
return self.send_success(goods_dict=goods_dict)
def post(self):
date = self.args["date"]
fee_list = self.args["fee_list"]
valid, message = self.validate_fee_list(fee_list)
if not valid:
return self.send_fail(message)
for fee in fee_list:
type = check_int(fee["type"])
money = check_float(fee["money"])
remarks = fee.get("remarks", "")
new_fee = models.Fee(
date=date,
type=type,
money=check_int(money * 100),
remarks=remarks,
station_id=self.current_station.id,
creator_id=self.current_user.id,
)
self.session.add(new_fee)
self.session.commit()
return self.send_success()
def validate_goods_list(self, goods_list):
"""验证商品列表参数"""
if not isinstance(goods_list, list):
return False, "商品列表参数格式有误"
for goods in goods_list:
if not isinstance(goods, dict):
return False, "商品列表参数项格式有误"
if "goods_id" not in goods:
return False, "参数缺失：goods_id"
if "order_goods_name" not in goods:
return False, "参数缺失：order_goods_name"
elif len(goods["order_goods_name"]) > 128:
return False, "商品名过长：{}".format(goods["order_goods_name"])
if "status" not in goods:
return False, "参数缺失：status"
elif goods["status"] not in (0, 1, 2):
return False, "参数无效：status == {}".format(goods["status"])
# 检验商品名称是否重复
name_list = [goods["order_goods_name"] for goods in goods_list]
for name in name_list:
if name_list.count(name) > 1:
return False, "「{0}」商品名称重复".format(name)
# 检验goods_id有效性
goods_ids = {check_int(goods["goods_id"]) for goods in goods_list}
valid_goods_list = models.Goods.get_by_ids(self.session, goods_ids,
self.current_station.id)
valid_goods_ids = {goods.id for goods in valid_goods_list}
if goods_ids != valid_goods_ids:
return False, "提交了无效的商品"
return True, ""
def put(self, stock_outin_record_id):
action = self.args["action"]
amount = self.args.get("amount")
if amount and amount >= 2147483600:
return self.send_fail("出库数量过大")
if amount and amount < 0:
return self.send_fail("出库数量不能为负数")
stock_outin_record = models.StockOutInGoods.get_by_id(
self.session, stock_outin_record_id, self.current_station.id)
if not stock_outin_record:
return self.send_fail("出库记录不存在")
if stock_outin_record.status != 2:
return self.send_fail("出库记录状态有误")
staff = models.Staff.get_by_account_id(self.session,
self.current_user.id,
self.current_station.id)
if not staff:
return self.send_fail("您不是当前中转站的员工")
# 不是超管且没有仓库权限
if staff.super_admin_status != 1 and (
staff.admin_status != 1
or 4 not in staff.admin_permission_list):
return self.send_fail("无权操作出入库记录")
if action == "modify_stock_out_amount":
stock_outin_record.amount = check_int(amount * 100)
self.session.commit()
return self.send_success()
elif action == "stockout_affirm":
return self.stockout_affirm(stock_outin_record)
else:
return self.send_fail("不支持的操作类型")
def validate_goods_list(self, goods_list):
"""验证商品列表参数"""
if not isinstance(goods_list, list):
return False, "商品列表参数格式有误"
for goods in goods_list:
if not isinstance(goods, dict):
return False, "商品列表参数项格式有误"
if "id" not in goods:
return False, "参数缺失：id"
if "allocated_amount" not in goods:
return False, "参数缺失：allocated_amount"
elif check_float(goods["allocated_amount"]) >= 2147483600:
return False, "实配量过大：{}".format(goods["allocated_amount"])
# 有没有无效的分车单货品 ID
order_goods_ids = {check_int(goods["id"]) for goods in goods_list}
valid_goods_list = models.AllocationOrderGoods.get_by_ids(
self.session, order_goods_ids)
valid_goods_ids = {goods.id for goods in valid_goods_list}
if order_goods_ids != valid_goods_ids:
return False, "存在无效的分车单货品"
return True, ""
def validate_allocation_list(self, allocation_list):
"""校验分车列表参数"""
if not isinstance(allocation_list, list):
return False, "分车列表参数格式有误"
for allocation in allocation_list:
if not isinstance(allocation, dict):
return False, "商品列表参数项格式有误"
if "shop_id" not in allocation:
return False, "参数缺失：shop_id"
if "shop_name" not in allocation:
return False, "参数缺失：shop_name"
if "destination" not in allocation:
return False, "参数缺失：destination"
elif check_int(allocation["destination"]) not in {0, 1, 2}:
return False, "参数无效：destination == {}".format(
allocation["destination"])
allocating_amount = allocation.get("allocating_amount")
if allocating_amount:
try:
allocating_amount = float(allocating_amount)
except:
return self.send_fail(
"allocating_amount 格式有误: {}".format(allocating_amount))
return True, ""
def update_payout(self, payout):
payout_type = self.args.get("type", "")
money = self.args["money"]
remarks = self.args.get("remarks", "")
payout.type = payout_type
payout.money = check_int(money * 100)
payout.remarks = remarks
def put(self, goods_id):
accountinfo = self.current_user
station = self.current_station
stock = self.args["stock"]
remarks = self.args.get("remarks", "").strip()
if stock >= 2147483600:
return self.send_fail("库存值过大")
if stock < 0:
return self.send_fail("库存不能为负数")
if len(remarks) > constants.REMARKS_LEN:
return self.send_fail("备注长度超过128位")
goods = models.Goods.get_by_goods_id(self.session, goods_id)
if not goods:
return self.send_fail("此商品不存在")
# 生成修改记录
stock_operation_record = models.StockOperationRecord(
operation_detail="库存修改({0}→{1})".format(
check_float(goods.stock / 100), check_float(stock)),
remarks=remarks,
goods_id=goods_id,
creator_id=accountinfo.id,
station_id=station.id)
# 更新库存成本
goods.stock_cost += check_float(
(stock * 100 - goods.stock) * goods.stock_average_price / 100)
# 修改库存
goods.stock = check_int(stock * 100)
self.session.add(stock_operation_record)
self.session.commit()
return self.send_success()
def update_staff(self, staff):
"""更新员工信息"""
admin_status = self.args["admin_status"]
purchaser_status = self.args["purchaser_status"]
admin_permissions = self.args["admin_permissions"]
purchaser_permissions = self.args["purchaser_permissions"]
position = self.args.get("position", "")
birthday = self.args.get("birthday")
date_onboarding = self.args.get("date_onboarding")
remarks = self.args.get("remarks", "")
realname = self.args.get("realname", "")
# 添加日志
self.add_modify_log(admin_status, purchaser_status, staff,
admin_permissions, purchaser_permissions)
staff.admin_status = admin_status
staff.purchaser_status = purchaser_status
admin_permissions = {
check_int(permission)
for permission in admin_permissions
} - {0}
staff.set_admin_permissions(admin_permissions)
purchaser_permissions = {
check_int(permission)
for permission in purchaser_permissions
} - {0}
staff.set_purchaser_permissions(purchaser_permissions)
staff.position = position
staff.remarks = remarks
staff.account.realname = realname
if birthday:
staff.birthday = birthday
if date_onboarding:
staff.date_onboarding = date_onboarding
def get(self):
page = self.args.get("page", 0)
limit = self.args.get("limit", constants.PAGE_SIZE)
goods_ids = self.args.get("goods_ids")
if limit > constants.PAGE_MAX_LIMIT:
limit = constants.PAGE_SIZE
station = self.current_station
query_set = self.session.query(models.StockOutInGoods)
if goods_ids:
goods_ids = [
check_int(goods_id) for goods_id in goods_ids.split("|")
]
query_set = query_set.filter(
models.StockOutInGoods.goods_id.in_(goods_ids))
stock_outin_record_objects = query_set.filter(models.StockOutInGoods.station_id == station.id,
models.StockOutInGoods.status.in_([1, 3, 4]))\
.order_by(models.StockOutInGoods.create_time.desc())\
.offset(page * limit)\
.limit(limit)\
.all()
stock_outin_record_list = list()
for stock_outin_record in stock_outin_record_objects:
data = stock_outin_record.to_dict()
stock_outin_record_list.append(data)
# 出入库记录商品信息(搜索使用)
goods_ids = [
stock_outin_record.goods_id
for stock_outin_record in stock_outin_record_objects
]
goods_list = []
if len(goods_ids) > 0:
goods_objects = self.session.query(models.Goods) \
.filter(models.Goods.id.in_(goods_ids),
models.Goods.station_id == self.current_station.id,
models.Goods.status == 0) \
.all()
goods_list = [{
"goods_id": goods.id,
"goods_name": goods.name
} for goods in goods_objects]
has_more = len(stock_outin_record_objects) >= limit
return self.send_success(
stock_outin_record_list=stock_outin_record_list,
goods_list=goods_list,
has_more=has_more)
def validate_firm_list(self, firm_list):
"""
[
{
"firm_id": 1,
"remarks": "备注"
},
...
]
"""
if not isinstance(firm_list, list):
return False, "供货商列表参数格式有误"
for firm in firm_list:
if not isinstance(firm, dict):
return False, "供货商字典参数格式有误"
if "firm_id" not in firm:
return False, "参数缺失：firm_id"
elif not is_int(firm["firm_id"]):
return False, "参数 firm_id 应为整数类型"
if "remarks" not in firm:
return False, "参数缺失：remarks"
elif len(firm["remarks"]) > constants.REMARKS_LEN:
return False, "备注长度超过128位"
firm_id_set = {check_int(firm["firm_id"]) for firm in firm_list}
firm_id_list = [check_int(firm["firm_id"]) for firm in firm_list]
if len(firm_id_list) != len(firm_id_set):
return False, "供货商ID重复"
valid_firm_list = models.Firm.get_by_ids(self.session, firm_id_set,
self.current_station.id)
valid_firm_ids = {firm.id for firm in valid_firm_list}
if firm_id_set != valid_firm_ids:
return False, "提交了无效的供货商"
return True, ""
def validate_goods_today_price(self, goods_today_price):
"""验证商品今日报价字典"""
if not isinstance(goods_today_price, dict):
return False, "商品报价字典参数格式有误", ""
for goods_id, price in goods_today_price.items():
try:
int(goods_id)
int(price)
except:
return False, "商品报价参数无效", ""
# 将json数据中的key转换为int类型
goods_today_price = {
check_int(key): value
for key, value in goods_today_price.items()
}
return True, "", goods_today_price
def get(self, keyword):
account_info = self.session.query(models.AccountInfo) \
.filter(or_(models.AccountInfo.id == check_int(keyword),
models.AccountInfo.phone == keyword)) \
.first()
account_data = {}
if account_info:
account_data = {
"id": account_info.id,
"avatar": account_info.headimgurl,
"name": account_info.nickname,
"phone": account_info.phone,
}
return self.send_success(account_data=account_data)
def get(self):
record_date = self.args.get("record_date")
goods_ids = self.args.get("goods_ids")
if goods_ids is not None:
goods_ids = set(map(lambda i: check_int(i), goods_ids.split("|")))
page = self.args.get("page", 0)
limit = self.args.get("limit", constants.PAGE_SIZE)
if limit > constants.PAGE_MAX_LIMIT:
limit = constants.PAGE_SIZE
station = self.current_station
records = self.session.query(models.StockOutInGoods)\
.filter(models.StockOutInGoods.station_id == station.id,
models.StockOutInGoods.status == 2)
if record_date:
records = records.filter(
func.DATE(models.StockOutInGoods.create_time) == record_date)
if goods_ids is not None:
records = records.filter(
models.StockOutInGoods.goods_id.in_(goods_ids))
all_goods_ids = records.with_entities(
models.StockOutInGoods.goods_id).all()
all_goods_ids = {i[0] for i in all_goods_ids}
all_goods = self.session.query(models.Goods) \
.filter(models.Goods.id.in_(all_goods_ids)) \
.all()
records = records.order_by(models.StockOutInGoods.id.desc())\
.offset(page * limit)\
.limit(limit)\
.all()
record_list = list()
for record in records:
data = record.to_dict()
record_list.append(data)
goods_data = [{
"id": goods.id,
"name": goods.name,
} for goods in all_goods]
has_more = len(record_list) >= limit
return self.send_success(record_list=record_list,
goods_data=goods_data,
has_more=has_more)
def update_goods_list(self, demand_order, goods_list):
"""更新订货单货品列表"""
valid, message = self.validate_goods_list(goods_list)
if not valid:
self.send_fail(message)
raise Finish()
wish_order = models.WishOrder.get_by_id(self.session,
demand_order.wish_order_id)
if not wish_order:
self.send_fail("没有找到对应的意向单")
raise Finish()
if wish_order.status >= 3:
self.send_fail("意向单已截止订货")
raise Finish()
demand_order_goods_list = models.DemandOrderGoods.get_by_order_id(
self.session, demand_order.id)
demand_order_goods_dict = {
goods.id: goods
for goods in demand_order_goods_list
}
for goods in goods_list:
demand_goods_id = check_int(goods["id"])
current_storage = round(
check_float(goods.get("current_storage", 0)) * 100)
demand_amount = round(
check_float(goods.get("demand_amount", 0)) * 100)
demand_remarks = goods.get("demand_remarks", "")
demand_order_goods = demand_order_goods_dict[demand_goods_id]
demand_order_goods.current_storage = current_storage
demand_order_goods.demand_amount = demand_amount
demand_order_goods.remarks = demand_remarks
# 初次提交
if demand_order.status == 0:
demand_order.status = 2
def validate_fee_list(self, fee_list):
"""验证费用列表参数"""
if not isinstance(fee_list, list):
return False, "费用列表参数格式有误"
for fee in fee_list:
if not isinstance(fee, dict):
return False, "费用列表参数项格式有误"
if "type" not in fee:
return False, "参数缺失：type"
elif check_int(fee["type"]) not in (1, 2):
return False, "参数无效：type == {}".format(fee["type"])
if "money" not in fee:
return False, "参数缺失：money"
elif check_float(fee["money"]) > 21474836:
return False, "金额过大"
if "remarks" in fee and len(fee["remarks"]) > 128:
return False, "备注不能超过 128 个字符"
return True, ""
def get(self):
api = GetPifaData(self.current_user.passport_id, AuthFunc.gen_token())
ret_dict = api.get_pf_shops(self.current_user.phone)
if not ret_dict["success"]:
return self.send_fail(ret_dict.get("msg", ""))
data_list = []
for data in ret_dict["data_list"]:
data_list.append({
"shop_id":
check_int(PfSimpleEncrypt.decrypt(data.get("shop_id", 0))),
"shop_name":
data.get("shop_name", ""),
"purchase_times":
data.get("purchase_times", 0),
"latest_order_time":
data.get("latest_order_time", ""),
"is_online_order_open":
data.get("is_online_order_open", 0),
})
return self.send_success(data_list=data_list)
def validate_goods_list(self, goods_list):
"""校验商品列表参数"""
if not isinstance(goods_list, list):
return False, "商品列表参数格式有误"
for goods in goods_list:
if not isinstance(goods, dict):
return False, "商品列表参数项格式有误"
if "id" not in goods:
return False, "参数缺失：id"
# 有没有无效的订货单货品 ID
demand_order_goods_ids = {
check_int(goods["id"])
for goods in goods_list if "id" in goods and goods["id"]
}
valid_goods_list = models.DemandOrderGoods.get_by_ids(
self.session, demand_order_goods_ids)
valid_goods_ids = {goods.id for goods in valid_goods_list}
if demand_order_goods_ids != valid_goods_ids:
return False, "存在无效的订货单商品"
return True, ""
def post(self):
goods_id = self.args["goods_id"]
amount = check_int(self.args.get("amount", 0) * 100)
# 以意向日期最新的一个意向单为准
wish_order = self.session.query(models.WishOrder) \
.filter(models.WishOrder.station_id == self.current_station.id,
models.WishOrder.status >= 2) \
.order_by(models.WishOrder.wish_date.desc()) \
.first()
if not wish_order:
return self.send_fail("没有找到已提交的意向单")
goods = models.Goods.get_by_goods_id(self.session, goods_id,
self.current_station.id)
if not goods:
return self.send_fail("没有找到对应的商品")
new_record = models.StockOutInGoods(
station_id=self.current_station.id,
wish_order_id=wish_order.id,
creator_id=self.current_user.id,
operator_id=self.current_user.id,
goods_id=goods_id,
amount=amount,
type=0,
status=2,
)
self.session.add(new_record)
self.session.flush()
models.SerialNumberMap.generate(self.session, 2, new_record.id,
self.current_station.id)
self.session.commit()
return self.send_success()
def purchasing_dynamics(self, record_type, purchase_goods_dict):
"""
给采购小程序记录采购动态
"""
record_type = record_type # 记录类型
goods_id = purchase_goods_dict["goods_id"] # 商品 ID
purchaser_id = purchase_goods_dict["purchaser_id"] # 采购员 ID，不安排采购时为空
creator_id = purchase_goods_dict["creator_id"] # 操作用户 ID
goods_name = purchase_goods_dict["goods_name"] # 商品名称
last_goods_name = purchase_goods_dict["last_goods_name"] # 上次的商品名称
last_goods_name = last_goods_name if last_goods_name else goods_name
actual_amount = check_int(purchase_goods_dict["actual_amount"] * 100) # 实际采购件数
last_actual_amount = purchase_goods_dict["last_actual_amount"] # 上次的采购件数
last_actual_amount = last_actual_amount if last_actual_amount else actual_amount
actual_weight = check_int(purchase_goods_dict["actual_weight"] * 100) # 实际采购重量
last_actual_weight = purchase_goods_dict["last_actual_weight"] # 上次的采购重量
last_actual_weight = last_actual_weight if last_actual_weight else actual_weight
actual_unit = purchase_goods_dict["actual_unit"] # 实际采购单位 0: 件 1: 斤
price = check_int(purchase_goods_dict["price"] * 100) # 采购单价
last_price = purchase_goods_dict["last_price"] # 上次的采购单价
last_price = last_price if last_price else price
subtotal = check_int(purchase_goods_dict["subtotal"] * 100) # 小计
last_subtotal = purchase_goods_dict["last_subtotal"] # 上次的采购小计
last_subtotal = last_subtotal if last_subtotal else subtotal
firm_id = purchase_goods_dict["firm_id"] # 供货商id
last_firm_id = purchase_goods_dict["last_firm_id"] # 上次的供货商id
last_firm_id = last_firm_id if last_firm_id else firm_id
payment = purchase_goods_dict["payment"] # 支付方式 0: 现金 1: 银行卡 2: 微信 3: 支付宝 4: 赊账 5: 其他
is_purchase = purchase_goods_dict["is_purchase"] # 0: 正常 1: 不采了
tag = purchase_goods_dict["tag"] # 商品标签 0: 正常 1：采购员手动添加
remarks = purchase_goods_dict["remarks"] # 采购备注
purchase_order_goods_id = purchase_goods_dict["id"] # 采购单商品 ID
purchase_order_id = purchase_goods_dict["purchase_order_id"] # 采购单 ID
wish_order_goods_id = purchase_goods_dict["wish_order_goods_id"] # 意向单商品 ID, 手动添加的采购商品，没有对应的意向单id
session = DBSession()
new_dynamic = models.PurchasingDynamics(
record_type=record_type,
goods_id=goods_id,
purchaser_id=purchaser_id,
creator_id=creator_id,
goods_name=goods_name,
last_goods_name=last_goods_name,
actual_amount=actual_amount,
last_actual_amount=last_actual_amount,
actual_weight=actual_weight,
last_actual_weight=last_actual_weight,
actual_unit=actual_unit,
price=price,
last_price=last_price,
subtotal=subtotal,
last_subtotal=last_subtotal,
firm_id=firm_id,
last_firm_id=last_firm_id,
payment=payment,
is_purchase=is_purchase,
tag=tag,
remarks=remarks,
purchase_order_goods_id=purchase_order_goods_id,
purchase_order_id=purchase_order_id,
wish_order_goods_id=wish_order_goods_id
)
session.add(new_dynamic)
session.commit()
session.close()
return "success"
def update_shop_financial_statistics(session,
statistics_session,
update_packing=True,
update_shop_payout=True,
date=None,
station_id=None,
shop_ids=None):
statistics_list = statistics_session.query(models_statistics.StatisticsShopFinancial) \
.filter(models_statistics.StatisticsShopFinancial.statistics_type == 0)
if date is not None:
statistics_list = statistics_list.filter(
models_statistics.StatisticsShopFinancial.statistics_date == date)
if station_id is not None:
statistics_list = statistics_list.filter(
models_statistics.StatisticsShopFinancial.station_id == station_id)
if shop_ids is not None:
statistics_list = statistics_list.filter(
models_statistics.StatisticsShopFinancial.shop_id.in_(shop_ids))
statistics_list = statistics_list.all()
statistics_dict = {
"{}:{}".format(s.statistics_date, s.shop_id): s
for s in statistics_list
}
if update_packing:
packing_sums = session.query(func.DATE(models.AllocationOrderGoods.create_time).label("create_date"),
models.AllocationOrderGoods.shop_id,
models.Shop,
func.count(models.AllocationOrder.id).label("allocated_count"),
func.sum(models.ShopPackingPrice.price
* models.AllocationOrderGoods.actual_allocated_amount).label("allocated_sum")) \
.join(models.Shop, models.Shop.id == models.AllocationOrderGoods.shop_id) \
.join(models.AllocationOrder, models.AllocationOrder.id == models.AllocationOrderGoods.order_id) \
.join(models.ShopPackingPrice, and_(models.ShopPackingPrice.shop_id == models.AllocationOrderGoods.shop_id,
models.ShopPackingPrice.wish_order_id == models.AllocationOrder.wish_order_id,
models.ShopPackingPrice.goods_id == models.AllocationOrder.goods_id)) \
.filter(models.AllocationOrder.status == 1)
if date is not None:
packing_sums = packing_sums.filter(
func.DATE(models.AllocationOrderGoods.create_time) == date)
if station_id is not None:
packing_sums = packing_sums.filter(
models.AllocationOrder.station_id == station_id)
if shop_ids is not None:
packing_sums = packing_sums.filter(
models.AllocationOrderGoods.shop_id.in_(shop_ids))
packing_sums = packing_sums.group_by(
func.DATE(models.AllocationOrderGoods.create_time),
models.AllocationOrderGoods.shop_id).all()
for packing_sum in packing_sums:
key = "{}:{}".format(packing_sum.create_date, packing_sum.shop_id)
statistics = statistics_dict.get(key)
if not statistics:
statistics = models_statistics.StatisticsShopFinancial(
statistics_date=packing_sum.create_date,
statistics_type=0,
station_id=packing_sum.Shop.station_id,
shop_id=packing_sum.shop_id,
)
statistics_session.add(statistics)
statistics_session.flush()
statistics_dict[key] = statistics
statistics.allocation_count = packing_sum.allocated_count or 0
statistics.allocation_money = check_int(
(packing_sum.allocated_sum or 0) / 100)
if update_shop_payout:
payouts = session.query(
models.ShopPayout.date, models.ShopPayout.shop_id,
models.ShopPayout.station_id,
func.count(models.ShopPayout.id).label("payout_count"),
func.sum(models.ShopPayout.money).label("payout_sum"))
if date is not None:
payouts = payouts.filter(models.ShopPayout.date == date)
if station_id is not None:
payouts = payouts.filter(
models.ShopPayout.station_id == station_id)
if shop_ids is not None:
payouts = payouts.filter(models.ShopPayout.shop_id.in_(shop_ids))
payouts = payouts.group_by(models.ShopPayout.date, models.ShopPayout.shop_id) \
.all()
for payout in payouts:
key = "{}:{}".format(payout.date, payout.shop_id)
statistics = statistics_dict.get(key)
if not statistics:
statistics = models_statistics.StatisticsShopFinancial(
statistics_date=payout.date,
statistics_type=0,
station_id=payout.station_id,
shop_id=payout.shop_id,
)
statistics_session.add(statistics)
statistics_session.flush()
statistics_dict[key] = statistics
statistics.shop_payout_count = payout.payout_count or 0
statistics.shop_payout_money = payout.payout_sum or 0
statistics_session.commit()
def get(self):
today = datetime.date.today()
from_date = self.args.get("from_date", today - datetime.timedelta(days=30))
to_date = self.args.get("to_date", today)
firm_ids = self.args.get("firm_ids")
firm_ids = set(map(lambda i: check_int(i), firm_ids.split("|"))) if firm_ids else None
page = self.args.get("page", 0)
limit = self.args.get("limit", 20)
# 预先对结算单分页
order_ids_base = self.session.query(models.FirmSettlementOrder.id) \
.join(models.FirmSettlementVoucher,
models.FirmSettlementVoucher.settlement_order_id == models.FirmSettlementOrder.id) \
.filter(models.FirmSettlementOrder.station_id == self.current_station.id,
func.DATE(models.FirmSettlementOrder.create_time) >= from_date,
func.DATE(models.FirmSettlementOrder.create_time) <= to_date) \
.order_by(models.FirmSettlementOrder.create_time.desc())
# 未筛选的所有结算单
unfiltered_order_ids = order_ids_base.all()
unfiltered_order_ids = [o.id for o in unfiltered_order_ids]
if firm_ids is not None:
order_ids_base = order_ids_base.filter(models.FirmSettlementVoucher.firm_id.in_(firm_ids))
order_ids = order_ids_base.distinct() \
.offset(page * limit).limit(limit).all()
# 本页所有结算单
order_ids = {o.id for o in order_ids}
orders = self.session.query(models.FirmSettlementOrder) \
.filter(models.FirmSettlementOrder.id.in_(order_ids)) \
.order_by(models.FirmSettlementOrder.create_time.desc()) \
.all()
# 对应的所有待结算单
vouchers_firms = self.session.query(models.FirmSettlementVoucher, models.Firm) \
.join(models.Firm, models.Firm.id == models.FirmSettlementVoucher.firm_id) \
.filter(models.FirmSettlementVoucher.settlement_order_id.in_(order_ids)) \
.all()
firms_dict = defaultdict(set)
[firms_dict[voucher.settlement_order_id].add(firm) for voucher, firm in vouchers_firms]
firm_account_ids = {order.payment_account_id for order in orders}
accounts = self.session.query(models.FirmPaymentAccount) \
.filter(models.FirmPaymentAccount.id.in_(firm_account_ids)) \
.all()
account_dict = {account.id: account for account in accounts}
order_list = []
for order in orders:
creator = order.creator
settlement_account = account_dict.get(order.payment_account_id)
firms = firms_dict.get(order.id, [])
firms = [{
"id": firm.id,
"name": firm.name,
} for firm in firms]
order_list.append({
"id": order.id,
"creator_id": creator.id,
"creator_name": creator.username,
"create_time": TimeFunc.time_to_str(order.create_time),
"agent_name": order.agent_name,
"agent_phone": order.agent_phone,
"payment": order.payment,
"firms": firms,
"settlement_account_id": settlement_account.id if settlement_account else 0,
"settlement_account_num": settlement_account.account_num if settlement_account else "现金",
"total_money": check_float(order.total_money / 100),
"remarks": order.remarks,
})
all_firms = self.session.query(models.Firm) \
.join(models.FirmSettlementVoucher, models.FirmSettlementVoucher.firm_id == models.Firm.id) \
.filter(models.FirmSettlementVoucher.settlement_order_id.in_(unfiltered_order_ids)) \
.distinct() \
.all()
all_firms = [{
"id": firm.id,
"name": firm.name,
} for firm in all_firms]
has_more = len(orders) >= limit
return self.send_success(orders=order_list, all_firms=all_firms, has_more=has_more)
def firm_summary(self):
"""各供货商的结算汇总"""
scope = self.args["scope"]
summary_date = self.args["summary_date"]
firm_ids = self.args.get("firm_ids")
firm_ids = set(map(lambda i: check_int(i), firm_ids.split("|"))) if firm_ids else None
page = self.args.get("page", 0)
limit = self.args.get("limit", 20)
# 更新一下统计表相关信息
update_firm_payment_statistics(self.session, self.statistic_session,
station_id=self.current_station.id)
# 汇总日期范围
if scope == 0:
date_start = summary_date
date_end = summary_date + datetime.timedelta(days=1)
elif scope == 1:
date_start = datetime.date(summary_date.year, summary_date.month, 1)
# 当月最后一天
date_end = TimeFunc.add_months(date_start, 1) - datetime.timedelta(days=1)
elif scope == 2:
date_start = datetime.date(summary_date.year, 1, 1)
date_end = datetime.date(summary_date.year + 1, 1, 1)
else:
return self.send_fail("不支持的汇总范围")
statistics = self.statistic_session.query(models_statistics.StatisticsFirmPayment) \
.filter(models_statistics.StatisticsFirmPayment.station_id == self.current_station.id,
models_statistics.StatisticsFirmPayment.statistics_type == 0,
func.DATE(models_statistics.StatisticsFirmPayment.statistics_date) >= date_start,
func.DATE(models_statistics.StatisticsFirmPayment.statistics_date) < date_end)
# 待筛选的所有供货商 ID
all_firm_ids = statistics.with_entities(models_statistics.StatisticsFirmPayment.firm_id).all()
all_firm_ids = {i.firm_id for i in all_firm_ids}
# 累计数据
total_sum = \
statistics.with_entities(func.count(models_statistics.StatisticsFirmPayment.settle_times),
func.count(models_statistics.StatisticsFirmPayment.settle_nums),
func.sum(models_statistics.StatisticsFirmPayment.settle_money)) \
.first()
if firm_ids:
statistics = statistics.filter(models_statistics.StatisticsFirmPayment.firm_id.in_(firm_ids))
statistics = statistics.all()
all_firms = self.session.query(models.Firm) \
.filter(models.Firm.id.in_(all_firm_ids)).all()
firm_dict = {firm.id: firm for firm in all_firms}
# 待筛选的所有供货商
firms = [{"id": firm.id, "name": firm.name} for firm in all_firms]
summary_dict = {}
for statics in statistics:
if statics.firm_id not in summary_dict:
summary_dict[statics.firm_id] = {
"settle_times": 0, # 结算次数
"settle_nums": 0, # 结算票数
"settle_money": 0, # 结算总金额
}
summary_dict[statics.firm_id]["settle_times"] += statics.settle_times
summary_dict[statics.firm_id]["settle_nums"] += statics.settle_nums
summary_dict[statics.firm_id]["settle_money"] += statics.settle_money
# 累计数据
settle_times = total_sum[0] or 0 if total_sum else 0
settle_nums = total_sum[1] or 0 if total_sum else 0
total_money = check_float(total_sum[2] or 0 / 10000) if total_sum else 0
sum_data = {
"times": settle_times,
"voucher_count": settle_nums,
"total_money": total_money,
"firms": firms
}
# 汇总列表
summarys = []
for firm_id, summary in summary_dict.items():
firm = firm_dict.get(firm_id)
summarys.append({
"firm_id": firm.id if firm else 0,
"firm_name": firm.name if firm else "",
"times": summary["settle_times"],
"voucher_count": summary["settle_nums"],
"total_money": check_float(summary["settle_money"] / 10000),
})
# 暂时不分页
nomore = True
return self.send_success(sum_data=sum_data, summarys=summarys, nomore=nomore)
def post(self):
firm_name = self.args["firm_name"]
purchase_goods_id = self.args.get("purchase_goods_id")
stock_out_record_id = self.args.get("stock_out_record_id")
allocation_list = self.args["allocate_list"]
valid, message = self.validate_allocation_list(allocation_list)
if not valid:
return self.send_fail(message)
config = models.Config.get_by_station_id(self.session,
self.current_station.id)
printer_id = config.allocation_printer_id
copies = config.allocation_print_copies
printer = models.Printer.get_by_id(self.session, printer_id,
self.current_station.id)
if not printer:
return self.send_fail("分车单打印机设置无效，请在中转站设置中配置")
# 采购分车单
if purchase_goods_id:
purchase_goods = models.PurchaseOrderGoods.get_by_id(
self.session, purchase_goods_id, self.current_station.id)
if not purchase_goods:
return self.send_fail("没有找到 {} 的对应采购单商品".format(firm_name))
goods = purchase_goods.goods
goods_id = goods.id
goods_name = goods.name
firm_name = purchase_goods.firm.name
number_map = models.SerialNumberMap.generate(
self.session, 5, purchase_goods.id, self.current_station.id)
wish_order_id = purchase_goods.order.wish_order_id
# 出库分车单
elif stock_out_record_id:
stock_out_record = models.StockOutInGoods.get_by_id(
self.session, stock_out_record_id, self.current_station.id)
if not stock_out_record:
return self.send_fail("没有找到 {} 的对应出库记录".format(firm_name))
elif stock_out_record.status < 3:
return self.send_fail("{} 的商品还没有确认出库".format(firm_name))
goods = stock_out_record.goods
goods_id = goods.id
goods_name = goods.name
firm_name = "仓库"
number_map = models.SerialNumberMap.generate(
self.session, 6, stock_out_record.id, self.current_station.id)
wish_order_id = stock_out_record.wish_order_id
else:
return self.send_fail(
"参数错误：purchase_goods_id 和 stock_out_record_id 必选其一")
# 创建分车订单
new_allocation_order = models.AllocationOrder(
wish_order_id=wish_order_id,
purchase_order_goods_id=purchase_goods_id,
stock_out_record_id=stock_out_record_id,
order_no=number_map.order_no,
creator_id=self.current_user.id,
station_id=self.current_station.id,
goods_id=goods_id,
)
self.session.add(new_allocation_order)
self.session.flush()
# 配送部分
total_amount = 0
for allocate_item in allocation_list:
shop_id = allocate_item["shop_id"]
shop_name = allocate_item["shop_name"]
destination = allocate_item["destination"]
allocated_amount = check_float(
allocate_item.get("allocating_amount", 0))
total_amount += allocated_amount
if allocated_amount:
allocated_amount = check_int(allocated_amount * 100)
new_allocation_goods = models.AllocationOrderGoods(
order_id=new_allocation_order.id,
shop_id=shop_id or None,
destination=destination,
allocated_amount=allocated_amount,
actual_allocated_amount=allocated_amount,
)
self.session.add(new_allocation_goods)
self.session.commit()
# 打印分车单据
receipt_printer = ReceiptPrinter(printer.wireless_print_num,
printer.wireless_print_key)
receipt_content = receipt_printer.allocation_order_template(
goods_name=goods_name,
firm_name=firm_name,
order_no=number_map.order_no,
total_amount=total_amount,
allocation_list=allocation_list,
operator_name=self.current_user.username,
create_time=TimeFunc.time_to_str(datetime.datetime.now()),
)
for i in range(copies):
success, error_msg = receipt_printer.print(receipt_content)
if not success:
return self.send_fail(error_msg)
return self.send_success()
def post(self):
vouchers = self.args["vouchers"]
agent_name = self.args["agent_name"]
agent_phone = self.args["agent_phone"]
total_money_sum = self.args["total_money_sum"]
payment_account_id = self.args["payment_account_id"] or None
remarks = self.args.get("remarks", "")
send_sms = self.args.get("send_sms", False)
valid, message = self.validate_goods_list(vouchers)
if not valid:
return self.send_fail(message)
voucher_ids = {check_int(voucher["id"]) for voucher in vouchers}
valid_vouchers = self.session.query(models.FirmSettlementVoucher) \
.filter(models.FirmSettlementVoucher.id.in_(voucher_ids),
models.FirmSettlementVoucher.status == 0) \
.all()
if {voucher.id for voucher in valid_vouchers} != voucher_ids:
return self.send_fail("提交了无效的或已结算过的记录")
valid_vouchers_dict = {voucher.id: voucher for voucher in valid_vouchers}
payment = 0
if payment_account_id:
payment_account = models.FirmPaymentAccount.get_by_id(self.session, payment_account_id, self.current_station.id)
if not payment_account:
return self.send_fail("没有找到指定的供货商收款账号")
payment = 2 if payment_account.account_type == 1 else 1
settlement_order = models.FirmSettlementOrder(
agent_name=agent_name,
agent_phone=agent_phone,
payment=payment,
payment_account_id=payment_account_id,
total_money=check_int(total_money_sum * 100),
remarks=remarks,
station_id=self.current_station.id,
creator_id=self.current_user.id
)
self.session.add(settlement_order)
self.session.flush()
voucher_money_sum = 0
for voucher_arg in vouchers:
voucher_id = check_int(voucher_arg["id"])
amount = check_float(voucher_arg["amount"])
price = check_float(voucher_arg["price"])
total_money = check_float(voucher_arg["total_money"])
voucher = valid_vouchers_dict[voucher_id]
voucher.settlement_order_id = settlement_order.id
voucher.settled_amount = check_int(amount * 100)
voucher.settled_price = check_int(price * 100)
voucher.status = 1
voucher_money_sum += total_money
if total_money_sum != voucher_money_sum:
return self.send_fail("结算总金额计算有误，应为 {}".format(voucher_money_sum))
self.session.commit()
if send_sms:
from libs import yunpian
yunpian.send_firm_settlement(agent_phone,
TimeFunc.time_to_str(datetime.datetime.now()),
self.current_station.name,
total_money_sum)
return self.send_success()
def get(self):
from_date = self.args.get("from_date")
to_date = self.args.get("to_date")
before_date = self.args.get("before_date")
shop_ids_filter = set(
map(lambda x: check_int(x),
self.args.get("shop_ids", "").split("|"))) - {0}
scope = self.args.get("scope", 0)
order_by = self.args.get("order_by")
asc = self.args.get("asc", False)
page = self.args.get("page", 0)
limit = self.args.get("limit", 20)
if scope not in [0, 1, 2]:
return self.send_fail("scope invalid")
update_shop_financial_statistics(self.session,
self.statistic_session,
station_id=self.current_station.id)
date_query = None
if scope == 0:
date_query = func.DATE(models_statistics.StatisticsShopFinancial.
statistics_date).label("data_date")
elif scope == 1:
date_query = func.date_format(
models_statistics.StatisticsShopFinancial.statistics_date,
"%Y-%m").label("data_date")
elif scope == 2:
date_query = func.date_format(
models_statistics.StatisticsShopFinancial.statistics_date,
"%Y").label("data_date")
packing_sums = self.statistic_session.query(date_query,
models_statistics.StatisticsShopFinancial.shop_id,
func.sum(models_statistics.StatisticsShopFinancial.allocation_money).label("allocation_money"),
func.sum(models_statistics.StatisticsShopFinancial.shop_payout_money).label("shop_payout_money")) \
.filter(models_statistics.StatisticsShopFinancial.station_id == self.current_station.id,
models_statistics.StatisticsShopFinancial.statistics_type == 0)
# 待筛选的门店列表
shop_ids = packing_sums.with_entities(
models_statistics.StatisticsShopFinancial.shop_id).distinct().all(
)
shop_ids = {i[0] for i in shop_ids}
shops = self.session.query(models.Shop) \
.filter(models.Shop.id.in_(shop_ids)) \
.all()
shop_dict = {s.id: s for s in shops}
# 门店筛选
if shop_ids_filter:
packing_sums = packing_sums.filter(
models_statistics.StatisticsShopFinancial.shop_id.in_(
shop_ids_filter))
if from_date:
packing_sums = packing_sums.filter(
models_statistics.StatisticsShopFinancial.statistics_date >=
from_date)
if to_date:
packing_sums = packing_sums.filter(
models_statistics.StatisticsShopFinancial.statistics_date <=
to_date)
if before_date:
packing_sums = packing_sums.filter(
models_statistics.StatisticsShopFinancial.statistics_date <
before_date)
if order_by == "other_payout":
if asc:
packing_sums = packing_sums.order_by(
sqlalchemy.asc(models_statistics.StatisticsShopFinancial.
shop_payout_money))
else:
packing_sums = packing_sums.order_by(
sqlalchemy.desc(models_statistics.StatisticsShopFinancial.
shop_payout_money))
elif order_by == "packing_money":
if asc:
packing_sums = packing_sums.order_by(
sqlalchemy.asc(models_statistics.StatisticsShopFinancial.
allocation_money))
else:
packing_sums = packing_sums.order_by(
sqlalchemy.desc(models_statistics.StatisticsShopFinancial.
allocation_money))
elif order_by == "payout_sum":
if asc:
packing_sums = packing_sums.order_by(
sqlalchemy.asc(
func.sum(models_statistics.StatisticsShopFinancial.
allocation_money + models_statistics.
StatisticsShopFinancial.shop_payout_money)))
else:
packing_sums = packing_sums.order_by(
sqlalchemy.desc(
func.sum(models_statistics.StatisticsShopFinancial.
allocation_money + models_statistics.
StatisticsShopFinancial.shop_payout_money)))
else:
packing_sums = packing_sums.order_by(
models_statistics.StatisticsShopFinancial.statistics_date.desc(
))
# 累计实配金额
payout_money_sum = packing_sums.with_entities(func.sum(models_statistics.StatisticsShopFinancial.allocation_money),
func.sum(models_statistics.StatisticsShopFinancial.shop_payout_money)) \
.first()
packing_sums = packing_sums.group_by("data_date", models_statistics.StatisticsShopFinancial.shop_id) \
.offset(page * limit) \
.limit(limit) \
.all()
data_list = []
for packing_data in packing_sums:
packing_money = check_float(packing_data.allocation_money / 100)
other_payout = check_float(packing_data.shop_payout_money / 100)
if scope == 0:
payout_date = TimeFunc.time_to_str(packing_data.data_date,
"date")
else:
payout_date = packing_data.data_date
shop = shop_dict.get(packing_data.shop_id)
data_list.append({
"date":
payout_date,
"shop_id":
shop.id if shop else 0,
"shop_name":
shop.abbreviation if shop else "已删除",
"packing_money":
packing_money,
"other_payout":
other_payout,
"payout_sum":
check_float(packing_money + other_payout)
})
packing_money_sum = (payout_money_sum[0]
or 0) if payout_money_sum else 0
other_payout_sum = (payout_money_sum[1]
or 0) if payout_money_sum else 0
sum_data = {
"shops": [{
"id": shop.id,
"name": shop.abbreviation,
} for shop in shops],
"packing_money":
check_float(packing_money_sum / 100),
"other_payout":
check_float(other_payout_sum / 100),
"payout_sum":
check_float((packing_money_sum + other_payout_sum) / 100),
}
has_more = len(data_list) >= limit
return self.send_success(data_list=data_list,
sum_data=sum_data,
has_more=has_more)
def update_shop_packing_price(self, order):
"""更新分车目标门店的商品配货价"""
if order.purchase_order_goods_id:
# 分车目标门店
allocated_shops = self.session.query(models.AllocationOrderGoods.shop_id) \
.filter(models.AllocationOrderGoods.destination == 0,
models.AllocationOrderGoods.order_id == order.id) \
.all()
allocated_shops = {shop[0] for shop in allocated_shops}
# 重新计算各门店的采购价
purchase_data = self.session.query(models.AllocationOrderGoods.shop_id,
func.sum(models.AllocationOrderGoods.actual_allocated_amount).label("allocated_amount"),
func.sum(models.PurchaseOrderGoods.subtotal).label("subtotal"),
func.sum(models.PurchaseOrderGoods.actual_amount).label("actual_amount")) \
.join(models.AllocationOrder) \
.outerjoin(models.PurchaseOrderGoods, models.PurchaseOrderGoods.id == models.AllocationOrder.purchase_order_goods_id) \
.filter(models.AllocationOrder.wish_order_id == order.wish_order_id,
models.AllocationOrder.status == 1,
models.AllocationOrder.goods_id == order.goods_id,
models.AllocationOrderGoods.shop_id.in_(allocated_shops)) \
.group_by(models.AllocationOrderGoods.shop_id) \
.all()
purchase_price_dict = {
data.shop_id: (data.subtotal or 0) / (data.actual_amount or 1)
for data in purchase_data
}
allocated_amount_dict = {
data.shop_id: data.allocated_amount
for data in purchase_data
}
# 已有的配货价数据
packing_price_list = self.session.query(models.ShopPackingPrice) \
.filter(models.ShopPackingPrice.goods_id == order.goods_id,
models.ShopPackingPrice.station_id == self.current_station.id,
models.ShopPackingPrice.wish_order_id == order.wish_order_id,
models.ShopPackingPrice.shop_id.in_(allocated_shops)) \
.all()
packing_price_dict = {
packing_price.shop_id: packing_price
for packing_price in packing_price_list
}
# 更新各门店配货价
for shop_id in allocated_shops:
packing_price = packing_price_dict.get(shop_id)
if not packing_price:
packing_price = models.ShopPackingPrice(
station_id=self.current_station.id,
creator_id=self.current_user.id,
wish_order_id=order.wish_order_id,
shop_id=shop_id,
goods_id=order.goods_id,
)
self.session.add(packing_price)
# 直接覆盖为采购价
purchase_price = purchase_price_dict.get(shop_id, 0)
packing_price.price = check_int(purchase_price * 100)
# 更新总配货量
allocated_amount = allocated_amount_dict.get(shop_id, 0)
packing_price.allocated_amount = allocated_amount
def post(self):
allocation_order_id = self.args["allocation_order_id"]
stock_in_amount = self.args.get("stock_in_amount")
allocation_order = models.AllocationOrder.get_by_id(
self.session, allocation_order_id, self.current_station.id)
if not allocation_order:
return self.send_fail("没有找到对应的分车单")
elif not allocation_order.purchase_order_goods_id:
return self.send_fail("没有找到有效的供货商分车单")
existed_record = self.session.query(models.StockOutInGoods) \
.filter(models.StockOutInGoods.type == 1,
models.StockOutInGoods.allocation_order_id == allocation_order.id,
models.StockOutInGoods.status >= 0) \
.first()
if existed_record:
return self.send_fail("已经创建过此采购单商品的入库单了")
if stock_in_amount is not None:
# 修改过的分车量
allocated_amount = check_int(stock_in_amount * 100)
else:
# 所有送到仓库的分车量
allocated_amount = self.session.query(func.sum(models.AllocationOrderGoods.actual_allocated_amount)) \
.filter(models.AllocationOrderGoods.order_id == allocation_order.id,
models.AllocationOrderGoods.destination == 1) \
.first()
allocated_amount = allocated_amount[
0] or 0 if allocated_amount else 0
# 采购分到仓库
if allocation_order.purchase_order_goods_id:
purchase_goods = models.PurchaseOrderGoods.get_by_id(
self.session, allocation_order.purchase_order_goods_id,
self.current_station.id)
if not purchase_goods:
return self.send_fail("没有找到对应的采购单商品")
goods = purchase_goods.goods
goods_id = goods.id
# 库存采购均价 = (原有库存的实际成本 + 本次进货的实际成本) / (原有库存数量 + 本次进货数量)
if goods.stock_average_price:
goods.stock_average_price = check_float(
(goods.stock_cost + purchase_goods.subtotal /
purchase_goods.actual_amount * allocated_amount / 100) /
(goods.stock + allocated_amount) * 100)
else:
goods.stock_average_price = purchase_goods.price
# 库存成本（数据库中存储时都 * 100，所以再做乘法处理时需要 / 100）
goods.stock_cost += check_float(purchase_goods.subtotal /
purchase_goods.actual_amount *
allocated_amount / 100)
elif allocation_order.stock_out_record_id:
stock_out_record = models.StockOutInGoods.get_by_id(
self.session, allocation_order.stock_out_record_id,
self.current_station, [3, 4])
if not stock_out_record:
return self.send_fail("没有找到对应的出库记录")
goods = stock_out_record.goods
goods_id = goods.id
# 库存成本（数据库中存储时都 * 100，所以再做乘法处理时需要 / 100）
goods.stock_cost += check_float(goods.stock_average_price *
allocated_amount / 100)
else:
return self.send_fail("分车单类型未知")
# 创建入库单
new_stock_in_record = models.StockOutInGoods(
type=1,
status=1,
amount=allocated_amount,
allocation_order_id=allocation_order_id,
goods_id=goods_id,
wish_order_id=allocation_order.wish_order_id,
station_id=self.current_station.id,
creator_id=self.current_user.id,
operator_id=self.current_user.id,
)
self.session.add(new_stock_in_record)
self.session.flush()
# 增加库存
new_stock_in_record.goods.stock += new_stock_in_record.amount
self.session.flush()
# 生成单号
models.SerialNumberMap.generate(self.session, 1,
new_stock_in_record.id,
self.current_station.id)
# 确认分车单
allocation_order.status = 1
self.session.commit()
return self.send_success()
def update_goods_list(self, order_id):
""" 更新分车单货品列表 """
goods_list = self.args["goods_list"]
amount_other_dest = self.args.get("amount_other_dest")
amount_stock_in = self.args.get("amount_stock_in")
valid, message = self.validate_goods_list(goods_list)
if not valid:
return self.send_fail(message)
order = models.AllocationOrder.get_by_id(self.session, order_id,
self.current_station.id)
if not order:
return self.send_fail("没有找到该分车单")
order_goods_list = order.goods_list.all()
order_goods_dict = {}
order_goods_other = None
order_goods_stock_in = None
for goods in order_goods_list:
# 目前入库分车单货品和其他目标分车单货品只能有一个
if goods.destination == 0:
order_goods_dict[goods.id] = goods
elif goods.destination == 1:
order_goods_stock_in = goods
elif goods.destination == 2:
order_goods_other = goods
# 更新已有的分车单货品
for goods_param in goods_list:
order_goods_id = check_int(goods_param["id"])
allocated_amount = check_float(goods_param["allocated_amount"])
order_goods = order_goods_dict[order_goods_id]
order_goods.actual_allocated_amount = check_int(allocated_amount *
100)
# 其他目标的分车单货品
if amount_other_dest is not None:
amount_other_dest = check_int(amount_other_dest * 100)
if not order_goods_other:
order_goods_other = models.AllocationOrderGoods(
destination=2,
allocated_amount=amount_other_dest,
order_id=order.id,
)
self.session.add(order_goods_other)
order_goods_other.actual_allocated_amount = amount_other_dest
# 入库的分车单货品
if amount_stock_in is not None:
amount_stock_in = check_int(amount_stock_in * 100)
if not order_goods_stock_in:
order_goods_stock_in = models.AllocationOrderGoods(
destination=1,
allocated_amount=amount_stock_in,
order_id=order.id,
)
self.session.add(order_goods_stock_in)
order_goods_stock_in.actual_allocated_amount = amount_stock_in
self.session.commit()
return self.send_success()
def get(self):
page = self.args.get("page", 0)
limit = self.args.get("limit", constants.PAGE_SIZE)
if limit > constants.PAGE_MAX_LIMIT:
limit = constants.PAGE_SIZE
search = self.args.get("search", "").strip()
goods_ids = self.args.get("goods_ids")
order_by = self.args.get("order_by")
asc = self.args.get("asc", False)
station = self.current_station
query_set = self.session.query(models.Goods)\
.filter(models.Goods.station_id == station.id,
models.Goods.status == 0)
if search:
query_set = query_set.filter(models.Goods.code == search)
if goods_ids:
goods_ids = [
check_int(goods_id) for goods_id in goods_ids.split("|")
]
query_set = query_set.filter(models.Goods.id.in_(goods_ids))
if order_by == "code":
if asc:
query_set = query_set.order_by(models.Goods.code.asc())
else:
query_set = query_set.order_by(models.Goods.code.desc())
elif order_by == "stock":
if asc:
query_set = query_set.order_by(models.Goods.stock.asc())
else:
query_set = query_set.order_by(models.Goods.stock.desc())
elif order_by == "stock_average_price":
if asc:
query_set = query_set.order_by(
models.Goods.stock_average_price.asc())
else:
query_set = query_set.order_by(
models.Goods.stock_average_price.desc())
elif order_by == "stock_cost":
if asc:
query_set = query_set.order_by(models.Goods.stock_cost.asc())
else:
query_set = query_set.order_by(models.Goods.stock_cost.desc())
stock_goods_objects = query_set.offset(page * limit)\
.limit(limit)\
.all()
stock_goods_list = list()
for stock_goods in stock_goods_objects:
data = stock_goods.to_stock_dict()
# 根据权限查看仓库库存均价和采购成本
staff_permission_list = self.current_staff.admin_permission_list
is_permission = 10 in staff_permission_list
if not ((self.current_staff.super_admin_status
or self.current_staff.admin_status) and is_permission):
data["stock_average_price"] = 0
data["stock_cost"] = 0
stock_goods_list.append(data)
# 所有商品信息(搜索使用)
goods_objects = self.session.query(models.Goods)\
.filter(models.Goods.station_id == self.current_station.id,
models.Goods.status == 0)\
.all()
goods_list = [{
"goods_id": goods.id,
"goods_name": goods.name
} for goods in goods_objects]
has_more = len(stock_goods_objects) >= limit
return self.send_success(stock_goods_list=stock_goods_list,
goods_list=goods_list,
has_more=has_more)
