app/api/inventory.py

from flask import jsonify, request, current_app, send_file
from flask_jwt_extended import jwt_required, get_jwt_identity
from app.models.inventory import Inventory
from app.models.user import User
from app.models.material import Material
from app.models.store import Store
from app.models.inventory_log import InventoryLog
from app.api import bp, ns_inventory, api
from app import db
from app.utils.validators import validate_json, validate_decimal
from app.utils.cache import cache, clear_cache
from flask_restx import Resource, fields
from sqlalchemy import func
from app.utils.export import export_to_excel, export_to_csv
from datetime import datetime, date
from decimal import Decimal
# pandas 依赖已从requirements.txt中移除
import tempfile
import os
import io
import csv

# 定义模型
inventory_model = api.model('Inventory', {
    'material_id': fields.Integer(required=True),
    'store_id': fields.Integer(required=True),
    'batch_number': fields.String(),
    'quantity': fields.Float(required=True),
    'unit_price': fields.Float(),
    'expiry_date': fields.Date(),
    'production_date': fields.Date(),
    'warning_threshold': fields.Float()
})

inventory_response = api.inherit('InventoryResponse', inventory_model, {
    'id': fields.Integer(description='Inventory ID'),
    'warning': fields.Boolean(description='Warning flag'),
    'material_name': fields.String(description='Material name'),
    'store_name': fields.String(description='Store name')
})

# 定义出库模型
checkout_model = api.model('CheckoutInventory', {
    'material_id': fields.Integer(required=True, description='Material ID'),
    'store_id': fields.Integer(required=True, description='Store ID'),
    'quantity': fields.Float(required=True, description='Quantity to checkout')
})

# 出库明细响应模型
checkout_detail_model = api.model('CheckoutDetail', {
    'batch_number': fields.String(description='Batch number'),
    'quantity': fields.Float(description='Quantity'),
    'unit_price': fields.Float(description='Unit price')
})

# 出库响应模型
checkout_response = api.model('CheckoutResponse', {
    'success': fields.Boolean(description='Success status'),
    'updated_inventories': fields.List(fields.Nested(inventory_response), description='Updated inventory records'),
    'checkout_details': fields.List(fields.Nested(checkout_detail_model), description='Checkout details')
})

# 添加物料加工模型
process_model = api.model('ProcessMaterial', {
    'inventory_id': fields.Integer(required=True, description='Inventory record ID'),
    'material_id': fields.Integer(required=True, description='Material ID'),
    'store_id': fields.Integer(required=True, description='Store ID'),
    'quantity': fields.Float(required=True, description='Quantity to process'),
    'batch_number': fields.String(required=False, description='Batch number')
})

@ns_inventory.route('/')
class InventoryResource(Resource):
    @api.doc('list_inventory')
    @jwt_required()
    def get(self):
        """获取库存列表"""
        try:
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 构建基础查询
            query = (Inventory.query
                .join(Material)
                .join(Store))
            
            # 如果是门店经理，只能看到自己门店的库存
            if user.role == 'store_manager':
                query = query.filter(Inventory.store_id == user.store_id)
            
            inventory_list = query.all()
            
            result = [inv.to_dict() for inv in inventory_list]
            
            return {'data': result}
            
        except Exception as e:
            current_app.logger.error(f'Error fetching inventory: {str(e)}')
            return {'message': 'Error fetching inventory'}, 500

    @api.doc('create_inventory')
    @api.expect(inventory_model)
    @jwt_required()
    def post(self):
        """创建库存记录"""
        try:
            data = request.get_json()
            current_app.logger.info(f'开始创建库存记录，数据: {data}')

            # 处理日期字段
            expiry_date = datetime.strptime(data['expiry_date'], '%Y-%m-%d').date() if data.get('expiry_date') else None
            production_date = datetime.strptime(data['production_date'], '%Y-%m-%d').date() if data.get('production_date') else None
            current_app.logger.info(f'日期处理完成 - 生产日期: {production_date}, 到期日期: {expiry_date}')

            # 创建原始库存记录
            inventory = Inventory(
                material_id=data['material_id'],
                store_id=data['store_id'],
                batch_number=data.get('batch_number'),
                quantity=data['quantity'],
                unit_price=data.get('unit_price'),
                expiry_date=expiry_date,
                production_date=production_date,
                warning_threshold=data.get('warning_threshold')
            )

            db.session.add(inventory)
            current_app.logger.info(f'原始库存记录已添加到会话，ID将在提交后生成')

            # 检查是否需要自动入库加工
            auto_process = data.get('auto_process', False)
            processed_inventory = None
            current_app.logger.info(f'自动加工标志: {auto_process}')

            if auto_process:
                # 获取物料信息
                material = Material.query.get(data['material_id'])
                current_app.logger.info(f'物料查询结果: {material.name if material else "未找到"}, 加工信息: {material.processed_name if material else "无"}, 转换比例: {material.conversion_ratio if material else "无"}')

                if material and material.processed_name and material.conversion_ratio:
                    current_app.logger.info(f'开始执行自动加工逻辑')
                    # 执行自动加工逻辑
                    processed_inventory = self._auto_process_material(
                        inventory, material, get_jwt_identity()
                    )
                    current_app.logger.info(f'自动加工完成，生成加工后库存记录')
                else:
                    current_app.logger.warning(f'物料不支持自动加工，跳过加工步骤')

            current_app.logger.info(f'准备提交数据库事务')
            db.session.commit()
            current_app.logger.info(f'数据库事务提交成功，原始库存ID: {inventory.id}')

            # 返回结果
            result = inventory.to_dict()
            if processed_inventory:
                result['processed_inventory'] = processed_inventory.to_dict()
                result['auto_processed'] = True
                current_app.logger.info(f'返回结果包含自动加工信息 - 原始ID: {inventory.id}, 加工后ID: {processed_inventory.id}')
            else:
                result['auto_processed'] = False
                current_app.logger.info(f'返回结果不包含自动加工信息 - 库存ID: {inventory.id}')

            current_app.logger.info(f'入库操作完成，返回结果: {result}')
            return result
        except Exception as e:
            current_app.logger.error(f'Error creating inventory: {str(e)}')
            db.session.rollback()
            return {'message': 'Error creating inventory'}, 500

    def _auto_process_material(self, original_inventory, material, user_id):
        """自动加工物料的辅助方法"""
        try:
            current_app.logger.info(f'开始自动加工 - 原材料: {material.name}, 数量: {original_inventory.quantity}, 转换比例: {material.conversion_ratio}')

            # 计算加工后的数量
            processed_quantity = float(original_inventory.quantity) * float(material.conversion_ratio)
            current_app.logger.info(f'计算加工后数量: {original_inventory.quantity} * {material.conversion_ratio} = {processed_quantity}')

            # 构建新批次号 (P前缀表示加工)
            now = datetime.now()
            processed_batch_number = f"P{now.strftime('%y%m%d%H%M%S')}"
            current_app.logger.info(f'生成加工批次号: {processed_batch_number}')

            # 创建加工后的库存记录
            processed_inventory = Inventory(
                material_id=original_inventory.material_id,
                store_id=original_inventory.store_id,
                batch_number=processed_batch_number,
                quantity=processed_quantity,
                unit_price=original_inventory.unit_price,  # 使用原始单价
                expiry_date=original_inventory.expiry_date,  # 使用原始到期日期
                production_date=original_inventory.production_date,  # 使用原始生产日期
                warning_threshold=material.processed_warning_threshold
            )

            db.session.add(processed_inventory)
            current_app.logger.info(f'加工后库存记录已添加到会话')

            # 注意：这里不创建 InventoryLog，因为 original_inventory.id 还是 None
            # 日志记录将在主函数中处理，或者我们需要先 flush 来获取 ID

            # 先 flush 以获取原始库存的 ID
            db.session.flush()
            current_app.logger.info(f'数据库会话已刷新，原始库存ID: {original_inventory.id}')

            # 现在可以创建加工操作日志
            process_log = InventoryLog(
                inventory_id=original_inventory.id,
                material_id=original_inventory.material_id,
                store_id=original_inventory.store_id,
                operation_type='auto_process',
                quantity=float(original_inventory.quantity),
                batch_number=original_inventory.batch_number,
                user_id=user_id
            )
            db.session.add(process_log)
            current_app.logger.info(f'加工操作日志已创建')

            # 自动入库加工的业务逻辑：
            # 1. 原材料入库（已完成）
            # 2. 立即消耗原材料进行加工，生成加工后产品
            # 3. 最终结果：原材料数量为0，加工后产品数量为转换后的数量
            original_inventory.quantity = 0
            current_app.logger.info(f'原材料已被自动加工消耗，数量设为0，生成加工后产品数量: {processed_quantity}')

            return processed_inventory

        except Exception as e:
            current_app.logger.error(f'自动加工过程中发生错误: {str(e)}')
            import traceback
            current_app.logger.error(f'错误堆栈: {traceback.format_exc()}')
            raise e

@ns_inventory.route('/stats/')
class InventoryStats(Resource):
    @api.doc('get_inventory_stats')
    @jwt_required()
    def get(self):
        """获取库存统计数据"""
        try:
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 构建基础查询
            query = (Inventory.query
                .join(Material)
                .join(Store))
            
            # 如果是门店经理，只能看到自己门店的数据
            if user.role == 'store_manager':
                query = query.filter(Inventory.store_id == user.store_id)
            
            # 获取物料总数
            total_materials = Material.query.count()
            
            # 获取所有库存记录
            inventory_list = query.all()
            
            # 计算总库存量
            total_quantity = 0
            
            # 使用字典合并同一门店同一物料的数量（加工前后合并）
            material_store_totals = {}

            for inv in inventory_list:
                total_quantity += float(inv.quantity)

                # 判断是否为加工物料
                is_processed = inv.batch_number and inv.batch_number.startswith('P')

                # 创建门店-物料的组合键（不区分加工状态，实现合并）
                key = f"{inv.store_id}-{inv.material_id}"

                # 累加同一门店同一物料的总库存（加工前后合并）
                if key in material_store_totals:
                    material_store_totals[key]['total_quantity'] += float(inv.quantity)
                    # 分别记录加工前后的数量
                    if is_processed:
                        material_store_totals[key]['processed_quantity'] += float(inv.quantity)
                    else:
                        material_store_totals[key]['raw_quantity'] += float(inv.quantity)
                else:
                    # 获取物料信息
                    material = inv.material

                    # 使用原始物料名称作为主要显示名称
                    material_name = material.name

                    # 预警阈值使用原始物料的阈值（因为预警基于原始需求）
                    warning_threshold = float(material.warning_threshold) if material.warning_threshold else 0

                    material_store_totals[key] = {
                        'material_name': material_name,
                        'store_name': inv.store.name,
                        'total_quantity': float(inv.quantity),  # 总库存
                        'raw_quantity': float(inv.quantity) if not is_processed else 0,  # 加工前数量
                        'processed_quantity': float(inv.quantity) if is_processed else 0,  # 加工后数量
                        'warning_threshold': warning_threshold,
                        'unit': material.unit,  # 使用原始单位
                        'material_id': inv.material_id,
                        'store_id': inv.store_id,
                        'has_processed': material.processed_name is not None,  # 是否支持加工
                        'processed_name': material.processed_name,  # 加工后名称
                        'processed_unit': material.processed_unit  # 加工后单位
                    }
            
            # 计算预警物料
            warning_items = []
            warning_count = 0
            
            # 预先加载所有物料信息，避免循环中重复查询
            material_ids = [item['material_id'] for item in material_store_totals.values()]
            materials_dict = {}
            try:
                all_materials = Material.query.filter(Material.id.in_(material_ids)).all()
                for material in all_materials:
                    materials_dict[material.id] = material
                current_app.logger.info(f'Loaded {len(materials_dict)} materials')
            except Exception as e:
                current_app.logger.error(f'Error loading materials: {str(e)}')
            
            for key, item in material_store_totals.items():
                try:
                    # 基于合并后的总库存判断是否需要预警
                    warning_threshold = item['warning_threshold']
                    total_quantity = item['total_quantity']

                    # 判断总库存是否低于预警阈值
                    if warning_threshold > 0 and total_quantity <= warning_threshold:
                        warning_count += 1

                        # 构建预警项目信息
                        warning_item = {
                            'material_name': item['material_name'],
                            'store_name': item['store_name'],
                            'quantity': total_quantity,  # 显示总库存
                            'warning_threshold': warning_threshold,
                            'unit': item['unit'],
                            'material_id': item['material_id'],
                            'store_id': item['store_id'],
                            # 额外信息：分别显示加工前后的数量
                            'raw_quantity': item['raw_quantity'],
                            'processed_quantity': item['processed_quantity'],
                            'has_processed': item['has_processed'],
                            'processed_name': item['processed_name'],
                            'processed_unit': item['processed_unit']
                        }
                        warning_items.append(warning_item)

                        current_app.logger.info(f'Warning: {item["material_name"]} at {item["store_name"]} - Total: {total_quantity}, Raw: {item["raw_quantity"]}, Processed: {item["processed_quantity"]}, Threshold: {warning_threshold}')

                except Exception as e:
                    current_app.logger.error(f'Error processing inventory item: {str(e)}')
                    # 继续处理下一个物料，而不是中断整个流程
                    continue
            
            # 构建并返回响应数据
            response_data = {
                'total_materials': total_materials,
                'warning_count': warning_count,
                'total_quantity': float(total_quantity),
                'warning_items': warning_items
            }
            
            current_app.logger.info(f'Inventory stats response: {response_data}')
            return response_data
        
        except Exception as e:
            current_app.logger.error(f'Error getting inventory stats: {str(e)}')
            import traceback
            current_app.logger.error(traceback.format_exc())
            return {'message': 'Error getting inventory statistics', 'error': str(e)}, 500

@ns_inventory.route('/export/')
class InventoryExportResource(Resource):
    @api.doc('export_inventory')
    @jwt_required()
    def get(self):
        """导出库存数据"""
        try:
            # 获取用户信息和权限检查
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 构建查询
            query = (Inventory.query
                    .join(Material)
                    .join(Store))
            
            # 如果是门店经理，只能导出自己门店的数据
            if user.role == 'store_manager':
                query = query.filter(Inventory.store_id == user.store_id)
            
            # 获取数据
            records = query.all()
            current_app.logger.debug(f"Found {len(records)} records to export")
            
            # 先计算每个门店-物料组合的总库存
            material_store_totals = {}
            for inv in records:
                key = f"{inv.store_id}-{inv.material_id}"
                
                if key in material_store_totals:
                    material_store_totals[key]['quantity'] += float(inv.quantity)
                else:
                    material_store_totals[key] = {
                        'quantity': float(inv.quantity),
                        'warning_threshold': float(inv.warning_threshold) if inv.warning_threshold else 0
                    }
            
            inventory_data = []
            for inv in records:
                try:
                    # 获取当前物料-门店组合的总库存与预警状态
                    key = f"{inv.store_id}-{inv.material_id}"
                    total_data = material_store_totals[key]
                    is_warning = total_data['warning_threshold'] > 0 and total_data['quantity'] <= total_data['warning_threshold']
                    
                    item = {
                        'ID': inv.id,
                        'Material': inv.material.name,
                        'Store': inv.store.name,
                        'Quantity': float(inv.quantity),
                        'Unit': inv.material.unit,
                        'Warning_Threshold': float(inv.warning_threshold) if inv.warning_threshold else 0,
                        'Status': '库存不足' if is_warning else '正常',
                        'Total_Quantity': total_data['quantity'],
                        'Last_Updated': inv.updated_at.strftime('%Y-%m-%d %H:%M:%S')
                    }
                    inventory_data.append(item)
                except Exception as e:
                    current_app.logger.error(f"Error processing record {inv.id}: {str(e)}")
                    raise
            
            # 导出为Excel
            headers = ['ID', 'Material', 'Store', 'Quantity', 'Unit', 
                      'Warning_Threshold', 'Total_Quantity', 'Status', 'Last_Updated']
            
            response = export_to_excel(
                data=inventory_data,
                headers=headers,
                sheet_name='Inventory'
            )
            
            # 添加CORS头
            response.headers['Access-Control-Allow-Origin'] = '*'
            response.headers['Access-Control-Allow-Methods'] = 'GET, OPTIONS'
            response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
            
            return response
            
        except Exception as e:
            current_app.logger.error(f'Error exporting inventory: {str(e)}')
            current_app.logger.exception("Full traceback:")
            return {'message': f'Error exporting inventory: {str(e)}'}, 500

# 添加物料调拨接口
transfer_model = api.model('TransferStock', {
    'material_id': fields.Integer(required=True, description='要调拨的物料ID'),
    'source_store_id': fields.Integer(required=True, description='源门店ID'),
    'target_store_id': fields.Integer(required=True, description='目标门店ID'),
    'quantity': fields.Float(required=True, description='调拨数量'),
    'batch_number': fields.String(description='批次号')
})

@ns_inventory.route('/transfer/')
class InventoryTransferResource(Resource):
    @api.doc('transfer_inventory')
    @api.expect(transfer_model)
    @jwt_required()
    def post(self):
        """物料调拨 - 从一个门店调拨物料到另一个门店"""
        try:
            data = request.get_json()
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 权限检查：只有管理员和总部采购员可以执行调拨操作
            if user.role not in ['admin', 'purchaser']:
                return {'message': '权限不足，无法执行调拨操作'}, 403
            
            # 获取必要参数
            material_id = data.get('material_id')
            source_store_id = data.get('source_store_id')
            target_store_id = data.get('target_store_id')
            quantity = data.get('quantity')
            batch_number = data.get('batch_number')
            
            # 参数合法性验证
            if not all([material_id, source_store_id, target_store_id, quantity]):
                return {'message': '缺少必要参数'}, 400
                
            if float(quantity) <= 0:
                return {'message': '调拨数量必须大于0'}, 400
                
            if source_store_id == target_store_id:
                return {'message': '源门店和目标门店不能相同'}, 400
            
            # 检查源库存是否充足 - 修改为考虑所有批次的总库存
            source_inventories = Inventory.query.filter_by(
                material_id=material_id,
                store_id=source_store_id
            ).all()
            
            if not source_inventories:
                return {'message': '源门店中没有该物料库存'}, 404
            
            # 计算所有批次的总库存
            total_source_quantity = sum(float(inv.quantity) for inv in source_inventories)
            if total_source_quantity < float(quantity):
                return {'message': f'源门店库存不足，需要{quantity}，但只有{total_source_quantity}'}, 400
            
            # 获取物料和价格信息
            material = Material.query.get(material_id)
            if not material:
                return {'message': '物料不存在'}, 404
            
            # 获取目标门店的库存记录，若不存在则创建新记录
            is_processed = batch_number and batch_number.startswith('P')
            
            # 如果是加工物料，查找同物料ID、同门店且批次号以P开头的记录
            if is_processed:
                target_inventory = Inventory.query.filter(
                    Inventory.material_id == material_id,
                    Inventory.store_id == target_store_id,
                    Inventory.batch_number.like('P%')
                ).first()
            else:
                # 如果不是加工物料，查找同物料ID、同门店且批次号不以P开头的记录
                target_inventory = Inventory.query.filter(
                    Inventory.material_id == material_id,
                    Inventory.store_id == target_store_id,
                    ~Inventory.batch_number.like('P%')
                ).first()
            
            # 获取调拨价格
            from app.models.price import MaterialPrice
            current_price = MaterialPrice.query.filter_by(
                material_id=material_id,
                status='active'
            ).first()
            
            # 使用转移价格，若没有则使用源库存的单价
            transfer_price = current_price.transfer_price if current_price else source_inventories[0].unit_price
            
            db.session.begin_nested()  # 创建保存点
            try:
                # 按照FIFO原则排序库存批次（先按生产日期，再按ID）
                source_inventories.sort(key=lambda x: (x.production_date or datetime.min.date(), x.id))
                
                remaining_quantity = float(quantity)
                processed_inventories = []
                
                # 从最早的批次开始扣减
                for inv in source_inventories:
                    if remaining_quantity <= 0:
                        break
                        
                    batch_quantity = float(inv.quantity)
                    batch_id = inv.id  # 保存批次ID，以便后续创建日志
                    
                    if batch_quantity <= remaining_quantity:
                        # 当前批次全部扣减
                        deduct_amount = batch_quantity
                        inv.quantity = Decimal('0')  # 使用Decimal类型的0
                        # 不删除库存记录，只是将其数量设为0
                        to_be_deleted = False
                    else:
                        # 部分扣减
                        deduct_amount = remaining_quantity
                        # 使用Decimal类型进行减法运算，确保类型一致
                        inv.quantity = inv.quantity - Decimal(str(deduct_amount))
                        to_be_deleted = False
                    
                    remaining_quantity -= deduct_amount
                    processed_inventories.append({
                        'id': batch_id,
                        'batch_number': inv.batch_number or '未指定批次',
                        'deducted': deduct_amount,
                        'delete_after_log': to_be_deleted,  # 保留这个字段作为记录，但实际上已经不会删除
                        'inventory_id': inv.id  # 替换完整对象引用为ID
                    })
                
                # 更新或创建目标库存
                if target_inventory:
                    # 将float转换为Decimal，避免类型不兼容
                    target_inventory.quantity = target_inventory.quantity + Decimal(str(quantity))
                    # 如果目标库存没有单价，则使用调拨价格
                    if not target_inventory.unit_price:
                        target_inventory.unit_price = transfer_price
                else:
                    # 创建新的目标库存记录
                    new_batch_number = batch_number
                    if not new_batch_number:  # 如果没有提供批次号
                        if is_processed:
                            # 为加工物料生成新的P前缀批次号
                            now = datetime.now()
                            new_batch_number = f"P{now.strftime('%y%m%d%H%M%S')}"
                        else:
                            # 非加工物料使用默认批次号
                            new_batch_number = f"调拨自{source_store_id}的多批次"
                    
                    target_inventory = Inventory(
                        material_id=material_id,
                        store_id=target_store_id,
                        quantity=Decimal(str(quantity)),  # 使用Decimal
                        batch_number=new_batch_number,
                        unit_price=transfer_price,
                        warning_threshold=material.processed_warning_threshold if is_processed else material.warning_threshold
                    )
                    db.session.add(target_inventory)
                    db.session.flush()  # 添加flush确保新创建的目标库存有ID
                
                # 创建日志记录
                for proc in processed_inventories:
                    log = InventoryLog(
                        inventory_id=proc['id'],
                        material_id=material_id,
                        store_id=source_store_id,
                        operation_type='transfer_out',
                        quantity=Decimal(str(proc['deducted'])),  # 确保使用Decimal类型
                        batch_number=proc['batch_number'],
                        unit_price=transfer_price,
                        user_id=user_id
                    )
                    db.session.add(log)
                
                # 添加调入日志
                log = InventoryLog(
                    inventory_id=target_inventory.id,
                    material_id=material_id,
                    store_id=target_store_id,
                    operation_type='transfer_in',
                    quantity=Decimal(str(quantity)),  # 确保使用Decimal类型
                    batch_number=target_inventory.batch_number,
                    unit_price=transfer_price,
                    user_id=user_id
                )
                db.session.add(log)
                
                # 直接提交，不需要先flush了
                db.session.commit()
                
                # 不再需要处理删除库存记录的代码
                # 因为我们保留所有库存记录，只是将数量设为0
                
                # 让我们确保返回的数据是可以序列化的
                serializable_processed_batches = []
                for proc in processed_inventories:
                    # 创建一个不包含任何对象引用的字典
                    serializable_proc = {
                        'id': proc['id'],
                        'batch_number': proc['batch_number'],
                        'deducted': float(proc['deducted']),  # 转换为原生Python数字类型
                        'delete_after_log': proc['delete_after_log']
                    }
                    serializable_processed_batches.append(serializable_proc)
                
                return {
                    'message': '物料调拨成功',
                    'source': [inv.to_dict() for inv in source_inventories if float(inv.quantity) > 0],
                    'target': target_inventory.to_dict(),
                    'processed_batches': serializable_processed_batches
                }
                
            except Exception as e:
                db.session.rollback()
                current_app.logger.error(f'调拨过程中发生错误: {str(e)}')
                return {'message': f'调拨失败: {str(e)}'}, 500
                
        except Exception as e:
            current_app.logger.error(f'物料调拨失败: {str(e)}')
            return {'message': f'物料调拨失败: {str(e)}'}, 500

@ns_inventory.route('/<int:id>/')
class InventoryItemResource(Resource):
    @api.doc('update_inventory_item')
    @api.expect(inventory_model)
    @jwt_required()
    def put(self, id):
        """更新特定库存记录"""
        try:
            # 获取用户信息
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 查找要更新的库存记录
            inventory = Inventory.query.get_or_404(id)
            
            # 如果是门店经理，只能更新自己门店的库存
            if user.role == 'store_manager' and inventory.store_id != user.store_id:
                return {'message': '您没有权限更新其他门店的库存'}, 403
            
            # 获取请求数据
            data = request.get_json()
            
            # 处理日期字段
            expiry_date = None
            if data.get('expiry_date'):
                try:
                    expiry_date = datetime.strptime(data['expiry_date'], '%Y-%m-%d').date()
                except ValueError:
                    pass
                    
            production_date = None
            if data.get('production_date'):
                try:
                    production_date = datetime.strptime(data['production_date'], '%Y-%m-%d').date()
                except ValueError:
                    pass
            
            # 更新库存记录的各个字段
            if 'quantity' in data:
                inventory.quantity = data['quantity']
            if 'batch_number' in data:
                inventory.batch_number = data['batch_number']
            if 'unit_price' in data:
                inventory.unit_price = data['unit_price']
            if expiry_date:
                inventory.expiry_date = expiry_date
            if production_date:
                inventory.production_date = production_date
            if 'warning_threshold' in data:
                inventory.warning_threshold = data['warning_threshold']
            
            # 保存更改
            db.session.commit()
            
            # 返回更新后的记录
            return inventory.to_dict()
            
        except Exception as e:
            current_app.logger.error(f'Error updating inventory: {str(e)}')
            db.session.rollback()
            return {'message': f'Error updating inventory: {str(e)}'}, 500

@ns_inventory.route('/checkout/')
class InventoryCheckoutResource(Resource):
    @api.doc('checkout_inventory')
    @api.expect(checkout_model)
    @api.response(200, 'Success', checkout_response)
    @api.response(400, 'Validation Error')
    @api.response(401, 'Unauthorized')
    @api.response(500, 'Internal Server Error')
    @jwt_required()
    def post(self):
        """物料出库 - 基于FIFO原则自动从最早入库的批次开始出库"""
        try:
            # 获取用户身份和权限检查
            user_id = get_jwt_identity()
            user = User.query.get(user_id)
            
            # 门店经理只能操作自己门店的库存
            if user.role == 'store_manager':
                store_id = request.json.get('store_id')
                if store_id != user.store_id:
                    return {'message': '您只能操作自己门店的库存'}, 403
            
            # 获取请求数据
            data = request.get_json()
            material_id = data.get('material_id')
            store_id = data.get('store_id')
            checkout_quantity = float(data.get('quantity'))
            
            # 验证必填字段
            if not all([material_id, store_id, checkout_quantity]):
                return {'message': '物料ID、门店ID和出库数量不能为空'}, 400
            
            if checkout_quantity <= 0:
                return {'message': '出库数量必须大于0'}, 400
            
            # 查询物料信息
            material = Material.query.get(material_id)
            if not material:
                return {'message': '物料不存在'}, 404
            
            # 查询门店信息
            store = Store.query.get(store_id)
            if not store:
                return {'message': '门店不存在'}, 404
            
            # 查询该物料在该门店的所有批次库存，按生产日期和ID（创建时间）排序
            # 对于没有生产日期的记录，将它们放在后面
            inventory_batches = Inventory.query.filter_by(
                material_id=material_id,
                store_id=store_id
            ).order_by(
                # 使用coalesce函数，如果production_date为NULL，则使用一个较大的日期
                func.coalesce(Inventory.production_date, '9999-12-31'),
                # 对于同一生产日期的，按ID排序（较小的ID表示较早创建的记录）
                Inventory.id
            ).all()
            
            # 检查总库存是否足够
            total_quantity = sum(float(batch.quantity) for batch in inventory_batches)
            if total_quantity < checkout_quantity:
                return {'message': f'库存不足，当前库存: {total_quantity}{material.unit}'}, 400
            
            remaining_checkout = checkout_quantity
            updated_inventories = []
            checkout_details = []
            
            # 开始事务
            with db.session.begin_nested():
                # 按FIFO原则从最早的批次开始出库
                for batch in inventory_batches:
                    batch_quantity = float(batch.quantity)
                    
                    # 如果当前批次足够出库
                    if batch_quantity >= remaining_checkout:
                        # 创建出库明细记录
                        checkout_details.append({
                            'batch_number': batch.batch_number or '未指定批次',
                            'quantity': remaining_checkout,
                            'unit_price': float(batch.unit_price) if batch.unit_price else 0
                        })
                        
                        # 记录出库日志
                        log = InventoryLog(
                            inventory_id=batch.id,
                            material_id=material_id,
                            store_id=store_id,
                            operation_type='out',
                            quantity=Decimal(str(remaining_checkout)),
                            batch_number=batch.batch_number,
                            unit_price=batch.unit_price,
                            user_id=user_id
                        )
                        db.session.add(log)
                        
                        # 更新批次库存
                        batch.quantity = batch.quantity - Decimal(str(remaining_checkout))
                        updated_inventories.append(batch)
                        remaining_checkout = 0
                        break
                    else:
                        # 当前批次不足，全部出库，继续下一个批次
                        checkout_details.append({
                            'batch_number': batch.batch_number or '未指定批次',
                            'quantity': batch_quantity,
                            'unit_price': float(batch.unit_price) if batch.unit_price else 0
                        })
                        
                        # 记录出库日志
                        log = InventoryLog(
                            inventory_id=batch.id,
                            material_id=material_id,
                            store_id=store_id,
                            operation_type='out',
                            quantity=batch.quantity,  # 全部出库
                            batch_number=batch.batch_number,
                            unit_price=batch.unit_price,
                            user_id=user_id
                        )
                        db.session.add(log)
                        
                        # 更新批次库存为0
                        batch.quantity = Decimal('0')
                        updated_inventories.append(batch)
                        remaining_checkout -= batch_quantity
            
            # 提交事务
            db.session.commit()
            
            # 清除缓存
            clear_cache('inventory')
            
            # 返回成功响应
            return {
                'success': True,
                'updated_inventories': [inv.to_dict() for inv in updated_inventories],
                'checkout_details': checkout_details
            }, 200
        
        except Exception as e:
            current_app.logger.error(f'Error during checkout: {str(e)}')
            db.session.rollback()
            return {'message': f'出库失败: {str(e)}'}, 500

@ns_inventory.route('/process/')
class InventoryProcessResource(Resource):
    @api.doc('process_material')
    @api.expect(process_model)
    @api.response(200, 'Success')
    @api.response(400, 'Validation Error')
    @api.response(401, 'Unauthorized')
    @api.response(500, 'Internal Server Error')
    @jwt_required()
    def post(self):
        """将原材料加工为成品"""
        try:
            # 获取当前用户
            current_user_id = get_jwt_identity()
            
            # 获取请求数据
            data = request.get_json()
            
            # 获取物料信息
            material = Material.query.get_or_404(data['material_id'])
            
            # 验证该物料是否有加工信息
            if not material.processed_name or not material.conversion_ratio:
                return {'message': 'Material does not have processing information'}, 400
            
            # 验证加工数量是否为正数
            quantity = float(data['quantity'])
            if quantity <= 0:
                return {'message': 'Quantity must be positive'}, 400
            
            # 如果提供了库存ID，使用该条库存记录
            if 'inventory_id' in data and data['inventory_id']:
                inventory = Inventory.query.get_or_404(data['inventory_id'])
                
                # 检查库存是否足够
                if float(inventory.quantity) < quantity:
                    return {'message': 'Insufficient inventory'}, 400
                
                # 扣减原材料库存
                inventory.quantity = inventory.quantity - Decimal(str(quantity))
                
                # 使用原始库存的批次号
                orig_batch_number = inventory.batch_number
            else:
                # 查找该门店该物料的所有库存
                inventories = Inventory.query.filter_by(
                    material_id=data['material_id'],
                    store_id=data['store_id']
                ).all()
                
                # 检查库存总数是否足够
                total_quantity = sum(float(inv.quantity) for inv in inventories)
                if total_quantity < quantity:
                    return {'message': 'Insufficient inventory'}, 400
                
                # 从库存中扣减，优先使用即将过期的库存
                inventories.sort(key=lambda x: x.expiry_date if x.expiry_date else date.max)
                remaining = Decimal(str(quantity))
                
                # 使用指定批次号或默认使用第一个批次号
                orig_batch_number = data.get('batch_number') or inventories[0].batch_number
                
                for inv in inventories:
                    if remaining <= 0:
                        break
                        
                    if float(inv.quantity) <= float(remaining):
                        # 如果当前库存不足以满足全部需求，全部扣减
                        remaining -= inv.quantity
                        inv.quantity = 0
                    else:
                        # 否则部分扣减
                        inv.quantity = inv.quantity - remaining
                        remaining = 0
            
            # 计算加工后的数量
            processed_quantity = quantity * float(material.conversion_ratio)
            
            # 构建新批次号 (P前缀表示加工)
            now = datetime.now()
            processed_batch_number = f"P{now.strftime('%y%m%d%H%M%S')}"
            
            # 查找加工后物料是否存在于同一门店，同一批次
            processed_inventory = Inventory.query.filter_by(
                material_id=data['material_id'],
                store_id=data['store_id'],
                batch_number=processed_batch_number
            ).first()
            
            if processed_inventory:
                # 如果存在，增加库存
                processed_inventory.quantity = processed_inventory.quantity + Decimal(str(processed_quantity))
            else:
                # 如果不存在，创建新库存记录
                processed_inventory = Inventory(
                    material_id=data['material_id'],
                    store_id=data['store_id'],
                    batch_number=processed_batch_number,
                    quantity=processed_quantity,
                    warning_threshold=material.processed_warning_threshold
                )
                db.session.add(processed_inventory)
            
            # 创建加工操作日志
            process_log = InventoryLog(
                inventory_id=data.get('inventory_id'),
                material_id=data['material_id'],
                store_id=data['store_id'],
                operation_type='process',
                quantity=quantity,
                batch_number=orig_batch_number,
                user_id=current_user_id
            )
            db.session.add(process_log)
            
            # 提交事务
            db.session.commit()
            
            # 返回结果
            return {
                'success': True,
                'original_inventory': {
                    'material_id': data['material_id'],
                    'material_name': material.name,
                    'quantity': float(quantity),
                    'unit': material.unit
                },
                'processed_inventory': {
                    'material_id': data['material_id'],
                    'material_name': material.processed_name,
                    'quantity': processed_quantity,
                    'unit': material.processed_unit,
                    'batch_number': processed_batch_number
                }
            }
            
        except Exception as e:
            current_app.logger.error(f'Error processing material: {str(e)}')
            db.session.rollback()
            return {'message': f'Error processing material: {str(e)}'}, 500