package com.lingnan.supermarket.dao.impl;

import com.lingnan.supermarket.dao.BufferService;
import com.lingnan.supermarket.dto.Buffer;
import com.lingnan.supermarket.dto.Production;
import com.lingnan.supermarket.utils.JDBCUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;

// 实现BufferService接口的缓冲区操作类
public class BufferImpl implements BufferService  {

	/*------------------------收银出货模块-----------------------*/
	/*返回出货缓冲表所有delmark=1的记录并排序*/
	// 获取所有出货缓冲区的记录
	public Vector<Buffer> allOutBuffer(){
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		Vector<Buffer> v = new Vector<Buffer>(); // 创建一个向量用于存储Buffer对象
		Buffer Buffer; // 声明一个Buffer对象
		try {
			pstmt = conn.prepareStatement("select * from OutBuffer  "); // 准备SQL查询语句
			resultSet = pstmt.executeQuery(); // 执行查询
			while(resultSet.next()) { // 遍历结果集
				Buffer = new Buffer(); // 创建一个新的Buffer对象
				Buffer.setId(resultSet.getString("id")); // 设置商品ID
				Buffer.setName(resultSet.getString("name")); // 设置商品名称
				Buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格
				Buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格
				Buffer.setLife(resultSet.getInt("life")); // 设置商品保质期
				Buffer.setSum(resultSet.getInt("sum")); // 设置商品数量
				Buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
				Buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID
				Buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称
				Buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价
				Buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
				v.add(Buffer); // 将Buffer对象添加到向量中
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return v; // 返回存储所有Buffer对象的向量
	}

	/*通过id查找返回boolean*/
	// 根据ID查找出货缓冲区的记录
	public Buffer findOutBufferbyId(String id)
	{
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		Buffer buffer = new Buffer(); // 创建一个新的Buffer对象
		try {
			pstmt = conn.prepareStatement("select * from OutBuffer where id=? "); // 准备SQL查询语句
			pstmt.setString(1, id); // 设置查询参数
			resultSet = pstmt.executeQuery(); // 执行查询

			if(resultSet.next()) { // 如果找到对应记录
				buffer.setId(resultSet.getString("id")); // 设置商品ID
				buffer.setName(resultSet.getString("name")); // 设置商品名称
				buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格
				buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格
				buffer.setLife(resultSet.getInt("life")); // 设置商品保质期
				buffer.setSum(resultSet.getInt("sum")); // 设置商品数量
				buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
				buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID
				buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称
				buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价
				buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
				flag = true; // 设置标志为true
			}else {
				return null; // 没有找到该商品，返回null
			}

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return buffer; // 返回找到的Buffer对象
	}

	/*如果缓冲区没有那就把整条记录插入插入操作*/
	// 向出货缓冲区添加新商品记录
	public boolean addOutBufferNewProd(String id,int sum) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("call InsertOutBuffer(?,?) "); // 准备存储过程调用语句
			pstmt.setString(1, id); // 设置商品ID参数
			pstmt.setInt(2, sum); // 设置商品数量参数


			if( pstmt.executeUpdate()==1) { // 执行更新操作
				flag = true; // 如果成功执行插入，设置标志为true
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回插入结果标志
	}


	/*根据商品id获取sum和outprice
	public Buffer findOutBufferSumAndOutPrice(String id) {
		Buffer Buffer = new Buffer();
		Connection conn = JDBCUtil.getConn();
		PreparedStatement pstmt = null;
		ResultSet resultSet=null;
		try {
			pstmt = conn.prepareStatement("select * from OutBuffer where id=? ");
			pstmt.setString(1, id);
			resultSet = pstmt.executeQuery();

			if(resultSet.next()) {
				Buffer.setSum(resultSet.getInt("sum"));
				Buffer.setOutPrice(resultSet.getFloat("OutPrice"));
			}


		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.close(resultSet, pstmt, conn);
		}
		return Buffer;
	}
	*/


	/*如果delmark是1，即是已经添加的商品*/
	// 更新已存在商品的出货缓冲区记录
	public boolean addOutBufferExeistProd(String id,int sum,Buffer buffer){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("update  OutBuffer set sum=?,price=? where id=? "); // 准备SQL更新语句
			pstmt.setInt(1, sum+buffer.getSum()); // 设置更新后的商品数量
			pstmt.setFloat(2,( sum+buffer.getSum()*buffer.getOutPrice())); // 设置更新后的商品总价
			pstmt.setString(3, id); // 设置商品ID
			if(pstmt.executeUpdate()==1) { // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}

	/*获得购物车总价*/
	// 计算出货缓冲区所有商品的总价
	public Float OutBufferAllPrice(){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("select sum(price) from OutBuffer "); // 准备SQL查询语句
			resultSet=pstmt.executeQuery(); // 执行查询
			if(resultSet.next()) { // 如果有结果
				return resultSet.getFloat("sum(price)"); // 返回总价
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return null; // 如果没有结果，返回null
	}


	/*结账后对5个表进行操作*/
	// 进行结账操作并更新数据库
	public boolean Account(String number,String time,String id,int sum,Float price){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("call Account(?,?,?,?,?)"); // 准备存储过程调用语句
			pstmt.setString(1,number); // 设置订单号
			pstmt.setString(2,time ); // 设置时间
			pstmt.setString(3,id ); // 设置商品ID
			pstmt.setInt(4,sum ); // 设置商品数量
			pstmt.setFloat(5, price); // 设置商品总价
			if(pstmt.execute()) // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true




		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}

	/*删除所有购物车*/
	// 清空出货缓冲区
	public boolean DelAllOutBuffer(){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("delete from OutBuffer"); // 准备SQL删除语句
			if(pstmt.execute()) // 执行删除操作
				flag = true; // 如果成功执行删除，设置标志为true


			flag = true; // 如果成功执行删除，设置标志为true


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回删除结果标志
	}

	/*往订单表插入一条记录*/
	// 向订单表插入一条新记录
	public boolean InsertOutOrder(String number,Float allPrice,String time,String username){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("insert into OutOrder values(?,?,?,?,?)"); // 准备SQL插入语句
			pstmt.setString(1, number); // 设置订单号
			pstmt.setFloat(2, allPrice); // 设置总价
			pstmt.setString(3, time); // 设置时间
			pstmt.setString(4, username); // 设置用户名
			pstmt.setInt(5, 1); // 设置删除标记
			if(pstmt.execute()) // 执行插入操作
				flag = true; // 如果成功执行插入，设置标志为true


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回插入结果标志
	}

	/*删除缓冲区OutBuffer一条记录通过id*/
	// 根据ID删除出货缓冲区的一条记录
	public boolean DelOutBufferById(String id) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("delete from OutBuffer where id=?"); // 准备SQL删除语句
			pstmt.setString(1, id); // 设置商品ID
			if(pstmt.executeUpdate()==1) // 执行删除操作
				flag = true; // 如果成功执行删除，设置标志为true

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回删除结果标志
	}

	/*更改记录通过id*/
	// 更新出货缓冲区记录
	public boolean UpdateOutBufferById(String id,int sum) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("update OutBuffer set sum=? where  id=?"); // 准备SQL更新语句
			pstmt.setInt(1, sum); // 设置更新后的商品数量
			pstmt.setString(2, id); // 设置商品ID
			if(pstmt.execute()) // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}









	/*---------------------------进货模块----------------------------*/
	/*编辑人程文锋2210461197*/
	/*返回出货缓冲表所有delmark=1的记录并排序*/
	// 获取所有进货缓冲区的记录
	/**
	 * 从数据库中获取所有在库的商品信息，并返回一个包含Production对象的向量。
	 *
	 * @return 包含所有Production对象的向量
	 */
	public Vector<Production> allInBuffer(){
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		Vector<Production> v = new Vector<Production>(); // 创建一个向量用于存储Production对象
		Production production; // 声明一个Production对象
		try {
			pstmt = conn.prepareStatement("select * from InBuffer  "); // 准备SQL查询语句
			resultSet = pstmt.executeQuery(); // 执行查询
			while(resultSet.next()) { // 遍历结果集
				production = new Production(); // 创建一个新的Production对象
				production.setId(resultSet.getString("id")); // 设置商品ID
				production.setName(resultSet.getString("name")); // 设置商品名称
				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格
				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格
				production.setLife(resultSet.getInt("life")); // 设置商品保质期
				production.setSum(resultSet.getInt("sum")); // 设置商品数量
				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
				production.setId2(resultSet.getString("id2")); // 设置商品类别ID
				production.setName2(resultSet.getString("name2")); // 设置商品类别名称
				production.setPrice(resultSet.getFloat("price")); // 设置商品总价
				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
				v.add(production); // 将Production对象添加到向量中
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return v; // 返回存储所有Production对象的向量
	}

	/**
	 * 根据商品ID在数据库中查找对应的Buffer对象
	 * @param id 商品的ID
	 * @return 找到的Buffer对象，若未找到则返回null
	 */
	public Buffer findInBufferbyId(String id)
	{
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		Buffer buffer = new Buffer(); // 创建一个新的Buffer对象
		try {
			pstmt = conn.prepareStatement("select * from InBuffer where id=? "); // 准备SQL查询语句
			pstmt.setString(1, id); // 设置查询参数
			resultSet = pstmt.executeQuery(); // 执行查询

			if(resultSet.next()) { // 如果找到对应记录
				buffer.setId(resultSet.getString("id")); // 设置商品ID
				buffer.setName(resultSet.getString("name")); // 设置商品名称
				buffer.setInPrice(resultSet.getFloat("inPrice")); // 设置进货价格
				buffer.setOutPrice(resultSet.getFloat("OutPrice")); // 设置出货价格
				buffer.setLife(resultSet.getInt("life")); // 设置商品保质期
				buffer.setSum(resultSet.getInt("sum")); // 设置商品数量
				buffer.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
				buffer.setId2(resultSet.getString("id2")); // 设置商品类别ID
				buffer.setName2(resultSet.getString("name2")); // 设置商品类别名称
				buffer.setPrice(resultSet.getFloat("price")); // 设置商品总价
				buffer.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
			}
			else {
				return null; // 没有找到该商品，返回null
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return buffer; // 返回找到的Buffer对象
	}



	/*如果缓冲区没有那就把整条记录插入插入操作*/
// 向进货缓冲区添加新商品记录
	/**
	 * 添加新商品记录到进货缓冲区
	 *
	 * @param id 商品ID
	 * @param sum 商品数量
	 * @return 返回插入操作是否成功的标志
	 */
	public boolean addInBufferNewProd(String id,int sum) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("call InsertInBuffer(?,?) "); // 准备存储过程调用语句
			pstmt.setString(1, id); // 设置商品ID参数
			pstmt.setInt(2, sum); // 设置商品数量参数


			if( pstmt.executeUpdate()==1) { // 执行更新操作
				flag = true; // 如果成功执行插入，设置标志为true
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回插入结果标志
	}



	// 向进货缓冲区插入一条记录
	// 此方法负责将一个商品记录插入到进货缓冲区中，并返回插入操作是否成功的标志
	public boolean insertInBuffer(Production p) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet=null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("insert into InBuffer values(?,?,?,?,?,?,?,?,?,?,?)"); // 准备SQL插入语句
			pstmt.setString(1, p.getId()); // 设置商品ID
			pstmt.setString(2, p.getName()); // 设置商品名称
			pstmt.setFloat(3, p.getInPrice()); // 设置进货价格
			pstmt.setFloat(4, p.getOutPrice()); // 设置出货价格
			pstmt.setInt(5, p.getLife()); // 设置商品保质期
			pstmt.setInt(6, p.getSum()); // 设置商品数量
			pstmt.setInt(7, p.getSupplyId()); // 设置供应商ID
			pstmt.setString(8, p.getId2()); // 设置商品类别ID
			pstmt.setString(9, p.getName2()); // 设置商品类别名称
			pstmt.setFloat(10,p.getPrice()); // 设置商品总价
			pstmt.setInt(11, 1); // 设置删除标记
			pstmt.executeUpdate(); // 执行插入操作


			if( pstmt.execute()) { // 如果成功执行插入，设置标志为true
				flag = true;
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块
			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回插入结果标志
	}


/*	根据商品id获取sum和outprice
	public Buffer findInBufferSumAndInPrice(String id) {
		Buffer Buffer = new Buffer();
		Connection conn = JDBCUtil.getConn();
		PreparedStatement pstmt = null;
		ResultSet resultSet=null;
		try {
			pstmt = conn.prepareStatement("select * from InBuffer where id=? ");
			pstmt.setString(1, id);
			resultSet = pstmt.executeQuery();

			if(resultSet.next()) {
				Buffer.setSum(resultSet.getInt("sum"));
				Buffer.setOutPrice(resultSet.getFloat("InPrice"));
			}


		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.close(resultSet, pstmt, conn);
		}
		return Buffer;
	}*/


	/*如果delmark是1，即是已经添加的商品*/
			// 更新已存在商品的进货缓冲区记录
			// 方法名称：addInBufferExeistProd
			// 参数：
			// id - 商品的唯一标识符
			// sum - 要添加的商品数量
			// buffer - 包含商品信息的缓冲区对象
			// 返回值：布尔值，表示更新操作是否成功
	public boolean addInBufferExeistProd(String id,int sum,Buffer buffer){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("update  InBuffer set sum=?,price=? where id=? "); // 准备SQL更新语句
			pstmt.setInt(1, sum+buffer.getSum()); // 设置更新后的商品数量
			pstmt.setFloat(2,( sum+buffer.getSum()*buffer.getInPrice())); // 设置更新后的商品总价
			pstmt.setString(3, id); // 设置商品ID
			if(pstmt.executeUpdate()==1) { // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true
			}

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}


	/*获得购物车总价*/
// 计算进货缓冲区所有商品的总价
// 此方法用于计算数据库中进货缓冲区所有商品的总价，并返回相应的浮点数值。
	public Float InBufferAllPrice(){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("select sum(price) from InBuffer "); // 准备SQL查询语句
			resultSet=pstmt.executeQuery(); // 执行查询
			if(resultSet.next()) { // 如果有结果
				return resultSet.getFloat("sum(price)"); // 返回总价
			}


		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return null; // 如果没有结果，返回null
	}


	/*结账后对5个表进行操作*/
// 进行进货时的记录操作
	/**
	 * 在库存中记录进货信息的函数
	 *
	 * @param number 订单号
	 * @param time 进货时间
	 * @param id 商品ID
	 * @param sum 商品数量
	 * @param price 商品总价
	 * @return 返回操作是否成功的标志
	 */
	public boolean Stock(String number,String time,String id,int sum,Float price){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("call Stock(?,?,?,?,?)"); // 准备存储过程调用语句
			pstmt.setString(1,number); // 设置订单号
			pstmt.setString(2,time ); // 设置时间
			pstmt.setString(3,id ); // 设置商品ID
			pstmt.setInt(4,sum ); // 设置商品数量
			pstmt.setFloat(5, price); // 设置商品总价
			if(pstmt.executeUpdate()==1) // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true
		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}


	/*删除所有购物车*/
	// 清空进货缓冲区
	/**
	 * 从数据库中删除进货缓冲区中的所有记录
	 *
	 * @return 返回操作是否成功的标志
	 */
	public boolean DelAllInBuffer(){
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("delete from InBuffer"); // 准备SQL删除语句
			if(pstmt.execute()) // 执行删除操作
				flag = true; // 如果成功执行删除，设置标志为true
		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回删除结果标志
	}


	/*删除缓冲区InBuffer一条记录通过id*/
	// 根据ID删除进货缓冲区的一条记录
	/**
	 * 根据商品ID删除进货缓冲区中的一条记录
	 *
	 * @param id 商品ID
	 * @return 删除操作是否成功的标志
	 */
	public boolean DelInBufferById(String id) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null;; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("delete from InBuffer where id=?"); // 准备SQL删除语句
			pstmt.setString(1, id); // 设置商品ID
			if(pstmt.executeUpdate()==1) // 执行删除操作
				flag = true; // 如果成功执行删除，设置标志为true

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回删除结果标志
	}





		/*更改记录通过id*/
		// 更新进货缓冲区记录
		/**
		 * 更新进货缓冲区中指定商品ID的数量。
		 *
		 * @param id 商品的ID
		 * @param sum 更新后的商品数量
		 * @return 返回更新是否成功的标志
		 */
public boolean UpdateInBufferById(String id,int sum) {
		boolean flag = false; // 初始化标志为false
		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
		PreparedStatement pstmt = null; // 初始化预编译语句对象
		ResultSet resultSet = null; // 初始化结果集对象
		try {
			pstmt = conn.prepareStatement("update InBuffer set sum=? where  id=?"); // 准备SQL更新语句
			pstmt.setInt(1, sum); // 设置更新后的商品数量
			pstmt.setString(2, id); // 设置商品ID
			if(pstmt.execute()) // 执行更新操作
				flag = true; // 如果成功执行更新，设置标志为true

		} catch (SQLException e) { // 捕获SQL异常
			e.printStackTrace(); // 打印异常堆栈信息
		}finally { // 无论是否发生异常，都会执行的代码块

			JDBCUtil.close(resultSet, pstmt, conn); // 关闭结果集、预编译语句和数据库连接
		}
		return flag; // 返回更新结果标志
	}


	/**
	 * 按照顺序插入订单
	 *
	 * @param number 订单编号
	 * @param allPrice 总价格
	 * @param time 订单时间
	 * @param username 用户名
	 * @return 返回插入成功与否
	 */
	@Override
	public boolean InsertInOrder(String number, Float allPrice, String time, String username) {
		// TODO Auto-generated method stub
		// 插入订单的操作
		return false;
	}


}