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

第一次注释

Browse Source
lihaobo
屑哈哈 9 months ago
parent cd8fb5a54e
commit 9d7d4971ca
41 changed files with 579 additions and 198 deletions
Show Stats Download Patch File Download Diff File

105
src/main/java/com/yeqifu/bus/cache/BusinessCacheAspect.java vendored
Unescape View File

@ -19,6 +19,7 @@ import java.util.Map;
/**
* @Author: 落亦-
* @Date: 2019/12/5 16:39
* 该类是一个切面类，用于实现业务缓存的相关切面逻辑
*/
@Aspect
@Component
@ -30,13 +31,13 @@ public class BusinessCacheAspect {
private Log log = LogFactory.getLog(BusinessCacheAspect.class);
/**
* 声明一个缓存容器
* 声明一个缓存容器，从 CachePool 中获取 CACHE_CONTAINER
*/
private Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 声明客户的切面表达式
* 声明客户的切面表达式，用于匹配 CustomerServiceImpl 中的不同方法
*/
private static final String POINTCUT_CUSTOMER_ADD="execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.save(..))";
private static final String POINTCUT_CUSTOMER_UPDATE="execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.updateById(..))";
@ -48,15 +49,18 @@ public class BusinessCacheAspect {
/**
* 添加客户切入
* @param joinPoint
* @return
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_CUSTOMER_ADD)
public Object cacheCustomerAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Customer 类型
Customer object = (Customer) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean res = (Boolean) joinPoint.proceed();
if (res){
// 如果执行成功，将客户对象添加到缓存容器中，以 customer:id 为键存储
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX + object.getId(),object);
}
return res;
@ -64,19 +68,21 @@ public class BusinessCacheAspect {
/**
* 查询客户切入
* @param joinPoint
* @return
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_CUSTOMER_GET)
public Object cacheCustomerGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Integer 类型的客户 id
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
//从缓存里面取客户对象
Object res1 = CACHE_CONTAINER.get(CACHE_CUSTOMER_PROFIX + object);
if (res1!=null){
log.info("已从缓存里面找到客户对象"+CACHE_CUSTOMER_PROFIX + object);
return res1;
}else {
// 若缓存中不存在，则从数据库中查询，将结果放入缓存，并打印日志信息
log.info("未从缓存里面找到客户对象，从数据库中查询并放入缓存");
Customer res2 =(Customer) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX+res2.getId(),res2);
@ -85,20 +91,24 @@ public class BusinessCacheAspect {
}
/**
* 更新客户切入
* @param joinPoint
* @return
* 更新客户切入方法
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_CUSTOMER_UPDATE)
public Object cacheCustomerUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Customer 类型
Customer customerVo = (Customer) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
// 从缓存中获取客户对象
Customer customer =(Customer) CACHE_CONTAINER.get(CACHE_CUSTOMER_PROFIX + customerVo.getId());
if (null==customer){
customer=new Customer();
}
// 将更新后的客户信息复制到缓存对象中
BeanUtils.copyProperties(customerVo,customer);
log.info("客户对象缓存已更新"+CACHE_CUSTOMER_PROFIX + customerVo.getId());
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX+customer.getId(),customer);
@ -107,36 +117,40 @@ public class BusinessCacheAspect {
}
/**
* 删除客户切入
* @param joinPoint
* @return
* 删除客户切入方法
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_CUSTOMER_DELETE)
public Object cacheCustomerDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Integer 类型的客户 id
Integer id = (Integer) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
// 删除缓存中的客户对象
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX+id);
}
return isSuccess;
}
/**
* 批量删除客户切入
*
* @throws Throwable
* 批量删除客户切入方法
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_CUSTOMER_BATCHDELETE)
public Object cacheCustomerBatchDelete(ProceedingJoinPoint joinPoint) throws Throwable {
// 取出第一个参数
// 取出第一个参数，这里假设第一个参数是一个可序列化对象的集合
@SuppressWarnings("unchecked")
Collection<Serializable> idList = (Collection<Serializable>) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess) {
for (Serializable id : idList) {
// 删除缓存
// 遍历集合，删除每个客户的缓存
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX + id);
log.info("客户对象缓存已删除" + CACHE_CUSTOMER_PROFIX + id);
}
@ -146,7 +160,7 @@ public class BusinessCacheAspect {
/**
* 声明商品的切面表达式
* 声明商品的切面表达式，用于匹配 GoodsServiceImpl 中的不同方法
*/
private static final String POINTCUT_GOODS_ADD="execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.save(..))";
private static final String POINTCUT_GOODS_UPDATE="execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.updateById(..))";
@ -157,35 +171,41 @@ public class BusinessCacheAspect {
/**
* 添加商品切入
* @param joinPoint
* @return
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_GOODS_ADD)
public Object cacheGoodsAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Goods 类型
Goods object = (Goods) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean res = (Boolean) joinPoint.proceed();
if (res){
// 如果执行成功，将商品对象添加到缓存容器中，以 goods:id 为键存储
CACHE_CONTAINER.put(CACHE_GOODS_PROFIX + object.getId(),object);
}
return res;
}
/**
* 查询商品切入
* @param joinPoint
* @return
* 添加商品切入方法
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_GOODS_GET)
public Object cacheGoodsGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Integer 类型的商品 id
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
//从缓存里面取商品对象
Object res1 = CACHE_CONTAINER.get(CACHE_GOODS_PROFIX + object);
if (res1!=null){
// 若缓存中存在，则打印日志信息
log.info("已从缓存里面找到商品对象"+CACHE_GOODS_PROFIX + object);
return res1;
}else {
// 若缓存中不存在，则从数据库中查询，将结果放入缓存，并打印日志信息
log.info("未从缓存里面找到商品对象，从数据库中查询并放入缓存");
Goods res2 =(Goods) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_GOODS_PROFIX+res2.getId(),res2);
@ -195,21 +215,26 @@ public class BusinessCacheAspect {
/**
* 更新商品切入
* @param joinPoint
* @return
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_GOODS_UPDATE)
public Object cacheGoodsUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Goods 类型
Goods goodsVo = (Goods) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
// 从缓存中获取商品对象
Goods goods =(Goods) CACHE_CONTAINER.get(CACHE_GOODS_PROFIX + goodsVo.getId());
if (null==goods){
goods=new Goods();
}
// 将更新后的商品信息复制到缓存对象中
BeanUtils.copyProperties(goodsVo,goods);
log.info("商品对象缓存已更新"+CACHE_GOODS_PROFIX + goodsVo.getId());
// 将更新后的商品对象重新放入缓存
CACHE_CONTAINER.put(CACHE_GOODS_PROFIX+goods.getId(),goods);
}
return isSuccess;
@ -217,16 +242,18 @@ public class BusinessCacheAspect {
/**
* 删除商品切入
* @param joinPoint
* @return
* @param joinPoint 连接点，代表被拦截的方法
* @return 方法的执行结果
* @throws Throwable 可能抛出的异常
*/
@Around(value = POINTCUT_GOODS_DELETE)
public Object cacheGoodsDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
//取出第一个参数，这里假设第一个参数是 Integer 类型的商品 id
Integer id = (Integer) joinPoint.getArgs()[0];
// 执行被拦截的方法
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
//删除缓存中的商品对象
CACHE_CONTAINER.remove(CACHE_GOODS_PROFIX+id);
}
return isSuccess;

22
src/main/java/com/yeqifu/bus/controller/BusinessController.java
Unescape View File

@ -7,6 +7,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
* 业务管理的路由器
* @Author: 落亦-
* @Date: 2019/12/5 9:33
* 该类是一个 Spring 的控制器类，用于处理与业务相关的页面跳转请求
*/
@Controller
@RequestMapping("bus")
@ -14,63 +15,70 @@ public class BusinessController {
/**
* 跳转到客户管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toCustomerManager")
// 返回客户管理页面的视图名称
public String toCustomerManager(){
return "business/customer/customerManager";
}
/**
* 跳转到供应商管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toProviderManager")
// 返回供应商管理页面的视图名称
public String toProviderManager(){
return "business/provider/providerManager";
}
/**
* 跳转到商品管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toGoodsManager")
// 返回商品管理页面的视图名称
public String toGoodsManager(){
return "business/goods/goodsManager";
}
/**
* 跳转到进货管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toInportManager")
// 返回进货管理页面的视图名称
public String toInportManager(){
return "business/inport/inportManager";
}
/**
* 跳转到退货管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toOutportManager")
// 返回退货管理页面的视图名称
public String toOutportManager(){
return "business/outport/outportManager";
}
/**
* 跳转到商品销售管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toSalesManager")
//返回商品销售管理页面的视图名称
public String toSalesManager(){
return "business/sales/salesManager";
}
/**
* 跳转到商品销售管理页面
* @return
* @return 要跳转的页面的视图名称
*/
@RequestMapping("toSalesbackManager")
返回商品销售退货管理页面的视图名称
public String toSalesbackManager(){
return "business/salesback/salesbackManager";
}

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

@ -23,11 +23,12 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* InnoDB free: 9216 kB 前端客户控制器
* </p>
*
* @author luoyi-
* @since 2019-12-05
* * 该类是一个 Restful 风格的控制器，用于处理与客户相关的业务操作，如查询、添加、修改、删除和加载下拉列表等
*/
@RestController
@RequestMapping("/customer")
@ -38,68 +39,85 @@ public class CustomerController {
/**
* 查询所有的客户
* @param customerVo
* @return
* @param customerVo 包含查询条件的客户值对象，如分页信息、客户名称、联系人、电话等
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllCustomer")
public DataGridView loadAllCustomer(CustomerVo customerVo){
//1.声明一个分页page对象
//1.声明一个分页page对象，根据传入的 customerVo 中的页码和每页记录数进行初始化
IPage<Customer> page = new Page<Customer>(customerVo.getPage(),customerVo.getLimit());
//2.声明一个queryWrapper
//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);
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和当前页的记录
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加一个客户
* @param customerVo
* @return
* @param customerVo 要添加的客户信息
* @return 操作结果对象，指示添加操作是否成功
*/
@RequestMapping("addCustomer")
public ResultObj addCustomer(CustomerVo customerVo){
try {
// 调用服务层的保存方法，将客户信息保存到数据库
customerService.save(customerVo);
// 如果保存成功，返回添加成功的结果对象
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
// 打印异常信息，方便调试
e.printStackTrace();
// 如果保存失败，返回添加失败的结果对象
return ResultObj.ADD_ERROR;
}
}
/**
* 修改一个客户
* @param customerVo
* @return
* @param customerVo 要修改的客户信息
* @return 操作结果对象，指示修改操作是否成功
*/
@RequestMapping("updateCustomer")
public ResultObj updateCustomer(CustomerVo customerVo){
try {
// 调用服务层的更新方法，根据客户 ID 更新客户信息
customerService.updateById(customerVo);
// 如果更新成功，返回更新成功的结果对象
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
// 打印异常信息，方便调试
e.printStackTrace();
// 如果更新失败，返回更新失败的结果对象
return ResultObj.UPDATE_ERROR;
}
}
/**
* 删除一个客户
* @param id 客户的ID
* @return
* @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){
try {
// 调用服务层的删除方法，根据客户 ID 删除客户
customerService.deleteCustomerById(id);
// 如果删除成功，返回删除成功的结果对象
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
// 打印异常信息，方便调试
e.printStackTrace();
// 如果删除失败，返回删除失败的结果对象
return ResultObj.DELETE_ERROR;
}
}
@ -107,13 +125,17 @@ public class CustomerController {
/**
* 加载所有客户的下拉列表
* @return
* @return DataGridView 包含符合条件的客户列表的数据视图对象
*/
@RequestMapping("loadAllCustomerForSelect")
public DataGridView loadAllCustomerForSelect(){
// 创建一个查询包装器，用于构建查询条件
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>();
// 查询条件为 available 字段等于可用状态常量
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 调用服务层的查询方法，获取满足条件的客户列表
List<Customer> list = customerService.list(queryWrapper);
// 将查询结果封装到 DataGridView 中并返回
return new DataGridView(list);
}

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

@ -22,7 +22,7 @@ import java.util.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-
@ -40,65 +40,81 @@ public class GoodsController {
/**
* 查询商品
* @param goodsVo
* @return
* @param goodsVo 包含查询条件和分页信息的商品值对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllGoods")
public DataGridView loadAllGoods(GoodsVo goodsVo){
// 创建分页对象，根据传入的页码和每页记录数初始化
IPage<Goods> page = new Page<Goods>(goodsVo.getPage(),goodsVo.getLimit());
// 创建查询包装器，用于构建查询条件
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
// 根据 providerid 进行精确查询，当 providerid 不为空且不为 0 时添加条件
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());
// 按照 id 降序排序
queryWrapper.orderByDesc("id");
// 调用服务层进行分页查询
goodsService.page(page,queryWrapper);
List<Goods> records = page.getRecords();
// 遍历查询结果，为每个商品设置供应商名称
for (Goods goods : records) {
Provider provider = providerService.getById(goods.getProviderid());
if (null!=provider){
goods.setProvidername(provider.getProvidername());
}
}
// 将查询结果封装到 DataGridView 中并返回
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加商品
* @param goodsVo
* @return
* @param goodsVo 包含要添加的商品信息的值对象
* @return ResultObj 操作结果对象，指示添加操作是否成功
*/
@RequestMapping("addGoods")
public ResultObj addGoods(GoodsVo goodsVo){
try {
System.out.println("====================================");
System.out.println(goodsVo.getGoodsimg());
// 当商品图片不为空且以 "_temp" 结尾时，重命名文件
if (goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().endsWith("_temp")){
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
goodsVo.setGoodsimg(newName);
}
// 调用服务层保存商品信息
goodsService.save(goodsVo);
// 保存成功，返回添加成功结果对象
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
// 打印异常信息
e.printStackTrace();
// 保存失败，返回添加失败结果对象
return ResultObj.ADD_ERROR;
}
}
/**
* 修改商品
* @param goodsVo
* @return
* @param goodsVo 包含要修改的商品信息的值对象
* @return ResultObj 操作结果对象，指示修改操作是否成功
*/
@RequestMapping("updateGoods")
public ResultObj updateGoods(GoodsVo goodsVo){
try {
//商品图片不是默认图片
if (!(goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))){
// 当商品图片以 "_temp" 结尾时，重命名文件
if (goodsVo.getGoodsimg().endsWith("_temp")){
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
goodsVo.setGoodsimg(newName);
@ -107,18 +123,23 @@ public class GoodsController {
AppFileUtils.removeFileByPath(oldPath);
}
}
// 调用服务层更新商品信息
goodsService.updateById(goodsVo);
// 更新成功，返回更新成功结果对象
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
// 打印异常信息
e.printStackTrace();
// 更新失败，返回更新失败结果对象
return ResultObj.UPDATE_ERROR;
}
}
/**
* 删除商品
* @param id 商品id
* @return
* @param id 商品 id
* @param goodsimg 商品图片路径
* @return ResultObj 操作结果对象，指示删除操作是否成功
*/
@RequestMapping("deleteGoods")
public ResultObj deleteGoods(Integer id,String goodsimg){
@ -126,55 +147,74 @@ public class GoodsController {
//删除商品的图片
AppFileUtils.removeFileByPath(goodsimg);
//goodsService.removeById(id);
// 调用服务层删除商品信息
goodsService.deleteGoodsById(id);
// 删除成功，返回删除成功结果对象
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
// 打印异常信息
e.printStackTrace();
// 删除失败，返回删除失败结果对象
return ResultObj.DELETE_ERROR;
}
}
/**
* 加载所有可用的商品
* @return
* @return DataGridView 包含可用商品列表的数据视图对象
*/
@RequestMapping("loadAllGoodsForSelect")
public DataGridView loadAllGoodsForSelect(){
// 创建查询包装器，用于构建查询条件
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
// 查询条件为 available 字段等于可用状态常量
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){
goods.setProvidername(provider.getProvidername());
}
}
// 将查询结果封装到 DataGridView 中并返回
return new DataGridView(list);
}
/**
* 根据供应商ID查询商品信息
* @param providerid 供应商ID
* @return
* @param providerid 供应商 ID
* @return DataGridView 包含符合条件的商品列表的数据视图对象
*/
@RequestMapping("loadGoodsByProviderId")
public DataGridView loadGoodsByProviderId(Integer providerid){
// 创建查询包装器，用于构建查询条件
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
// 查询条件为 available 字段等于可用状态常量，且 providerid 等于传入的供应商 ID
queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
queryWrapper.eq(providerid!=null,"providerid",providerid);
List<Goods> list = goodsService.list(queryWrapper);
// 遍历商品列表，为每个商品设置供应商名称
for (Goods goods : list) {
Provider provider = providerService.getById(goods.getProviderid());
if (null!=provider){
goods.setProvidername(provider.getProvidername());
}
}
// 将查询结果封装到 DataGridView 中并返回
return new DataGridView(list);
}
/**
* 加载所有预警商品
*
* @return DataGridView 包含预警商品列表的数据视图对象
*/
@RequestMapping("loadAllWarningGoods")
public DataGridView loadAllWarningGoods(){
// 调用服务层加载所有预警商品
List<Goods> goods = goodsService.loadAllWarning();
// 将结果封装到 DataGridView 中并返回，包含商品列表的大小和商品列表
return new DataGridView((long) goods.size(),goods);
}

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

@ -24,7 +24,7 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 前端控制器
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 前端进货控制器
* </p>
*
* @author luoyi-
@ -45,76 +45,92 @@ public class InportController {
/**
* 查询商品进货
* @param inportVo
* @return
* @param inportVo 包含查询条件和分页信息的进货信息对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllInport")
public DataGridView loadAllInport(InportVo inportVo){
// 创建一个分页对象，根据传入的分页信息（页码和每页记录数）初始化
IPage<Inport> page = new Page<Inport>(inportVo.getPage(),inportVo.getLimit());
// 创建一个查询包装器，用于构建查询条件
QueryWrapper<Inport> queryWrapper = new QueryWrapper<Inport>();
//对供应商进行查询
//对供应商进行查询，当 providerid 不为空且不为 0 时添加查询条件
queryWrapper.eq(inportVo.getProviderid()!=null&&inportVo.getProviderid()!=0,"providerid",inportVo.getProviderid());
//对商品进行查询
//对商品进行查询，当 goodsid 不为空且不为 0 时添加查询条件
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) {
// 根据供应商 ID 获取供应商信息
Provider provider = providerService.getById(inport.getProviderid());
if (provider!=null){
//设置供应商姓名
// 将供应商名称设置到 Inport 对象中
inport.setProvidername(provider.getProvidername());
}
// 根据商品 ID 获取商品信息
Goods goods = goodsService.getById(inport.getGoodsid());
if (goods!=null){
//设置商品名称
// 将商品名称设置到 Inport 对象中
inport.setGoodsname(goods.getGoodsname());
//设置商品规格
// 将商品规格设置到 Inport 对象中
inport.setSize(goods.getSize());
}
}
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和记录列表
return new DataGridView(page1.getTotal(),page1.getRecords());
}
/**
* 添加进货商品
* @param inportVo
* @return
* @param inportVo 包含要添加的进货商品信息的对象
* @return ResultObj 表示添加操作的结果对象
*/
@RequestMapping("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;
}
}
/**
* 更新进货商品
* @param inportVo
* @return
* @param inportVo 包含要更新的进货商品信息的对象
* @return ResultObj 表示更新操作的结果对象
*/
@RequestMapping("updateInport")
public ResultObj updateInport(InportVo inportVo){
try {
// 调用服务层更新进货信息
inportService.updateById(inportVo);
// 操作成功，返回更新成功的结果对象
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
// 打印异常信息，以便于调试
e.printStackTrace();
// 操作失败，返回更新失败的结果对象
return ResultObj.UPDATE_ERROR;
}
@ -122,16 +138,20 @@ public class InportController {
/**
* 删除进货商品
* @param id
* @return
* @param id 要删除的进货商品的 ID
* @return ResultObj 表示删除操作的结果对象
*/
@RequestMapping("deleteInport")
public ResultObj deleteInport(Integer id){
try {
// 调用服务层删除进货信息
inportService.removeById(id);
// 操作成功，返回删除成功的结果对象
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
// 打印异常信息，以便于调试
e.printStackTrace();
// 操作失败，返回删除失败的结果对象
return ResultObj.DELETE_ERROR;
}
}

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

@ -21,7 +21,7 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* InnoDB free: 9216 kB 前端出货控制器
* </p>
*
* @author luoyi-
@ -42,48 +42,59 @@ public class OutportController {
/**
* 添加退货信息
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
* @return
* @param id 进货单 ID
* @param number 退货数量
* @param remark 备注
* @return ResultObj 操作结果对象，表示添加退货信息操作是否成功
*/
@RequestMapping("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;
}
}
/**t
* 查询商品退货
* @param outportVo
* @return
* @param outportVo 包含查询条件和分页信息的退货信息值对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllOutport")
public DataGridView loadAllOuport(OutportVo outportVo){
// 创建分页对象，根据传入的分页信息（页码和每页记录数）初始化
IPage<Outport> page = new Page<Outport>(outportVo.getPage(),outportVo.getLimit());
// 创建查询包装器，用于构建查询条件
QueryWrapper<Outport> queryWrapper = new QueryWrapper<Outport>();
//对供应商进行查询
//对供应商进行查询，当 providerid 不为空且不为 0 时添加查询条件
queryWrapper.eq(outportVo.getProviderid()!=null&&outportVo.getProviderid()!=0,"providerid",outportVo.getProviderid());
//对商品进行查询
//对商品进行查询，当 goodsid 不为空且不为 0 时添加查询条件
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) {
// 根据供应商 ID 获取供应商信息
Provider provider = providerService.getById(ouport.getProviderid());
if (provider!=null){
//设置供应商姓名
ouport.setProvidername(provider.getProvidername());
}
// 根据商品 ID 获取商品信息
Goods goods = goodsService.getById(ouport.getGoodsid());
if (goods!=null){
//设置商品名称
@ -92,21 +103,26 @@ public class OutportController {
ouport.setSize(goods.getSize());
}
}
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和记录列表
return new DataGridView(page1.getTotal(),page1.getRecords());
}
/**
* 删除退货信息
* @param id
* @return
* @param id 要删除的退货信息的 ID
* @return ResultObj 操作结果对象，表示删除退货信息操作是否成功
*/
@RequestMapping("deleteOutport")
public ResultObj deleteOutport(Integer id){
try {
// 调用服务层的方法删除退货信息
outportService.removeById(id);
// 操作成功，返回删除成功的结果对象
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
// 打印异常信息，便于调试
e.printStackTrace();
// 操作失败，返回删除失败的结果对象
return ResultObj.DELETE_ERROR;
}
}

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

@ -19,7 +19,7 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* InnoDB free: 9216 kB 前端供应商控制器
* </p>
*
* @author luoyi-
@ -34,46 +34,56 @@ public class ProviderController {
/**
* 查询所有的供应商
* @param providerVo
* @return
* @param providerVo 包含查询条件和分页信息的供应商值对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllProvider")
public DataGridView loadAllProvider(ProviderVo providerVo){
//1.声明一个分页page对象
//1.声明一个分页page对象，根据 providerVo 中的分页信息（页码和每页记录数）进行初始化
IPage<Provider> page = new Page(providerVo.getPage(),providerVo.getLimit());
//2.声明一个queryWrapper
//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);
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和当前页的记录
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加一个供应商
* @param providerVo
* @return
* @param providerVo 包含要添加的供应商信息的值对象
* @return ResultObj 操作结果对象，表示添加操作是否成功
*/
@RequestMapping("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 ResultObj 操作结果对象，表示修改操作是否成功
*/
@RequestMapping("updateProvider")
public ResultObj updateProvider(ProviderVo providerVo){
try {
// 调用服务层更新供应商信息
providerService.updateById(providerVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
@ -85,12 +95,13 @@ public class ProviderController {
/**
* 删除一个供应商
* @param id
* @return
* @param id 要删除的供应商的 ID
* @return ResultObj 操作结果对象，表示删除操作是否成功
*/
@RequestMapping("deleteProvider")
public ResultObj deleteProvider(Integer id){
try {
// 调用服务层删除供应商信息
providerService.deleteProviderById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
@ -102,13 +113,17 @@ public class ProviderController {
/**
* 加载所有可用的供应商
* @return
* @return DataGridView 包含可用供应商列表的数据视图对象
*/
@RequestMapping("loadAllProviderForSelect")
public DataGridView loadAllProviderForSelect(){
// 创建查询包装器，用于构建查询条件
QueryWrapper<Provider> queryWrapper = new QueryWrapper<Provider>();
// 查询条件为 available 字段等于可用状态常量
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 调用服务层查询可用供应商列表
List<Provider> list = providerService.list(queryWrapper);
// 将查询结果封装到 DataGridView 中并返回
return new DataGridView(list);
}

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

@ -24,7 +24,7 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* InnoDB free: 9216 kB 前端销售控制器
* </p>
*
* @author luoyi-
@ -45,29 +45,34 @@ public class SalesController {
/**
* 查询所有商品销售信息
* @param salesVo
* @return
* @param salesVo 包含查询条件和分页信息的销售信息对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllSales")
public DataGridView loadAllSales(SalesVo salesVo){
// 创建分页对象，根据传入的分页信息（页码和每页记录数）初始化
IPage<Sales> page = new Page<>(salesVo.getPage(),salesVo.getLimit());
// 创建查询包装器，用于构建查询条件
QueryWrapper<Sales> queryWrapper = new QueryWrapper<Sales>();
//根据客户进行模糊查询
//根据客户进行模糊查询，当客户 ID 不为空且不为 0 时添加条件
queryWrapper.eq(salesVo.getCustomerid()!=null&&salesVo.getCustomerid()!=0,"customerid",salesVo.getCustomerid());
//根据商品模糊查询
//根据商品模糊查询，当商品 ID 不为空且不为 0 时添加条件
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());
// 调用服务层进行分页查询
IPage<Sales> page1 = salesService.page(page, queryWrapper);
List<Sales> records = page1.getRecords();
for (Sales sales : records) {
//设置客户姓名
// 根据客户 ID 获取客户信息
Customer customer = customerService.getById(sales.getCustomerid());
if(null!=customer){
// 设置客户姓名
sales.setCustomername(customer.getCustomername());
}
//设置商品名称
// 根据商品 ID 获取商品信息
Goods goods = goodsService.getById(sales.getGoodsid());
if (null!=goods){
//设置商品名称
@ -76,39 +81,45 @@ public class SalesController {
sales.setSize(goods.getSize());
}
}
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和记录列表
return new DataGridView(page1.getTotal(),page1.getRecords());
}
/**
* 添加商品销售信息
* @param salesVo
* @return
* @param salesVo 包含要添加的商品销售信息的对象
* @return ResultObj 表示添加操作的结果对象
*/
@RequestMapping("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) {
// 打印异常信息，便于调试
e.printStackTrace();
// 操作失败，返回添加失败的结果对象
return ResultObj.ADD_ERROR;
}
}
/**
* 更新商品销售信息
* @param salesVo
* @return
* @param salesVo 包含要更新的商品销售信息的对象
* @return ResultObj 表示更新操作的结果对象
*/
@RequestMapping("updateSales")
public ResultObj updateSales(SalesVo salesVo){
try {
// 调用服务层更新商品销售信息
salesService.updateById(salesVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
@ -119,12 +130,13 @@ public class SalesController {
/**
* 删除商品销售信息
* @param id
* @return
* @param id 要删除的商品销售信息的 ID
* @return ResultObj 表示删除操作的结果对象
*/
@RequestMapping("deleteSales")
public ResultObj deleteSales(Integer id){
try {
// 调用服务层删除商品销售信息
salesService.removeById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {

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

@ -21,7 +21,7 @@ import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* InnoDB free: 9216 kB 前端销售退货控制器
* </p>
*
* @author luoyi-
@ -42,49 +42,60 @@ public class SalesbackController {
/**
* 添加退货信息
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
* @return
* @param id 进货单 ID
* @param number 退货数量
* @param remark 备注
* @return ResultObj 操作结果对象，表示添加退货信息操作是否成功
*/
@RequestMapping("addSalesback")
public ResultObj addSalesback(Integer id,Integer number,String remark){
try {
// 调用服务层的方法添加退货信息
salesbackService.addSalesback(id,number,remark);
// 操作成功，返回退货成功的结果对象
return ResultObj.BACKINPORT_SUCCESS;
} catch (Exception e) {
// 打印异常信息，方便调试
e.printStackTrace();
// 操作失败，返回退货失败的结果对象
return ResultObj.BACKINPORT_ERROR;
}
}
/**
* 查询商品销售退货
* @param salesbackVo
* @return
* @param salesbackVo 包含查询条件和分页信息的销售退货信息值对象
* @return DataGridView 包含分页数据和总记录数的数据视图对象
*/
@RequestMapping("loadAllSalesback")
public DataGridView loadAllSalesback(SalesbackVo salesbackVo){
// 创建分页对象，根据传入的分页信息（页码和每页记录数）初始化
IPage<Salesback> page = new Page<Salesback>(salesbackVo.getPage(),salesbackVo.getLimit());
// 创建查询包装器，用于构建查询条件
QueryWrapper<Salesback> queryWrapper = new QueryWrapper<Salesback>();
//对客户进行查询
//对客户进行查询，当 customerid 不为空且不为 0 时添加查询条件
queryWrapper.eq(salesbackVo.getCustomerid()!=null&&salesbackVo.getCustomerid()!=0,"customerid",salesbackVo.getCustomerid());
//对商品进行查询
//对商品进行查询，当 goodsid 不为空且不为 0 时添加查询条件
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());
//通过商品退货时间对商品进行排序
// 按照商品退货时间降序排序
queryWrapper.orderByDesc("salesbacktime");
// 调用服务层进行分页查询
salesbackService.page(page, queryWrapper);
List<Salesback> records = page.getRecords();
// 遍历查询结果
for (Salesback salesback : records) {
System.out.println("============================");
// 根据客户 ID 获取客户信息
Customer customer = customerService.getById(salesback.getCustomerid());
if (customer!=null){
//设置客户姓名
salesback.setCustomername(customer.getCustomername());
}
// 根据商品 ID 获取商品信息
Goods goods = goodsService.getById(salesback.getGoodsid());
if (goods!=null){
//设置商品名称
@ -93,17 +104,19 @@ public class SalesbackController {
salesback.setSize(goods.getSize());
}
}
// 将查询结果封装到 DataGridView 中并返回，包含总记录数和记录列表
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 删除商品销售退回信息
* @param id
* @return
* @param id 要删除的商品销售退回信息的 ID
* @return ResultObj 操作结果对象，表示删除操作是否成功
*/
@RequestMapping("deleteSalesback")
public ResultObj deleteSalesback(Integer id){
try {
// 调用服务层的方法删除商品销售退回信息
salesbackService.removeById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {

14
src/main/java/com/yeqifu/bus/entity/Customer.java
Unescape View File

@ -14,7 +14,7 @@ import java.io.Serializable;
* <p>
* InnoDB free: 9216 kB
* </p>
*
*实体：客户
* @author luoyi-
* @since 2019-12-05
*/
@ -27,29 +27,41 @@ public class Customer implements Serializable {
private static final long serialVersionUID=1L;
// 客户的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 客户名称
private String customername;
// 邮政编码
private String zip;
// 地址
private String address;
// 电话号码
private String telephone;
// 联系人
private String connectionpersion;
// 手机号
private String phone;
// 银行信息
private String bank;
// 银行账户
private String account;
// 邮箱地址
private String email;
// 传真号码
private String fax;
// 表示客户是否可用
private Integer available;

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

@ -15,7 +15,7 @@ import java.io.Serializable;
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* </p>
*
*实体：商品
* @author luoyi-
* @since 2019-12-06
*/
@ -28,35 +28,52 @@ public class Goods implements Serializable {
private static final long serialVersionUID=1L;
// 商品的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 商品名称
private String goodsname;
// 商品的生产地
private String produceplace;
// 商品的尺寸
private String size;
// 商品的包装信息
private String goodspackage;
// 产品代码
private String productcode;
// 许可代码
private String promitcode;
// 商品的描述信息
private String description;
// 商品的价格
private Double price;
// 商品的数量
private Integer number;
// 商品的危险数量
private Integer dangernum;
// 商品的图片路径或名称
private String goodsimg;
// 商品的可用性状态
private Integer available;
// 商品所属的供应商的 ID
private Integer providerid;
/**
* 供应商名称
*/
@TableField(exist = false)
private String providername;

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

@ -15,7 +15,7 @@ import java.util.Date;
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo
* </p>
*
*实体：进货
* @author luoyi-
* @since 2019-12-18
*/
@ -27,23 +27,32 @@ public class Inport implements Serializable {
private static final long serialVersionUID=1L;
// 进货记录的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 付款类型
private String paytype;
// 进货时间
private Date inporttime;
// 操作人
private String operateperson;
// 进货数量
private Integer number;
// 备注信息
private String remark;
// 进货价格
private Double inportprice;
// 供应商的 ID
private Integer providerid;
// 商品的 ID
private Integer goodsid;
/**

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

@ -15,7 +15,7 @@ import java.util.Date;
* <p>
* InnoDB free: 9216 kB
* </p>
*
*实体：出货
* @author luoyi-
* @since 2019-12-19
*/
@ -27,23 +27,32 @@ public class Outport implements Serializable {
private static final long serialVersionUID=1L;
// 出货记录的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 供应商的 ID
private Integer providerid;
// 付款类型
private String paytype;
// 出货时间
private Date outputtime;
// 操作人
private String operateperson;
// 出货价格
private Double outportprice;
// 出货数量
private Integer number;
// 备注信息
private String remark;
// 商品的 ID
private Integer goodsid;
/**

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

@ -14,7 +14,7 @@ import java.io.Serializable;
* <p>
* InnoDB free: 9216 kB
* </p>
*
*实体：供应商
* @author luoyi-
* @since 2019-12-05
*/
@ -27,29 +27,41 @@ public class Provider implements Serializable {
private static final long serialVersionUID=1L;
// 供应商的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 供应商名称
private String providername;
// 邮政编码
private String zip;
// 地址
private String address;
// 电话号码
private String telephone;
// 联系人
private String connectionperson;
//手机号码
private String phone;
//银行名称
private String bank;
// 银行账户
private String account;
// 电子邮件地址
private String email;
// 传真号码
private String fax;
// 表示供应商是否可用
private Integer available;

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

@ -15,7 +15,7 @@ import java.util.Date;
* <p>
* InnoDB free: 9216 kB
* </p>
*
*实体：销售
* @author luoyi-
* @since 2019-12-21
*/
@ -27,23 +27,32 @@ public class Sales implements Serializable {
private static final long serialVersionUID=1L;
// 销售记录的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 客户的 ID
private Integer customerid;
// 付款类型
private String paytype;
// 销售时间
private Date salestime;
// 操作人
private String operateperson;
// 销售数量
private Integer number;
// 备注信息
private String remark;
// 销售价格
private Double saleprice;
// 商品的 ID
private Integer goodsid;
/**

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

@ -15,7 +15,7 @@ import java.util.Date;
* <p>
* InnoDB free: 9216 kB
* </p>
*
*实体：退货
* @author luoyi-
* @since 2019-12-23
*/
@ -27,23 +27,32 @@ public class Salesback implements Serializable {
private static final long serialVersionUID=1L;
// 退货记录的唯一标识符，使用数据库自增作为主键
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
// 客户的 ID
private Integer customerid;
// 付款类型
private String paytype;
// 退货时间
private Date salesbacktime;
// 退货价格
private Double salebackprice;
// 操作人
private String operateperson;
// 退货数量
private Integer number;
// 备注信息
private String remark;
// 商品的 ID
private Integer goodsid;
/**

1
src/main/java/com/yeqifu/bus/mapper/CustomerMapper.java
Unescape View File

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-05
*/
// 该接口继承自 MyBatis-Plus 的 BaseMapper 接口，用于对 Customer 实体类进行数据库操作
public interface CustomerMapper extends BaseMapper<Customer> {
}

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

@ -18,43 +18,43 @@ public interface GoodsMapper extends BaseMapper<Goods> {
/**
* 根据商品id删除商品销售信息
* @param id1
* @param id1 用于定位要删除销售信息的商品
*/
void deleteSaleByGoodsId(@Param("goodsid") Integer id1);
/**
* 根据商品id删除商品销售退货信息
* @param id1
* @param id1 用于定位要删除销售退货信息的商品
*/
void deleteSaleBackByGoodsId(@Param("goodsid") Integer id1);
/**
* 根据商品id删除商品进货信息
* @param id
* @param id 用于定位要删除进货信息的商品
*/
void deleteInportByGoodsId(@Param("goodsid") Integer id);
/**
* 根据商品id删除商品退货信息
* @param id
* @param id用于定位要删除退货信息的商品
*/
void deleteOutportByGoodsId(@Param("goodsid") Integer id);
/**
* 根据客户id删除商品销售
* @param id 客户id
* @param id 客户id，用于定位要删除其商品销售信息的客户
*/
void deleteSaleByCustomerId(Integer id);
/**
* 根据客户id删除商品销售退货信息
* @param id 客户id
* @param id 客户id，用于定位要删除其商品销售退货信息的客户
*/
void deleteSaleBackByCustomerId(Integer id);
/**
* 加载所有库存预警商品
* 加载所有库存预警商品信息的商品列表
*/
List<Goods> loadAllWarning();
}

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-18
*/
// 该接口继承自 MyBatis-Plus 的 BaseMapper 接口，用于对 Inport 实体类进行数据库操作
public interface InportMapper extends BaseMapper<Inport> {
}

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-19
*/
// 该接口继承自 MyBatis-Plus 的 BaseMapper 接口，用于对 Outport 实体类进行数据库操作
public interface OutportMapper extends BaseMapper<Outport> {
}

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

@ -16,19 +16,19 @@ public interface ProviderMapper extends BaseMapper<Provider> {
/**
* 根据供应商id删除商品信息
* @param id
* @param id供应商的唯一标识符，用于定位要删除其商品信息的供应商
*/
void deleteGoodsByProviderId(@Param("pid") Integer id);
/**
* 根据供应商id删除商品进货信息
* @param id
* @param id供应商的唯一标识符，用于定位要删除其商品进货信息的供应商
*/
void deleteInportByProviderId(@Param("pid") Integer id);
/**
* 根据供应商id删除商品退货信息
* @param id
* @param id供应商的唯一标识符，用于定位要删除其商品退货信息的供应商
*/
void deleteOutPortByProviderId(@Param("pid") Integer id);

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-21
*/
// 该接口继承自 MyBatis-Plus 的 BaseMapper 接口，用于对 Sales 实体类进行数据库操作
public interface SalesMapper extends BaseMapper<Sales> {
}

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-23
*/
// 该接口继承自 MyBatis-Plus 的 BaseMapper 接口，用于对 Salesback 实体类进行数据库操作
public interface SalesbackMapper extends BaseMapper<Salesback> {
}

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

@ -23,7 +23,7 @@ public interface IGoodsService extends IService<Goods> {
/**
* 加载所有的库存预警商品
* @return
* @return 包含所有库存预警商品的列表
*/
List<Goods> loadAllWarning();
}

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.extension.service.IService;
* @author luoyi-
* @since 2019-12-18
*/
// 该接口继承自 MyBatis-Plus 的 IService 接口，为 Inport 实体类提供服务接口
public interface IInportService extends IService<Inport> {
}

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

@ -15,7 +15,7 @@ public interface IProviderService extends IService<Provider> {
/**
* 根据供应商ID删除供应商
* @param id
* @param id 供应商的ID，用于定位要删除的供应商
*/
void deleteProviderById(Integer id);
}

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

@ -11,6 +11,7 @@ import com.baomidou.mybatisplus.extension.service.IService;
* @author luoyi-
* @since 2019-12-21
*/
// 此接口继承自 MyBatis-Plus 的 IService 接口，为 Sales 实体类提供服务接口
public interface ISalesService extends IService<Sales> {
}

6
src/main/java/com/yeqifu/bus/service/impl/CustomerServiceImpl.java
Unescape View File

@ -27,25 +27,31 @@ public class CustomerServiceImpl extends ServiceImpl<CustomerMapper, Customer> i
@Autowired
private GoodsMapper goodsMapper;
// 保存客户信息，调用父类的保存方法
@Override
public boolean save(Customer entity) {
return super.save(entity);
}
// 更新客户信息，调用父类的更新方法
@Override
public boolean updateById(Customer entity) {
return super.updateById(entity);
}
// 根据客户id删除客户信息，调用父类的删除方法
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
}
// 根据客户id获取客户信息，调用父类的获取方法
@Override
public Customer getById(Serializable id) {
return super.getById(id);
}
// 根据客户id集合删除多个客户信息，调用父类的批量删除方法
@Override
public boolean removeByIds(Collection<? extends Serializable> idList) {
return super.removeByIds(idList);

11
src/main/java/com/yeqifu/bus/service/impl/GoodsServiceImpl.java
Unescape View File

@ -22,26 +22,34 @@ import java.util.List;
@Transactional
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements IGoodsService {
// 保存商品信息，调用父类的保存方法
@Override
public boolean save(Goods entity) {
return super.save(entity);
}
// 更新商品信息，调用父类的更新方法
@Override
public boolean updateById(Goods entity) {
return super.updateById(entity);
}
// 根据商品id删除商品信息，调用父类的删除方法
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
}
// 根据商品id获取商品信息，调用父类的获取方法
@Override
public Goods getById(Serializable id) {
return super.getById(id);
}
/**
* 根据商品 ID 删除商品信息及相关关联信息
* @param id 商品的唯一标识符
*/
@Override
public void deleteGoodsById(Integer id) {
//根据商品id删除商品销售信息
@ -58,10 +66,11 @@ public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements
/**
* 查询所有库存预警商品
* @return
* @return 包含所有库存预警商品信息的商品列表
*/
@Override
public List<Goods> loadAllWarning() {
// 调用对应的 mapper 中的 loadAllWarning 方法获取库存预警商品列表
List<Goods> goods = baseMapper.loadAllWarning();
return goods;
}

18
src/main/java/com/yeqifu/bus/service/impl/InportServiceImpl.java
Unescape View File

@ -29,14 +29,16 @@ public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> impleme
/**
* 保存商品进货
* @param entity
* @return
* @param entity 要保存的进货信息
* @return 保存操作是否成功
*/
@Override
public boolean save(Inport entity) {
//根据商品ID查询商品
Goods goods = goodsMapper.selectById(entity.getGoodsid());
// 更新商品的数量，将进货数量累加到商品原有的数量上
goods.setNumber(goods.getNumber()+entity.getNumber());
//更新商品信息
goodsMapper.updateById(goods);
//保存进货信息
return super.save(entity);
@ -44,8 +46,8 @@ public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> impleme
/**
* 更新商品进货
* @param entity
* @return
* @param entity 要更新的进货信息
* @return 更新操作是否成功
*/
@Override
public boolean updateById(Inport entity) {
@ -55,6 +57,7 @@ public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> impleme
Goods goods = goodsMapper.selectById(entity.getGoodsid());
//库存算法 当前库存-进货单修改之前的数量+修改之后的数量
goods.setNumber(goods.getNumber()-inport.getNumber()+entity.getNumber());
// 更新商品信息
goodsMapper.updateById(goods);
//更新进货单
return super.updateById(entity);
@ -62,8 +65,8 @@ public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> impleme
/**
* 删除商品进货信息
* @param id
* @return
* @param id 要删除的进货信息的id
* @return 删除操作是否成功
*/
@Override
public boolean removeById(Serializable id) {
@ -73,8 +76,9 @@ public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> impleme
Goods goods = goodsMapper.selectById(inport.getGoodsid());
//库存算法 当前库存-进货单数量
goods.setNumber(goods.getNumber()-inport.getNumber());
//更新商品数量
goodsMapper.updateById(goods);
//更新商品的数量
//删除进货信息
return super.removeById(id);
}
}

11
src/main/java/com/yeqifu/bus/service/impl/OutportServiceImpl.java
Unescape View File

@ -33,9 +33,9 @@ public class OutportServiceImpl extends ServiceImpl<OutportMapper, Outport> impl
private GoodsMapper goodsMapper;
/**
* @param id 进货单ID
* @param number 退货数量
* @param remark 备注
* @param id 进货单 ID
* @param number 退货数量
* @param remark 备注
*/
@Override
public void addOutport(Integer id, Integer number, String remark) {
@ -46,8 +46,9 @@ public class OutportServiceImpl extends ServiceImpl<OutportMapper, Outport> impl
//3.修改商品的数量 商品的数量-退货的数量
goods.setNumber(goods.getNumber()-number);
//修改进货的数量
//修改进货的数量，将进货的数量减去退货的数量
inport.setNumber(inport.getNumber()-number);
// 更新进货单信息
inportMapper.updateById(inport);
//4.进行修改
@ -57,6 +58,7 @@ public class OutportServiceImpl extends ServiceImpl<OutportMapper, Outport> impl
Outport outport = new Outport();
outport.setGoodsid(inport.getGoodsid());
outport.setNumber(number);
// 从会话中获取用户信息
User user = (User) WebUtils.getSession().getAttribute("user");
outport.setOperateperson(user.getName());
@ -66,6 +68,7 @@ public class OutportServiceImpl extends ServiceImpl<OutportMapper, Outport> impl
outport.setOutputtime(new Date());
outport.setRemark(remark);
outport.setProviderid(inport.getProviderid());
// 将出货信息插入到数据库中
getBaseMapper().insert(outport);
}
}

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

@ -30,25 +30,31 @@ public class ProviderServiceImpl extends ServiceImpl<ProviderMapper, Provider> i
@Autowired
private GoodsMapper goodsMapper;
// 保存供应商信息，调用父类的保存方法
@Override
public boolean save(Provider entity) {
return super.save(entity);
}
// 更新供应商信息，调用父类的更新方法
@Override
public boolean updateById(Provider entity) {
return super.updateById(entity);
}
// 根据供应商id删除供应商信息，调用父类的删除方法
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
}
// 根据供应商id获取供应商信息，调用父类的获取方法
@Override
public Provider getById(Serializable id) {
return super.getById(id);
}
// 根据供应商id集合删除多个供应商信息，调用父类的批量删除方法
@Override
public boolean removeByIds(Collection<? extends Serializable> idList) {
return super.removeByIds(idList);
@ -56,14 +62,17 @@ public class ProviderServiceImpl extends ServiceImpl<ProviderMapper, Provider> i
/**
* 根据供应商id删除供应商
* @param id 供应商id
* @param id 供应商的唯一标识符
*/
@Override
public void deleteProviderById(Integer id) {
//根据供应商id查询出商品id
// 创建一个查询包装器，用于构建查询条件
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
// 添加查询条件，筛选出 providerid 等于指定供应商 id 的商品
queryWrapper.eq("providerid",id);
// 根据查询条件查询出与该供应商关联的商品列表
List<Goods> goods = goodsMapper.selectList(queryWrapper);
// 遍历查询到的商品列表
for (Goods good : goods) {
//获取一个商品id
Integer id1 = good.getId();

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

@ -27,49 +27,57 @@ public class SalesServiceImpl extends ServiceImpl<SalesMapper, Sales> implements
/**
* 添加商品销售
* @param entity 商品销售实体类
* @return
* @param entity 商品销售实体类
* @return 保存操作是否成功
*/
@Override
public boolean save(Sales entity) {
// 根据商品ID从 goodsMapper 中查询商品信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
// 减少商品的库存数量，库存数量减去销售数量
goods.setNumber(goods.getNumber()-entity.getNumber());
//更新商品的库存信息
goodsMapper.updateById(goods);
// 保存商品销售信息
return super.save(entity);
}
/**
* 更新商品销售
* @param entity 商品销售实体类
* @return
* @param entity 商品销售实体类
* @return 更新操作是否成功
*/
@Override
public boolean updateById(Sales entity) {
//根据销售单ID查询销售单信息
Sales sales = baseMapper.selectById(entity.getId());
// 根据商品ID从 goodsMapper 中查询商品信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
//仓库商品数量=原库存-销售单修改之前的数量+修改之后的数量
// 80 +40 - 50 30
goods.setNumber(goods.getNumber()+sales.getNumber()-entity.getNumber());
//更新商品
// 更新商品信息
goodsMapper.updateById(goods);
// 更新商品销售信息
return super.updateById(entity);
}
/**
* 删除商品销售信息
* @param id 商品销售单ID
* @return
* @return 删除操作是否成功
*/
@Override
public boolean removeById(Serializable id) {
//根据商品销售单ID查询出销售单数据
Sales sales = baseMapper.selectById(id);
// 根据商品ID从 goodsMapper 中查询商品信息
Goods goods = goodsMapper.selectById(sales.getGoodsid());
//仓库商品数量=原库存+删除商品销售单的数量
goods.setNumber(goods.getNumber()+sales.getNumber());
// 更新商品信息
goodsMapper.updateById(goods);
// 删除商品销售信息
return super.removeById(id);
}
}

29
src/main/java/com/yeqifu/bus/service/impl/SalesbackServiceImpl.java
Unescape View File

@ -33,9 +33,9 @@ public class SalesbackServiceImpl extends ServiceImpl<SalesbackMapper, Salesback
private GoodsMapper goodsMapper;
/**
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
* @param id 销售单的id
* @param number 退货的数量
* @param remark 退货的备注信息
*/
@Override
public void addSalesback(Integer id, Integer number, String remark) {
@ -43,35 +43,40 @@ public class SalesbackServiceImpl extends ServiceImpl<SalesbackMapper, Salesback
Sales sales = salesMapper.selectById(id);
//2.根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(sales.getGoodsid());
//3.修改商品的数量 商品的数量-退货的数量
//3.修改商品的数量 ，将商品的现有数量加上退货的数量
goods.setNumber(goods.getNumber()+number);
//修改进货的数量
// 修改销售单的数量，将销售单的数量减去退货的数量
sales.setNumber(sales.getNumber()-number);
// 更新销售单信息
salesMapper.updateById(sales);
//4.进行修改
// 4. 更新商品信息
goodsMapper.updateById(goods);
//5.添加退货单信息
Salesback salesback = new Salesback();
// 设置退货单的商品ID，从销售单中获取
salesback.setGoodsid(sales.getGoodsid());
// 设置退货数量
salesback.setNumber(number);
// 从会话中获取用户信息
User user = (User) WebUtils.getSession().getAttribute("user");
// 设置操作人，使用从会话中获取的用户名称
salesback.setOperateperson(user.getName());
// 设置退货价格，从销售单中获取
salesback.setSalebackprice(sales.getSaleprice());
// 设置付款类型，从销售单中获取
salesback.setPaytype(sales.getPaytype());
// 设置退货时间为当前时间
salesback.setSalesbacktime(new Date());
// 设置备注信息
salesback.setRemark(remark);
// 设置客户ID，从销售单中获取
salesback.setCustomerid(sales.getCustomerid());
// 将退货单信息插入到数据库中
getBaseMapper().insert(salesback);
}

5
src/main/java/com/yeqifu/bus/vo/CustomerVo.java
Unescape View File

@ -14,12 +14,17 @@ public class CustomerVo extends Customer{
/**
* 分页参数，当前是第一页，每页10条数据
* 用于表示当前页面的页码，默认为 1
*/
private Integer page=1;
/**
* 用于表示每页的数据条数，默认为 10
*/
private Integer limit=10;
/**
* 批量删除客户，存放客户ID的数组
* 当需要进行批量删除客户操作时，存储需要删除的客户的 ID 数组
*/
private Integer[] ids;

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

@ -11,8 +11,14 @@ import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode(callSuper = false)
public class GoodsVo extends Goods {
/**
* 分页参数，当前是第一页，每页显示 10 条数据
* 用于表示当前请求的页码，默认值为 1
*/
private Integer page=1;
/**
* 分页参数，用于指定每页的数据条数，默认值为 10
*/
private Integer limit=10;
}

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

@ -15,13 +15,29 @@ import java.util.Date;
@EqualsAndHashCode(callSuper = false)
public class InportVo extends Inport {
/**
* 分页参数，当前是第一页
* 用于表示分页查询时的当前页码，默认为 1
*/
private Integer page = 1;
/**
* 分页参数，每页显示 10 条数据
* 用于表示分页查询时每页的记录数量，默认为 10
*/
private Integer limit = 10;
/**
* 起始时间
* 用于表示时间范围查询的起始时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
/**
* 结束时间
* 用于表示时间范围查询的结束时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;

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

@ -15,13 +15,29 @@ import java.util.Date;
@EqualsAndHashCode(callSuper = false)
public class OutportVo extends Outport {
/**
* 分页参数，当前是第一页
* 用于表示分页查询时的当前页码，默认为 1
*/
private Integer page = 1;
/**
* 分页参数，每页显示 10 条数据
* 用于表示分页查询时每页的记录数量，默认为 10
*/
private Integer limit = 10;
/**
* 起始时间
* 用于表示时间范围查询的起始时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
/**
* 结束时间
* 用于表示时间范围查询的结束时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;

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

@ -14,9 +14,14 @@ import lombok.EqualsAndHashCode;
public class ProviderVo extends Provider{
/**
* 分页参数，当前是第一页，每页10条数据
* 分页参数，当前是第一页
* 用于表示分页查询时的当前页码，默认为 1
*/
private Integer page=1;
/**
* 分页参数，每页显示 10 条数据
* 用于表示分页查询时每页的记录数量，默认为 10
*/
private Integer limit=10;
/**

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

@ -15,13 +15,29 @@ import java.util.Date;
@EqualsAndHashCode(callSuper = false)
public class SalesVo extends Sales {
/**
* 分页参数，当前是第一页
* 用于表示分页查询时的当前页码，默认为 1
*/
private Integer page = 1;
/**
* 分页参数，每页显示 10 条数据
* 用于表示分页查询时每页的记录数量，默认为 10
*/
private Integer limit = 10;
/**
* 起始时间
* 用于表示时间范围查询的起始时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
/**
* 结束时间
* 用于表示时间范围查询的结束时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;

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

@ -15,13 +15,29 @@ import java.util.Date;
@EqualsAndHashCode(callSuper = false)
public class SalesbackVo extends Salesback {
/**
* 分页参数，当前是第一页
* 用于表示分页查询时的当前页码，默认为 1
*/
private Integer page = 1;
/**
* 分页参数，每页显示 10 条数据
* 用于表示分页查询时每页的记录数量，默认为 10
*/
private Integer limit = 10;
/**
* 起始时间
* 用于表示时间范围查询的起始时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
/**
* 结束时间
* 用于表示时间范围查询的结束时间，使用 @DateTimeFormat 注解指定日期格式为 "yyyy-MM-dd"
*/
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;

Write Preview
Loading…
Cancel
Save