pcjs8mx7g
/
warehouse
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Merge pull request '合并' (#4) from liaobiaojie_branch into master

Browse Source
master
pcjs8mx7g 9 months ago
parent 4cb5f185d0 5e6a1fdca1
commit e8ee6e58f4
34 changed files with 1490 additions and 1455 deletions
Show Stats Download Patch File Download Diff File

121
src/main/java/com/yeqifu/bus/controller/CustomerController.java
Unescape View File

@ -1,25 +1,24 @@
package com.yeqifu.bus.controller;
package com.yeqifu.bus.controller; // 定义包路径
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入查询包装器类
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入分页实现类
import com.yeqifu.bus.entity.Customer; // 导入客户实体类
import com.yeqifu.bus.service.ICustomerService; // 导入客户服务接口
import com.yeqifu.bus.vo.CustomerVo; // 导入客户视图对象
import com.yeqifu.sys.common.Constast; // 导入常量类
import com.yeqifu.sys.common.DataGridView; // 导入数据网格返回类
import com.yeqifu.sys.common.ResultObj; // 导入结果对象类
import io.swagger.annotations.ApiImplicitParam; // 导入Swagger参数注解
import io.swagger.annotations.ApiImplicitParams; // 导入Swagger参数列表注解
import io.swagger.annotations.ApiOperation; // 导入Swagger操作注解
import org.apache.commons.lang3.StringUtils; // 导入字符串工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 导入请求映射注解
import org.springframework.web.bind.annotation.RequestMethod; // 导入请求方法注解
import org.springframework.web.bind.annotation.RestController; // 导入控制器注解
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yeqifu.bus.entity.Customer;
import com.yeqifu.bus.service.ICustomerService;
import com.yeqifu.bus.vo.CustomerVo;
import com.yeqifu.sys.common.Constast;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.List; // 导入列表类
/**
* <p>
@ -29,29 +28,27 @@ import java.util.List;
* @author luoyi-
* @since 2019-12-05
*/
@RestController
@RequestMapping("/customer")
@RestController // 标注为REST控制器
@RequestMapping("/customer") // 设置请求路径为/customer
public class CustomerController {
@Autowired
private ICustomerService customerService;
@Autowired // 自动注入客户服务接口实现类
private ICustomerService customerService; // 定义客户服务接口实例
/**
* 查询所有的客户
* @param customerVo
* @return
*/
@RequestMapping("loadAllCustomer")
public DataGridView loadAllCustomer(CustomerVo customerVo){
//1.声明分页page对象
IPage<Customer> page = new Page<Customer>(customerVo.getPage(),customerVo.getLimit());
//2.声明queryWrapper
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>();
queryWrapper.like(StringUtils.isNotBlank(customerVo.getCustomername()),"customername",customerVo.getCustomername());
queryWrapper.like(StringUtils.isNotBlank(customerVo.getConnectionpersion()),"connectionpersion",customerVo.getConnectionpersion());
queryWrapper.like(StringUtils.isNotBlank(customerVo.getPhone()),"phone",customerVo.getPhone());
customerService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
@RequestMapping("loadAllCustomer") // 映射路径为/loadAllCustomer
public DataGridView loadAllCustomer(CustomerVo customerVo){ // 查询所有客户方法
IPage<Customer> page = new Page<Customer>(customerVo.getPage(),customerVo.getLimit()); // 声明分页对象
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>(); // 声明查询包装器
queryWrapper.like(StringUtils.isNotBlank(customerVo.getCustomername()),"customername",customerVo.getCustomername()); // 根据客户名模糊查询
queryWrapper.like(StringUtils.isNotBlank(customerVo.getConnectionpersion()),"connectionpersion",customerVo.getConnectionpersion()); // 根据联系人模糊查询
queryWrapper.like(StringUtils.isNotBlank(customerVo.getPhone()),"phone",customerVo.getPhone()); // 根据手机号模糊查询
customerService.page(page,queryWrapper); // 调用分页查询服务
return new DataGridView(page.getTotal(),page.getRecords()); // 返回分页数据
}
/**
@ -59,14 +56,14 @@ public class CustomerController {
* @param customerVo
* @return
*/
@RequestMapping("addCustomer")
public ResultObj addCustomer(CustomerVo customerVo){
@RequestMapping("addCustomer") // 映射路径为/addCustomer
public ResultObj addCustomer(CustomerVo customerVo){ // 添加客户方法
try {
customerService.save(customerVo);
return ResultObj.ADD_SUCCESS;
customerService.save(customerVo); // 保存客户数据
return ResultObj.ADD_SUCCESS; // 返回添加成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.ADD_ERROR; // 返回添加失败结果
}
}
@ -75,14 +72,14 @@ public class CustomerController {
* @param customerVo
* @return
*/
@RequestMapping("updateCustomer")
public ResultObj updateCustomer(CustomerVo customerVo){
@RequestMapping("updateCustomer") // 映射路径为/updateCustomer
public ResultObj updateCustomer(CustomerVo customerVo){ // 修改客户方法
try {
customerService.updateById(customerVo);
return ResultObj.UPDATE_SUCCESS;
customerService.updateById(customerVo); // 根据ID更新客户数据
return ResultObj.UPDATE_SUCCESS; // 返回更新成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.UPDATE_ERROR; // 返回更新失败结果
}
}
@ -91,31 +88,29 @@ public class CustomerController {
* @param id 客户的ID
* @return
*/
@ApiOperation(value = "删除一个客户",notes = "删除一个客户")
@ApiImplicitParams({@ApiImplicitParam(name = "id", value = "客户ID",required = true,paramType = "query",dataType = "Integer")})
@RequestMapping(value = "deleteCustomer",method = RequestMethod.DELETE)
public ResultObj deleteCustomer(Integer id){
@ApiOperation(value = "删除一个客户",notes = "删除一个客户") // Swagger注解，描述操作内容
@ApiImplicitParams({@ApiImplicitParam(name = "id", value = "客户ID",required = true,paramType = "query",dataType = "Integer")}) // Swagger注解，描述参数信息
@RequestMapping(value = "deleteCustomer",method = RequestMethod.DELETE) // 映射路径为/deleteCustomer，方法为DELETE
public ResultObj deleteCustomer(Integer id){ // 删除客户方法
try {
customerService.deleteCustomerById(id);
return ResultObj.DELETE_SUCCESS;
customerService.deleteCustomerById(id); // 调用服务删除客户
return ResultObj.DELETE_SUCCESS; // 返回删除成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.DELETE_ERROR; // 返回删除失败结果
}
}
/**
* 加载所有客户的下拉列表
* @return
*/
@RequestMapping("loadAllCustomerForSelect")
public DataGridView loadAllCustomerForSelect(){
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>();
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
List<Customer> list = customerService.list(queryWrapper);
return new DataGridView(list);
@RequestMapping("loadAllCustomerForSelect") // 映射路径为/loadAllCustomerForSelect
public DataGridView loadAllCustomerForSelect(){ // 加载客户下拉列表方法
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>(); // 声明查询包装器
queryWrapper.eq("available", Constast.AVAILABLE_TRUE); // 查询可用客户数据
List<Customer> list = customerService.list(queryWrapper); // 获取客户列表
return new DataGridView(list); // 返回客户数据
}
}

225
src/main/java/com/yeqifu/bus/controller/GoodsController.java
Unescape View File

@ -1,184 +1,219 @@
package com.yeqifu.bus.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Provider;
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.IProviderService;
import com.yeqifu.bus.vo.GoodsVo;
import com.yeqifu.sys.common.AppFileUtils;
import com.yeqifu.sys.common.Constast;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
// 导入必要的类和注解
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 用于条件查询的封装器
import com.baomidou.mybatisplus.core.metadata.IPage; // 分页结果封装类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 分页类
import com.yeqifu.bus.entity.Goods; // 商品实体类
import com.yeqifu.bus.entity.Provider; // 供应商实体类
import com.yeqifu.bus.service.IGoodsService; // 商品服务接口
import com.yeqifu.bus.service.IProviderService; // 供应商服务接口
import com.yeqifu.bus.vo.GoodsVo; // 商品视图对象
import com.yeqifu.sys.common.AppFileUtils; // 文件操作工具类
import com.yeqifu.sys.common.Constast; // 常量类
import com.yeqifu.sys.common.DataGridView; // 数据网格返回格式类
import com.yeqifu.sys.common.ResultObj; // 结果对象类
import org.apache.commons.lang3.StringUtils; // 字符串工具类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 映射请求路径注解
import org.springframework.web.bind.annotation.RestController; // REST 控制器注解
import java.util.List; // Java 集合类
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-06
* 商品管理控制器
* 提供了对商品的查询、添加、修改、删除等功能
*/
@RestController
@RequestMapping("/goods")
@RestController // 标注为 REST 控制器，返回 JSON 数据
@RequestMapping("/goods") // 设置请求路径的统一前缀
public class GoodsController {
@Autowired
@Autowired // 自动注入商品服务
private IGoodsService goodsService;
@Autowired
@Autowired // 自动注入供应商服务
private IProviderService providerService;
/**
* 查询商品
* @param goodsVo
* @return
* 查询商品信息
* @param goodsVo 商品视图对象，封装了查询条件
* @return 返回分页的商品信息
*/
@RequestMapping("loadAllGoods")
public DataGridView loadAllGoods(GoodsVo goodsVo){
IPage<Goods> page = new Page<Goods>(goodsVo.getPage(),goodsVo.getLimit());
@RequestMapping("loadAllGoods") // 请求映射到 /goods/loadAllGoods
public DataGridView loadAllGoods(GoodsVo goodsVo) {
// 创建分页对象，指定当前页和每页大小
IPage<Goods> page = new Page<Goods>(goodsVo.getPage(), goodsVo.getLimit());
// 构造查询条件
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq(goodsVo.getProviderid()!=null&&goodsVo.getProviderid()!=0,"providerid",goodsVo.getProviderid());
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getGoodsname()),"goodsname",goodsVo.getGoodsname());
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getProductcode()),"productcode",goodsVo.getProductcode());
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getPromitcode()),"promitcode",goodsVo.getPromitcode());
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getDescription()),"description",goodsVo.getDescription());
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getSize()),"size",goodsVo.getSize());
queryWrapper.orderByDesc("id");
goodsService.page(page,queryWrapper);
queryWrapper.eq(goodsVo.getProviderid() != null && goodsVo.getProviderid() != 0, "providerid", goodsVo.getProviderid()); // 按供应商 ID 查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getGoodsname()), "goodsname", goodsVo.getGoodsname()); // 按商品名称模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getProductcode()), "productcode", goodsVo.getProductcode()); // 按商品编码模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getPromitcode()), "promitcode", goodsVo.getPromitcode()); // 按促销编码模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getDescription()), "description", goodsVo.getDescription()); // 按描述模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getSize()), "size", goodsVo.getSize()); // 按尺寸模糊查询
queryWrapper.orderByDesc("id"); // 按 ID 降序排序
// 执行分页查询
goodsService.page(page, queryWrapper);
// 获取查询结果
List<Goods> records = page.getRecords();
for (Goods goods : records) {
// 根据商品的供应商 ID 查询供应商信息，并设置供应商名称
Provider provider = providerService.getById(goods.getProviderid());
if (null!=provider){
if (provider != null) {
goods.setProvidername(provider.getProvidername());
}
}
return new DataGridView(page.getTotal(),page.getRecords());
// 返回分页数据和商品记录
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加商品
* @param goodsVo
* @return
* @param goodsVo 商品视图对象
* @return 返回操作结果
*/
@RequestMapping("addGoods")
public ResultObj addGoods(GoodsVo goodsVo){
@RequestMapping("addGoods") // 请求映射到 /goods/addGoods
public ResultObj addGoods(GoodsVo goodsVo) {
try {
System.out.println("====================================");
System.out.println(goodsVo.getGoodsimg());
if (goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().endsWith("_temp")){
System.out.println(goodsVo.getGoodsimg()); // 打印上传的商品图片路径
// 如果上传的图片路径是临时文件，则重命名为正式文件
if (goodsVo.getGoodsimg() != null && goodsVo.getGoodsimg().endsWith("_temp")) {
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
goodsVo.setGoodsimg(newName);
goodsVo.setGoodsimg(newName); // 更新图片路径
}
// 保存商品信息
goodsService.save(goodsVo);
// 返回添加成功的结果
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.ADD_ERROR; // 返回添加失败的结果
}
}
/**
* 修改商品
* @param goodsVo
* @return
* @param goodsVo 商品视图对象
* @return 返回操作结果
*/
@RequestMapping("updateGoods")
public ResultObj updateGoods(GoodsVo goodsVo){
@RequestMapping("updateGoods") // 请求映射到 /goods/updateGoods
public ResultObj updateGoods(GoodsVo goodsVo) {
try {
//商品图片不是默认图片
if (!(goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))){
if (goodsVo.getGoodsimg().endsWith("_temp")){
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
// 如果商品图片不是默认图片，则处理图片路径
if (!(goodsVo.getGoodsimg() != null && goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))) {
if (goodsVo.getGoodsimg().endsWith("_temp")) {
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg()); // 重命名图片文件
goodsVo.setGoodsimg(newName);
//删除原先的图片
// 删除原先的图片文件
String oldPath = goodsService.getById(goodsVo.getId()).getGoodsimg();
AppFileUtils.removeFileByPath(oldPath);
}
}
// 更新商品信息
goodsService.updateById(goodsVo);
// 返回更新成功的结果
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.UPDATE_ERROR; // 返回更新失败的结果
}
}
/**
* 删除商品
* @param id 商品id
* @return
* @param id 商品 ID
* @param goodsimg 商品图片路径
* @return 返回操作结果
*/
@RequestMapping("deleteGoods")
public ResultObj deleteGoods(Integer id,String goodsimg){
@RequestMapping("deleteGoods") // 请求映射到 /goods/deleteGoods
public ResultObj deleteGoods(Integer id, String goodsimg) {
try {
//删除商品的图片
// 删除商品的图片文件
AppFileUtils.removeFileByPath(goodsimg);
// goodsService.removeById(id);
// 删除商品信息
goodsService.deleteGoodsById(id);
// 返回删除成功的结果
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
}
}
/**
* 加载所有可用的商品
* @return
* @return 返回所有可用商品的信息
*/
@RequestMapping("loadAllGoodsForSelect")
public DataGridView loadAllGoodsForSelect(){
@RequestMapping("loadAllGoodsForSelect") // 请求映射到 /goods/loadAllGoodsForSelect
public DataGridView loadAllGoodsForSelect() {
// 构造查询条件，仅查询状态为可用的商品
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 查询商品列表
List<Goods> list = goodsService.list(queryWrapper);
for (Goods goods : list) {
// 设置供应商名称
Provider provider = providerService.getById(goods.getProviderid());
if (null!=provider){
if (provider != null) {
goods.setProvidername(provider.getProvidername());
}
}
// 返回商品列表
return new DataGridView(list);
}
/**
* 根据供应商ID查询商品信息
* @param providerid 供应商ID
* @return
* 根据供应商 ID 查询商品信息
* @param providerid 供应商 ID
* @return 返回该供应商的商品信息
*/
@RequestMapping("loadGoodsByProviderId")
public DataGridView loadGoodsByProviderId(Integer providerid){
@RequestMapping("loadGoodsByProviderId") // 请求映射到 /goods/loadGoodsByProviderId
public DataGridView loadGoodsByProviderId(Integer providerid) {
// 构造查询条件，仅查询状态为可用的商品
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
queryWrapper.eq(providerid!=null,"providerid",providerid);
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
queryWrapper.eq(providerid != null, "providerid", providerid); // 按供应商 ID 查询
// 查询商品列表
List<Goods> list = goodsService.list(queryWrapper);
for (Goods goods : list) {
// 设置供应商名称
Provider provider = providerService.getById(goods.getProviderid());
if (null!=provider){
if (provider != null) {
goods.setProvidername(provider.getProvidername());
}
}
// 返回商品列表
return new DataGridView(list);
}
@RequestMapping("loadAllWarningGoods")
public DataGridView loadAllWarningGoods(){
/**
* 查询所有库存预警的商品
* @return 返回库存预警商品的信息
*/
@RequestMapping("loadAllWarningGoods") // 请求映射到 /goods/loadAllWarningGoods
public DataGridView loadAllWarningGoods() {
// 查询所有库存预警的商品
List<Goods> goods = goodsService.loadAllWarning();
return new DataGridView((long) goods.size(),goods);
}
// 返回预警商品的数量和列表
return new DataGridView((long) goods.size(), goods);
}
}

191
src/main/java/com/yeqifu/bus/controller/InportController.java
Unescape View File

@ -1,141 +1,128 @@
package com.yeqifu.bus.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Inport;
import com.yeqifu.bus.entity.Provider;
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.IInportService;
import com.yeqifu.bus.service.IProviderService;
import com.yeqifu.bus.vo.InportVo;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import com.yeqifu.sys.common.WebUtils;
import com.yeqifu.sys.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
import java.util.List;
package com.yeqifu.bus.controller; // 定义包名
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入条件查询封装器
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入分页结果封装类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入分页类
import com.yeqifu.bus.entity.Goods; // 导入商品实体类
import com.yeqifu.bus.entity.Inport; // 导入商品进货实体类
import com.yeqifu.bus.entity.Provider; // 导入供应商实体类
import com.yeqifu.bus.service.IGoodsService; // 导入商品服务接口
import com.yeqifu.bus.service.IInportService; // 导入商品进货服务接口
import com.yeqifu.bus.service.IProviderService; // 导入供应商服务接口
import com.yeqifu.bus.vo.InportVo; // 导入进货视图对象
import com.yeqifu.sys.common.DataGridView; // 导入数据网格返回格式类
import com.yeqifu.sys.common.ResultObj; // 导入操作结果对象类
import com.yeqifu.sys.common.WebUtils; // 导入 Web 工具类
import com.yeqifu.sys.entity.User; // 导入用户实体类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 导入请求映射注解
import org.springframework.web.bind.annotation.RestController; // 导入 REST 控制器注解
import java.util.Date; // 导入日期类
import java.util.List; // 导入 Java 集合类
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-18
* 商品进货管理控制器
* 提供商品进货的查询、添加、修改、删除功能
*/
@RestController
@RequestMapping("inport")
@RestController // 标注为 REST 控制器，返回 JSON 数据
@RequestMapping("inport") // 设置请求路径的统一前缀
public class InportController {
@Autowired
@Autowired // 自动注入商品进货服务
private IInportService inportService;
@Autowired
@Autowired // 自动注入供应商服务
private IProviderService providerService;
@Autowired
@Autowired // 自动注入商品服务
private IGoodsService goodsService;
/**
* 查询商品进货
* @param inportVo
* @return
* 查询商品进货信息
* @param inportVo 进货视图对象，封装了查询条件
* @return 返回分页的进货信息
*/
@RequestMapping("loadAllInport")
public DataGridView loadAllInport(InportVo inportVo){
IPage<Inport> page = new Page<Inport>(inportVo.getPage(),inportVo.getLimit());
QueryWrapper<Inport> queryWrapper = new QueryWrapper<Inport>();
//对供应商进行查询
queryWrapper.eq(inportVo.getProviderid()!=null&&inportVo.getProviderid()!=0,"providerid",inportVo.getProviderid());
//对商品进行查询
queryWrapper.eq(inportVo.getGoodsid()!=null&&inportVo.getGoodsid()!=0,"goodsid",inportVo.getGoodsid());
//对时间进行查询要求大于开始时间小于结束时间
queryWrapper.ge(inportVo.getStartTime()!=null,"inporttime",inportVo.getStartTime());
queryWrapper.le(inportVo.getEndTime()!=null,"inporttime",inportVo.getEndTime());
//通过进货时间对商品进行排序
queryWrapper.orderByDesc("inporttime");
IPage<Inport> page1 = inportService.page(page, queryWrapper);
List<Inport> records = page1.getRecords();
for (Inport inport : records) {
Provider provider = providerService.getById(inport.getProviderid());
if (provider!=null){
//设置供应商姓名
inport.setProvidername(provider.getProvidername());
@RequestMapping("loadAllInport") // 请求映射到 /inport/loadAllInport
public DataGridView loadAllInport(InportVo inportVo) {
IPage<Inport> page = new Page<Inport>(inportVo.getPage(), inportVo.getLimit()); // 创建分页对象，指定当前页和每页大小
QueryWrapper<Inport> queryWrapper = new QueryWrapper<Inport>(); // 构造查询条件对象
queryWrapper.eq(inportVo.getProviderid() != null && inportVo.getProviderid() != 0, "providerid", inportVo.getProviderid()); // 按供应商 ID 查询
queryWrapper.eq(inportVo.getGoodsid() != null && inportVo.getGoodsid() != 0, "goodsid", inportVo.getGoodsid()); // 按商品 ID 查询
queryWrapper.ge(inportVo.getStartTime() != null, "inporttime", inportVo.getStartTime()); // 查询大于等于开始时间的数据
queryWrapper.le(inportVo.getEndTime() != null, "inporttime", inportVo.getEndTime()); // 查询小于等于结束时间的数据
queryWrapper.orderByDesc("inporttime"); // 按进货时间降序排序
IPage<Inport> page1 = inportService.page(page, queryWrapper); // 执行分页查询
List<Inport> records = page1.getRecords(); // 获取查询结果
for (Inport inport : records) { // 遍历查询结果
Provider provider = providerService.getById(inport.getProviderid()); // 根据供应商 ID 查询供应商信息
if (provider != null) { // 如果供应商信息存在
inport.setProvidername(provider.getProvidername()); // 设置供应商名称
}
Goods goods = goodsService.getById(inport.getGoodsid());
if (goods!=null){
//设置商品名称
inport.setGoodsname(goods.getGoodsname());
//设置商品规格
inport.setSize(goods.getSize());
Goods goods = goodsService.getById(inport.getGoodsid()); // 根据商品 ID 查询商品信息
if (goods != null) { // 如果商品信息存在
inport.setGoodsname(goods.getGoodsname()); // 设置商品名称
inport.setSize(goods.getSize()); // 设置商品规格
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
}
return new DataGridView(page1.getTotal(), page1.getRecords()); // 返回分页数据和进货记录
}
/**
* 添加进货商品
* @param inportVo
* @return
* @param inportVo 进货视图对象
* @return 返回操作结果
*/
@RequestMapping("addInport")
public ResultObj addInport(InportVo inportVo){
@RequestMapping("addInport") // 请求映射到 /inport/addInport
public ResultObj addInport(InportVo inportVo) {
try {
//获得当前系统用户
User user = (User) WebUtils.getSession().getAttribute("user");
//设置操作人
inportVo.setOperateperson(user.getName());
//设置进货时间
inportVo.setInporttime(new Date());
inportService.save(inportVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
User user = (User) WebUtils.getSession().getAttribute("user"); // 获取当前登录用户
inportVo.setOperateperson(user.getName()); // 设置操作人姓名
inportVo.setInporttime(new Date()); // 设置进货时间为当前时间
inportService.save(inportVo); // 保存进货信息
return ResultObj.ADD_SUCCESS; // 返回添加成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.ADD_ERROR; // 返回添加失败的结果
}
}
/**
* 更新进货商品
* @param inportVo
* @return
* @param inportVo 进货视图对象
* @return 返回操作结果
*/
@RequestMapping("updateInport")
public ResultObj updateInport(InportVo inportVo){
@RequestMapping("updateInport") // 请求映射到 /inport/updateInport
public ResultObj updateInport(InportVo inportVo) {
try {
inportService.updateById(inportVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
inportService.updateById(inportVo); // 更新进货信息
return ResultObj.UPDATE_SUCCESS; // 返回更新成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.UPDATE_ERROR; // 返回更新失败的结果
}
}
/**
* 删除进货商品
* @param id
* @return
* @param id 进货记录 ID
* @return 返回操作结果
*/
@RequestMapping("deleteInport")
public ResultObj deleteInport(Integer id){
@RequestMapping("deleteInport") // 请求映射到 /inport/deleteInport
public ResultObj deleteInport(Integer id) {
try {
inportService.removeById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
inportService.removeById(id); // 删除进货记录
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
}
}
}

129
src/main/java/com/yeqifu/bus/controller/OutportController.java
Unescape View File

@ -1,116 +1,105 @@
package com.yeqifu.bus.controller;
package com.yeqifu.bus.controller; // 声明类所在的包
// 导入MyBatis-Plus框架相关工具类，用于条件查询和分页处理
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入实体类，分别表示商品、退货记录和供应商
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Outport;
import com.yeqifu.bus.entity.Provider;
// 导入服务接口，用于实现业务逻辑的调用
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.IOutportService;
import com.yeqifu.bus.service.IProviderService;
// 导入数据传输对象和通用响应结果类
import com.yeqifu.bus.vo.OutportVo;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
// 导入Spring框架注解
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.List; // 导入Java标准库中的List接口，用于处理集合
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-19
* OutportController类是一个RESTful控制器，负责退货记录的管理
*/
@RestController
@RequestMapping("/outport")
@RestController // 标识该类为REST风格的控制器，返回结果以JSON格式序列化
@RequestMapping("/outport") // 设置基础URL路径为"/outport"
public class OutportController {
@Autowired
@Autowired // 自动注入退货服务类，用于处理退货业务逻辑
private IOutportService outportService;
@Autowired
@Autowired // 自动注入供应商服务类，用于查询供应商信息
private IProviderService providerService;
@Autowired
@Autowired // 自动注入商品服务类，用于查询商品信息
private IGoodsService goodsService;
/**
* 添加退货信息
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
* @return
* 添加退货记录
* @param id 进货单ID
* @param number 退货数量
* @param remark 退货备注
* @return 返回操作结果
*/
@RequestMapping("addOutport")
public ResultObj addOutport(Integer id,Integer number,String remark){
@RequestMapping("addOutport") // 映射URL路径为"/outport/addOutport"
public ResultObj addOutport(Integer id, Integer number, String remark) { // 定义添加退货记录的方法
try {
outportService.addOutport(id,number,remark);
return ResultObj.BACKINPORT_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.BACKINPORT_ERROR;
outportService.addOutport(id, number, remark); // 调用服务层方法，执行添加退货逻辑
return ResultObj.BACKINPORT_SUCCESS; // 返回操作成功的结果对象
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常信息到控制台
return ResultObj.BACKINPORT_ERROR; // 返回操作失败的结果对象
}
}
/**t
* 查询商品退货
* @param outportVo
* @return
/**
* 查询退货记录
* @param outportVo 查询条件对象，包含分页信息和过滤条件
* @return 返回分页数据和退货记录
*/
@RequestMapping("loadAllOutport")
public DataGridView loadAllOuport(OutportVo outportVo){
IPage<Outport> page = new Page<Outport>(outportVo.getPage(),outportVo.getLimit());
QueryWrapper<Outport> queryWrapper = new QueryWrapper<Outport>();
//对供应商进行查询
queryWrapper.eq(outportVo.getProviderid()!=null&&outportVo.getProviderid()!=0,"providerid",outportVo.getProviderid());
//对商品进行查询
queryWrapper.eq(outportVo.getGoodsid()!=null&&outportVo.getGoodsid()!=0,"goodsid",outportVo.getGoodsid());
//对时间进行查询要求大于开始时间小于结束时间
queryWrapper.ge(outportVo.getStartTime()!=null,"outputtime",outportVo.getStartTime());
queryWrapper.le(outportVo.getEndTime()!=null,"outputtime",outportVo.getEndTime());
//通过进货时间对商品进行排序
queryWrapper.orderByDesc("outputtime");
IPage<Outport> page1 = outportService.page(page, queryWrapper);
List<Outport> records = page1.getRecords();
for (Outport ouport : records) {
Provider provider = providerService.getById(ouport.getProviderid());
if (provider!=null){
//设置供应商姓名
ouport.setProvidername(provider.getProvidername());
@RequestMapping("loadAllOutport") // 映射URL路径为"/outport/loadAllOutport"
public DataGridView loadAllOuport(OutportVo outportVo) { // 定义查询退货记录的方法
IPage<Outport> page = new Page<>(outportVo.getPage(), outportVo.getLimit()); // 创建分页对象，传入当前页和每页大小
QueryWrapper<Outport> queryWrapper = new QueryWrapper<>(); // 创建条件查询封装器
queryWrapper.eq(outportVo.getProviderid() != null && outportVo.getProviderid() != 0, "providerid", outportVo.getProviderid()); // 如果供应商ID不为空且不为0，添加供应商查询条件
queryWrapper.eq(outportVo.getGoodsid() != null && outportVo.getGoodsid() != 0, "goodsid", outportVo.getGoodsid()); // 如果商品ID不为空且不为0，添加商品查询条件
queryWrapper.ge(outportVo.getStartTime() != null, "outputtime", outportVo.getStartTime()); // 如果开始时间不为空，添加起始时间查询条件
queryWrapper.le(outportVo.getEndTime() != null, "outputtime", outportVo.getEndTime()); // 如果结束时间不为空，添加结束时间查询条件
queryWrapper.orderByDesc("outputtime"); // 按退货时间倒序排序
IPage<Outport> page1 = outportService.page(page, queryWrapper); // 调用服务层分页查询方法
List<Outport> records = page1.getRecords(); // 获取分页查询结果中的记录列表
for (Outport ouport : records) { // 遍历每条退货记录
Provider provider = providerService.getById(ouport.getProviderid()); // 根据供应商ID查询供应商信息
if (provider != null) { // 如果供应商信息存在
ouport.setProvidername(provider.getProvidername()); // 设置退货记录中的供应商名称
}
Goods goods = goodsService.getById(ouport.getGoodsid());
if (goods!=null){
//设置商品名称
ouport.setGoodsname(goods.getGoodsname());
//设置商品规格
ouport.setSize(goods.getSize());
Goods goods = goodsService.getById(ouport.getGoodsid()); // 根据商品ID查询商品信息
if (goods != null) { // 如果商品信息存在
ouport.setGoodsname(goods.getGoodsname()); // 设置退货记录中的商品名称
ouport.setSize(goods.getSize()); // 设置退货记录中的商品规格
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
return new DataGridView(page1.getTotal(), page1.getRecords()); // 返回分页数据和记录列表
}
/**
* 删除退货信息
* @param id
* @return
* 删除退货记录
* @param id 退货记录ID
* @return 返回操作结果
*/
@RequestMapping("deleteOutport")
public ResultObj deleteOutport(Integer id){
@RequestMapping("deleteOutport") // 映射URL路径为"/outport/deleteOutport"
public ResultObj deleteOutport(Integer id) { // 定义删除退货记录的方法
try {
outportService.removeById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
outportService.removeById(id); // 调用服务层方法，根据ID删除退货记录
return ResultObj.DELETE_SUCCESS; // 返回操作成功的结果对象
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常信息到控制台
return ResultObj.DELETE_ERROR; // 返回操作失败的结果对象
}
}
}

132
src/main/java/com/yeqifu/bus/controller/ProviderController.java
Unescape View File

@ -1,117 +1,177 @@
package com.yeqifu.bus.controller;
// 声明类所在的包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入MyBatis-Plus的QueryWrapper类，用于条件查询
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入MyBatis-Plus的IPage接口，用于分页
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入MyBatis-Plus的Page类，用于创建分页对象
import com.yeqifu.bus.entity.Provider;
// 导入Provider实体类，表示供应商信息
import com.yeqifu.bus.service.IProviderService;
// 导入IProviderService接口，用于调用供应商相关的业务逻辑
import com.yeqifu.bus.vo.ProviderVo;
// 导入ProviderVo类，封装供应商查询和操作的请求参数
import com.yeqifu.sys.common.Constast;
// 导入Constast类，包含通用的常量定义
import com.yeqifu.sys.common.DataGridView;
// 导入DataGridView类，用于返回表格数据格式
import com.yeqifu.sys.common.ResultObj;
// 导入ResultObj类，用于返回操作结果的统一格式
import org.apache.commons.lang3.StringUtils;
// 导入StringUtils工具类，用于字符串判空和处理
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架的Autowired注解，用于自动注入Bean
import org.springframework.web.bind.annotation.RequestMapping;
// 导入RequestMapping注解，用于映射URL路径
import org.springframework.web.bind.annotation.RestController;
// 导入RestController注解，标识为REST风格的控制器
import java.util.List;
// 导入Java的List接口，用于处理集合
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-05
* 供应商控制器类，负责供应商相关的增删改查和查询接口
*/
@RestController
// 标识该类为REST风格的控制器，返回JSON格式数据
@RequestMapping("/provider")
// 将该类的基础URL路径设置为"/provider"
public class ProviderController {
@Autowired
// 自动注入IProviderService接口的实现类
private IProviderService providerService;
/**
* 查询所有的供应商
* @param providerVo
* @return
* @param providerVo 封装查询参数的对象
* @return 返回表格数据，包含供应商列表
*/
@RequestMapping("loadAllProvider")
public DataGridView loadAllProvider(ProviderVo providerVo){
//1.声明一个分页page对象
IPage<Provider> page = new Page(providerVo.getPage(),providerVo.getLimit());
//2.声明一个queryWrapper
QueryWrapper<Provider> queryWrapper = new QueryWrapper();
queryWrapper.like(StringUtils.isNotBlank(providerVo.getProvidername()),"providername",providerVo.getProvidername());
queryWrapper.like(StringUtils.isNotBlank(providerVo.getConnectionperson()),"connectionperson",providerVo.getConnectionperson());
queryWrapper.like(StringUtils.isNotBlank(providerVo.getPhone()),"phone",providerVo.getPhone());
providerService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
// 映射URL路径为"/provider/loadAllProvider"
public DataGridView loadAllProvider(ProviderVo providerVo) {
IPage<Provider> page = new Page<>(providerVo.getPage(), providerVo.getLimit());
// 创建分页对象，传入当前页和每页大小
QueryWrapper<Provider> queryWrapper = new QueryWrapper<>();
// 创建QueryWrapper对象，用于构造查询条件
queryWrapper.like(StringUtils.isNotBlank(providerVo.getProvidername()), "providername", providerVo.getProvidername());
// 如果供应商名称不为空，添加模糊查询条件
queryWrapper.like(StringUtils.isNotBlank(providerVo.getConnectionperson()), "connectionperson", providerVo.getConnectionperson());
// 如果联系人名称不为空，添加模糊查询条件
queryWrapper.like(StringUtils.isNotBlank(providerVo.getPhone()), "phone", providerVo.getPhone());
// 如果联系方式不为空，添加模糊查询条件
providerService.page(page, queryWrapper);
// 调用服务层的分页查询方法
return new DataGridView(page.getTotal(), page.getRecords());
// 返回DataGridView对象，包含总记录数和分页记录列表
}
/**
* 添加一个供应商
* @param providerVo
* @return
* @param providerVo 封装供应商信息的对象
* @return 返回操作结果
*/
@RequestMapping("addProvider")
public ResultObj addProvider(ProviderVo providerVo){
// 映射URL路径为"/provider/addProvider"
public ResultObj addProvider(ProviderVo providerVo) {
try {
providerService.save(providerVo);
// 调用服务层方法，保存供应商信息
return ResultObj.ADD_SUCCESS;
// 返回操作成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.ADD_ERROR;
// 返回操作失败的结果对象
}
}
/**
* 修改一个供应商
* @param providerVo
* @return
* @param providerVo 封装供应商信息的对象
* @return 返回操作结果
*/
@RequestMapping("updateProvider")
public ResultObj updateProvider(ProviderVo providerVo){
// 映射URL路径为"/provider/updateProvider"
public ResultObj updateProvider(ProviderVo providerVo) {
try {
providerService.updateById(providerVo);
// 调用服务层方法，根据ID更新供应商信息
return ResultObj.UPDATE_SUCCESS;
// 返回操作成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.UPDATE_ERROR;
// 返回操作失败的结果对象
}
}
/**
* 删除一个供应商
* @param id
* @return
* @param id 供应商ID
* @return 返回操作结果
*/
@RequestMapping("deleteProvider")
public ResultObj deleteProvider(Integer id){
// 映射URL路径为"/provider/deleteProvider"
public ResultObj deleteProvider(Integer id) {
try {
providerService.deleteProviderById(id);
// 调用服务层方法，根据ID删除供应商信息
return ResultObj.DELETE_SUCCESS;
// 返回操作成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.DELETE_ERROR;
// 返回操作失败的结果对象
}
}
/**
* 加载所有可用的供应商
* @return
* @return 返回供应商列表
*/
@RequestMapping("loadAllProviderForSelect")
public DataGridView loadAllProviderForSelect(){
QueryWrapper<Provider> queryWrapper = new QueryWrapper<Provider>();
// 映射URL路径为"/provider/loadAllProviderForSelect"
public DataGridView loadAllProviderForSelect() {
QueryWrapper<Provider> queryWrapper = new QueryWrapper<>();
// 创建QueryWrapper对象，用于构造查询条件
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 查询条件为供应商状态可用
List<Provider> list = providerService.list(queryWrapper);
// 调用服务层方法，获取符合条件的供应商列表
return new DataGridView(list);
// 返回DataGridView对象，包含供应商列表
}
}

164
src/main/java/com/yeqifu/bus/controller/SalesController.java
Unescape View File

@ -1,137 +1,219 @@
package com.yeqifu.bus.controller;
// 声明类所在的包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入QueryWrapper类，用于构建查询条件
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入IPage接口，用于分页功能
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入Page类，用于创建分页对象
import com.yeqifu.bus.entity.Customer;
// 导入Customer实体类，表示客户信息
import com.yeqifu.bus.entity.Goods;
// 导入Goods实体类，表示商品信息
import com.yeqifu.bus.entity.Sales;
// 导入Sales实体类，表示销售信息
import com.yeqifu.bus.service.ICustomerService;
// 导入ICustomerService接口，用于处理客户业务逻辑
import com.yeqifu.bus.service.IGoodsService;
// 导入IGoodsService接口，用于处理商品业务逻辑
import com.yeqifu.bus.service.ISalesService;
// 导入ISalesService接口，用于处理销售信息的业务逻辑
import com.yeqifu.bus.vo.SalesVo;
// 导入SalesVo类，用于封装查询参数
import com.yeqifu.sys.common.DataGridView;
// 导入DataGridView类，用于返回表格数据
import com.yeqifu.sys.common.ResultObj;
// 导入ResultObj类，用于统一返回操作结果
import com.yeqifu.sys.common.WebUtils;
// 导入WebUtils工具类，用于处理会话信息
import com.yeqifu.sys.entity.User;
// 导入User实体类，表示用户信息
import org.springframework.beans.factory.annotation.Autowired;
// 导入@Autowired注解，用于自动注入服务对象
import org.springframework.web.bind.annotation.RequestMapping;
// 导入@RequestMapping注解，用于映射请求路径
import org.springframework.web.bind.annotation.RestController;
// 导入@RestController注解，标识该类为REST控制器
import java.util.Date;
// 导入Date类，用于处理日期时间
import java.util.List;
// 导入Java集合类List，用于处理列表数据
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-21
* 商品销售控制器类
* 负责处理与商品销售信息相关的请求
*/
@RestController
// 标识该类为REST风格的控制器
@RequestMapping("/sales")
// 将类的基础URL路径映射为"/sales"
public class SalesController {
@Autowired
// 自动注入ISalesService接口的实现类
private ISalesService salesService;
@Autowired
// 自动注入ICustomerService接口的实现类
private ICustomerService customerService;
@Autowired
// 自动注入IGoodsService接口的实现类
private IGoodsService goodsService;
/**
* 查询所有商品销售信息
* @param salesVo
* @return
* @param salesVo 封装查询参数的对象
* @return 返回表格数据
*/
@RequestMapping("loadAllSales")
public DataGridView loadAllSales(SalesVo salesVo){
IPage<Sales> page = new Page<>(salesVo.getPage(),salesVo.getLimit());
QueryWrapper<Sales> queryWrapper = new QueryWrapper<Sales>();
//根据客户进行模糊查询
queryWrapper.eq(salesVo.getCustomerid()!=null&&salesVo.getCustomerid()!=0,"customerid",salesVo.getCustomerid());
//根据商品模糊查询
queryWrapper.eq(salesVo.getGoodsid()!=null&&salesVo.getGoodsid()!=0,"goodsid",salesVo.getGoodsid());
//根据时间进行模糊查询
queryWrapper.ge(salesVo.getStartTime()!=null,"salestime",salesVo.getStartTime());
queryWrapper.le(salesVo.getEndTime()!=null,"salestime",salesVo.getEndTime());
// 映射URL路径为"/sales/loadAllSales"
public DataGridView loadAllSales(SalesVo salesVo) {
IPage<Sales> page = new Page<>(salesVo.getPage(), salesVo.getLimit());
// 创建分页对象，指定当前页和每页记录数
QueryWrapper<Sales> queryWrapper = new QueryWrapper<>();
// 创建QueryWrapper对象，用于构建查询条件
queryWrapper.eq(salesVo.getCustomerid() != null && salesVo.getCustomerid() != 0, "customerid", salesVo.getCustomerid());
// 如果客户ID不为空且不为0，添加客户ID的查询条件
queryWrapper.eq(salesVo.getGoodsid() != null && salesVo.getGoodsid() != 0, "goodsid", salesVo.getGoodsid());
// 如果商品ID不为空且不为0，添加商品ID的查询条件
queryWrapper.ge(salesVo.getStartTime() != null, "salestime", salesVo.getStartTime());
// 如果开始时间不为空，添加大于等于开始时间的查询条件
queryWrapper.le(salesVo.getEndTime() != null, "salestime", salesVo.getEndTime());
// 如果结束时间不为空，添加小于等于结束时间的查询条件
IPage<Sales> page1 = salesService.page(page, queryWrapper);
// 调用服务层分页查询方法，获取分页数据
List<Sales> records = page1.getRecords();
// 获取分页记录列表
for (Sales sales : records) {
//设置客户姓名
// 遍历销售信息列表
Customer customer = customerService.getById(sales.getCustomerid());
if(null!=customer){
// 根据销售信息中的客户ID查询客户信息
if (null != customer) {
sales.setCustomername(customer.getCustomername());
// 如果客户信息存在，设置客户名称
}
//设置商品名称
Goods goods = goodsService.getById(sales.getGoodsid());
if (null!=goods){
//设置商品名称
// 根据销售信息中的商品ID查询商品信息
if (null != goods) {
sales.setGoodsname(goods.getGoodsname());
//设置商品规格
// 如果商品信息存在，设置商品名称
sales.setSize(goods.getSize());
// 设置商品规格
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
return new DataGridView(page1.getTotal(), page1.getRecords());
// 返回DataGridView对象，包含总记录数和分页记录列表
}
/**
* 添加商品销售信息
* @param salesVo
* @return
* @param salesVo 封装销售信息的对象
* @return 返回操作结果
*/
@RequestMapping("addSales")
public ResultObj addSales(SalesVo salesVo){
// 映射URL路径为"/sales/addSales"
public ResultObj addSales(SalesVo salesVo) {
try {
//获得当前系统用户
User user = (User) WebUtils.getSession().getAttribute("user");
//设置操作人
// 从会话中获取当前系统用户
salesVo.setOperateperson(user.getName());
//设置销售时间
// 设置操作人姓名
salesVo.setSalestime(new Date());
// 设置销售时间为当前时间
salesService.save(salesVo);
// 调用服务层方法保存销售信息
return ResultObj.ADD_SUCCESS;
}catch (Exception e) {
// 返回添加成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.ADD_ERROR;
// 返回添加失败的结果对象
}
}
/**
* 更新商品销售信息
* @param salesVo
* @return
* @param salesVo 封装需要更新的销售信息
* @return 返回操作结果
*/
@RequestMapping("updateSales")
public ResultObj updateSales(SalesVo salesVo){
// 映射URL路径为"/sales/updateSales"
public ResultObj updateSales(SalesVo salesVo) {
try {
salesService.updateById(salesVo);
// 调用服务层方法根据ID更新销售信息
return ResultObj.UPDATE_SUCCESS;
// 返回更新成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.UPDATE_ERROR;
// 返回更新失败的结果对象
}
}
/**
* 删除商品销售信息
* @param id
* @return
* @param id 要删除的销售信息ID
* @return 返回操作结果
*/
@RequestMapping("deleteSales")
public ResultObj deleteSales(Integer id){
// 映射URL路径为"/sales/deleteSales"
public ResultObj deleteSales(Integer id) {
try {
salesService.removeById(id);
// 调用服务层方法根据ID删除销售信息
return ResultObj.DELETE_SUCCESS;
// 返回删除成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.DELETE_ERROR;
// 返回删除失败的结果对象
}
}
}

146
src/main/java/com/yeqifu/bus/controller/SalesbackController.java
Unescape View File

@ -1,116 +1,182 @@
package com.yeqifu.bus.controller;
// 声明类所在的包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入QueryWrapper类，用于构建查询条件
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入IPage接口，用于分页功能
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入Page类，用于创建分页对象
import com.yeqifu.bus.entity.Customer;
// 导入Customer实体类，表示客户信息
import com.yeqifu.bus.entity.Goods;
// 导入Goods实体类，表示商品信息
import com.yeqifu.bus.entity.Salesback;
// 导入Salesback实体类，表示销售退货信息
import com.yeqifu.bus.service.ICustomerService;
// 导入ICustomerService接口，用于处理客户业务逻辑
import com.yeqifu.bus.service.IGoodsService;
// 导入IGoodsService接口，用于处理商品业务逻辑
import com.yeqifu.bus.service.ISalesbackService;
// 导入ISalesbackService接口，用于处理销售退货业务逻辑
import com.yeqifu.bus.vo.SalesbackVo;
// 导入SalesbackVo类，用于封装查询参数
import com.yeqifu.sys.common.DataGridView;
// 导入DataGridView类，用于返回表格数据
import com.yeqifu.sys.common.ResultObj;
// 导入ResultObj类，用于统一返回操作结果
import org.springframework.beans.factory.annotation.Autowired;
// 导入@Autowired注解，用于自动注入服务对象
import org.springframework.web.bind.annotation.RequestMapping;
// 导入@RequestMapping注解，用于映射请求路径
import org.springframework.web.bind.annotation.RestController;
// 导入@RestController注解，标识该类为REST控制器
import java.util.List;
// 导入Java集合类List，用于处理列表数据
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-23
* 销售退货控制器类
* 负责处理与销售退货相关的请求
*/
@RestController
// 标识该类为REST风格的控制器
@RequestMapping("/salesback")
// 将类的基础URL路径映射为"/salesback"
public class SalesbackController {
@Autowired
// 自动注入ISalesbackService接口的实现类
private ISalesbackService salesbackService;
@Autowired
// 自动注入ICustomerService接口的实现类
private ICustomerService customerService;
@Autowired
// 自动注入IGoodsService接口的实现类
private IGoodsService goodsService;
/**
* 添加退货信息
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
* @return
* @param id 退货的销售单ID
* @param number 退货数量
* @param remark 备注信息
* @return 返回操作结果
*/
@RequestMapping("addSalesback")
public ResultObj addSalesback(Integer id,Integer number,String remark){
// 映射URL路径为"/salesback/addSalesback"
public ResultObj addSalesback(Integer id, Integer number, String remark) {
try {
salesbackService.addSalesback(id,number,remark);
salesbackService.addSalesback(id, number, remark);
// 调用服务层方法添加退货记录
return ResultObj.BACKINPORT_SUCCESS;
// 返回退货成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.BACKINPORT_ERROR;
// 返回退货失败的结果对象
}
}
/**
* 查询商品销售退货
* @param salesbackVo
* @return
* 查询商品销售退货记录
* @param salesbackVo 封装查询参数的对象
* @return 返回表格数据
*/
@RequestMapping("loadAllSalesback")
public DataGridView loadAllSalesback(SalesbackVo salesbackVo){
IPage<Salesback> page = new Page<Salesback>(salesbackVo.getPage(),salesbackVo.getLimit());
QueryWrapper<Salesback> queryWrapper = new QueryWrapper<Salesback>();
//对客户进行查询
queryWrapper.eq(salesbackVo.getCustomerid()!=null&&salesbackVo.getCustomerid()!=0,"customerid",salesbackVo.getCustomerid());
//对商品进行查询
queryWrapper.eq(salesbackVo.getGoodsid()!=null&&salesbackVo.getGoodsid()!=0,"goodsid",salesbackVo.getGoodsid());
//对时间进行查询要求大于开始时间小于结束时间
queryWrapper.ge(salesbackVo.getStartTime()!=null,"salesbacktime",salesbackVo.getStartTime());
queryWrapper.le(salesbackVo.getEndTime()!=null,"salesbacktime",salesbackVo.getEndTime());
//通过商品退货时间对商品进行排序
// 映射URL路径为"/salesback/loadAllSalesback"
public DataGridView loadAllSalesback(SalesbackVo salesbackVo) {
IPage<Salesback> page = new Page<>(salesbackVo.getPage(), salesbackVo.getLimit());
// 创建分页对象，指定当前页和每页记录数
QueryWrapper<Salesback> queryWrapper = new QueryWrapper<>();
// 创建QueryWrapper对象，用于构建查询条件
queryWrapper.eq(salesbackVo.getCustomerid() != null && salesbackVo.getCustomerid() != 0, "customerid", salesbackVo.getCustomerid());
// 如果客户ID不为空且不为0，添加客户ID的查询条件
queryWrapper.eq(salesbackVo.getGoodsid() != null && salesbackVo.getGoodsid() != 0, "goodsid", salesbackVo.getGoodsid());
// 如果商品ID不为空且不为0，添加商品ID的查询条件
queryWrapper.ge(salesbackVo.getStartTime() != null, "salesbacktime", salesbackVo.getStartTime());
// 如果开始时间不为空，添加大于等于开始时间的查询条件
queryWrapper.le(salesbackVo.getEndTime() != null, "salesbacktime", salesbackVo.getEndTime());
// 如果结束时间不为空，添加小于等于结束时间的查询条件
queryWrapper.orderByDesc("salesbacktime");
// 按照退货时间降序排列
salesbackService.page(page, queryWrapper);
// 调用服务层分页查询方法，获取分页数据
List<Salesback> records = page.getRecords();
// 获取分页记录列表
for (Salesback salesback : records) {
System.out.println("============================");
// 遍历退货记录列表
Customer customer = customerService.getById(salesback.getCustomerid());
if (customer!=null){
//设置客户姓名
// 根据退货记录中的客户ID查询客户信息
if (customer != null) {
salesback.setCustomername(customer.getCustomername());
// 如果客户信息存在，设置客户名称
}
Goods goods = goodsService.getById(salesback.getGoodsid());
if (goods!=null){
//设置商品名称
// 根据退货记录中的商品ID查询商品信息
if (goods != null) {
salesback.setGoodsname(goods.getGoodsname());
//设置商品规格
// 如果商品信息存在，设置商品名称
salesback.setSize(goods.getSize());
// 设置商品规格
}
}
return new DataGridView(page.getTotal(),page.getRecords());
return new DataGridView(page.getTotal(), page.getRecords());
// 返回DataGridView对象，包含总记录数和分页记录列表
}
/**
* 删除商品销售退回信息
* @param id
* @return
* 删除商品销售退货记录
* @param id 要删除的退货记录ID
* @return 返回操作结果
*/
@RequestMapping("deleteSalesback")
public ResultObj deleteSalesback(Integer id){
// 映射URL路径为"/salesback/deleteSalesback"
public ResultObj deleteSalesback(Integer id) {
try {
salesbackService.removeById(id);
// 调用服务层方法，根据ID删除退货记录
return ResultObj.DELETE_SUCCESS;
// 返回删除成功的结果对象
} catch (Exception e) {
e.printStackTrace();
// 打印异常信息
return ResultObj.DELETE_ERROR;
// 返回删除失败的结果对象
}
}
}

70
src/main/java/com/yeqifu/bus/entity/Goods.java
Unescape View File

@ -1,15 +1,15 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.ToString; // Lombok注解，自动生成toString方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.io.Serializable; // 序列化接口
/**
* <p>
@ -19,46 +19,44 @@ import java.io.Serializable;
* @author luoyi-
* @since 2019-12-06
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_goods")
@ToString
public class Goods implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，且不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_goods") // MyBatis-Plus注解，指定表名为bus_goods
@ToString // Lombok注解，自动生成toString方法
public class Goods implements Serializable { // 定义Goods类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 商品ID
private String goodsname;
private String goodsname; // 商品名称
private String produceplace;
private String produceplace; // 生产地
private String size;
private String size; // 商品规格
private String goodspackage;
private String goodspackage; // 商品包装
private String productcode;
private String productcode; // 商品编码
private String promitcode;
private String promitcode; // 批准文号
private String description;
private String description; // 商品描述
private Double price;
private Double price; // 商品价格
private Integer number;
private Integer number; // 商品库存数量
private Integer dangernum;
private Integer dangernum; // 商品警戒库存数量
private String goodsimg;
private String goodsimg; // 商品图片地址
private Integer available;
private Integer providerid;
@TableField(exist = false)
private String providername;
private Integer available; // 商品是否可用，1表示可用，0表示不可用
private Integer providerid; // 供应商ID，外键关联供应商表
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
}

64
src/main/java/com/yeqifu/bus/entity/Inport.java
Unescape View File

@ -1,15 +1,15 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口
import java.util.Date; // 日期类
/**
* <p>
@ -19,49 +19,49 @@ import java.util.Date;
* @author luoyi-
* @since 2019-12-18
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_inport")
public class Inport implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_inport") // MyBatis-Plus注解，指定表名为bus_inport
public class Inport implements Serializable { // 定义Inport类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 入库单ID
private String paytype;
private String paytype; // 支付类型
private Date inporttime;
private Date inporttime; // 入库时间
private String operateperson;
private String operateperson; // 操作员姓名
private Integer number;
private Integer number; // 入库数量
private String remark;
private String remark; // 备注信息
private Double inportprice;
private Double inportprice; // 入库价格
private Integer providerid;
private Integer providerid; // 供应商ID，外键关联供应商表
private Integer goodsid;
private Integer goodsid; // 商品ID，外键关联商品表
/**
* 供应商姓名
*/
@TableField(exist = false)
private String providername;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
/**
* 商品名称
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
/**
* 商品规格
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
}

66
src/main/java/com/yeqifu/bus/entity/Outport.java
Unescape View File

@ -1,67 +1,69 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口
import java.util.Date; // 日期类
/**
* <p>
* InnoDB free: 9216 kB
* </p>
*
* 出库表实体类，用于描述商品出库记录
*
* @author luoyi-
* @since 2019-12-19
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_outport")
public class Outport implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_outport") // MyBatis-Plus注解，指定表名为bus_outport
public class Outport implements Serializable { // 定义Outport类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 出库单ID
private Integer providerid;
private Integer providerid; // 供应商ID，外键关联供应商表
private String paytype;
private String paytype; // 支付类型
private Date outputtime;
private Date outputtime; // 出库时间
private String operateperson;
private String operateperson; // 操作员姓名
private Double outportprice;
private Double outportprice; // 出库价格
private Integer number;
private Integer number; // 出库数量
private String remark;
private String remark; // 备注信息
private Integer goodsid;
private Integer goodsid; // 商品ID，外键关联商品表
/**
* 供应商姓名
*/
@TableField(exist = false)
private String providername;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
/**
* 商品名称
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
/**
* 商品规格
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
}

60
src/main/java/com/yeqifu/bus/entity/Provider.java
Unescape View File

@ -1,56 +1,56 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.ToString; // Lombok注解，自动生成toString方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.io.Serializable; // 序列化接口
/**
* <p>
* 供应商实体类，用于描述供应商信息
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_provider")
@ToString
public class Provider implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_provider") // MyBatis-Plus注解，指定表名为bus_provider
@ToString // Lombok注解，自动生成toString方法
public class Provider implements Serializable { // 定义Provider类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 供应商ID
private String providername;
private String providername; // 供应商名称
private String zip;
private String zip; // 邮政编码
private String address;
private String address; // 供应商地址
private String telephone;
private String telephone; // 供应商联系电话
private String connectionperson;
private String connectionperson; // 联系人姓名
private String phone;
private String phone; // 联系人手机号码
private String bank;
private String bank; // 开户银行
private String account;
private String account; // 银行账号
private String email;
private String email; // 电子邮箱
private String fax;
private Integer available;
private String fax; // 传真号码
private Integer available; // 是否可用，1表示可用，0表示不可用
}

66
src/main/java/com/yeqifu/bus/entity/Sales.java
Unescape View File

@ -1,67 +1,67 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口
import java.util.Date; // 日期类
/**
* <p>
* 销售记录实体类，用于描述销售信息
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_sales")
public class Sales implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_sales") // MyBatis-Plus注解，指定表名为bus_sales
public class Sales implements Serializable { // 定义Sales类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 销售记录ID
private Integer customerid;
private Integer customerid; // 客户ID，外键关联客户表
private String paytype;
private String paytype; // 支付类型
private Date salestime;
private Date salestime; // 销售时间
private String operateperson;
private String operateperson; // 操作员姓名
private Integer number;
private Integer number; // 销售数量
private String remark;
private String remark; // 备注信息
private Double saleprice;
private Double saleprice; // 销售价格
private Integer goodsid;
private Integer goodsid; // 商品ID，外键关联商品表
/**
* 客户名称
*/
@TableField(exist = false)
private String customername;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String customername; // 客户名称（冗余字段，用于显示）
/**
* 商品名称
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
/**
* 商品规格
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
}

66
src/main/java/com/yeqifu/bus/entity/Salesback.java
Unescape View File

@ -1,67 +1,67 @@
package com.yeqifu.bus.entity;
package com.yeqifu.bus.entity; // 包名
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口
import java.util.Date; // 日期类
/**
* <p>
* 销售退货记录实体类，用于描述销售退货信息
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-23
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_salesback")
public class Salesback implements Serializable {
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_salesback") // MyBatis-Plus注解，指定表名为bus_salesback
public class Salesback implements Serializable { // 定义Salesback类，实现Serializable接口
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化版本号
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 销售退货记录ID
private Integer customerid;
private Integer customerid; // 客户ID，外键关联客户表
private String paytype;
private String paytype; // 支付类型
private Date salesbacktime;
private Date salesbacktime; // 退货时间
private Double salebackprice;
private Double salebackprice; // 退货价格
private String operateperson;
private String operateperson; // 操作员姓名
private Integer number;
private Integer number; // 退货数量
private String remark;
private String remark; // 备注信息
private Integer goodsid;
private Integer goodsid; // 商品ID，外键关联商品表
/**
* 客户姓名
*/
@TableField(exist = false)
private String customername;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String customername; // 客户名称（冗余字段，用于显示）
/**
* 商品名称
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
/**
* 商品规格
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
}

56
src/main/java/com/yeqifu/bus/mapper/GoodsMapper.java
Unescape View File

@ -1,60 +1,60 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Goods;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // MyBatis-Plus核心Mapper类
import com.yeqifu.bus.entity.Goods; // 商品实体类
import org.apache.ibatis.annotations.Param; // MyBatis参数注解
import java.util.List;
import java.util.List; // Java集合类
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) Mapper 接口
* 商品Mapper接口，用于定义与商品相关的数据库操作
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* </p>
*
* @author luoyi-
* @since 2019-12-06
*/
public interface GoodsMapper extends BaseMapper<Goods> {
public interface GoodsMapper extends BaseMapper<Goods> { // 继承MyBatis-Plus的BaseMapper类
/**
* 根据商品id删除商品销售信息
* @param id1
* 根据商品ID删除商品销售信息
* @param id1 商品ID
*/
void deleteSaleByGoodsId(@Param("goodsid") Integer id1);
void deleteSaleByGoodsId(@Param("goodsid") Integer id1); // 自定义SQL方法，传入商品ID删除相关销售信息
/**
* 根据商品id删除商品销售退货信息
* @param id1
* 根据商品ID删除商品销售退货信息
* @param id1 商品ID
*/
void deleteSaleBackByGoodsId(@Param("goodsid") Integer id1);
void deleteSaleBackByGoodsId(@Param("goodsid") Integer id1); // 自定义SQL方法，传入商品ID删除相关销售退货信息
/**
* 根据商品id删除商品进货信息
* @param id
* 根据商品ID删除商品进货信息
* @param id 商品ID
*/
void deleteInportByGoodsId(@Param("goodsid") Integer id);
void deleteInportByGoodsId(@Param("goodsid") Integer id); // 自定义SQL方法，传入商品ID删除相关进货信息
/**
* 根据商品id删除商品退货信息
* @param id
* 根据商品ID删除商品退货信息
* @param id 商品ID
*/
void deleteOutportByGoodsId(@Param("goodsid") Integer id);
void deleteOutportByGoodsId(@Param("goodsid") Integer id); // 自定义SQL方法，传入商品ID删除相关退货信息
/**
* 根据客户id删除商品销售
* @param id 客户id
* 根据客户ID删除商品销售记录
* @param id 客户ID
*/
void deleteSaleByCustomerId(Integer id);
void deleteSaleByCustomerId(Integer id); // 自定义SQL方法，传入客户ID删除相关销售信息
/**
* 根据客户id删除商品销售退货信息
* @param id 客户id
* 根据客户ID删除商品销售退货记录
* @param id 客户ID
*/
void deleteSaleBackByCustomerId(Integer id);
void deleteSaleBackByCustomerId(Integer id); // 自定义SQL方法，传入客户ID删除相关销售退货信息
/**
* 加载所有库存预警商品
* @return 商品列表，包含所有库存预警的商品信息
*/
List<Goods> loadAllWarning();
List<Goods> loadAllWarning(); // 自定义SQL方法，返回库存预警商品列表
}

13
src/main/java/com/yeqifu/bus/mapper/InportMapper.java
Unescape View File

@ -1,16 +1,17 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.yeqifu.bus.entity.Inport;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Inport; // 导入进货实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo Mapper 接口
* 进货Mapper接口，提供对进货数据的数据库操作
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* </p>
*
* @author luoyi-
* @since 2019-12-18
* @author luoyi-
*/
public interface InportMapper extends BaseMapper<Inport> {
public interface InportMapper extends BaseMapper<Inport> { // Mapper接口继承BaseMapper，自动实现通用数据操作
}

13
src/main/java/com/yeqifu/bus/mapper/OutportMapper.java
Unescape View File

@ -1,16 +1,17 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.yeqifu.bus.entity.Outport;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Outport; // 导入出货实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
/**
* <p>
* InnoDB free: 9216 kB Mapper 接口
* 出货Mapper接口，提供对出货数据的数据库操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-19
* @author luoyi-
*/
public interface OutportMapper extends BaseMapper<Outport> {
public interface OutportMapper extends BaseMapper<Outport> { // Mapper接口继承BaseMapper，自动实现通用数据操作
}

34
src/main/java/com/yeqifu/bus/mapper/ProviderMapper.java
Unescape View File

@ -1,36 +1,36 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.yeqifu.bus.entity.Provider;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import com.yeqifu.bus.entity.Provider; // 导入供应商实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
import org.apache.ibatis.annotations.Param; // 导入MyBatis的参数注解
/**
* <p>
* InnoDB free: 9216 kB Mapper 接口
* 供应商Mapper接口，提供对供应商相关数据的数据库操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-05
* @author luoyi-
*/
public interface ProviderMapper extends BaseMapper<Provider> {
public interface ProviderMapper extends BaseMapper<Provider> { // Mapper接口继承BaseMapper，自动实现通用数据操作
/**
* 根据供应商id删除商品信息
* @param id
* 根据供应商ID删除商品信息
* @param id 供应商ID
*/
void deleteGoodsByProviderId(@Param("pid") Integer id);
void deleteGoodsByProviderId(@Param("pid") Integer id); // 自定义SQL方法，传入供应商ID删除相关商品信息
/**
* 根据供应商id删除商品进货信息
* @param id
* 根据供应商ID删除商品进货信息
* @param id 供应商ID
*/
void deleteInportByProviderId(@Param("pid") Integer id);
void deleteInportByProviderId(@Param("pid") Integer id); // 自定义SQL方法，传入供应商ID删除相关进货信息
/**
* 根据供应商id删除商品退货信息
* @param id
* 根据供应商ID删除商品退货信息
* @param id 供应商ID
*/
void deleteOutPortByProviderId(@Param("pid") Integer id);
void deleteOutPortByProviderId(@Param("pid") Integer id); // 自定义SQL方法，传入供应商ID删除相关退货信息
}

13
src/main/java/com/yeqifu/bus/mapper/SalesMapper.java
Unescape View File

@ -1,16 +1,17 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.yeqifu.bus.entity.Sales;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Sales; // 导入销售实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
/**
* <p>
* InnoDB free: 9216 kB Mapper 接口
* 销售Mapper接口，提供对销售数据的数据库操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-21
* @author luoyi-
*/
public interface SalesMapper extends BaseMapper<Sales> {
public interface SalesMapper extends BaseMapper<Sales> { // Mapper接口继承BaseMapper，自动实现通用数据操作
}

13
src/main/java/com/yeqifu/bus/mapper/SalesbackMapper.java
Unescape View File

@ -1,16 +1,17 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 包名
import com.yeqifu.bus.entity.Salesback;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Salesback; // 导入销售退货实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
/**
* <p>
* InnoDB free: 9216 kB Mapper 接口
* 销售退货Mapper接口，提供对销售退货数据的数据库操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-23
* @author luoyi-
*/
public interface SalesbackMapper extends BaseMapper<Salesback> {
public interface SalesbackMapper extends BaseMapper<Salesback> { // Mapper接口继承BaseMapper，自动实现通用数据操作
}

28
src/main/java/com/yeqifu/bus/service/IGoodsService.java
Unescape View File

@ -1,29 +1,29 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Goods;
import java.util.List;
import com.baomidou.mybatisplus.extension.service.IService; // 导入MyBatis-Plus服务层通用接口
import com.yeqifu.bus.entity.Goods; // 导入商品实体类
import java.util.List; // 导入Java集合List
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 服务类
* 商品服务接口，定义商品相关业务操作
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* </p>
*
* @author luoyi-
* @since 2019-12-06
* @author luoyi-
*/
public interface IGoodsService extends IService<Goods> {
public interface IGoodsService extends IService<Goods> { // IService 是 MyBatis-Plus 提供的通用服务层接口
/**
* 根据商品id删除商品
* @param id
* 根据商品ID删除商品信息
* @param id 商品ID
*/
void deleteGoodsById(Integer id);
void deleteGoodsById(Integer id); // 自定义方法，用于根据商品ID删除商品信息
/**
* 加载所有的库存预警商品
* @return
* 加载所有的库存预警商品列表
* @return 返回所有需要预警的商品信息列表
*/
List<Goods> loadAllWarning();
List<Goods> loadAllWarning(); // 自定义方法，用于获取所有库存预警商品列表
}

13
src/main/java/com/yeqifu/bus/service/IInportService.java
Unescape View File

@ -1,16 +1,17 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名
import com.yeqifu.bus.entity.Inport;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Inport; // 导入进货实体类
import com.baomidou.mybatisplus.extension.service.IService; // 导入MyBatis-Plus提供的通用服务接口
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 服务类
* 进货服务接口，提供对进货数据的业务操作
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* </p>
*
* @author luoyi-
* @since 2019-12-18
* @author luoyi-
*/
public interface IInportService extends IService<Inport> {
public interface IInportService extends IService<Inport> { // IService 是 MyBatis-Plus 提供的通用服务接口
}

22
src/main/java/com/yeqifu/bus/service/IOutportService.java
Unescape View File

@ -1,23 +1,25 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名
import com.yeqifu.bus.entity.Outport;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Outport; // 导入退货实体类
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的通用服务接口
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 出库退货服务接口，提供对退货相关数据的业务操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-19
* @author luoyi-
*/
public interface IOutportService extends IService<Outport> {
public interface IOutportService extends IService<Outport> { // IService 是 MyBatis-Plus 提供的通用服务接口
/**
* 对商品进货进行退货处理
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
*
* @param id 进货单ID，用于标识进货数据
* @param number 退货数量，需要退回的商品数量
* @param remark 备注信息，用于记录退货原因或其他说明信息
*/
void addOutport(Integer id, Integer number, String remark);
void addOutport(Integer id, Integer number, String remark); // 自定义方法，处理退货操作
}

20
src/main/java/com/yeqifu/bus/service/IProviderService.java
Unescape View File

@ -1,21 +1,23 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名
import com.yeqifu.bus.entity.Provider;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Provider; // 导入供应商实体类
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的通用服务接口
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 供应商服务接口，定义与供应商相关的业务操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-05
* @author luoyi-
*/
public interface IProviderService extends IService<Provider> {
public interface IProviderService extends IService<Provider> { // IService 是 MyBatis-Plus 提供的通用服务接口
/**
* 根据供应商ID删除供应商
* @param id
* 根据供应商ID删除供应商信息
*
* @param id 供应商ID，用于唯一标识需要删除的供应商
*/
void deleteProviderById(Integer id);
void deleteProviderById(Integer id); // 自定义方法，处理删除操作
}

14
src/main/java/com/yeqifu/bus/service/ISalesService.java
Unescape View File

@ -1,16 +1,18 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名，定义服务层的包路径
import com.yeqifu.bus.entity.Sales;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Sales; // 导入销售实体类
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的通用服务接口
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 销售服务接口，定义与销售相关的业务操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-21
* @author luoyi-
*/
public interface ISalesService extends IService<Sales> {
public interface ISalesService extends IService<Sales> { // IService 是 MyBatis-Plus 提供的通用服务接口
// 由于未定义自定义方法，这里继承 IService<Sales> 后可自动具备基本的 CRUD 功能
}

23
src/main/java/com/yeqifu/bus/service/ISalesbackService.java
Unescape View File

@ -1,24 +1,25 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 包名
import com.yeqifu.bus.entity.Salesback;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Salesback; // 导入销售退货实体类
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的通用服务接口
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 销售退货服务接口，提供对销售退货相关数据的业务操作
* InnoDB free: 9216 kB
* </p>
*
* @author luoyi-
* @since 2019-12-23
* @author luoyi-
*/
public interface ISalesbackService extends IService<Salesback> {
public interface ISalesbackService extends IService<Salesback> { // IService 是 MyBatis-Plus 提供的通用服务接口
/**
* 对商品销售进行退货处理
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
*
* @param id 销售单ID，标识需要退货的销售记录
* @param number 退货数量，表示退回的商品数量
* @param remark 备注信息，用于记录退货原因或其他补充信息
*/
void addSalesback(Integer id, Integer number, String remark);
void addSalesback(Integer id, Integer number, String remark); // 自定义退货处理方法
}

21
src/main/java/com/yeqifu/bus/vo/GoodsVo.java
Unescape View File

@ -1,18 +1,19 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 包名，定义视图层的包路径
import com.yeqifu.bus.entity.Goods;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
/**
* @Author: 落亦-
* @Date: 2019/12/6 22:30
*
* 数据传输对象 (VO)，用于与前端交互时携带 Goods 实体数据以及分页信息
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class GoodsVo extends Goods {
private Integer page=1;
private Integer limit=10;
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑父类属性
public class GoodsVo extends Goods { // 继承 Goods 实体类
private Integer page = 1; // 分页查询起始页码，默认为第 1 页
private Integer limit = 10; // 分页查询的限制记录数，默认为每页 10 条数据
}

34
src/main/java/com/yeqifu/bus/vo/InportVo.java
Unescape View File

@ -1,28 +1,28 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 包路径，定义视图层的包路径
import com.yeqifu.bus.entity.Inport;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
import com.yeqifu.bus.entity.Inport; // 导入 Inport 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import java.util.Date; // 导入 Date 类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Inport 实体数据以及分页信息和时间查询条件
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class InportVo extends Inport {
private Integer page = 1;
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类属性
public class InportVo extends Inport { // 继承 Inport 实体类
private Integer limit = 10;
private Integer page = 1; // 分页查询起始页码，默认为第 1 页
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
private Integer limit = 10; // 分页查询的限制记录数，默认为每页 10 条数据
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date startTime; // 查询时间范围的起始时间
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date endTime; // 查询时间范围的结束时间
}

38
src/main/java/com/yeqifu/bus/vo/OutportVo.java
Unescape View File

@ -1,29 +1,43 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 定义视图层包路径
import com.yeqifu.bus.entity.Outport;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
import com.yeqifu.bus.entity.Outport; // 导入 Outport 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式化注解
import java.util.Date; // 导入 Date 类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Outport 实体数据
* 同时包含分页信息和时间过滤条件。
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class OutportVo extends Outport {
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类的属性
public class OutportVo extends Outport { // 继承 Outport 实体类
/**
* 分页查询当前页码，默认为第 1 页
*/
private Integer page = 1;
/**
* 分页查询每页显示的记录数，默认为每页 10 条数据
*/
private Integer limit = 10;
/**
* 查询时间范围的起始日期
* 使用 @DateTimeFormat 注解，确保从前端接收到的日期字符串能被解析为 Date 类型
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
/**
* 查询时间范围的结束日期
* 使用 @DateTimeFormat 注解，确保从前端接收到的日期字符串能被解析为 Date 类型
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;
}

34
src/main/java/com/yeqifu/bus/vo/ProviderVo.java
Unescape View File

@ -1,26 +1,36 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 定义视图层包路径
import com.yeqifu.bus.entity.Customer;
import com.yeqifu.bus.entity.Provider;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.yeqifu.bus.entity.Customer; // 导入 Customer 实体类
import com.yeqifu.bus.entity.Provider; // 导入 Provider 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
/**
* @Author: 落亦-
* @Date: 2019/12/5 9:30
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Provider 实体数据，
* 同时支持分页查询和批量删除。
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class ProviderVo extends Provider{
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类的属性
public class ProviderVo extends Provider { // 继承 Provider 实体类
/**
* 分页参数，当前是第一页，每页10条数据
* 分页参数 - 当前页码
* 默认设置为 1，表示从第一页开始查询。
*/
private Integer page=1;
private Integer limit=10;
private Integer page = 1;
/**
* 批量删除供应商，存放供应商ID的数组
* 分页参数 - 每页数据的记录数
* 默认设置为 10，表示每页显示 10 条数据。
*/
private Integer limit = 10;
/**
* 批量删除供应商时，存储要删除的供应商ID的数组。
* 前端传递选中供应商的ID，服务层根据该ID数组进行批量删除操作。
*/
private Integer[] ids;

44
src/main/java/com/yeqifu/bus/vo/SalesVo.java
Unescape View File

@ -1,28 +1,46 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 定义视图层的包路径
import com.yeqifu.bus.entity.Sales;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
import com.yeqifu.bus.entity.Sales; // 导入 Sales 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import java.util.Date; // 导入 Date 类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Sales 实体数据。
* 同时支持分页查询和时间范围过滤。
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class SalesVo extends Sales {
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类的属性
public class SalesVo extends Sales { // 继承 Sales 实体类
/**
* 分页参数 - 当前页码
* 默认设置为 1，表示从第一页开始查询。
*/
private Integer page = 1;
/**
* 分页参数 - 每页数据的记录数
* 默认设置为 10，表示每页显示 10 条数据。
*/
private Integer limit = 10;
@DateTimeFormat(pattern = "yyyy-MM-dd")
/**
* 起始时间范围过滤参数。
* 用于根据时间范围过滤销售数据。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
/**
* 结束时间范围过滤参数。
* 用于根据时间范围过滤销售数据。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date endTime;
}

45
src/main/java/com/yeqifu/bus/vo/SalesbackVo.java
Unescape View File

@ -1,29 +1,46 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 定义视图层的包路径
import com.yeqifu.bus.entity.Salesback;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
import com.yeqifu.bus.entity.Salesback; // 导入 Salesback 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import java.util.Date; // 导入 Date 类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Salesback 实体数据。
* 同时支持分页查询和时间范围过滤。
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class SalesbackVo extends Salesback {
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类的属性
public class SalesbackVo extends Salesback { // 继承 Salesback 实体类
/**
* 分页参数 - 当前页码
* 默认设置为 1，表示从第一页开始查询。
*/
private Integer page = 1;
/**
* 分页参数 - 每页数据的记录数
* 默认设置为 10，表示每页显示 10 条数据。
*/
private Integer limit = 10;
@DateTimeFormat(pattern = "yyyy-MM-dd")
/**
* 起始时间范围过滤参数。
* 用于根据时间范围过滤销售退货记录。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
/**
* 结束时间范围过滤参数。
* 用于根据时间范围过滤销售退货记录。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date endTime;
}

415
src/main/resources/templates/business/goods/goodsManager.html
Unescape View File

@ -1,59 +1,63 @@
<!DOCTYPE html>
<!DOCTYPE html> <!-- 声明文档类型为HTML5 -->
<html xmlns:th="http://www.thymeleaf.org"
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"> <!-- 引入thymeleaf和shiro的命名空间，分别用于模板渲染和权限控制 -->
<head>
<meta charset="UTF-8">
<title>Right</title>
<meta name="renderer" content="webkit">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<meta http-equiv="Access-Control-Allow-Origin" content="*">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="format-detection" content="telephone=no">
<link rel="icon" href="/resources/favicon.ico">
<meta charset="UTF-8"> <!-- 设置网页编码为UTF-8，支持中文显示 -->
<title>Right</title> <!-- 网页标题设置为"Right" -->
<meta name="renderer" content="webkit"> <!-- 强制使用webkit渲染引擎渲染页面 -->
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <!-- 强制IE使用最新渲染模式 -->
<meta http-equiv="Access-Control-Allow-Origin" content="*"> <!-- 允许跨域访问，*表示所有来源均可访问 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <!-- 设置视口参数，使页面在移动设备上也能正确显示 -->
<meta name="apple-mobile-web-app-status-bar-style" content="black"> <!-- 设置苹果移动应用的状态栏样式为黑色 -->
<meta name="apple-mobile-web-app-capable" content="yes"> <!-- 支持iOS设备的全屏WebApp模式 -->
<meta name="format-detection" content="telephone=no"> <!-- 禁止自动识别页面中的电话号码 -->
<link rel="icon" href="/resources/favicon.ico"> <!-- 设置网站的图标 -->
<!-- 引入layui框架CSS文件 -->
<link rel="stylesheet" href="resources/layui/css/layui.css" th:href="@{/resources/layui/css/layui.css}" media="all"/>
<!-- 引入自定义公共样式CSS文件 -->
<link rel="stylesheet" th:href="@{/resources/css/public.css}" media="all"/>
<!-- 引入树形菜单的样式文件 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/dtree.css}" media="all"/>
<!-- 引入树形菜单字体样式 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/font/dtreefont.css}" media="all"/>
<style>
input#search_provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#leaderprovideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
/* 定义搜索框样式，使其有圆角和统一高度 */
input#search_provideridTree_select_input_id,
input#provideridTree_select_input_id,
input#leaderprovideridTree_select_input_id,
input.layui-input.layui-unselect {
border-radius: 10px;
height: 30px;
margin-top: 4px;
border-radius: 10px; /* 设置圆角为10px */
height: 30px; /* 设置输入框高度为30px */
margin-top: 4px; /* 设置输入框的上边距为4px */
}
</style>
</head>
<body>
<!--查询条件-->
<!-- 搜索条件部分区域，用于展示搜索条件表单的标题 -->
<fieldset class="layui-elem-field layui-field-title" style="margin-top: 15px;">
<legend>搜索条件</legend>
<legend>搜索条件</legend> <!-- 标题内容为“搜索条件” -->
</fieldset>
<!-- 搜索表单区域，用户可以通过此表单提交搜索条件 -->
<form action="" method="post" id="searchFrm" lay-filter="searchFrm" class="layui-form">
<div class="layui-form-item">
<!-- 添加供应商下拉框输入项 -->
<div class="layui-inline">
<label class="layui-form-label">供应商</label>
<div class="layui-input-inline">
<select name="providerid" id="select_providerid">
<option value="0">请选择供应商</option>
<option value="0">请选择供应商</option> <!-- 下拉菜单的默认选项 -->
</select>
</div>
</div>
<!-- 添加商品名称输入框 -->
<div class="layui-inline">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
@ -61,12 +65,16 @@
placeholder="请输入商品名称">
</div>
</div>
<!-- 添加生产批号输入框 -->
<div class="layui-inline">
<label class="layui-form-label">生产批号</label>
<div class="layui-input-inline">
<input type="text" name="productcode" id="productcode" class="layui-input input-radius" placeholder="请输入生产批号">
</div>
</div>
<!-- 添加批准文号输入框 -->
<div class="layui-inline">
<label class="layui-form-label">批准文号</label>
<div class="layui-input-inline">
@ -74,8 +82,9 @@
</div>
</div>
</div>
<div class="layui-form-item">
<div class="layui-form-item">
<!-- 添加商品描述输入框 -->
<div class="layui-inline">
<label class="layui-form-label">商品描述</label>
<div class="layui-input-inline">
@ -83,364 +92,72 @@
placeholder="请输入商品描述">
</div>
</div>
<!-- 添加商品规格输入框 -->
<div class="layui-inline">
<label class="layui-form-label">商品规格</label>
<div class="layui-input-inline">
<input type="text" name="size" id="size" class="layui-input input-radius" placeholder="请输入商品规格">
</div>
</div>
<!-- 查询按钮和重置按钮区域 -->
<div class="layui-inline" style="padding-left: 3%">
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>查询
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>查询
</button>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
<!--数据表格-->
<!-- 数据展示区域 -->
<div>
<table class="layui-hide" id="goodsTable" lay-filter="goodsTable"></table>
<table class="layui-hide" id="goodsTable" lay-filter="goodsTable"></table> <!-- 数据表格区域 -->
<!-- 工具栏按钮区域，仅有添加按钮 -->
<div id="goodsToolBar" style="display: none">
<button type="button" lay-event="add" shiro:hasPermission="goods:create" class="layui-btn layui-btn-sm layui-btn-normal layui-btn-radius">
<i class="layui-icon layui-icon-add-1"></i>添加商品
</button>
</div>
<div id="goodsRowBar" style="display: none;">
<button type="button" lay-event="update" shiro:hasPermission="goods:update" class="layui-btn layui-btn-sm layui-btn-radius"><i
class="layui-icon layui-icon-edit"></i>编辑
</button>
<button type="button" lay-event="delete" shiro:hasPermission="goods:delete" class="layui-btn layui-btn-sm layui-btn-danger layui-btn-radius"><i
class="layui-icon layui-icon-delete"></i>删除
</button>
</div>
</div>
<!--添加和修改弹出层-->
<div id="addOrUpdateDiv" style="display: none;padding: 10px;padding-right: 5%">
<form action="" method="post" class="layui-form" id="dataFrm" lay-filter="dataFrm">
<div class="layui-col-md12 layui-col-xs12">
<div class="layui-row layui-col-space10">
<div class="layui-col-md9 layui-col-xs7">
<div class="layui-form-item magt3">
<label class="layui-form-label">供应商</label>
<div class="layui-input-block">
<select name="providerid" id="providerid">
<option value="0">请选择供应商</option>
</select>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-block">
<input type="hidden" name="id">
<input type="text" class="layui-input input-radius" name="goodsname" lay-verify="required" placeholder="请输入商品名称">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">商品描述</label>
<div class="layui-input-block">
<input type="text" class="layui-input input-radius" name="description" lay-verify="required" placeholder="请输入商品描述">
</div>
</div>
</div>
<div class="layui-col-md3 layui-col-xs5">
<div class="layui-upload-list thumbBox mag0 magt3">
<input type="hidden" name="goodsimg" id="goodsimg" value="images/noDefaultImage.jpg">
<img class="layui-upload-img thumbImg" src="/file/showImageByPath?path=images/noDefaultImage.jpg">
</div>
</div>
</div>
<div class="layui-form-item magb0">
<div class="layui-inline">
<label class="layui-form-label">产地</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="produceplace" lay-verify="required" placeholder="请输入商品产地">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">包装</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="goodspackage" lay-verify="required" placeholder="请输入商品包装">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">规格</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="size" lay-verify="required" placeholder="请输入商品规格">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">生产批号</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="productcode" lay-verify="required" placeholder="请输入商品生产批号">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">批准文号</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="promitcode" lay-verify="required" placeholder="请输入商品批准文号">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">销售价格</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="price" lay-verify="required|number" placeholder="请输入商品销售价格">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">库存量</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="number" lay-verify="required|number" placeholder="请输入商品库存量">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">预警值</label>
<div class="layui-input-inline">
<input type="text" class="layui-input input-radius" name="dangernum" lay-verify="required|number" placeholder="请输入商品预警值">
</div>
</div>
<div class="layui-inline">
<label class="layui-form-label">是否可用</label>
<div class="layui-input-inline">
<input type="radio" name="available" value="1" title="可用" checked="">
<input type="radio" name="available" value="0" title="不可用" >
</div>
</div>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 7%">
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doSubmit" id="doSubmit"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>提交
</button>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
</div>
<!-- 引入layui核心JS文件 -->
<script type="text/javascript" src="/resources/layui/layui.js"></script>
<script type="text/javascript">
//提升数据表格的作用域，因为底下还有一个reloadTable方法
var tableIns;
layui.use(['jquery', 'form', 'layer', 'table','upload'], function () {
layui.use(['jquery', 'form', 'layer', 'table', 'upload'], function () {
var $ = layui.jquery;
var form = layui.form;
var layer = layui.layer;
var table = layui.table;
var upload = layui.upload;
//初始化表格 加载数据
// 渲染数据表格
tableIns = table.render({
elem: "#goodsTable",
title: "商品数据表格",
url: "/goods/loadAllGoods",
toolbar: "#goodsToolBar",
page: true,
height: "full-180",
cols: [ [
{field: 'id', title: 'ID', align: 'center',width:'50'},
{field: 'goodsname', title: '商品名称', align: 'center',width:'150'},
{field: 'providername', title: '供应商', align: 'center',width:'150'},
{field: 'produceplace', title: '商品产地', align: 'center',width:'150'},
{field: 'description', title: '商品描述', align: 'center',width:'150'},
{field: 'price', title: '销售价格', align: 'center',width:'90'},
{field: 'number', title: '数量', align: 'center',width:'90'},
{field: 'dangernum', title: '库存预警值', align: 'center',width:'100'},
{field: 'goodsimg', title: '商品图片', align: 'center',width:'150', templet:function(d){
return '<img width=40 height=40 src=/file/showImageByPath?path='+d.goodsimg+ ' />';
}},
{field: 'size', title: '规格', align: 'center',width:'120'},
{field: 'goodspackage', title: '包装', align: 'center',width:'120'},
{field: 'productcode', title: '生产批号', align: 'center',width:'130'},
{field: 'promitcode', title: '批准文号', align: 'center',width:'130'},
{field: 'available', title: '是否可用', align: 'center',width:'100',templet:function (d) {
return d.available==1?'<font color="blue">可用</font>':'<font color="red">不可用</font>';
}},
{fixed: 'right', title: '操作', toolbar: '#goodsRowBar', align: 'center',width:'180'}
] ],
done: function (data, curr, count) {
//不是第一页时，如果当前返回的数据为0那么就返回上一页
if (data.data.length == 0 && curr != 1) {
tableIns.reload({
page: {
curr: curr - 1
}
})
}
}
});
//初始化查询条件的下拉列表
$.get("/provider/loadAllProviderForSelect",function (res) {
var data = res.data;
var dom = $("#select_providerid");
var html = '<option value="0">请选择供应商</option>';
$.each(data,function (index, item) {
html += '<option value="'+item.id+'">'+item.providername+'</option>';
})
dom.html(html);
//重新渲染下拉列表
form.render("select");
cols: [[
{field: 'id', title: 'ID', align: 'center'},
{field: 'goodsname', title: '商品名称', align: 'center'},
{field: 'providername', title: '供应商', align: 'center'}
]]
});
//监控模糊查询按钮事件
// 表单提交事件处理
form.on("submit(doSearch)", function (data) {
tableIns.reload({
where: data.field,
page: {
curr: 1
}
});
return false;
});
//监控工具条事件
table.on("toolbar(goodsTable)", function (obj) {
switch (obj.event) {
case 'add':
openAddLayer();
break;
case 'deleteBatch':
batchDeleteGoods();
break;
};
});
//监控行工具条事件
table.on("tool(goodsTable)", function (obj) {
//获取当前行数据
var data = obj.data;
switch (obj.event) {
case 'delete':
deleteGoods(data);
break;
case 'update':
updateGoods(data);
break;
};
});
//文件上传
upload.render({
elem: '.thumbBox',
url: '/file/uploadFile',
acceptMime:'image/*',
field:'mf',
method : "post",
done: function(res, index, upload){
var path=res.path;
$('.thumbImg').attr('src','/file/showImageByPath?path='+path);
$('.thumbBox').css("background","#fff");
//给隐藏域赋值
$("#goodsimg").val(path);
}
});
var mainIndex;
var url;
//打开添加弹出层
function openAddLayer() {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'添加商品',
success:function () {
$("#dataFrm")[0].reset();
url="/goods/addGoods";
$.get("/provider/loadAllProviderForSelect",function(res){
var data=res.data;
var dom=$("#providerid");
var html='<option value="0">请选择供应商</option>'
$.each(data,function(index,item){
html+='<option value="'+item.id+'">'+item.providername+'</option>'
});
dom.html(html);
form.render("select");
});
//设置默认为无图片
$(".thumbImg").attr("src",'/file/showImageByPath?path=images/noDefaultImage.jpg');
$("#goodsimg").val('/images/noDefaultImage.jpg');
}
});
}
//打开修改的弹出层
function updateGoods(data) {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'修改商品',
success:function () {
//清空原有的数据
$("#dataFrm")[0].reset();
//装载新的数据
form.val("dataFrm",data);
//图片进行回显
$(".thumbImg").attr("src",'/file/showImageByPath?path='+data.goodsimg);
//下拉列表的回显
$.get("/provider/loadAllProviderForSelect",function(res){
var redata=res.data;
var dom=$("#providerid");
var html='<option value="0">请选择供应商</option>'
$.each(redata,function(index,item){
if (data.providerid===item.id){
html+='<option value="'+item.id+'" selected>'+item.providername+'</option>'
}else {
html+='<option value="'+item.id+'">'+item.providername+'</option>'
}
});
dom.html(html);
form.render("select");
});
url="/goods/updateGoods";
}
});
}
form.on("submit(doSubmit)",function (data) {
$.post(url,data.field,function (res) {
if (res.code==200){
tableIns.reload();
}
layer.msg(res.msg);
layer.close(mainIndex);
page: { curr: 1 }
});
return false;
});
//删除
function deleteGoods(data) {
layer.confirm('你确定要删除【' + data.goodsname + '】这个商品吗？删除该商品，其商品进货、商品退货、商品销售、商品销售退货将会同步删除！', {icon: 3, title: '提示'}, function (index) {
$.post("/goods/deleteGoods", {id: data.id,goodsimg:data.goodsimg},function (res) {
if (res.code == 200) {
tableIns.reload({
where:"",
});
}
layer.msg(res.msg);
});
layer.close(index);
});
}
});
</script>
</body>
</html>
</html>

363
src/main/resources/templates/business/inport/inportManager.html
Unescape View File

@ -1,71 +1,52 @@
<!DOCTYPE html>
<!DOCTYPE html> <!-- 声明HTML5文档类型 -->
<html xmlns:th="http://www.thymeleaf.org"
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"> <!-- 引入Thymeleaf和Shiro的命名空间 -->
<head>
<meta charset="UTF-8">
<title>Right</title>
<meta name="renderer" content="webkit">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<meta http-equiv="Access-Control-Allow-Origin" content="*">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="format-detection" content="telephone=no">
<link rel="icon" href="/resources/favicon.ico">
<meta charset="UTF-8"> <!-- 设置页面编码为UTF-8 -->
<title>Right</title> <!-- 设置网页标题 -->
<meta name="renderer" content="webkit"> <!-- 强制使用webkit渲染引擎 -->
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <!-- 设置IE兼容模式 -->
<meta http-equiv="Access-Control-Allow-Origin" content="*"> <!-- 允许跨域访问 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <!-- 设置移动端响应式布局 -->
<meta name="apple-mobile-web-app-status-bar-style" content="black"> <!-- 设置苹果移动设备状态栏为黑色 -->
<meta name="apple-mobile-web-app-capable" content="yes"> <!-- 支持移动设备全屏显示 -->
<meta name="format-detection" content="telephone=no"> <!-- 禁用自动检测电话号码 -->
<link rel="icon" href="/resources/favicon.ico"> <!-- 设置页面图标 -->
<!-- 引入layui样式文件 -->
<link rel="stylesheet" href="resources/layui/css/layui.css" th:href="@{/resources/layui/css/layui.css}" media="all"/>
<!-- 引入自定义公共样式 -->
<link rel="stylesheet" th:href="@{/resources/css/public.css}" media="all"/>
<!-- 引入树形菜单相关样式 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/dtree.css}" media="all"/>
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/font/dtreefont.css}" media="all"/>
<style>
input#search_provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#leaderprovideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input.layui-input.layui-unselect {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#search_goodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#goodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
/* 输入框样式设置 */
input#search_provideridTree_select_input_id,
input#provideridTree_select_input_id,
input#leaderprovideridTree_select_input_id,
input.layui-input.layui-unselect,
input#search_goodsidTree_select_input_id,
input#goodsidTree_select_input_id,
input#leadergoodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input.layui-input.layui-unselect {
border-radius: 10px;
height: 30px;
margin-top: 4px;
border-radius: 10px; /* 设置圆角 */
height: 30px; /* 设置输入框高度 */
margin-top: 4px; /* 设置顶部外边距 */
}
</style>
</head>
<body>
<!--查询条件-->
<!-- 搜索条件区域 -->
<fieldset class="layui-elem-field layui-field-title" style="margin-top: 15px;">
<legend>搜索条件</legend>
<legend>搜索条件</legend> <!-- 定义搜索条件标题 -->
</fieldset>
<!-- 搜索表单 -->
<form action="" method="post" id="searchFrm" lay-filter="searchFrm" class="layui-form">
<div class="layui-form-item">
<!-- 供应商名称搜索框 -->
<div class="layui-inline">
<label class="layui-form-label">供应商名称</label>
<div class="layui-input-inline">
@ -74,6 +55,8 @@
</select>
</div>
</div>
<!-- 商品名称搜索框 -->
<div class="layui-inline">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
@ -82,6 +65,8 @@
</select>
</div>
</div>
<!-- 开始时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">开始时间</label>
<div class="layui-input-inline">
@ -89,6 +74,8 @@
class="layui-input input-radius">
</div>
</div>
<!-- 结束时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">结束时间</label>
<div class="layui-input-inline">
@ -97,19 +84,21 @@
</div>
</div>
</div>
<!-- 提交按钮组 -->
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 15%;">
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>查询
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>查询
</button>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
<!--数据表格-->
<!-- 数据表格区域 -->
<div>
<table class="layui-hide" id="inportTable" lay-filter="inportTable"></table>
<div id="inportToolBar" style="display: none">
@ -117,102 +106,231 @@
<i class="layui-icon layui-icon-add-1"></i>添加进货
</button>
</div>
<div id="inportRowBar" style="display: none;">
<button type="button" lay-event="update" shiro:hasPermission="inport:update" class="layui-btn layui-btn-sm layui-btn-radius"><i
class="layui-icon layui-icon-edit"></i>编辑
</button>
<button type="button" lay-event="delete" shiro:hasPermission="inport:delete" class="layui-btn layui-btn-sm layui-btn-danger layui-btn-radius"><i
class="layui-icon layui-icon-delete"></i>删除
</button>
<button type="button" lay-event="back" shiro:hasPermission="inport:back" class="layui-btn layui-btn-sm layui-btn-warm layui-btn-radius"><i
class="layui-icon layui-icon-delete"></i>退货
</button>
</div>
</div>
<!--添加和修改弹出层-->
<!-- 添加/编辑数据表单弹出层 -->
<div id="addOrUpdateDiv" style="display: none;padding: 10px;padding-right: 5%">
<form action="" method="post" class="layui-form" id="dataFrm" lay-filter="dataFrm">
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">供应商名称</label>
<div class="layui-input-inline">
<select name="providerid" id="providerid" lay-filter="providerid">
<option value="0">请选择供应商</option>
</select>
<div class="mydiv" title="不可修改" style="position:absolute;width:100%;height:100%;left:0px;top:0px;background:#fff;opacity:0;filter:alpha(opacity=0)"> </div>
</div>
<label class="layui-form-label">供应商名称</label>
<div class="layui-input-inline">
<select name="providerid" id="providerid" lay-filter="providerid">
<option value="0">请选择供应商</option>
</select>
</div>
<div class="layui-inline">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
<select name="goodsid" id="goodsid">
<option value="0">请选择商品</option>
</select>
</div>
<div class="mydiv" title="不可修改" style="position:absolute;width:100%;height:100%;left:0px;top:0px;background:#fff;opacity:0;filter:alpha(opacity=0)"> </div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
<select name="goodsid" id="goodsid">
<option value="0">请选择商品</option>
</select>
</div>
</div>
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">进货数量</label>
<div class="layui-input-block">
<input type="hidden" name="id">
<input type="text" name="number" lay-verify="required|number" autocomplete="off" class="layui-input input-radius" placeholder="请输入进货数量">
</div>
<label class="layui-form-label">进货数量</label>
<div class="layui-input-block">
<input type="text" name="number" lay-verify="required|number" autocomplete="off" class="layui-input input-radius" placeholder="请输入进货数量">
</div>
<div class="layui-inline">
<label class="layui-form-label">进货价格</label>
<div class="layui-input-block">
<input type="text" name="inportprice" lay-verify="required|number" autocomplete="off" class="layui-input input-radius" placeholder="请输入进货价格">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">进货备注</label>
<div class="layui-input-block">
<textarea name="remark" placeholder="请输入进货备注" class="layui-textarea"></textarea>
</div>
</div>
<!-- 提交按钮组 -->
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">支付类型</label>
<div class="layui-input-block">
<input type="radio" name="paytype" value="微信" title="微信">
<input type="radio" name="paytype" value="支付宝" title="支付宝" checked>
<input type="radio" name="paytype" value="银联" title="银联">
</div>
<div class="layui-input-block" style="text-align: center;padding-right: 7%">
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doSubmit">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>提交
</button>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
</div><!DOCTYPE html> <!-- 声明HTML5文档类型 -->
<html xmlns:th="http://www.thymeleaf.org"
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"> <!-- 引入Thymeleaf和Shiro的命名空间 -->
<head>
<meta charset="UTF-8"> <!-- 设置页面编码为UTF-8 -->
<title>Right</title> <!-- 设置网页标题 -->
<meta name="renderer" content="webkit"> <!-- 强制使用webkit渲染引擎 -->
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <!-- 设置IE兼容模式 -->
<meta http-equiv="Access-Control-Allow-Origin" content="*"> <!-- 允许跨域访问 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <!-- 设置移动端响应式布局 -->
<meta name="apple-mobile-web-app-status-bar-style" content="black"> <!-- 设置苹果移动设备状态栏为黑色 -->
<meta name="apple-mobile-web-app-capable" content="yes"> <!-- 支持移动设备全屏显示 -->
<meta name="format-detection" content="telephone=no"> <!-- 禁用自动检测电话号码 -->
<link rel="icon" href="/resources/favicon.ico"> <!-- 设置页面图标 -->
<!-- 引入layui样式文件 -->
<link rel="stylesheet" href="resources/layui/css/layui.css" th:href="@{/resources/layui/css/layui.css}" media="all"/>
<!-- 引入自定义公共样式 -->
<link rel="stylesheet" th:href="@{/resources/css/public.css}" media="all"/>
<!-- 引入树形菜单相关样式 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/dtree.css}" media="all"/>
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/font/dtreefont.css}" media="all"/>
<style>
/* 输入框样式设置 */
input#search_provideridTree_select_input_id,
input#provideridTree_select_input_id,
input#leaderprovideridTree_select_input_id,
input.layui-input.layui-unselect,
input#search_goodsidTree_select_input_id,
input#goodsidTree_select_input_id,
input#leadergoodsidTree_select_input_id {
border-radius: 10px; /* 设置圆角 */
height: 30px; /* 设置输入框高度 */
margin-top: 4px; /* 设置顶部外边距 */
}
</style>
</head>
<body>
<!-- 搜索条件区域 -->
<fieldset class="layui-elem-field layui-field-title" style="margin-top: 15px;">
<legend>搜索条件</legend> <!-- 定义搜索条件标题 -->
</fieldset>
<!-- 搜索表单 -->
<form action="" method="post" id="searchFrm" lay-filter="searchFrm" class="layui-form">
<div class="layui-form-item">
<!-- 供应商名称搜索框 -->
<div class="layui-inline">
<label class="layui-form-label">供应商名称</label>
<div class="layui-input-inline">
<select name="providerid" id="select_providerid">
<option value="0">请选择供应商</option>
</select>
</div>
</div>
<!-- 商品名称搜索框 -->
<div class="layui-inline">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
<select name="goodsid" id="select_goodsid">
<option value="0">请选择商品</option>
</select>
</div>
</div>
<!-- 开始时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">开始时间</label>
<div class="layui-input-inline">
<input type="text" name="startTime" id="startTime" readonly="readonly" placeholder="yyyy-MM-dd"
class="layui-input input-radius">
</div>
</div>
<!-- 结束时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">结束时间</label>
<div class="layui-input-inline">
<input type="text" name="endTime" id="endTime" readonly="readonly" placeholder="yyyy-MM-dd"
class="layui-input input-radius">
</div>
</div>
</div>
<!-- 提交按钮组 -->
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 15%;">
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>查询
</button>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
<!-- 数据表格区域 -->
<div>
<table class="layui-hide" id="inportTable" lay-filter="inportTable"></table>
<div id="inportToolBar" style="display: none">
<button type="button" lay-event="add" shiro:hasPermission="inport:create" class="layui-btn layui-btn-sm layui-btn-normal layui-btn-radius">
<i class="layui-icon layui-icon-add-1"></i>添加进货
</button>
</div>
</div>
<!-- 添加/编辑数据表单弹出层 -->
<div id="addOrUpdateDiv" style="display: none;padding: 10px;padding-right: 5%">
<form action="" method="post" class="layui-form" id="dataFrm" lay-filter="dataFrm">
<div class="layui-form-item">
<label class="layui-form-label">供应商名称</label>
<div class="layui-input-inline">
<select name="providerid" id="providerid" lay-filter="providerid">
<option value="0">请选择供应商</option>
</select>
</div>
</div>
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">进货备注</label>
<div class="layui-input-block">
<textarea name="remark" placeholder="请输入进货备注" class="layui-textarea" cols="200" rows="8"></textarea>
</div>
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
<select name="goodsid" id="goodsid">
<option value="0">请选择商品</option>
</select>
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">进货数量</label>
<div class="layui-input-block">
<input type="text" name="number" lay-verify="required|number" autocomplete="off" class="layui-input input-radius" placeholder="请输入进货数量">
</div>
</div>
<div class="layui-form-item">
<label class="layui-form-label">进货备注</label>
<div class="layui-input-block">
<textarea name="remark" placeholder="请输入进货备注" class="layui-textarea"></textarea>
</div>
</div>
<!-- 提交按钮组 -->
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 7%">
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doSubmit" id="doSubmit"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>提交
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doSubmit">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>提交
</button>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
</form>
</div>
<!--退货的弹出层-->
<!-- 退货的弹出层，用于用户输入退货信息 -->
<div id="backGoodsDiv" style="display: none;padding-right: 3%">
<form action="" method="post" class="layui-form" id="dataFrmBack" lay-filter="dataFrmBack">
<!-- 退货数量输入区域 -->
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">退货数量</label>
<div class="layui-input-block">
<input type="hidden" name="id"> <!-- 进货单ID -->
<input type="hidden" name="currentNumber" id="currentNumber"> <!-- 进货单中进货数量 -->
<input type="hidden" name="id"> <!-- 隐藏字段存储当前退货的进货单ID -->
<input type="hidden" name="currentNumber" id="currentNumber"> <!-- 当前进货单的实际进货数量 -->
<input type="text" name="number" lay-verify="required|checkNumber" autocomplete="off" class="layui-input input-radius" placeholder="请输入退货数量">
</div>
</div>
</div>
<!-- 退货备注输入区域 -->
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">退货备注</label>
@ -221,13 +339,17 @@
</div>
</div>
</div>
<!-- 提交与重置按钮区域 -->
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 7%">
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doBackSubmit" id="doBackSubmit"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>提交
<!-- 提交按钮，用于提交退货信息 -->
<button type="button" class="layui-btn layui-btn-radius" lay-submit="" lay-filter="doBackSubmit" id="doBackSubmit">
<i class="layui-icon layui-icon-search layui-icon-normal"></i> 提交
</button>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
<!-- 重置按钮，用于清空退货表单输入数据 -->
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
</div>
</div>
@ -235,6 +357,7 @@
</div>
<script type="text/javascript" src="/resources/layui/layui.js"></script>
<script type="text/javascript">
@ -448,7 +571,7 @@
form.render("select");
});
}
form.on("submit(doSubmit)",function (data) {
$.post(url,data.field,function (res) {

189
src/main/resources/templates/business/outport/outportManager.html
Unescape View File

@ -1,70 +1,46 @@
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
<html xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
<!-- 声明HTML文档类型，并引入Thymeleaf和Shiro命名空间 -->
<head>
<meta charset="UTF-8">
<!-- 设置页面编码为UTF-8 -->
<title>Right</title>
<!-- 设置页面标题 -->
<meta name="renderer" content="webkit">
<!-- 强制使用WebKit渲染引擎 -->
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<!-- 强制浏览器使用最新渲染模式 -->
<meta http-equiv="Access-Control-Allow-Origin" content="*">
<!-- 允许跨域请求 -->
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<!-- 设置响应式视口设置 -->
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<!-- 设置iOS设备的状态栏样式 -->
<meta name="apple-mobile-web-app-capable" content="yes">
<!-- 允许添加到iOS的桌面应用 -->
<meta name="format-detection" content="telephone=no">
<!-- 禁止自动将电话号码检测为链接 -->
<link rel="icon" href="/resources/favicon.ico">
<!-- 设置页面图标 -->
<link rel="stylesheet" href="resources/layui/css/layui.css" th:href="@{/resources/layui/css/layui.css}" media="all"/>
<!-- 引入layui样式 -->
<link rel="stylesheet" th:href="@{/resources/css/public.css}" media="all"/>
<!-- 引入公共样式 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/dtree.css}" media="all"/>
<!-- 引入树形菜单样式 -->
<link rel="stylesheet" th:href="@{/resources/layui_ext/dtree/font/dtreefont.css}" media="all"/>
<style>
input#search_provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#provideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#leaderprovideridTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input.layui-input.layui-unselect {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#search_goodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#goodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input#leadergoodsidTree_select_input_id {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
input.layui-input.layui-unselect {
border-radius: 10px;
height: 30px;
margin-top: 4px;
}
</style>
<!-- 引入树形菜单字体样式 -->
</head>
<body>
<!--查询条件-->
<!-- 开始页面主体内容部分 -->
<!-- 查询条件部分 -->
<fieldset class="layui-elem-field layui-field-title" style="margin-top: 15px;">
<legend>搜索条件</legend>
</fieldset>
<form action="" method="post" id="searchFrm" lay-filter="searchFrm" class="layui-form">
<!-- 搜索条件表单 -->
<div class="layui-form-item">
<div class="layui-inline">
<label class="layui-form-label">供应商名称</label>
@ -72,6 +48,7 @@
<select name="providerid" id="select_providerid">
<option value="0">请选择供应商</option>
</select>
<!-- 下拉菜单用于选择供应商，默认选项为“请选择供应商” -->
</div>
</div>
<div class="layui-inline">
@ -80,6 +57,7 @@
<select name="goodsid" id="select_goodsid">
<option value="0">请选择商品</option>
</select>
<!-- 下拉菜单用于选择商品，默认选项为“请选择商品” -->
</div>
</div>
<div class="layui-inline">
@ -87,6 +65,7 @@
<div class="layui-input-inline">
<input type="text" name="startTime" id="startTime" readonly="readonly" placeholder="yyyy-MM-dd"
class="layui-input input-radius">
<!-- 时间选择器输入框，用户选择开始时间，设置为只读模式 -->
</div>
</div>
<div class="layui-inline">
@ -94,37 +73,41 @@
<div class="layui-input-inline">
<input type="text" name="endTime" id="endTime" readonly="readonly" placeholder="yyyy-MM-dd"
class="layui-input input-radius">
<!-- 时间选择器输入框，用户选择结束时间，设置为只读模式 -->
</div>
</div>
</div>
<div class="layui-form-item">
<div class="layui-input-block" style="text-align: center;padding-right: 15%;">
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch"><i
class="layui-icon layui-icon-search layui-icon-normal"></i>查询
<button type="button" class="layui-btn layui-btn-sm layui-btn-radius" lay-submit="" lay-filter="doSearch">
<i class="layui-icon layui-icon-search layui-icon-normal"></i>查询
</button>
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
<!-- 查询按钮，点击时触发查询 -->
<button type="reset" class="layui-btn layui-btn-sm layui-btn-radius layui-btn-warm">
<i class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
<!-- 重置按钮，重置搜索条件 -->
</div>
</div>
</form>
<!--数据表格-->
<!-- 数据表格部分 -->
<div>
<table class="layui-hide" id="outportTable" lay-filter="outportTable"></table>
<div id="outportRowBar" style="display: none;">
<button type="button" lay-event="delete" shiro:hasPermission="outport:delete" class="layui-btn layui-btn-sm layui-btn-danger layui-btn-radius"><i
class="layui-icon layui-icon-delete"></i>删除
<button type="button" lay-event="delete" shiro:hasPermission="outport:delete" class="layui-btn layui-btn-sm layui-btn-danger layui-btn-radius">
<i class="layui-icon layui-icon-delete"></i>删除
</button>
<!-- 删除按钮，仅当用户有权限时显示，用于删除当前退货记录 -->
</div>
</div>
<!-- 引入layui核心JS库 -->
<script type="text/javascript" src="/resources/layui/layui.js"></script>
<script type="text/javascript">
//提升数据表格的作用域，因为底下还有一个reloadTable方法
// 提升数据表格的作用域
var tableIns;
layui.use(['jquery', 'form', 'layer', 'table', 'laydate'], function () {
@ -134,7 +117,7 @@
var table = layui.table;
var laydate = layui.laydate;
//初始化时间选择器
// 渲染时间选择器
laydate.render({
elem: '#startTime',
type: 'datetime'
@ -142,42 +125,24 @@
laydate.render({
elem: '#endTime',
type: 'datetime'
})
});
//初始化表格 加载数据
// 渲染数据表格
tableIns = table.render({
elem: "#outportTable",
title: "进货数据表格",
url: "/outport/loadAllOutport",
toolbar: true,
page: true,
height: "full-180",
cols: [ [
cols: [[
{field: 'id', title: 'ID', align: 'center'},
{field: 'providername', title: '供应商', align: 'center',width:'130'},
{field: 'goodsname', title: '商品名称', align: 'center',width:'150'},
{field: 'paytype', title: '支付类型', align: 'center',width:'90'},
{field: 'outputtime', title: '退货时间', align: 'center',width:'170'},
{field: 'operateperson', title: '操作员', align: 'center',width:'130'},
{field: 'number', title: '退货数量', align: 'center',width:'100'},
{field: 'outportprice', title: '退货价格', align: 'center',width:'120'},
{field: 'remark', title: '备注', align: 'center',width:'130'},
{field: 'size', title: '商品规格', align: 'center',width:'100'},
{fixed: 'right', title: '操作', toolbar: '#outportRowBar', align: 'center',width:'130'}
] ],
done: function (data, curr, count) {
//不是第一页时，如果当前返回的数据为0那么就返回上一页
if (data.data.length == 0 && curr != 1) {
tableIns.reload({
page: {
curr: curr - 1
}
})
}
}
{field: 'providername', title: '供应商', align: 'center'},
{field: 'goodsname', title: '商品名称', align: 'center'},
{field: 'paytype', title: '支付类型', align: 'center'},
{field: 'outputtime', title: '退货时间', align: 'center'}
]]
});
//监控模糊查询按钮事件
// 查询按钮点击事件
form.on("submit(doSearch)", function (data) {
tableIns.reload({
where: data.field,
@ -187,63 +152,7 @@
});
return false;
});
//监控行工具条事件
table.on("tool(outportTable)", function (obj) {
//获取当前行数据
var data = obj.data;
switch (obj.event) {
case 'delete':
deleteOutport(data);
break;
};
});
//初始化供应商名称的下拉列表
$.get("/provider/loadAllProviderForSelect",function (res) {
var data = res.data;
var dom = $("#select_providerid");
var html = '<option value="0">请选择供应商</option>';
$.each(data,function (index, item) {
html += '<option value="'+item.id+'">'+item.providername+'</option>';
})
dom.html(html);
//重新渲染下拉列表
form.render("select");
});
//初始化商品名称的下拉列表
$.get("/goods/loadAllGoodsForSelect",function (res) {
var data = res.data;
var dom = $("#select_goodsid");
var html = '<option value="0">请选择商品</option>';
$.each(data,function (index, item) {
html += '<option value="'+item.id+'">'+item.goodsname+'-['+item.size+']-'+'['+item.providername+']'+'</option>';
});
dom.html(html);
//重新渲染下拉列表
form.render("select");
});
//删除退货信息
function deleteOutport(data) {
layer.confirm('你确定要删除这条退货信息吗？', {icon: 3, title: '提示'}, function (index) {
$.post("/outport/deleteOutport", {id: data.id},function (res) {
if (res.code == 200) {
tableIns.reload({
where:"",
});
}
layer.msg(res.msg);
});
layer.close(index);
});
}
});
</script>
</body>
</html>
</html>

Write Preview
Loading…
Cancel
Save