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

合并 #5

Closed
pcjs8mx7g wants to merge 15 commits from liushenping_branch into master
Conversation 0 Commits 15 Files Changed 50
50 changed files with 1688 additions and 2144 deletions
Show Stats Download Patch File Download Diff File

39
src/main/java/com/yeqifu/WarehouseApplication.java
Unescape View File

@ -1,39 +1,44 @@
package com.yeqifu;
package com.yeqifu; // 定义该类所在的包路径
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.unit.DataSize;
import org.mybatis.spring.annotation.MapperScan; // 导入 MyBatis 的 @MapperScan 注解，用于扫描 Mapper 接口
import org.springframework.boot.SpringApplication; // 导入 Spring Boot 的 SpringApplication 类，用于启动 Spring Boot 应用
import org.springframework.boot.autoconfigure.SpringBootApplication; // 导入 Spring Boot 的 @SpringBootApplication 注解，表示该类是 Spring Boot 应用的入口
import org.springframework.boot.web.servlet.MultipartConfigFactory; // 导入 MultipartConfigFactory，用于配置文件上传的相关设置
import org.springframework.context.annotation.Bean; // 导入 Spring 的 @Bean 注解，用于注册 Bean 到 Spring 容器
import org.springframework.context.annotation.Configuration; // 导入 Spring 的 @Configuration 注解，用于标记该类为配置类
import org.springframework.util.unit.DataSize; // 导入 DataSize 类，用于处理文件大小的单位转换
import javax.servlet.MultipartConfigElement;
import javax.servlet.MultipartConfigElement; // 导入 MultipartConfigElement 类，用于配置文件上传的限制
/**
* @author luoyi-
*/
@Configuration
@SpringBootApplication
@MapperScan(basePackages = {"com.yeqifu.*.mapper"})
@Configuration // 标注该类是配置类
@SpringBootApplication // 标注该类为 Spring Boot 应用的启动类
@MapperScan(basePackages = {"com.yeqifu.*.mapper"}) // 扫描指定包路径下的 Mapper 接口
public class WarehouseApplication {
public static void main(String[] args) {
// 启动 Spring Boot 应用
SpringApplication.run(WarehouseApplication.class, args);
}
@Bean
public MultipartConfigElement multipartConfigElement() {
// 创建 MultipartConfigFactory 实例
MultipartConfigFactory factory = new MultipartConfigFactory();
/**
* 单个数据大小
* 设置单个上传文件的最大大小，单位为 KB
*/
factory.setMaxFileSize(DataSize.parse("102400KB"));
factory.setMaxFileSize(DataSize.parse("102400KB")); // 设置单个文件最大大小为 102400KB
/**
* 总上传数据大小6
* 设置请求中所有上传文件的总大小限制，单位为 KB
*/
factory.setMaxRequestSize(DataSize.parse("102400KB"));
factory.setMaxRequestSize(DataSize.parse("102400KB")); // 设置总上传大小为 102400KB
// 创建并返回 MultipartConfigElement 实例
return factory.createMultipartConfig();
}
}

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

@ -1,236 +1,184 @@
package com.yeqifu.bus.cache;
import com.yeqifu.bus.entity.Customer;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.sys.cache.CachePool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import com.yeqifu.bus.entity.Customer; // 导入客户实体类
import com.yeqifu.bus.entity.Goods; // 导入商品实体类
import com.yeqifu.sys.cache.CachePool; // 导入缓存池类
import org.apache.commons.logging.Log; // 导入日志接口
import org.apache.commons.logging.LogFactory; // 导入日志工厂类
import org.aspectj.lang.ProceedingJoinPoint; // 导入连接点类
import org.aspectj.lang.annotation.Around; // 导入环绕通知注解
import org.aspectj.lang.annotation.Aspect; // 导入切面注解
import org.springframework.beans.BeanUtils; // 导入属性拷贝工具类
import org.springframework.context.annotation.EnableAspectJAutoProxy; // 导入自动代理注解
import org.springframework.stereotype.Component; // 导入组件注解
import java.io.Serializable; // 导入序列化接口
import java.util.Collection; // 导入集合接口
import java.util.Map; // 导入Map接口
/**
* @Author: 落亦-
* @Date: 2019/12/5 16:39
* 业务缓存切面类
*/
@Aspect
@Component
@EnableAspectJAutoProxy
@Aspect // 声明这是一个切面类
@Component // 注册为Spring组件
@EnableAspectJAutoProxy // 开启AOP代理
public class BusinessCacheAspect {
/**
* 日志出处
* 日志对象
*/
private Log log = LogFactory.getLog(BusinessCacheAspect.class);
/**
* 声明一个缓存容器
*/
private Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
private Map<String, Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 声明客户的切面表达式
* 客户相关的切面表达式
*/
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(..))";
private static final String POINTCUT_CUSTOMER_GET="execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.getById(..))";
private static final String POINTCUT_CUSTOMER_DELETE="execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.removeById(..))";
private static final String POINTCUT_CUSTOMER_BATCHDELETE="execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.removeByIds(..))";
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(..))"; // 更新客户切点
private static final String POINTCUT_CUSTOMER_GET = "execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.getById(..))"; // 获取客户切点
private static final String POINTCUT_CUSTOMER_DELETE = "execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.removeById(..))"; // 删除客户切点
private static final String POINTCUT_CUSTOMER_BATCHDELETE = "execution(* com.yeqifu.bus.service.impl.CustomerServiceImpl.removeByIds(..))"; // 批量删除客户切点
private static final String CACHE_CUSTOMER_PROFIX="customer:";
private static final String CACHE_CUSTOMER_PROFIX = "customer:"; // 客户缓存前缀
/**
* 添加客户切入
* @param joinPoint
* @return
* 添加客户时的切入逻辑
* @param joinPoint 连接点
* @return 操作结果
*/
@Around(value = POINTCUT_CUSTOMER_ADD)
@Around(value = POINTCUT_CUSTOMER_ADD) // 环绕通知
public Object cacheCustomerAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Customer object = (Customer) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX + object.getId(),object);
Customer object = (Customer) joinPoint.getArgs()[0]; // 获取方法参数（客户对象）
Boolean res = (Boolean) joinPoint.proceed(); // 执行目标方法
if (res) {
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX + object.getId(), object); // 添加到缓存
}
return res;
return res; // 返回结果
}
/**
* 查询客户切入
* @param joinPoint
* @return
* 查询客户时的切入逻辑
* @param joinPoint 连接点
* @return 客户对象
*/
@Around(value = POINTCUT_CUSTOMER_GET)
public Object cacheCustomerGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
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);
return res2;
Integer object = (Integer) joinPoint.getArgs()[0]; // 获取方法参数（客户ID）
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); // 添加到缓存
return res2; // 返回查询结果
}
}
/**
* 更新客户切入
* @param joinPoint
* @return
* 更新客户时的切入逻辑
* @param joinPoint 连接点
* @return 操作结果
*/
@Around(value = POINTCUT_CUSTOMER_UPDATE)
public Object cacheCustomerUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
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();
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 (customer == null) {
customer = new Customer(); // 如果缓存中没有，则创建新对象
}
BeanUtils.copyProperties(customerVo,customer);
log.info("客户对象缓存已更新"+CACHE_CUSTOMER_PROFIX + customerVo.getId());
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX+customer.getId(),customer);
BeanUtils.copyProperties(customerVo, customer); // 属性拷贝
log.info("客户对象缓存已更新" + CACHE_CUSTOMER_PROFIX + customerVo.getId()); // 日志记录
CACHE_CONTAINER.put(CACHE_CUSTOMER_PROFIX + customer.getId(), customer); // 更新缓存
}
return isSuccess;
return isSuccess; // 返回结果
}
/**
* 删除客户切入
* @param joinPoint
* @return
* 删除客户时的切入逻辑
* @param joinPoint 连接点
* @return 操作结果
*/
@Around(value = POINTCUT_CUSTOMER_DELETE)
public Object cacheCustomerDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX+id);
Integer id = (Integer) joinPoint.getArgs()[0]; // 获取方法参数（客户ID）
Boolean isSuccess = (Boolean) joinPoint.proceed(); // 执行目标方法
if (isSuccess) {
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX + id); // 从缓存中删除
}
return isSuccess;
return isSuccess; // 返回结果
}
/**
* 批量删除客户切入
*
* @throws Throwable
* 批量删除客户时的切入逻辑
* @param joinPoint 连接点
* @return 操作结果
*/
@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();
Collection<Serializable> idList = (Collection<Serializable>) joinPoint.getArgs()[0]; // 获取方法参数（ID集合）
Boolean isSuccess = (Boolean) joinPoint.proceed(); // 执行目标方法
if (isSuccess) {
for (Serializable id : idList) {
// 删除缓存
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX + id);
log.info("客户对象缓存已删除" + CACHE_CUSTOMER_PROFIX + id);
CACHE_CONTAINER.remove(CACHE_CUSTOMER_PROFIX + id); // 从缓存中逐个删除
log.info("客户对象缓存已删除" + CACHE_CUSTOMER_PROFIX + id); // 日志记录
}
}
return isSuccess;
return isSuccess; // 返回结果
}
/**
* 声明商品的切面表达式
* 商品相关的切面表达式
*/
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(..))";
private static final String POINTCUT_GOODS_GET="execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.getById(..))";
private static final String POINTCUT_GOODS_DELETE="execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.removeById(..))";
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(..))"; // 更新商品切点
private static final String POINTCUT_GOODS_GET = "execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.getById(..))"; // 获取商品切点
private static final String POINTCUT_GOODS_DELETE = "execution(* com.yeqifu.bus.service.impl.GoodsServiceImpl.removeById(..))"; // 删除商品切点
private static final String CACHE_GOODS_PROFIX="goods:";
private static final String CACHE_GOODS_PROFIX = "goods:"; // 商品缓存前缀
/**
* 添加商品切入
* @param joinPoint
* @return
* 添加商品时的切入逻辑
* @param joinPoint 连接点
* @return 操作结果
*/
@Around(value = POINTCUT_GOODS_ADD)
public Object cacheGoodsAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Goods object = (Goods) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_GOODS_PROFIX + object.getId(),object);
Goods object = (Goods) joinPoint.getArgs()[0]; // 获取方法参数（商品对象）
Boolean res = (Boolean) joinPoint.proceed(); // 执行目标方法
if (res) {
CACHE_CONTAINER.put(CACHE_GOODS_PROFIX + object.getId(), object); // 添加到缓存
}
return res;
return res; // 返回结果
}
/**
* 查询商品切入
* @param joinPoint
* @return
* 查询商品时的切入逻辑
* @param joinPoint 连接点
* @return 商品对象
*/
@Around(value = POINTCUT_GOODS_GET)
public Object cacheGoodsGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
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);
return res2;
}
}
/**
* 更新商品切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_GOODS_UPDATE)
public Object cacheGoodsUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
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;
}
/**
* 删除商品切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_GOODS_DELETE)
public Object cacheGoodsDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_GOODS_PROFIX+id);
Integer object = (Integer) joinPoint.getArgs()[0]; // 获取方法参数（商品ID）
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); // 添加到缓存
return res2; // 返回查询结果
}
return isSuccess;
}
}

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

@ -1,78 +1,79 @@
package com.yeqifu.bus.controller;// 定义包名
package com.yeqifu.bus.controller; // 定义包名，表示该类属于com.yeqifu.bus.controller包
import org.springframework.stereotype.Controller; // 导入Spring的Controller注解
import org.springframework.web.bind.annotation.RequestMapping;// 导入Spring的RequestMapping注解
import org.springframework.stereotype.Controller; // 导入Spring框架中的Controller注解，用于定义控制器
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring框架中的RequestMapping注解，用于映射URL请求
/**
* 业务管理的路由器
* 业务管理的路由器控制器类
* 用于管理与业务相关的页面跳转
* @Author: 落亦-
* @Date: 2019/12/5 9:33
*/
@Controller// 标注为Spring的控制器组件
@RequestMapping("bus")// 定义类级别的请求路径前缀为"bus"
@Controller // 将该类标记为Spring的控制器组件，Spring会自动扫描并管理该类
@RequestMapping("bus") // 定义类级别的请求路径前缀为"bus"
public class BusinessController {
/**
* 跳转到客户管理页面
* @return
* 跳转到客户管理页面的方法
* @return 返回视图名称，跳转到客户管理页面
*/
@RequestMapping("toCustomerManager")// 定义方法的请求路径为"toCustomerManager"
public String toCustomerManager(){
return "business/customer/customerManager";
}// 返回视图名称，跳转到客户管理页面
@RequestMapping("toCustomerManager") // 映射请求路径为"bus/toCustomerManager"
public String toCustomerManager() {
return "business/customer/customerManager"; // 返回客户管理页面的视图名称
}
/**
* 跳转到供应商管理页面
* @return
* 跳转到供应商管理页面的方法
* @return 返回视图名称，跳转到供应商管理页面
*/
@RequestMapping("toProviderManager")// 定义方法的请求路径为"toProviderManager"
public String toProviderManager(){
return "business/provider/providerManager";
}// 返回视图名称，跳转到供应商管理页面
@RequestMapping("toProviderManager") // 映射请求路径为"bus/toProviderManager"
public String toProviderManager() {
return "business/provider/providerManager"; // 返回供应商管理页面的视图名称
}
/**
* 跳转到商品管理页面
* @return
* 跳转到商品管理页面的方法
* @return 返回视图名称，跳转到商品管理页面
*/
@RequestMapping("toGoodsManager")// 定义方法的请求路径为"toGoodsManager"
public String toGoodsManager(){
return "business/goods/goodsManager";
}// 返回视图名称，跳转到商品管理页面
@RequestMapping("toGoodsManager") // 映射请求路径为"bus/toGoodsManager"
public String toGoodsManager() {
return "business/goods/goodsManager"; // 返回商品管理页面的视图名称
}
/**
* 跳转到进货管理页面
* @return
* 跳转到进货管理页面的方法
* @return 返回视图名称，跳转到进货管理页面
*/
@RequestMapping("toInportManager")// 定义方法的请求路径为"toInportManager"
public String toInportManager(){
return "business/inport/inportManager";
}// 返回视图名称，跳转到进货管理页面
@RequestMapping("toInportManager") // 映射请求路径为"bus/toInportManager"
public String toInportManager() {
return "business/inport/inportManager"; // 返回进货管理页面的视图名称
}
/**
* 跳转到退货管理页面
* @return
* 跳转到退货管理页面的方法
* @return 返回视图名称，跳转到退货管理页面
*/
@RequestMapping("toOutportManager")// 定义方法的请求路径为"toOutportManager"
public String toOutportManager(){
return "business/outport/outportManager";
}// 返回视图名称，跳转到退货管理页面
@RequestMapping("toOutportManager") // 映射请求路径为"bus/toOutportManager"
public String toOutportManager() {
return "business/outport/outportManager"; // 返回退货管理页面的视图名称
}
/**
* 跳转到商品销售管理页面
* @return
* 跳转到商品销售管理页面的方法
* @return 返回视图名称，跳转到商品销售管理页面
*/
@RequestMapping("toSalesManager")// 定义方法的请求路径为"toSalesManager"
public String toSalesManager(){
return "business/sales/salesManager";
}// 返回视图名称，跳转到商品销售管理页面
@RequestMapping("toSalesManager") // 映射请求路径为"bus/toSalesManager"
public String toSalesManager() {
return "business/sales/salesManager"; // 返回商品销售管理页面的视图名称
}
/**
* 跳转到商品销售退货管理页面
* @return
* 跳转到商品销售退货管理页面的方法
* @return 返回视图名称，跳转到商品销售退货管理页面
*/
@RequestMapping("toSalesbackManager")// 定义方法的请求路径为"toSalesbackManager"
public String toSalesbackManager(){
return "business/salesback/salesbackManager";
}// 返回视图名称，跳转到商品销售退货管理页面
@RequestMapping("toSalesbackManager") // 映射请求路径为"bus/toSalesbackManager"
public String toSalesbackManager() {
return "business/salesback/salesbackManager"; // 返回商品销售退货管理页面的视图名称
}
}
}

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

@ -1,119 +1,129 @@
package com.yeqifu.bus.controller;
package com.yeqifu.bus.controller; // 定义包名，表示该类属于com.yeqifu.bus.controller包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入MyBatis-Plus的查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // 导入MyBatis-Plus的分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis-Plus的分页实现类
import com.yeqifu.bus.entity.Customer; // 导入Customer实体类
import com.yeqifu.bus.service.ICustomerService; // 导入Customer服务接口
import com.yeqifu.bus.vo.CustomerVo; // 导入CustomerVo类，用于封装请求参数
import com.yeqifu.sys.common.Constast; // 导入常量类
import com.yeqifu.sys.common.DataGridView; // 导入DataGridView类，用于封装数据表格响应
import com.yeqifu.sys.common.ResultObj; // 导入ResultObj类，用于封装操作结果
import io.swagger.annotations.ApiImplicitParam; // 导入Swagger的注解，用于描述API参数
import io.swagger.annotations.ApiImplicitParams; // 导入Swagger的注解，用于描述多个API参数
import io.swagger.annotations.ApiOperation; // 导入Swagger的注解，用于描述API操作
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang工具类，用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的@Autowired注解，用于自动注入依赖
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring的RequestMapping注解，用于映射请求路径
import org.springframework.web.bind.annotation.RequestMethod; // 导入Spring的RequestMethod枚举，用于指定HTTP方法
import org.springframework.web.bind.annotation.RestController; // 导入Spring的RestController注解，用于标记Restful控制器
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; // 导入Java的List接口
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* 客户管理的前端控制器
* 提供客户相关的增删改查和下拉列表功能
* @author luoyi-
* @since 2019-12-05
*/
@RestController
@RequestMapping("/customer")
@RestController // 标记为RestController，返回的数据将直接作为HTTP响应体
@RequestMapping("/customer") // 定义类级别的请求路径前缀为"/customer"
public class CustomerController {
@Autowired
@Autowired // 自动注入Customer服务接口的实现类
private ICustomerService customerService;
/**
* 查询所有的客户
* @param customerVo
* @return
* 查询所有的客户并返回分页数据
* @param customerVo 封装查询条件和分页参数
* @return DataGridView 包含总记录数和客户数据列表
*/
@RequestMapping("loadAllCustomer")
public DataGridView loadAllCustomer(CustomerVo customerVo){
//1.声明分页page对象
IPage<Customer> page = new Page<Customer>(customerVo.getPage(),customerVo.getLimit());
//2.声明queryWrapper
@RequestMapping("loadAllCustomer") // 映射请求路径为"customer/loadAllCustomer"
public DataGridView loadAllCustomer(CustomerVo customerVo) {
// 1. 创建分页对象，传入当前页码和每页显示条数
IPage<Customer> page = new Page<Customer>(customerVo.getPage(), customerVo.getLimit());
// 2. 创建查询条件构造器对象
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());
// 根据客户名称模糊查询（如果输入了客户名称）
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){
@RequestMapping("addCustomer") // 映射请求路径为"customer/addCustomer"
public ResultObj addCustomer(CustomerVo customerVo) {
try {
// 调用服务保存客户
customerService.save(customerVo);
return ResultObj.ADD_SUCCESS;
return ResultObj.ADD_SUCCESS; // 返回添加成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
e.printStackTrace(); // 打印异常信息
return ResultObj.ADD_ERROR; // 返回添加失败的结果
}
}
/**
* 修改一个客户
* @param customerVo
* @return
* @param customerVo 封装客户信息
* @return 操作结果对象
*/
@RequestMapping("updateCustomer")
public ResultObj updateCustomer(CustomerVo customerVo){
@RequestMapping("updateCustomer") // 映射请求路径为"customer/updateCustomer"
public ResultObj updateCustomer(CustomerVo customerVo) {
try {
// 调用服务更新客户信息
customerService.updateById(customerVo);
return ResultObj.UPDATE_SUCCESS;
return ResultObj.UPDATE_SUCCESS; // 返回更新成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
e.printStackTrace(); // 打印异常信息
return ResultObj.UPDATE_ERROR; // 返回更新失败的结果
}
}
/**
* 删除一个客户
* @param id 客户的ID
* @return
* @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 = "根据ID删除指定客户") // Swagger注解，描述API功能
@ApiImplicitParams({ // Swagger注解，描述API参数
@ApiImplicitParam(name = "id", value = "客户ID", required = true, paramType = "query", dataType = "Integer")
})
@RequestMapping(value = "deleteCustomer", method = RequestMethod.DELETE) // 映射请求路径为"customer/deleteCustomer"，指定HTTP方法为DELETE
public ResultObj deleteCustomer(Integer id) {
try {
// 调用服务根据ID删除客户
customerService.deleteCustomerById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
e.printStackTrace(); // 打印异常信息
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
}
}
/**
* 加载所有客户的下拉列表
* @return
* 加载所有客户的下拉列表数据
* @return DataGridView 包含所有可用客户的列表
*/
@RequestMapping("loadAllCustomerForSelect")
public DataGridView loadAllCustomerForSelect(){
@RequestMapping("loadAllCustomerForSelect") // 映射请求路径为"customer/loadAllCustomerForSelect"
public DataGridView loadAllCustomerForSelect() {
// 创建查询条件构造器
QueryWrapper<Customer> queryWrapper = new QueryWrapper<Customer>();
// 添加条件：客户状态为可用
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 查询所有满足条件的客户
List<Customer> list = customerService.list(queryWrapper);
// 返回DataGridView对象，包含客户列表
return new DataGridView(list);
}

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

@ -1,112 +1,115 @@
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; // MyBatis-Plus的查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus的分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus的分页实现类
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; // 商品的VO类，用于封装请求参数
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; // RESTful控制器注解
import java.util.List; // List集合类
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 前端控制器
* </p>
*
* 商品管理的前端控制器
* 提供商品的增删改查以及相关查询功能
* @author luoyi-
* @since 2019-12-06
*/
@RestController
@RequestMapping("/goods")
@RestController // 标记为RESTful控制器
@RequestMapping("/goods") // 定义请求路径前缀为"/goods"
public class GoodsController {
@Autowired
private IGoodsService goodsService;
private IGoodsService goodsService; // 自动注入商品服务
@Autowired
private IProviderService providerService;
private IProviderService providerService; // 自动注入供应商服务
/**
* 查询商品
* @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>();
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);
public DataGridView loadAllGoods(GoodsVo goodsVo) {
// 1. 创建分页对象
IPage<Goods> page = new Page<>(goodsVo.getPage(), goodsVo.getLimit());
// 2. 创建查询条件构造器
QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
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"); // 按照ID降序排列
// 3. 执行分页查询
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){
public ResultObj addGoods(GoodsVo goodsVo) {
try {
System.out.println("====================================");
System.out.println(goodsVo.getGoodsimg());
if (goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().endsWith("_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;
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 修改商品
* @param goodsVo
* @return
* 修改商品信息
* @param goodsVo 包含商品修改信息
* @return 操作结果
*/
@RequestMapping("updateGoods")
public ResultObj updateGoods(GoodsVo goodsVo){
public ResultObj updateGoods(GoodsVo goodsVo) {
try {
//商品图片不是默认图片
if (!(goodsVo.getGoodsimg()!=null&&goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))){
if (goodsVo.getGoodsimg().endsWith("_temp")){
// 如果商品图片不是默认图片
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) {
@ -117,15 +120,16 @@ public class GoodsController {
/**
* 删除商品
* @param id 商品id
* @return
* @param id 商品ID
* @param goodsimg 商品图片路径
* @return 操作结果
*/
@RequestMapping("deleteGoods")
public ResultObj deleteGoods(Integer id,String goodsimg){
public ResultObj deleteGoods(Integer id, String goodsimg) {
try {
//删除商品的图片
// 删除商品图片
AppFileUtils.removeFileByPath(goodsimg);
// goodsService.removeById(id);
// 删除商品记录
goodsService.deleteGoodsById(id);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
@ -135,17 +139,18 @@ public class GoodsController {
}
/**
* 加载所有可用的商品
* @return
* 加载所有可用商品
* @return 包含商品列表的DataGridView
*/
@RequestMapping("loadAllGoodsForSelect")
public DataGridView loadAllGoodsForSelect(){
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
public DataGridView loadAllGoodsForSelect() {
QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
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());
}
}
@ -154,31 +159,32 @@ public class GoodsController {
/**
* 根据供应商ID查询商品信息
* @param providerid 供应商ID
* @return
* @param providerid 供应商ID
* @return 包含商品列表的DataGridView
*/
@RequestMapping("loadGoodsByProviderId")
public DataGridView loadGoodsByProviderId(Integer providerid){
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq("available",Constast.AVAILABLE_TRUE);
queryWrapper.eq(providerid!=null,"providerid",providerid);
public DataGridView loadGoodsByProviderId(Integer providerid) {
QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
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){
if (provider != null) {
goods.setProvidername(provider.getProvidername());
}
}
return new DataGridView(list);
}
/**
* 加载所有库存预警的商品
* @return 包含预警商品列表的DataGridView
*/
@RequestMapping("loadAllWarningGoods")
public DataGridView loadAllWarningGoods(){
public DataGridView loadAllWarningGoods() {
List<Goods> goods = goodsService.loadAllWarning();
return new DataGridView((long) goods.size(),goods);
return new DataGridView((long) goods.size(), goods);
}
}

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

@ -1,141 +1,143 @@
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;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // MyBatis-Plus 查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus 分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus 分页实现类
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; // 商品进货 VO，用于封装请求参数
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; // RESTful 控制器注解
import java.util.Date; // 日期类
import java.util.List; // 集合类
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-18
* 商品进货管理的前端控制器
* 提供进货记录的增删改查等操作
*/
@RestController
@RequestMapping("inport")
@RequestMapping("inport") // 定义接口的基础路径
public class InportController {
@Autowired
private IInportService inportService;
private IInportService inportService; // 自动注入进货服务
@Autowired
private IProviderService providerService;
private IProviderService providerService; // 自动注入供应商服务
@Autowired
private IGoodsService goodsService;
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());
//通过进货时间对商品进行排序
public DataGridView loadAllInport(InportVo inportVo) {
// 1. 创建分页对象
IPage<Inport> page = new Page<>(inportVo.getPage(), inportVo.getLimit());
// 2. 创建查询条件
QueryWrapper<Inport> queryWrapper = new QueryWrapper<>();
// 按供应商ID查询
queryWrapper.eq(inportVo.getProviderid() != null && inportVo.getProviderid() != 0, "providerid", inportVo.getProviderid());
// 按商品ID查询
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();
// 3. 执行分页查询
IPage<Inport> resultPage = inportService.page(page, queryWrapper);
List<Inport> records = resultPage.getRecords();
// 4. 设置每条记录的供应商和商品信息
for (Inport inport : records) {
Provider provider = providerService.getById(inport.getProviderid());
if (provider!=null){
//设置供应商姓名
inport.setProvidername(provider.getProvidername());
if (provider != null) {
inport.setProvidername(provider.getProvidername()); // 设置供应商名称
}
Goods goods = goodsService.getById(inport.getGoodsid());
if (goods!=null){
//设置商品名称
inport.setGoodsname(goods.getGoodsname());
//设置商品规格
inport.setSize(goods.getSize());
if (goods != null) {
inport.setGoodsname(goods.getGoodsname()); // 设置商品名称
inport.setSize(goods.getSize()); // 设置商品规格
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
}
// 返回分页数据
return new DataGridView(resultPage.getTotal(), resultPage.getRecords());
}
/**
* 添加进货商品
* @param inportVo
* @return
* 添加进货记录
* @param inportVo 包含进货信息
* @return 操作结果
*/
@RequestMapping("addInport")
public ResultObj addInport(InportVo inportVo){
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;
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 更新进货商品
* @param inportVo
* @return
* 更新进货记录
* @param inportVo 包含修改后的进货信息
* @return 操作结果
*/
@RequestMapping("updateInport")
public ResultObj updateInport(InportVo inportVo){
public ResultObj updateInport(InportVo inportVo) {
try {
// 更新进货记录
inportService.updateById(inportVo);
return ResultObj.UPDATE_SUCCESS;
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 删除进货商品
* @param id
* @return
* 删除进货记录
* @param id 要删除的进货记录ID
* @return 操作结果
*/
@RequestMapping("deleteInport")
public ResultObj deleteInport(Integer id){
public ResultObj deleteInport(Integer id) {
try {
// 根据ID删除进货记录
inportService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

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

@ -1,116 +1,118 @@
package com.yeqifu.bus.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // MyBatis-Plus 查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus 分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus 分页实现类
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; // 商品退货 VO，用于封装请求参数
import com.yeqifu.sys.common.DataGridView; // 封装表格数据
import com.yeqifu.sys.common.ResultObj; // 封装操作结果
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解
import org.springframework.web.bind.annotation.RestController; // RESTful 控制器注解
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;
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; // 集合类
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-19
* 商品退货管理的前端控制器
* 提供退货记录的增删查功能
*/
@RestController
@RequestMapping("/outport")
@RequestMapping("/outport") // 定义接口基础路径
public class OutportController {
@Autowired
private IOutportService outportService;
private IOutportService outportService; // 自动注入退货服务
@Autowired
private IProviderService providerService;
private IProviderService providerService; // 自动注入供应商服务
@Autowired
private IGoodsService goodsService;
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){
public ResultObj addOutport(Integer id, Integer number, String remark) {
try {
outportService.addOutport(id,number,remark);
return ResultObj.BACKINPORT_SUCCESS;
// 调用服务层添加退货记录的逻辑
outportService.addOutport(id, number, remark);
return ResultObj.BACKINPORT_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.BACKINPORT_ERROR;
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());
//通过进货时间对商品进行排序
public DataGridView loadAllOuport(OutportVo outportVo) {
// 1. 创建分页对象
IPage<Outport> page = new Page<>(outportVo.getPage(), outportVo.getLimit());
// 2. 创建查询条件
QueryWrapper<Outport> queryWrapper = new QueryWrapper<>();
// 按供应商ID查询
queryWrapper.eq(outportVo.getProviderid() != null && outportVo.getProviderid() != 0, "providerid", outportVo.getProviderid());
// 按商品ID查询
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());
// 3. 执行分页查询
IPage<Outport> resultPage = outportService.page(page, queryWrapper);
List<Outport> records = resultPage.getRecords();
// 4. 设置每条记录的供应商和商品信息
for (Outport outport : records) {
Provider provider = providerService.getById(outport.getProviderid());
if (provider != null) {
outport.setProvidername(provider.getProvidername()); // 设置供应商名称
}
Goods goods = goodsService.getById(ouport.getGoodsid());
if (goods!=null){
//设置商品名称
ouport.setGoodsname(goods.getGoodsname());
//设置商品规格
ouport.setSize(goods.getSize());
Goods goods = goodsService.getById(outport.getGoodsid());
if (goods != null) {
outport.setGoodsname(goods.getGoodsname()); // 设置商品名称
outport.setSize(goods.getSize()); // 设置商品规格
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
// 返回分页数据
return new DataGridView(resultPage.getTotal(), resultPage.getRecords());
}
/**
* 删除退货信息
* @param id
* @return
* 删除退货记录
* @param id 要删除的退货记录ID
* @return 操作结果
*/
@RequestMapping("deleteOutport")
public ResultObj deleteOutport(Integer id){
public ResultObj deleteOutport(Integer id) {
try {
// 根据ID删除退货记录
outportService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

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

@ -1,117 +1,122 @@
package com.yeqifu.bus.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // MyBatis-Plus 查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus 分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus 分页实现类
import com.yeqifu.bus.entity.Provider; // 供应商实体类
import com.yeqifu.bus.service.IProviderService; // 供应商服务接口
import com.yeqifu.bus.vo.ProviderVo; // 供应商 VO，用于封装请求参数
import com.yeqifu.sys.common.Constast; // 常量类
import com.yeqifu.sys.common.DataGridView; // 封装表格数据
import com.yeqifu.sys.common.ResultObj; // 封装操作结果
import org.apache.commons.lang3.StringUtils; // Apache工具类，用于字符串操作
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解
import org.springframework.web.bind.annotation.RestController; // RESTful 控制器注解
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.Provider;
import com.yeqifu.bus.service.IProviderService;
import com.yeqifu.bus.vo.ProviderVo;
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 java.util.List; // 集合类
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-05
* 供应商管理前端控制器
* 提供供应商的增删改查功能
*/
@RestController
@RequestMapping("/provider")
@RequestMapping("/provider") // 定义接口基础路径
public class ProviderController {
@Autowired
private IProviderService providerService;
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());
public DataGridView loadAllProvider(ProviderVo providerVo) {
// 1. 声明分页对象
IPage<Provider> page = new Page<>(providerVo.getPage(), providerVo.getLimit());
// 2. 声明查询条件
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());
// 3. 执行查询
providerService.page(page, queryWrapper);
// 4. 返回结果
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加一个供应商
* @param providerVo
* @return
* 添加供应商
* @param providerVo 封装供应商数据
* @return 操作结果
*/
@RequestMapping("addProvider")
public ResultObj addProvider(ProviderVo providerVo){
public ResultObj addProvider(ProviderVo providerVo) {
try {
providerService.save(providerVo);
return ResultObj.ADD_SUCCESS;
providerService.save(providerVo); // 保存供应商信息
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 修改一个供应商
* @param providerVo
* @return
* 修改供应商信息
* @param providerVo 封装供应商数据
* @return 操作结果
*/
@RequestMapping("updateProvider")
public ResultObj updateProvider(ProviderVo providerVo){
public ResultObj updateProvider(ProviderVo providerVo) {
try {
providerService.updateById(providerVo);
return ResultObj.UPDATE_SUCCESS;
providerService.updateById(providerVo); // 更新供应商信息
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 删除一个供应商
* @param id
* @return
* 删除供应商
* @param id 供应商ID
* @return 操作结果
*/
@RequestMapping("deleteProvider")
public ResultObj deleteProvider(Integer id){
public ResultObj deleteProvider(Integer id) {
try {
providerService.deleteProviderById(id);
return ResultObj.DELETE_SUCCESS;
providerService.deleteProviderById(id); // 调用服务层删除方法
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
/**
* 加载所有可用的供应商
* @return
* 查询所有可用的供应商
* 用于下拉框选择等场景
* @return 可用供应商列表
*/
@RequestMapping("loadAllProviderForSelect")
public DataGridView loadAllProviderForSelect(){
QueryWrapper<Provider> queryWrapper = new QueryWrapper<Provider>();
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
public DataGridView loadAllProviderForSelect() {
// 1. 声明查询条件
QueryWrapper<Provider> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("available", Constast.AVAILABLE_TRUE); // 查询状态为“可用”的供应商
// 2. 获取可用供应商列表
List<Provider> list = providerService.list(queryWrapper);
// 3. 返回结果
return new DataGridView(list);
}
}

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

@ -1,137 +1,138 @@
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.entity.Goods;
import com.yeqifu.bus.entity.Sales;
import com.yeqifu.bus.service.ICustomerService;
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.ISalesService;
import com.yeqifu.bus.vo.SalesVo;
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 com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // MyBatis-Plus 查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus 分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus 分页实现类
import com.yeqifu.bus.entity.Customer; // 客户实体类
import com.yeqifu.bus.entity.Goods; // 商品实体类
import com.yeqifu.bus.entity.Sales; // 销售实体类
import com.yeqifu.bus.service.ICustomerService; // 客户服务接口
import com.yeqifu.bus.service.IGoodsService; // 商品服务接口
import com.yeqifu.bus.service.ISalesService; // 销售服务接口
import com.yeqifu.bus.vo.SalesVo; // 销售请求参数封装类
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; // RESTful 控制器注解
import java.util.Date;
import java.util.List;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-21
* 销售管理前端控制器
* 提供商品销售的增删改查功能
*/
@RestController
@RequestMapping("/sales")
@RequestMapping("/sales") // 定义接口基础路径
public class SalesController {
@Autowired
private ISalesService salesService;
private ISalesService salesService; // 自动注入销售服务
@Autowired
private ICustomerService customerService;
private ICustomerService customerService; // 自动注入客户服务
@Autowired
private IGoodsService goodsService;
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());
public DataGridView loadAllSales(SalesVo salesVo) {
// 1. 声明分页对象
IPage<Sales> page = new Page<>(salesVo.getPage(), salesVo.getLimit());
// 2. 创建查询条件构造器
QueryWrapper<Sales> queryWrapper = new QueryWrapper<>();
// 3. 根据客户ID进行查询
queryWrapper.eq(salesVo.getCustomerid() != null && salesVo.getCustomerid() != 0, "customerid", salesVo.getCustomerid());
// 4. 根据商品ID进行查询
queryWrapper.eq(salesVo.getGoodsid() != null && salesVo.getGoodsid() != 0, "goodsid", salesVo.getGoodsid());
// 5. 根据销售时间进行查询
queryWrapper.ge(salesVo.getStartTime() != null, "salestime", salesVo.getStartTime());
queryWrapper.le(salesVo.getEndTime() != null, "salestime", salesVo.getEndTime());
// 6. 执行分页查询
IPage<Sales> page1 = salesService.page(page, queryWrapper);
List<Sales> records = page1.getRecords();
// 7. 填充客户信息和商品信息
for (Sales sales : records) {
//设置客户姓名
// 设置客户姓名
Customer customer = customerService.getById(sales.getCustomerid());
if(null!=customer){
if (customer != null) {
sales.setCustomername(customer.getCustomername());
}
//设置商品名称
// 设置商品信息
Goods goods = goodsService.getById(sales.getGoodsid());
if (null!=goods){
//设置商品名称
if (goods != null) {
sales.setGoodsname(goods.getGoodsname());
//设置商品规格
sales.setSize(goods.getSize());
}
}
return new DataGridView(page1.getTotal(),page1.getRecords());
// 8. 返回分页结果
return new DataGridView(page1.getTotal(), page1.getRecords());
}
/**
* 添加商品销售信息
* @param salesVo
* @return
* @param salesVo 销售请求参数
* @return 操作结果
*/
@RequestMapping("addSales")
public ResultObj addSales(SalesVo salesVo){
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) {
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 更新商品销售信息
* @param salesVo
* @return
* @param salesVo 销售请求参数
* @return 操作结果
*/
@RequestMapping("updateSales")
public ResultObj updateSales(SalesVo salesVo){
public ResultObj updateSales(SalesVo salesVo) {
try {
// 更新销售信息
salesService.updateById(salesVo);
return ResultObj.UPDATE_SUCCESS;
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 删除商品销售信息
* @param id
* @return
* @param id 销售记录ID
* @return 操作结果
*/
@RequestMapping("deleteSales")
public ResultObj deleteSales(Integer id){
public ResultObj deleteSales(Integer id) {
try {
// 删除销售记录
salesService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

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

@ -1,116 +1,123 @@
package com.yeqifu.bus.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // MyBatis-Plus 查询条件构造器
import com.baomidou.mybatisplus.core.metadata.IPage; // MyBatis-Plus 分页接口
import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // MyBatis-Plus 分页实现类
import com.yeqifu.bus.entity.Customer; // 客户实体类
import com.yeqifu.bus.entity.Goods; // 商品实体类
import com.yeqifu.bus.entity.Salesback; // 销售退货实体类
import com.yeqifu.bus.service.ICustomerService; // 客户服务接口
import com.yeqifu.bus.service.IGoodsService; // 商品服务接口
import com.yeqifu.bus.service.ISalesbackService; // 销售退货服务接口
import com.yeqifu.bus.vo.SalesbackVo; // 销售退货请求参数封装类
import com.yeqifu.sys.common.DataGridView; // 封装表格数据类
import com.yeqifu.sys.common.ResultObj; // 操作结果封装类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解
import org.springframework.web.bind.annotation.RestController; // RESTful 控制器注解
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.entity.Goods;
import com.yeqifu.bus.entity.Salesback;
import com.yeqifu.bus.service.ICustomerService;
import com.yeqifu.bus.service.IGoodsService;
import com.yeqifu.bus.service.ISalesbackService;
import com.yeqifu.bus.vo.SalesbackVo;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
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; // 集合类
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-12-23
* 销售退货管理前端控制器
* 提供销售退货的增删改查功能
*/
@RestController
@RequestMapping("/salesback")
@RequestMapping("/salesback") // 定义接口基础路径
public class SalesbackController {
@Autowired
private ISalesbackService salesbackService;
private ISalesbackService salesbackService; // 自动注入销售退货服务
@Autowired
private ICustomerService customerService;
private ICustomerService customerService; // 自动注入客户服务
@Autowired
private IGoodsService goodsService;
private IGoodsService goodsService; // 自动注入商品服务
/**
* 添加退货信息
* @param id 进货单ID
* 添加销售退货信息
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
* @return
* @return 操作结果
*/
@RequestMapping("addSalesback")
public ResultObj addSalesback(Integer id,Integer number,String remark){
public ResultObj addSalesback(Integer id, Integer number, String remark) {
try {
salesbackService.addSalesback(id,number,remark);
return ResultObj.BACKINPORT_SUCCESS;
// 调用销售退货服务，处理退货
salesbackService.addSalesback(id, number, remark);
return ResultObj.BACKINPORT_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.BACKINPORT_ERROR;
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());
//通过商品退货时间对商品进行排序
public DataGridView loadAllSalesback(SalesbackVo salesbackVo) {
// 1. 声明分页对象
IPage<Salesback> page = new Page<>(salesbackVo.getPage(), salesbackVo.getLimit());
// 2. 创建查询条件构造器
QueryWrapper<Salesback> queryWrapper = new QueryWrapper<>();
// 3. 根据客户ID进行查询
queryWrapper.eq(salesbackVo.getCustomerid() != null && salesbackVo.getCustomerid() != 0, "customerid", salesbackVo.getCustomerid());
// 4. 根据商品ID进行查询
queryWrapper.eq(salesbackVo.getGoodsid() != null && salesbackVo.getGoodsid() != 0, "goodsid", salesbackVo.getGoodsid());
// 5. 根据时间范围进行查询
queryWrapper.ge(salesbackVo.getStartTime() != null, "salesbacktime", salesbackVo.getStartTime());
queryWrapper.le(salesbackVo.getEndTime() != null, "salesbacktime", salesbackVo.getEndTime());
// 6. 根据销售退货时间降序排序
queryWrapper.orderByDesc("salesbacktime");
// 7. 执行分页查询
salesbackService.page(page, queryWrapper);
// 8. 获取查询结果
List<Salesback> records = page.getRecords();
// 9. 填充客户和商品信息
for (Salesback salesback : records) {
System.out.println("============================");
// 查询客户信息
Customer customer = customerService.getById(salesback.getCustomerid());
if (customer!=null){
//设置客户姓名
if (customer != null) {
// 设置客户姓名
salesback.setCustomername(customer.getCustomername());
}
// 查询商品信息
Goods goods = goodsService.getById(salesback.getGoodsid());
if (goods!=null){
//设置商品名称
if (goods != null) {
// 设置商品名称和规格
salesback.setGoodsname(goods.getGoodsname());
//设置商品规格
salesback.setSize(goods.getSize());
}
}
return new DataGridView(page.getTotal(),page.getRecords());
// 10. 返回分页结果
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 删除商品销售退回信息
* @param id
* @return
* 删除商品销售退货信息
* @param id 销售退货ID
* @return 操作结果
*/
@RequestMapping("deleteSalesback")
public ResultObj deleteSalesback(Integer id){
public ResultObj deleteSalesback(Integer id) {
try {
// 调用销售退货服务，删除记录
salesbackService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

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

@ -1,56 +1,52 @@
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 注解，用于生成 getters、setters、toString 等
import lombok.EqualsAndHashCode; // Lombok 注解，用于生成 equals 和 hashCode 方法
import lombok.ToString; // Lombok 注解，用于生成 toString 方法
import lombok.experimental.Accessors; // Lombok 注解，支持链式调用
import java.io.Serializable;
import java.io.Serializable; // Serializable 接口，用于对象序列化
/**
* 客户实体类
* <p>
* InnoDB free: 9216 kB
* 该类对应数据库中的 `bus_customer` 表，包含客户的各种信息字段
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_customer")
@ToString
@Data // Lombok 自动生成 getter、setter、toString、equals 和 hashCode 等方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，但不调用父类的属性
@Accessors(chain = true) // 支持链式调用，例如 customer.setName("张三").setEmail("zhangsan@example.com")
@TableName("bus_customer") // 将该类映射到数据库中的 bus_customer 表
@ToString // 生成 toString 方法，便于打印输出对象信息
public class Customer implements 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) // 将 id 字段设置为主键，主键类型为自增
private Integer id; // 客户ID
private String customername;
private String customername; // 客户名称
private String zip;
private String zip; // 邮政编码
private String address;
private String address; // 客户地址
private String telephone;
private String telephone; // 客户的固定电话
private String connectionpersion;
private String connectionpersion; // 联系人姓名
private String phone;
private String phone; // 联系人手机号码
private String bank;
private String bank; // 客户开户行
private String account;
private String account; // 客户银行账户
private String email;
private String fax;
private Integer available;
private String email; // 客户邮箱
private String fax; // 客户传真号码
private Integer available; // 客户状态（是否可用，0表示禁用，1表示启用）
}

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

@ -1,64 +1,60 @@
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、toString 等方法
import lombok.EqualsAndHashCode; // Lombok 注解，用于生成 equals 和 hashCode 方法
import lombok.ToString; // Lombok 注解，用于生成 toString 方法
import lombok.experimental.Accessors; // Lombok 注解，支持链式调用
import java.io.Serializable;
import java.io.Serializable; // Serializable 接口，用于对象序列化
/**
* 商品实体类
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`)
* 该类对应数据库中的 `bus_goods` 表，包含商品的各种信息字段
* </p>
*
* @author luoyi-
* @since 2019-12-06
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_goods")
@ToString
@Data // Lombok 自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，但不调用父类属性
@Accessors(chain = true) // 支持链式调用，例如 goods.setGoodsname("商品A").setPrice(200.0)
@TableName("bus_goods") // 将该类映射到数据库中的 bus_goods 表
@ToString // 生成 toString 方法，便于打印输出对象信息
public class Goods implements Serializable {
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化ID，确保类在反序列化时版本一致
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // 将 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; // 商品图片的URL地址
private Integer available;
private Integer providerid;
@TableField(exist = false)
private String providername;
private Integer available; // 商品是否可用（0 表示不可用，1 表示可用）
private Integer providerid; // 供应商ID，外键关联供应商表 bus_provider
@TableField(exist = false) // 该字段不是数据库表中的字段，仅用于数据传输或展示
private String providername; // 供应商名称（非数据库字段，用于前端显示供应商信息）
}

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

@ -1,67 +1,65 @@
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、toString 等方法
import lombok.EqualsAndHashCode; // Lombok 注解，用于生成 equals 和 hashCode 方法
import lombok.experimental.Accessors; // Lombok 注解，支持链式调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // Serializable 接口，用于对象序列化
import java.util.Date; // Java 日期类，用于记录时间
/**
* 商品入库实体类
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo
* 该类对应数据库中的 `bus_inport` 表，包含商品入库的各种信息字段
* </p>
*
* @author luoyi-
* @since 2019-12-18
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_inport")
@Data // Lombok 自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，但不使用父类的属性
@Accessors(chain = true) // 支持链式调用，例如 inport.setPaytype("现金").setNumber(100)
@TableName("bus_inport") // 将该类映射到数据库中的 bus_inport 表
public class Inport implements Serializable {
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 序列化ID，确保反序列化时版本一致
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // 定义 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，外键关联 `bus_provider` 表
private Integer goodsid;
private Integer goodsid; // 商品ID，外键关联 `bus_goods` 表
/**
* 供应商姓名
* 供应商名称，非数据库字段
*/
@TableField(exist = false)
private String providername;
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String providername; // 供应商名称，用于在前端页面显示供应商信息
/**
* 商品名称
* 商品名称，非数据库字段
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String goodsname; // 商品名称，用于在前端页面显示商品信息
/**
* 商品规格
* 商品规格，非数据库字段
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String size; // 商品规格，例如：大、中、小，用于显示
}

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

@ -1,67 +1,63 @@
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; // 定义主键生成策略的注解
import com.baomidou.mybatisplus.annotation.TableField; // 标识当前属性不对应数据库字段
import com.baomidou.mybatisplus.annotation.TableId; // 声明主键字段的注解
import com.baomidou.mybatisplus.annotation.TableName; // 用于指定数据库表名的注解
import lombok.Data; // 自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 用于实现对象的 equals 和 hashCode 方法
import lombok.experimental.Accessors; // 支持链式调用的注解
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口，使对象可持久化
import java.util.Date; // Java 日期类，用于时间字段
/**
* <p>
* InnoDB free: 9216 kB
* </p>
* 商品出库记录类
*
* @author luoyi-
* @since 2019-12-19
* 该类与数据库的 `bus_outport` 表相对应，存储商品的出库相关信息。
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_outport")
@Data // 使用 Lombok 简化代码，自动生成常用方法
@EqualsAndHashCode(callSuper = false) // 覆盖 equals 和 hashCode 方法，忽略父类字段
@Accessors(chain = true) // 启用链式编程，如 outport.setPaytype("现金").setNumber(50)
@TableName("bus_outport") // 将该类映射为数据库表 bus_outport
public class Outport implements 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) // 定义主键字段为自增类型
private Integer id; // 出库记录唯一标识
private Integer providerid;
private Integer providerid; // 供应商ID，关联 `bus_provider` 表中的主键
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，关联 `bus_goods` 表中的主键
/**
* 供应商姓名
* 供应商名称（仅用于展示）
*/
@TableField(exist = false)
private String providername;
@TableField(exist = false) // 该字段不在数据库表中，仅用于逻辑传输和前端展示
private String providername; // 供应商的名称信息
/**
* 商品名称
* 商品名称（仅用于展示）
*/
@TableField(exist = false)
private String goodsname;
@TableField(exist = false) // 非持久化字段，仅用于业务传输
private String goodsname; // 商品的名称信息
/**
* 商品规格
* 商品规格（仅用于展示）
*/
@TableField(exist = false)
private String size;
@TableField(exist = false) // 不映射到数据库表中
private String size; // 商品的规格，例如：中、大、小
}

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

@ -1,56 +1,51 @@
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、toString 等方法
import lombok.EqualsAndHashCode; // Lombok 注解，自动覆盖 equals 和 hashCode 方法
import lombok.ToString; // Lombok 注解，自动生成 toString 方法
import lombok.experimental.Accessors; // Lombok 注解，提供链式 setter 方法
import java.io.Serializable;
import java.io.Serializable; // 实现序列化接口，便于对象持久化
/**
* <p>
* InnoDB free: 9216 kB
* </p>
* 供应商实体类
*
* @author luoyi-
* @since 2019-12-05
* 该类对应数据库表 "bus_provider"，主要用于存储供应商的各类信息。
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_provider")
@ToString
@Data // Lombok 注解，简化代码，自动生成基本方法
@EqualsAndHashCode(callSuper = false) // 定义 equals 和 hashCode 方法，排除父类字段
@Accessors(chain = true) // 支持链式调用，允许连续设置属性值
@TableName("bus_provider") // 指定与数据库表 bus_provider 进行映射
@ToString // 生成 toString 方法，便于调试和输出对象信息
public class Provider implements 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) // 指定 "id" 字段为主键，自动递增
private Integer 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 fax;
private Integer available;
private String email; // 供应商电子邮箱地址
private String fax; // 传真号码，供应商常用联系方式
private Integer available; // 状态标识（1 表示启用，0 表示禁用）
}

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

@ -1,67 +1,66 @@
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 注解，自动生成常用方法
import lombok.EqualsAndHashCode; // Lombok 注解，覆盖 equals 和 hashCode 方法
import lombok.experimental.Accessors; // Lombok 注解，提供链式 setter 调用
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 实现序列化接口，支持对象持久化
import java.util.Date; // 引入 Date 类，存储日期信息
/**
* <p>
* InnoDB free: 9216 kB
* </p>
* 销售记录类
*
* @author luoyi-
* @since 2019-12-21
* 此类与数据库中的 "bus_sales" 表关联，用于管理销售数据。
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_sales")
@Data // 自动生成 getter、setter、toString 等方法，简化代码编写
@EqualsAndHashCode(callSuper = false) // 定义 equals 和 hashCode，不考虑父类属性
@Accessors(chain = true) // 启用链式调用风格，例如 sales.setPaytype("现金").setNumber(5)
@TableName("bus_sales") // 对应数据库表 bus_sales
public class Sales implements Serializable {
private static final long serialVersionUID=1L;
private static final long serialVersionUID = 1L; // 定义序列化 ID，保证类的兼容性
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@TableId(value = "id", type = IdType.AUTO) // 定义主键 ID，自动递增
private Integer 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;
private String customername; // 客户的名称
/**
* 商品名称
* 非持久化字段：商品名称
* 仅用于结果展示
*/
@TableField(exist = false)
private String goodsname;
private String goodsname; // 商品名称
/**
* 商品规格
* 非持久化字段：商品规格
* 主要用于展示商品详细规格
*/
@TableField(exist = false)
private String size;
private String size; // 商品规格
}

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

@ -1,67 +1,66 @@
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 注解，简化实体类，自动生成常用方法
import lombok.EqualsAndHashCode; // Lombok 注解，生成 equals 与 hashCode 方法
import lombok.experimental.Accessors; // Lombok 注解，支持连续调用 setter 方法
import java.io.Serializable;
import java.util.Date;
import java.io.Serializable; // 序列化接口，用于对象的序列化和反序列化
import java.util.Date; // Date 类，用于存储日期和时间信息
/**
* <p>
* InnoDB free: 9216 kB
* </p>
* 销售退货记录类
*
* @author luoyi-
* @since 2019-12-23
* 该类用于映射数据库中的 "bus_salesback" 表，专门存储销售退货相关数据。
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("bus_salesback")
@Data // Lombok 注解，自动生成 getter、setter、toString 和 equals/hashCode 方法
@EqualsAndHashCode(callSuper = false) // 忽略父类字段，生成当前类的 equals 和 hashCode
@Accessors(chain = true) // 支持链式调用，例如 salesback.setRemark("退货").setNumber(5)
@TableName("bus_salesback") // 指定实体类与数据库表 "bus_salesback" 对应
public class Salesback implements 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) // 主键字段 id，值自动递增
private Integer id; // 唯一标识销售退货记录的主键
private Integer customerid;
private Integer customerid; // 关联客户的唯一编号
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; // 关联商品的唯一标识符
/**
* 客户姓名
* 非数据库字段：客户名称
* 用于业务逻辑或展示数据时显示客户的名字
*/
@TableField(exist = false)
private String customername;
private String customername; // 客户名称，便于展示时使用
/**
* 商品名称
* 非数据库字段：商品名称
* 在数据传输或展示时显示商品的名称
*/
@TableField(exist = false)
private String goodsname;
private String goodsname; // 商品名称
/**
* 商品规格
* 非数据库字段：商品规格
* 用于前端展示具体的商品规格信息
*/
@TableField(exist = false)
private String size;
private String size; // 商品规格详情
}

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

@ -1,16 +1,18 @@
package com.yeqifu.bus.mapper;
import com.yeqifu.bus.entity.Customer;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Customer; // 导入 Customer 实体类，映射数据库中的客户数据表
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的基础映射接口，用于简化数据库操作
/**
* <p>
* InnoDB free: 9216 kB Mapper 接口
* Mapper 接口，用于处理与数据库中 `Customer` 表相关的操作
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
public interface CustomerMapper extends BaseMapper<Customer> {
public interface CustomerMapper extends BaseMapper<Customer> { // 继承 BaseMapper<Customer>，获得基本的 CRUD 操作方法
}

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

@ -1,14 +1,14 @@
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; // 导入商品实体类，用于与数据库中的 `Goods` 表进行映射
import org.apache.ibatis.annotations.Param; // 导入 MyBatis 的注解，用于指定方法参数的映射
import java.util.List;
import java.util.List; // 导入 List，用于返回多个结果
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) Mapper 接口
* Mapper 接口，用于处理与商品相关的数据库操作
* </p>
*
* @author luoyi-
@ -17,44 +17,44 @@ import java.util.List;
public interface GoodsMapper extends BaseMapper<Goods> {
/**
* 根据商品id删除商品销售信息
* @param id1
* 删除与指定商品相关的销售记录
* @param id1 商品的 ID
*/
void deleteSaleByGoodsId(@Param("goodsid") Integer id1);
/**
* 根据商品id删除商品销售退货信息
* @param id1
* 删除与指定商品相关的销售退货记录
* @param id1 商品的 ID
*/
void deleteSaleBackByGoodsId(@Param("goodsid") Integer id1);
/**
* 根据商品id删除商品进货信息
* @param id
* 删除与指定商品相关的进货记录
* @param id 商品的 ID
*/
void deleteInportByGoodsId(@Param("goodsid") Integer id);
/**
* 根据商品id删除商品退货信息
* @param id
* 删除与指定商品相关的出货记录
* @param id 商品的 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);
/**
* 加载所有库存预警商品
* 获取所有库存预警商品
* @return 返回所有预警的商品列表
*/
List<Goods> loadAllWarning();
}

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

@ -1,7 +1,7 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 指定当前类所在的包路径，mapper 层负责处理与数据库的交互
import com.yeqifu.bus.entity.Inport;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Inport; // 导入 Inport 实体类，它代表了一个进货记录，映射到数据库的相应表
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 提供的 BaseMapper，作为所有 Mapper 接口的基础类，自动提供常见的数据库操作方法
/**
* <p>
@ -11,6 +11,10 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-18
*/
public interface InportMapper extends BaseMapper<Inport> {
public interface InportMapper extends BaseMapper<Inport> { // 创建 InportMapper 接口，继承 BaseMapper，使得该接口可以直接与 'bus_inport' 表进行交互
// 目前此接口没有添加任何自定义方法
// 由于继承了 BaseMapper<Inport>，它自动具备了基础的 CRUD 操作方法
// 例如：insert()、deleteById()、updateById()、selectList() 等，方便进行基本的增删改查操作
}

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

@ -1,7 +1,7 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 定义该类所在的包路径，mapper 层用于实现数据库操作
import com.yeqifu.bus.entity.Outport;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Outport; // 引入 Outport 实体类，它表示与 'bus_outport' 表相关的出货记录
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 提供的 BaseMapper，所有 Mapper 接口的父类，提供了基本的数据库操作方法
/**
* <p>
@ -11,6 +11,11 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-19
*/
public interface OutportMapper extends BaseMapper<Outport> {
public interface OutportMapper extends BaseMapper<Outport> { // 定义 OutportMapper 接口，继承 BaseMapper，便于与数据库 'bus_outport' 表交互
// 当前该接口没有定义任何额外的方法
// 因为继承了 BaseMapper<Outport>，所以自动拥有了 MyBatis-Plus 提供的基础 CRUD 操作方法
// 例如：insert()、deleteById()、updateById()、selectList() 等，可以直接进行增删改查操作
}

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

@ -1,8 +1,8 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 定义此类所在的包路径，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; // 导入 Provider 实体类，表示供应商的相关信息
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入 MyBatis-Plus 提供的 BaseMapper，提供了基础的 CRUD 操作
import org.apache.ibatis.annotations.Param; // 导入 MyBatis 注解，用于给方法参数指定别名
/**
* <p>
@ -12,25 +12,25 @@ import org.apache.ibatis.annotations.Param;
* @author luoyi-
* @since 2019-12-05
*/
public interface ProviderMapper extends BaseMapper<Provider> {
public interface ProviderMapper extends BaseMapper<Provider> { // 创建 ProviderMapper 接口，继承自 BaseMapper，便于与数据库中的 'bus_provider' 表进行交互
/**
* 根据供应商id删除商品信息
* @param id
* 根据供应商 ID 删除与该供应商相关的商品信息
* @param id 供应商 ID
*/
void deleteGoodsByProviderId(@Param("pid") Integer id);
void deleteGoodsByProviderId(@Param("pid") Integer id); // 根据供应商 ID 删除相关商品信息，@Param 用于指定参数名 'pid'
/**
* 根据供应商id删除商品进货信息
* @param id
* 根据供应商 ID 删除与该供应商相关的进货记录
* @param id 供应商 ID
*/
void deleteInportByProviderId(@Param("pid") Integer id);
void deleteInportByProviderId(@Param("pid") Integer id); // 根据供应商 ID 删除进货记录
/**
* 根据供应商id删除商品退货信息
* @param id
* 根据供应商 ID 删除与该供应商相关的商品退货记录
* @param id 供应商 ID
*/
void deleteOutPortByProviderId(@Param("pid") Integer id);
void deleteOutPortByProviderId(@Param("pid") Integer id); // 根据供应商 ID 删除商品退货记录
}

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

@ -1,7 +1,7 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 定义该接口所在的包路径，mapper 层用于与数据库进行交互操作
import com.yeqifu.bus.entity.Sales;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Sales; // 导入 Sales 实体类，Sales 类包含销售记录相关的数据字段
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 提供的 BaseMapper，BaseMapper 是所有 Mapper 接口的基础类，包含常见的 CRUD 操作方法
/**
* <p>
@ -11,6 +11,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-21
*/
public interface SalesMapper extends BaseMapper<Sales> {
public interface SalesMapper extends BaseMapper<Sales> { // 创建 SalesMapper 接口，继承 BaseMapper，表示与数据库中的 'bus_sales' 表进行交互
// BaseMapper 接口自动提供所有常用的 CRUD 操作方法，包括 insert、delete、update 和 select 等
}

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

@ -1,7 +1,7 @@
package com.yeqifu.bus.mapper;
package com.yeqifu.bus.mapper; // 定义该接口所在的包路径，mapper 层负责与数据库进行交互
import com.yeqifu.bus.entity.Salesback;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yeqifu.bus.entity.Salesback; // 引入 Salesback 实体类，Salesback 类代表销售退货相关的数据
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 提供的 BaseMapper，BaseMapper 是 MyBatis-Plus 的基础接口，包含常见的 CRUD 操作方法
/**
* <p>
@ -11,6 +11,6 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author luoyi-
* @since 2019-12-23
*/
public interface SalesbackMapper extends BaseMapper<Salesback> {
public interface SalesbackMapper extends BaseMapper<Salesback> { // 创建 SalesbackMapper 接口，继承 BaseMapper，表示与数据库中的 'bus_salesback' 表进行交互
// 由于继承了 BaseMapper，SalesbackMapper 已自动具备所有常用的 CRUD 操作，如 insert、delete、update、select 等方法
}

15
src/main/java/com/yeqifu/bus/service/ICustomerService.java
Unescape View File

@ -1,21 +1,20 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 定义该接口所在的包路径，属于业务层接口
import com.yeqifu.bus.entity.Customer;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Customer; // 导入客户实体类 Customer，表示客户数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 客户服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
public interface ICustomerService extends IService<Customer> {
public interface ICustomerService extends IService<Customer> { // 继承 IService 接口，泛型为 Customer，表示该接口提供 Customer 实体的基本业务操作
/**
* 根据客户id删除客户
* @param id 客户id
* @param id 客户id
*/
void deleteCustomerById(Integer id);
void deleteCustomerById(Integer id); // 声明一个根据客户ID删除客户的抽象方法
}

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

@ -1,29 +1,28 @@
package com.yeqifu.bus.service;
package com.yeqifu.bus.service; // 定义该接口所在的包路径，属于业务层接口
import com.baomidou.mybatisplus.extension.service.IService;
import com.yeqifu.bus.entity.Goods;
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
import com.yeqifu.bus.entity.Goods; // 导入商品实体类 Goods，表示商品相关数据
import java.util.List;
import java.util.List; // 导入 List 类，用于返回多个商品
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 服务类
* 商品服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-06
*/
public interface IGoodsService extends IService<Goods> {
public interface IGoodsService extends IService<Goods> { // 继承 IService 接口，泛型为 Goods，表示该接口提供 Goods 实体的基本业务操作
/**
* 根据商品id删除商品
* @param id
* @param id 商品id
*/
void deleteGoodsById(Integer id);
void deleteGoodsById(Integer id); // 声明一个根据商品ID删除商品的抽象方法
/**
* 加载所有的库存预警商品
* @return
* @return 返回所有库存预警商品的列表
*/
List<Goods> loadAllWarning();
List<Goods> loadAllWarning(); // 声明一个方法，用于加载所有库存预警商品
}

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

@ -1,16 +1,14 @@
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; // 导入商品进货实体类 Inport，表示商品进货相关数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 服务类
* 商品进货服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-18
*/
public interface IInportService extends IService<Inport> {
public interface IInportService extends IService<Inport> { // 继承 IService 接口，泛型为 Inport，表示该接口提供 Inport 实体的基本业务操作
}

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

@ -1,17 +1,16 @@
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; // 导入商品退货实体类 Outport，表示商品退货相关数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 商品退货服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-19
*/
public interface IOutportService extends IService<Outport> {
public interface IOutportService extends IService<Outport> { // 继承 IService 接口，泛型为 Outport，表示该接口提供 Outport 实体的基本业务操作
/**
* 对商品进货进行退货处理
@ -19,5 +18,5 @@ public interface IOutportService extends IService<Outport> {
* @param number 退货数量
* @param remark 备注
*/
void addOutport(Integer id, Integer number, String remark);
void addOutport(Integer id, Integer number, String remark); // 自定义方法：添加退货处理，接收进货单ID、退货数量和备注
}

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

@ -1,21 +1,21 @@
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; // 导入供应商实体类 Provider，表示供应商相关的数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 供应商服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
public interface IProviderService extends IService<Provider> {
public interface IProviderService extends IService<Provider> { // 继承 IService 接口，泛型为 Provider，表示该接口提供 Provider 实体的基本业务操作
/**
* 根据供应商ID删除供应商
* @param id
* @param id 供应商ID
*/
void deleteProviderById(Integer id);
void deleteProviderById(Integer id); // 自定义方法：根据供应商ID删除供应商及其相关信息
}

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

@ -1,16 +1,14 @@
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; // 导入商品销售实体类 Sales，表示商品销售相关的数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 商品销售服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-21
*/
public interface ISalesService extends IService<Sales> {
public interface ISalesService extends IService<Sales> { // 继承 IService 接口，泛型为 Sales，表示该接口提供 Sales 实体的基本业务操作
}

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

@ -1,17 +1,16 @@
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; // 导入商品销售退货实体类 Salesback，表示销售退货相关的数据
import com.baomidou.mybatisplus.extension.service.IService; // 导入 MyBatis-Plus 提供的 IService 接口，包含通用的 CRUD 操作
/**
* <p>
* InnoDB free: 9216 kB 服务类
* 商品销售退货服务接口
* </p>
*
* @author luoyi-
* @since 2019-12-23
*/
public interface ISalesbackService extends IService<Salesback> {
public interface ISalesbackService extends IService<Salesback> { // 继承 IService 接口，泛型为 Salesback，表示该接口提供 Salesback 实体的基本业务操作
/**
* 对商品销售进行退货处理
@ -19,6 +18,5 @@ public interface ISalesbackService extends IService<Salesback> {
* @param number 退货数量
* @param remark 备注
*/
void addSalesback(Integer id, Integer number, String remark);
void addSalesback(Integer id, Integer number, String remark); // 自定义方法：根据销售单ID、退货数量和备注处理商品销售退货
}

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

@ -1,66 +1,74 @@
package com.yeqifu.bus.service.impl;
package com.yeqifu.bus.service.impl; // 定义服务实现类所在的包路径，负责业务逻辑层的实现
import com.yeqifu.bus.entity.Customer;
import com.yeqifu.bus.mapper.CustomerMapper;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.service.ICustomerService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.yeqifu.bus.entity.Customer; // 导入 Customer 实体类，表示客户相关的信息
import com.yeqifu.bus.mapper.CustomerMapper; // 导入 CustomerMapper，用于与数据库交互
import com.yeqifu.bus.mapper.GoodsMapper; // 导入 GoodsMapper，用于操作商品相关的数据库表
import com.yeqifu.bus.service.ICustomerService; // 导入 ICustomerService 接口，定义了客户服务的业务方法
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的 ServiceImpl 基础服务实现类
import org.springframework.beans.factory.annotation.Autowired; // 引入自动注入的注解
import org.springframework.stereotype.Service; // 声明该类为 Spring 服务类
import org.springframework.transaction.annotation.Transactional; // 引入事务管理注解，用于处理事务
import java.io.Serializable;
import java.util.Collection;
import java.io.Serializable; // 引入 Serializable 接口，用于支持对象的序列化
import java.util.Collection; // 引入集合类，用于处理多个客户的删除
/**
* <p>
* InnoDB free: 9216 kB 服务实现类
* 服务实现类，用于处理客户相关的业务逻辑。
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
@Service
@Transactional
@Service // 表示这是一个 Spring 服务类
@Transactional // 表示该类中的方法需要事务管理
public class CustomerServiceImpl extends ServiceImpl<CustomerMapper, Customer> implements ICustomerService {
// 自动注入 GoodsMapper，用于删除与客户相关的商品销售和销售退货记录
@Autowired
private GoodsMapper goodsMapper;
// 覆盖 save 方法，保存客户实体
@Override
public boolean save(Customer entity) {
return super.save(entity);
return super.save(entity); // 调用父类的 save 方法
}
// 覆盖 updateById 方法，根据 ID 更新客户实体
@Override
public boolean updateById(Customer entity) {
return super.updateById(entity);
return super.updateById(entity); // 调用父类的 updateById 方法
}
// 覆盖 removeById 方法，根据 ID 删除客户
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
return super.removeById(id); // 调用父类的 removeById 方法
}
// 覆盖 getById 方法，根据 ID 获取客户实体
@Override
public Customer getById(Serializable id) {
return super.getById(id);
return super.getById(id); // 调用父类的 getById 方法
}
// 覆盖 removeByIds 方法，批量删除客户
@Override
public boolean removeByIds(Collection<? extends Serializable> idList) {
return super.removeByIds(idList);
return super.removeByIds(idList); // 调用父类的 removeByIds 方法
}
/**
* 根据客户id删除客户
* @param id 客户id
* 根据客户id删除客户及其相关的销售和退货记录
* @param id 客户id
*/
@Override
public void deleteCustomerById(Integer id) {
//根据客户id删除商品销售
// 根据客户id删除该客户的商品销售记录
goodsMapper.deleteSaleByCustomerId(id);
//根据客户id删除商品销售退货
// 根据客户id删除该客户的商品销售退货记录
goodsMapper.deleteSaleBackByCustomerId(id);
// 删除客户本身
this.removeById(id);
}
}

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

@ -1,68 +1,77 @@
package com.yeqifu.bus.service.impl;
package com.yeqifu.bus.service.impl; // 定义服务实现类所在的包路径，负责商品相关的业务逻辑
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.service.IGoodsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类，表示商品信息
import com.yeqifu.bus.mapper.GoodsMapper; // 导入 GoodsMapper，执行商品相关的数据库操作
import com.yeqifu.bus.service.IGoodsService; // 导入 IGoodsService 接口，定义了商品服务的业务方法
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的 ServiceImpl 类，提供基础服务实现
import org.springframework.stereotype.Service; // 声明该类为 Spring 服务类
import org.springframework.transaction.annotation.Transactional; // 引入事务管理注解，用于处理事务
import java.io.Serializable;
import java.util.List;
import java.io.Serializable; // 引入 Serializable 接口，用于支持对象的序列化
import java.util.List; // 引入 List 集合类，用于处理商品的列表
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`) 服务实现类
* 服务实现类，处理商品相关的业务逻辑。
* </p>
*
* @author luoyi-
* @since 2019-12-06
*/
@Service
@Transactional
@Service // 表示这是一个 Spring 服务类
@Transactional // 该类中的方法都将被事务管理，确保一致性
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements IGoodsService {
// 覆盖 save 方法，保存商品实体
@Override
public boolean save(Goods entity) {
return super.save(entity);
return super.save(entity); // 调用父类的 save 方法
}
// 覆盖 updateById 方法，根据商品 ID 更新商品实体
@Override
public boolean updateById(Goods entity) {
return super.updateById(entity);
return super.updateById(entity); // 调用父类的 updateById 方法
}
// 覆盖 removeById 方法，根据商品 ID 删除商品
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
return super.removeById(id); // 调用父类的 removeById 方法
}
// 覆盖 getById 方法，根据商品 ID 获取商品实体
@Override
public Goods getById(Serializable id) {
return super.getById(id);
return super.getById(id); // 调用父类的 getById 方法
}
/**
* 根据商品 ID 删除商品及其相关记录
* @param id 商品 ID
*/
@Override
public void deleteGoodsById(Integer id) {
//根据商品id删除商品销售信息
// 根据商品 ID 删除商品销售信息
this.getBaseMapper().deleteSaleByGoodsId(id);
//根据商品id删除商品销售退货信息
// 根据商品 ID 删除商品销售退货信息
this.getBaseMapper().deleteSaleBackByGoodsId(id);
//根据商品id删除商品进货信息
// 根据商品 ID 删除商品进货信息
this.getBaseMapper().deleteInportByGoodsId(id);
//根据商品id删除商品退货信息
// 根据商品 ID 删除商品退货信息
this.getBaseMapper().deleteOutportByGoodsId(id);
//删除商品信息
// 删除商品信息
this.removeById(id);
}
/**
* 查询所有库存预警商品
* @return
* @return 返回库存预警商品列表
*/
@Override
public List<Goods> loadAllWarning() {
List<Goods> goods = baseMapper.loadAllWarning();
List<Goods> goods = baseMapper.loadAllWarning(); // 调用 mapper 查询所有库存预警商品
return goods;
}
}

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

@ -1,80 +1,84 @@
package com.yeqifu.bus.service.impl;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Inport;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.mapper.InportMapper;
import com.yeqifu.bus.service.IInportService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类，表示商品信息
import com.yeqifu.bus.entity.Inport; // 导入 Inport 实体类，表示商品进货信息
import com.yeqifu.bus.mapper.GoodsMapper; // 导入 GoodsMapper，用于执行商品相关的数据库操作
import com.yeqifu.bus.mapper.InportMapper; // 导入 InportMapper，用于执行商品进货相关的数据库操作
import com.yeqifu.bus.service.IInportService; // 导入 IInportService 接口，定义商品进货服务的业务方法
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的 ServiceImpl 类，提供基础服务实现
import org.springframework.beans.factory.annotation.Autowired; // 引入 Autowired 注解，用于自动注入依赖
import org.springframework.stereotype.Service; // 声明该类为 Spring 服务类
import org.springframework.transaction.annotation.Transactional; // 引入事务管理注解，用于处理事务
import java.io.Serializable;
import java.io.Serializable; // 引入 Serializable 接口，用于支持对象的序列化
/**
* <p>
* InnoDB free: 9216 kB; (`providerid`) REFER `warehouse/bus_provider`(`id`); (`goo 服务实现类
* 服务实现类，处理商品进货相关的业务逻辑。
* </p>
*
* @author luoyi-
* @since 2019-12-18
*/
@Service
@Transactional
@Service // 表示这是一个 Spring 服务类
@Transactional // 该类中的方法都将被事务管理，确保一致性
public class InportServiceImpl extends ServiceImpl<InportMapper, Inport> implements IInportService {
@Autowired
private GoodsMapper goodsMapper;
private GoodsMapper goodsMapper; // 自动注入 GoodsMapper，用于查询和更新商品信息
/**
* 保存商品进货
* @param entity
* @return
* 保存商品进货信息
* @param entity 进货实体，包含进货的商品信息
* @return 如果保存成功返回 true，否则返回 false
*/
@Override
public boolean save(Inport entity) {
//根据商品ID查询商品
// 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
goods.setNumber(goods.getNumber()+entity.getNumber());
// 更新商品库存：当前库存 + 进货数量
goods.setNumber(goods.getNumber() + entity.getNumber());
// 更新商品库存信息
goodsMapper.updateById(goods);
//保存进货信息
// 保存进货信息
return super.save(entity);
}
/**
* 更新商品进货
* @param entity
* @return
* 更新商品进货信息
* @param entity 进货实体，包含进货的商品信息
* @return 如果更新成功返回 true，否则返回 false
*/
@Override
public boolean updateById(Inport entity) {
//根据进货ID查询进货信息
// 根据进货ID查询当前进货记录
Inport inport = baseMapper.selectById(entity.getId());
//根据商品ID查询商品信息
// 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
//库存算法 当前库存-进货单修改之前的数量+修改之后的数量
goods.setNumber(goods.getNumber()-inport.getNumber()+entity.getNumber());
// 更新库存：当前库存 - 旧进货数量 + 新进货数量
goods.setNumber(goods.getNumber() - inport.getNumber() + entity.getNumber());
// 更新商品库存信息
goodsMapper.updateById(goods);
//更新进货单
// 更新进货记录
return super.updateById(entity);
}
/**
* 删除商品进货信息
* @param id
* @return
* @param id 进货记录ID
* @return 如果删除成功返回 true，否则返回 false
*/
@Override
public boolean removeById(Serializable id) {
//根据进货ID查询进货信息
// 根据进货ID查询进货记录
Inport inport = baseMapper.selectById(id);
//根据商品ID查询商品信息
// 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(inport.getGoodsid());
//库存算法 当前库存-进货单数量
goods.setNumber(goods.getNumber()-inport.getNumber());
// 更新库存：当前库存 - 被删除的进货数量
goods.setNumber(goods.getNumber() - inport.getNumber());
// 更新商品库存信息
goodsMapper.updateById(goods);
//更新商品的数量
// 删除进货记录
return super.removeById(id);
}
}

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

@ -1,71 +1,75 @@
package com.yeqifu.bus.service.impl;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Inport;
import com.yeqifu.bus.entity.Outport;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.mapper.InportMapper;
import com.yeqifu.bus.mapper.OutportMapper;
import com.yeqifu.bus.service.IOutportService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yeqifu.sys.common.WebUtils;
import com.yeqifu.sys.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类，表示商品信息
import com.yeqifu.bus.entity.Inport; // 导入 Inport 实体类，表示商品进货记录
import com.yeqifu.bus.entity.Outport; // 导入 Outport 实体类，表示商品退货记录
import com.yeqifu.bus.mapper.GoodsMapper; // 导入 GoodsMapper，用于查询和更新商品信息
import com.yeqifu.bus.mapper.InportMapper; // 导入 InportMapper，用于查询进货记录
import com.yeqifu.bus.mapper.OutportMapper; // 导入 OutportMapper，用于插入退货记录
import com.yeqifu.bus.service.IOutportService; // 导入 IOutportService 接口，定义出货服务的业务方法
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的 ServiceImpl 类，提供基础服务实现
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.stereotype.Service; // 声明该类为 Spring 服务类
import java.util.Date;
import java.util.Date; // 导入 Date 类，用于设置退货时间
/**
* <p>
* InnoDB free: 9216 kB 服务实现类
* 服务实现类，处理商品退货相关的业务逻辑。
* </p>
*
* @author luoyi-
* @since 2019-12-19
*/
@Service
@Service // 表示这是一个 Spring 服务类
public class OutportServiceImpl extends ServiceImpl<OutportMapper, Outport> implements IOutportService {
@Autowired
private InportMapper inportMapper;
private InportMapper inportMapper; // 自动注入 InportMapper，用于查询进货记录
@Autowired
private GoodsMapper goodsMapper;
private GoodsMapper 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) {
//1.通过进货单ID查询出进货单信息
// 1. 根据进货单ID查询出进货单信息
Inport inport = inportMapper.selectById(id);
//2.根据商品ID查询商品信息
// 2. 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(inport.getGoodsid());
//3.修改商品的数量 商品的数量-退货的数量
goods.setNumber(goods.getNumber()-number);
//修改进货的数量
inport.setNumber(inport.getNumber()-number);
inportMapper.updateById(inport);
// 3. 更新商品库存，商品数量减少退货的数量
goods.setNumber(goods.getNumber() - number);
// 4. 更新进货记录的数量，减少退货的数量
inport.setNumber(inport.getNumber() - number);
inportMapper.updateById(inport); // 更新进货记录
//4.进行修改
goodsMapper.updateById(goods);
// 5. 更新商品库存信息
goodsMapper.updateById(goods); // 更新商品库存
//5.添加退货单信息
// 6. 创建并添加退货单信息
Outport outport = new Outport();
outport.setGoodsid(inport.getGoodsid());
outport.setNumber(number);
User user = (User) WebUtils.getSession().getAttribute("user");
outport.setOperateperson(user.getName());
outport.setGoodsid(inport.getGoodsid()); // 设置退货的商品ID
outport.setNumber(number); // 设置退货数量
User user = (User) WebUtils.getSession().getAttribute("user"); // 获取当前登录的用户信息
outport.setOperateperson(user.getName()); // 设置操作人（即当前登录的用户）
outport.setOutportprice(inport.getInportprice());
outport.setOutportprice(inport.getInportprice()); // 设置退货价格（使用进货价格）
outport.setPaytype(inport.getPaytype()); // 设置支付类型
outport.setOutputtime(new Date()); // 设置退货时间为当前时间
outport.setRemark(remark); // 设置备注
outport.setProviderid(inport.getProviderid()); // 设置供应商ID（来源于进货记录）
outport.setPaytype(inport.getPaytype());
outport.setOutputtime(new Date());
outport.setRemark(remark);
outport.setProviderid(inport.getProviderid());
getBaseMapper().insert(outport);
// 7. 插入退货单记录到数据库
getBaseMapper().insert(outport); // 使用 MyBatis-Plus 插入退货单记录
}
}

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

@ -1,84 +1,86 @@
package com.yeqifu.bus.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Provider;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.mapper.ProviderMapper;
import com.yeqifu.bus.service.IProviderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; // 导入 MyBatis-Plus QueryWrapper，用于构建查询条件
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 的 ServiceImpl 类，提供基本的服务实现
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类，表示商品信息
import com.yeqifu.bus.entity.Provider; // 导入 Provider 实体类，表示供应商信息
import com.yeqifu.bus.mapper.GoodsMapper; // 导入 GoodsMapper，用于查询和更新商品数据
import com.yeqifu.bus.mapper.ProviderMapper; // 导入 ProviderMapper，用于查询和更新供应商数据
import com.yeqifu.bus.service.IProviderService; // 导入 IProviderService 接口，定义供应商服务接口
import org.springframework.beans.factory.annotation.Autowired; // 导入 Autowired 注解，用于自动注入依赖
import org.springframework.stereotype.Service; // 表示这是一个 Spring 服务类
import org.springframework.transaction.annotation.Transactional; // 导入事务管理注解，确保数据库操作的原子性
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.io.Serializable; // 导入 Serializable，用于支持可序列化的ID
import java.util.Collection; // 导入 Collection 类，支持多数据项处理
import java.util.List; // 导入 List 类，用于存储商品列表
/**
* <p>
* InnoDB free: 9216 kB 服务实现类
* 供应商服务实现类，提供供应商的增、删、改、查功能。
* </p>
*
* @author luoyi-
* @since 2019-12-05
*/
@Service
@Transactional
@Service // 标记为 Spring 服务类
@Transactional // 添加事务管理，确保数据库操作的一致性
public class ProviderServiceImpl extends ServiceImpl<ProviderMapper, Provider> implements IProviderService {
@Autowired
private GoodsMapper goodsMapper;
private GoodsMapper goodsMapper; // 自动注入 GoodsMapper，用于与商品数据交互
@Override
public boolean save(Provider entity) {
return super.save(entity);
return super.save(entity); // 调用 ServiceImpl 的 save 方法保存供应商
}
@Override
public boolean updateById(Provider entity) {
return super.updateById(entity);
return super.updateById(entity); // 调用 ServiceImpl 的 updateById 方法更新供应商
}
@Override
public boolean removeById(Serializable id) {
return super.removeById(id);
return super.removeById(id); // 调用 ServiceImpl 的 removeById 方法删除供应商
}
@Override
public Provider getById(Serializable id) {
return super.getById(id);
return super.getById(id); // 调用 ServiceImpl 的 getById 方法获取供应商
}
@Override
public boolean removeByIds(Collection<? extends Serializable> idList) {
return super.removeByIds(idList);
return super.removeByIds(idList); // 调用 ServiceImpl 的 removeByIds 方法批量删除供应商
}
/**
* 根据供应商id删除供应商
* @param id 供应商id
* 根据供应商id删除供应商及其相关数据
* @param id 供应商id
*/
@Override
public void deleteProviderById(Integer id) {
//根据供应商id查询出商品id
// 1. 查询所有与该供应商相关的商品
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
queryWrapper.eq("providerid",id);
List<Goods> goods = goodsMapper.selectList(queryWrapper);
queryWrapper.eq("providerid", id); // 使用条件查询所有 providerid 为指定 id 的商品
List<Goods> goods = goodsMapper.selectList(queryWrapper); // 执行查询，获取商品列表
// 2. 删除商品相关的数据
for (Goods good : goods) {
//获取一个商品id
Integer id1 = good.getId();
//根据商品id删除商品销售信息
goodsMapper.deleteSaleByGoodsId(id1);
//根据商品id删除商品销售退货信息
goodsMapper.deleteSaleBackByGoodsId(id1);
Integer goodId = good.getId(); // 获取商品的 ID
// 删除商品的销售信息
goodsMapper.deleteSaleByGoodsId(goodId);
// 删除商品的销售退货信息
goodsMapper.deleteSaleBackByGoodsId(goodId);
}
//根据供应商id删除商品退货信息
this.getBaseMapper().deleteOutPortByProviderId(id);
//根据供应商id删除商品进货信息
this.getBaseMapper().deleteInportByProviderId(id);
//根据供应商id删除商品
this.getBaseMapper().deleteGoodsByProviderId(id);
//删除供应商
this.removeById(id);
// 3. 删除供应商相关的其他数据
this.getBaseMapper().deleteOutPortByProviderId(id); // 删除与供应商相关的商品退货记录
this.getBaseMapper().deleteInportByProviderId(id); // 删除与供应商相关的商品进货记录
this.getBaseMapper().deleteGoodsByProviderId(id); // 删除与供应商相关的商品记录
// 4. 删除供应商
this.removeById(id); // 删除供应商自身
}
}

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

@ -1,75 +1,81 @@
package com.yeqifu.bus.service.impl;
package com.yeqifu.bus.service.impl; // 定义该类所在的包路径，属于业务层实现
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Sales;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.mapper.SalesMapper;
import com.yeqifu.bus.service.ISalesService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的基础服务类 ServiceImpl，提供基本的 CRUD 操作
import com.yeqifu.bus.entity.Goods; // 导入商品实体类 Goods，表示商品数据
import com.yeqifu.bus.entity.Sales; // 导入销售实体类 Sales，表示销售数据
import com.yeqifu.bus.mapper.GoodsMapper; // 导入商品数据的 Mapper 接口，用于商品表的数据库操作
import com.yeqifu.bus.mapper.SalesMapper; // 导入销售数据的 Mapper 接口，用于销售表的数据库操作
import com.yeqifu.bus.service.ISalesService; // 导入销售业务层接口，用于定义销售相关的业务逻辑
import org.springframework.beans.factory.annotation.Autowired; // 导入注解 Autowired，表示自动注入依赖
import org.springframework.stereotype.Service; // 导入注解 Service，标识当前类为 Spring 服务组件
import java.io.Serializable;
import java.io.Serializable; // 导入 Serializable 接口，允许序列化
/**
* <p>
* InnoDB free: 9216 kB 服务实现类
* 商品销售服务实现类
* </p>
*
* @author luoyi-
* @since 2019-12-21
*/
@Service
@Service // 使用 Spring 的注解将该类声明为服务层组件，Spring 会管理该类的实例
public class SalesServiceImpl extends ServiceImpl<SalesMapper, Sales> implements ISalesService {
@Autowired
@Autowired // 自动注入 GoodsMapper，用于操作商品数据
private GoodsMapper goodsMapper;
/**
* 添加商品销售
* @param entity 商品销售实体类
* @return
* @param entity 商品销售实体类
* @return 操作成功或失败
*/
@Override
public boolean save(Sales entity) {
// 根据销售单中的商品ID查询该商品的信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
goods.setNumber(goods.getNumber()-entity.getNumber());
//更新商品的库存信息
// 更新商品的库存，扣除销售数量
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查询销售单信息
// 根据销售单ID查询出原始的销售单信息
Sales sales = baseMapper.selectById(entity.getId());
// 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(entity.getGoodsid());
//仓库商品数量=原库存-销售单修改之前的数量+修改之后的数量
// 80 +40 - 50 30
goods.setNumber(goods.getNumber()+sales.getNumber()-entity.getNumber());
//更新商品
// 更新商品库存，计算新的库存数量
goods.setNumber(goods.getNumber() + sales.getNumber() - entity.getNumber());
// 更新商品信息
goodsMapper.updateById(goods);
// 更新销售单信息
return super.updateById(entity);
}
/**
* 删除商品销售信息
* @param id 商品销售单ID
* @return
* @param id 商品销售单ID
* @return 操作成功或失败
*/
@Override
public boolean removeById(Serializable id) {
//根据商品销售单ID查询出销售单数据
// 根据商品销售单ID查询出销售单数据
Sales sales = baseMapper.selectById(id);
// 根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(sales.getGoodsid());
//仓库商品数量=原库存+删除商品销售单的数量
goods.setNumber(goods.getNumber()+sales.getNumber());
// 更新商品库存，回退销售单中的销售数量
goods.setNumber(goods.getNumber() + sales.getNumber());
// 更新商品库存信息
goodsMapper.updateById(goods);
// 删除销售单信息
return super.removeById(id);
}
}

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

@ -1,78 +1,76 @@
package com.yeqifu.bus.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yeqifu.bus.entity.Goods;
import com.yeqifu.bus.entity.Sales;
import com.yeqifu.bus.entity.Salesback;
import com.yeqifu.bus.mapper.GoodsMapper;
import com.yeqifu.bus.mapper.SalesMapper;
import com.yeqifu.bus.mapper.SalesbackMapper;
import com.yeqifu.bus.service.ISalesbackService;
import com.yeqifu.sys.common.WebUtils;
import com.yeqifu.sys.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
package com.yeqifu.bus.service.impl; // 定义该类所在的包路径，属于业务层实现
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; // 引入 MyBatis-Plus 提供的基础服务类 ServiceImpl，提供基本的 CRUD 操作
import com.yeqifu.bus.entity.Goods; // 导入商品实体类 Goods，表示商品数据
import com.yeqifu.bus.entity.Sales; // 导入销售实体类 Sales，表示销售数据
import com.yeqifu.bus.entity.Salesback; // 导入销售退货实体类 Salesback，表示销售退货数据
import com.yeqifu.bus.mapper.GoodsMapper; // 导入商品数据的 Mapper 接口，用于商品表的数据库操作
import com.yeqifu.bus.mapper.SalesMapper; // 导入销售数据的 Mapper 接口，用于销售表的数据库操作
import com.yeqifu.bus.mapper.SalesbackMapper; // 导入销售退货数据的 Mapper 接口，用于销售退货表的数据库操作
import com.yeqifu.bus.service.ISalesbackService; // 导入销售退货业务层接口，用于定义销售退货相关的业务逻辑
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.stereotype.Service; // 导入注解 Service，标识当前类为 Spring 服务组件
import java.util.Date; // 导入 Date 类，用于操作日期和时间
/**
* <p>
* InnoDB free: 9216 kB 服务实现类
* 销售退货业务层实现类
* </p>
*
* @author luoyi-
* @since 2019-12-23
*/
@Service
@Service // 使用 Spring 的注解将该类声明为服务层组件，Spring 会管理该类的实例
public class SalesbackServiceImpl extends ServiceImpl<SalesbackMapper, Salesback> implements ISalesbackService {
@Autowired
@Autowired // 自动注入 SalesMapper，用于操作销售数据
private SalesMapper salesMapper;
@Autowired
@Autowired // 自动注入 GoodsMapper，用于操作商品数据
private GoodsMapper goodsMapper;
/**
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
* 根据销售单ID、退货数量和备注添加销售退货记录
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
*/
@Override
public void addSalesback(Integer id, Integer number, String remark) {
//1.通过销售单ID查询出销售单信息
Sales sales = salesMapper.selectById(id);
//2.根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(sales.getGoodsid());
//3.修改商品的数量 商品的数量-退货的数量
goods.setNumber(goods.getNumber()+number);
// 1.通过销售单ID查询出销售单信息
Sales sales = salesMapper.selectById(id); // 根据销售单ID从数据库中查询对应的销售记录
//修改进货的数量
sales.setNumber(sales.getNumber()-number);
salesMapper.updateById(sales);
// 2.根据商品ID查询商品信息
Goods goods = goodsMapper.selectById(sales.getGoodsid()); // 根据销售记录中的商品ID查询商品数据
//4.进行修改
goodsMapper.updateById(goods);
// 3.修改商品的库存数量，商品库存 - 退货数量
goods.setNumber(goods.getNumber() + number); // 更新商品库存，将退货数量加回库存
//5.添加退货单信息
Salesback salesback = new Salesback();
salesback.setGoodsid(sales.getGoodsid());
// 4.修改销售单的数量，销售单数量 - 退货数量
sales.setNumber(sales.getNumber() - number); // 更新销售单的数量，扣除退货数量
salesMapper.updateById(sales); // 更新销售记录
salesback.setNumber(number);
User user = (User) WebUtils.getSession().getAttribute("user");
salesback.setOperateperson(user.getName());
// 5.更新商品库存
goodsMapper.updateById(goods); // 更新商品记录
// 6.创建销售退货记录
Salesback salesback = new Salesback(); // 创建一个新的销售退货对象
salesback.setGoodsid(sales.getGoodsid()); // 设置销售退货记录的商品ID
salesback.setSalebackprice(sales.getSaleprice());
salesback.setPaytype(sales.getPaytype());
salesback.setNumber(number); // 设置销售退货的数量
User user = (User) WebUtils.getSession().getAttribute("user"); // 从当前会话中获取用户信息
salesback.setOperateperson(user.getName()); // 设置退货操作的人员（当前登录的用户）
salesback.setSalesbacktime(new Date());
salesback.setRemark(remark);
salesback.setSalebackprice(sales.getSaleprice()); // 设置销售退货价格（与销售时的价格一致）
salesback.setPaytype(sales.getPaytype()); // 设置销售退货的支付类型
salesback.setSalesbacktime(new Date()); // 设置销售退货的时间为当前时间
salesback.setRemark(remark); // 设置退货的备注信息
salesback.setCustomerid(sales.getCustomerid());
salesback.setCustomerid(sales.getCustomerid()); // 设置退货对应的客户ID
getBaseMapper().insert(salesback);
getBaseMapper().insert(salesback); // 使用 MyBatis-Plus 插入销售退货记录
}
}

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

@ -1,26 +1,25 @@
package com.yeqifu.bus.vo;
package com.yeqifu.bus.vo; // 定义该类所在的包路径，属于视图层的对象包
import com.yeqifu.bus.entity.Customer;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.yeqifu.bus.entity.Customer; // 导入 Customer 实体类，表示客户信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
/**
* @Author: 落亦-
* @Date: 2019/12/5 9:30
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class CustomerVo extends Customer{
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class CustomerVo extends Customer { // CustomerVo 继承自 Customer，表示客户视图对象，添加一些分页和批量操作功能
/**
* 分页参数，当前是第一页，每页10条数据
*/
private Integer page=1;
private Integer limit=10;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
/**
* 批量删除客户，存放客户ID的数组
*/
private Integer[] ids;
private Integer[] ids; // 用于批量删除客户，存储客户ID的数组
}

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

@ -1,18 +1,17 @@
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 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
/**
* @Author: 落亦-
* @Date: 2019/12/6 22:30
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class GoodsVo extends Goods {
private Integer page=1;
private Integer limit=10;
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class GoodsVo extends Goods { // GoodsVo 继承自 Goods，表示商品视图对象，添加了分页功能
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
}

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

@ -1,28 +1,26 @@
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 com.yeqifu.bus.entity.Inport; // 导入 Inport 实体类，表示进货信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
import org.springframework.format.annotation.DateTimeFormat; // 导入用于格式化日期的注解
import java.util.Date;
import java.util.Date; // 导入日期类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class InportVo extends Inport {
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class InportVo extends Inport { // InportVo 继承自 Inport，表示进货视图对象，添加了分页和时间筛选功能
private Integer page = 1;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
private Integer limit = 10;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
@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; // 结束时间，用于筛选进货记录的结束时间
}

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

@ -1,29 +1,26 @@
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 com.yeqifu.bus.entity.Outport; // 导入 Outport 实体类，表示出货信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
import org.springframework.format.annotation.DateTimeFormat; // 导入用于格式化日期的注解
import java.util.Date;
import java.util.Date; // 导入日期类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class OutportVo extends Outport {
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class OutportVo extends Outport { // OutportVo 继承自 Outport，表示出货视图对象，添加了分页和时间筛选功能
private Integer page = 1;
private Integer limit = 10;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期字段，要求日期格式为 "yyyy-MM-dd"
private Date startTime; // 开始时间，用于筛选出货记录的起始时间
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期字段，要求日期格式为 "yyyy-MM-dd"
private Date endTime; // 结束时间，用于筛选出货记录的结束时间
}

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

@ -1,27 +1,25 @@
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.Provider; // 导入 Provider 实体类，表示供应商信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
/**
* @Author: 落亦-
* @Date: 2019/12/5 9:30
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class ProviderVo extends Provider{
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class ProviderVo extends Provider { // ProviderVo 继承自 Provider，表示供应商视图对象，添加了分页和批量删除功能
/**
* 分页参数，当前是第一页，每页10条数据
*/
private Integer page=1;
private Integer limit=10;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
/**
* 批量删除供应商，存放供应商ID的数组
*/
private Integer[] ids;
private Integer[] ids; // 存放多个供应商ID，用于批量删除
}

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

@ -1,28 +1,27 @@
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 com.yeqifu.bus.entity.Sales; // 导入 Sales 实体类，表示销售信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
import org.springframework.format.annotation.DateTimeFormat; // 导入 Spring 的 @DateTimeFormat 注解，用于格式化日期
import java.util.Date;
import java.util.Date; // 导入 Date 类，表示日期类型
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class SalesVo extends Sales {
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class SalesVo extends Sales { // SalesVo 继承自 Sales，表示销售的视图对象，添加了分页和日期过滤功能
private Integer page = 1;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10;
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;
@DateTimeFormat(pattern = "yyyy-MM-dd") // 设置日期格式化的注解，适用于 startTime 字段
private Date startTime; // 查询的起始时间，用于过滤销售数据的时间范围
@DateTimeFormat(pattern = "yyyy-MM-dd") // 设置日期格式化的注解，适用于 endTime 字段
private Date endTime; // 查询的结束时间，用于过滤销售数据的时间范围
}

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

@ -1,29 +1,27 @@
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 com.yeqifu.bus.entity.Salesback; // 导入 Salesback 实体类，表示销售退货信息
import lombok.Data; // 导入 Lombok 提供的 @Data 注解，自动生成 getter、setter、toString 等方法
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解，自动生成 equals 和 hashCode 方法
import org.springframework.format.annotation.DateTimeFormat; // 导入 Spring 的 @DateTimeFormat 注解，用于格式化日期
import java.util.Date;
import java.util.Date; // 导入 Date 类，表示日期类型
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class SalesbackVo extends Salesback {
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class SalesbackVo extends Salesback { // SalesbackVo 继承自 Salesback，表示销售退货的视图对象，添加了分页和日期过滤功能
private Integer page = 1;
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date endTime;
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
@DateTimeFormat(pattern = "yyyy-MM-dd") // 设置日期格式化的注解，适用于 startTime 字段
private Date startTime; // 查询的起始时间，用于过滤销售退货数据的时间范围
@DateTimeFormat(pattern = "yyyy-MM-dd") // 设置日期格式化的注解，适用于 endTime 字段
private Date endTime; // 查询的结束时间，用于过滤销售退货数据的时间范围
}

240
src/main/resources/templates/business/customer/customerManager.html
Unescape View File

@ -4,21 +4,30 @@
<head>
<meta charset="UTF-8">
<title>Right</title>
<!-- 设置渲染引擎为webkit -->
<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">
<!-- 设置苹果设备支持Web应用 -->
<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"/>
</head>
<body>
<!--查询条件-->
<!-- 查询条件区域 -->
<fieldset class="layui-elem-field layui-field-title" style="margin-top: 15px;">
<legend>搜索条件</legend>
</fieldset>
@ -46,9 +55,11 @@
</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>
@ -56,14 +67,16 @@
</div>
</form>
<!--数据表格-->
<!-- 数据表格显示区域 -->
<div>
<table class="layui-hide" id="customerTable" lay-filter="customerTable"></table>
<!-- 表格工具栏，包含添加客户按钮 -->
<div id="customerToolBar" style="display: none">
<button type="button" lay-event="add" shiro:hasPermission="customer: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="customerRowBar" style="display: none;">
<button type="button" lay-event="update" shiro:hasPermission="customer:update" class="layui-btn layui-btn-sm layui-btn-radius"><i
class="layui-icon layui-icon-edit"></i>编辑
@ -74,7 +87,7 @@
</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">
@ -92,7 +105,6 @@
<input type="text" name="address" lay-verify="required" autocomplete="off" class="layui-input input-radius" placeholder="请输入客户地址">
</div>
</div>
</div>
<div class="layui-form-item">
<div class="layui-inline">
@ -157,175 +169,89 @@
</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">
layui.use(['form', 'table', 'layer', 'dtree'], function () {
var form = layui.form,
layer = layui.layer,
$ = layui.jquery,
dtree = layui.dtree,
table = layui.table;
//提升数据表格的作用域，因为底下还有一个reloadTable方法
var tableIns;
layui.use(['jquery', 'form', 'layer', 'table'], function () {
var $ = layui.jquery;
var form = layui.form;
var layer = layui.layer;
var table = layui.table;
//初始化表格 加载数据
tableIns = table.render({
elem: "#customerTable",
title: "客户数据表格",
url: "/customer/loadAllCustomer",
toolbar: "#customerToolBar",
// 初始化table
table.render({
elem: '#customerTable',
url: '/customer/getCustomerList', // 客户数据请求的URL
page: true,
height: "full-180",
cols: [ [
{type:'checkbox',fixed:'left'},
{field: 'id', title: 'ID', align: 'center',width:'50'},
{field: 'customername', title: '客户名称', align: 'center',width:'100'},
{field: 'address', title: '客户地址', align: 'center',width:'150'},
{field: 'telephone', title: '客户电话', align: 'center',width:'140'},
{field: 'zip', title: '邮编', align: 'center',width:'90'},
{field: 'connectionpersion', title: '联系人', align: 'center',width:'130'},
{field: 'phone', title: '联系人电话', align: 'center',width:'130'},
{field: 'bank', title: '开户银行', align: 'center',width:'100'},
{field: 'account', title: '银行账号', align: 'center',width:'160'},
{field: 'email', title: '邮箱', align: 'center',width:'200'},
{field: 'fax', title: '传真', align: 'center',width:'100'},
{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: '#customerRowBar', align: 'center',width:'180'}
] ],
done: function (data, curr, count) {
//不是第一页时，如果当前返回的数据为0那么就返回上一页
if (data.data.length == 0 && curr != 1) {
tableIns.reload({
page: {
curr: curr - 1
}
})
}
}
toolbar: '#customerToolBar',
limit: 10,
cols: [[
{type: 'checkbox'},
{field: 'customername', title: '客户名称', align: 'center'},
{field: 'address', title: '客户地址', align: 'center'},
{field: 'telephone', title: '客户电话', align: 'center'},
{field: 'zip', title: '邮编', align: 'center'},
{field: 'connectionpersion', title: '联系人', align: 'center'},
{field: 'phone', title: '联系电话', align: 'center'},
{fixed: 'right', title: '操作', align: 'center', toolbar: '#customerRowBar'}
]]
});
//监控模糊查询按钮事件
form.on("submit(doSearch)", function (data) {
tableIns.reload({
where: data.field,
page: {
curr: 1
}
// 监听查询表单的提交事件
form.on('submit(doSearch)', function (data) {
table.reload('customerTable', {
where: data.field // 设置查询条件
});
return false;
});
//监控工具条事件
table.on("toolbar(customerTable)", function (obj) {
switch (obj.event) {
case 'add':
openAddLayer();
break;
case 'deleteBatch':
batchDeleteCustomer();
break;
};
return false; // 阻止表单默认提交
});
//监控行工具条事件
table.on("tool(customerTable)", function (obj) {
//获取当前行数据
// 监听行操作事件（编辑、删除）
table.on('tool(customerTable)', function (obj) {
var data = obj.data;
switch (obj.event) {
case 'delete':
deleteCustomer(data);
break;
case 'update':
updateCustomer(data);
break;
};
});
var layEvent = obj.event;
var mainIndex;
var url;
//打开添加弹出层
function openAddLayer() {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'添加客户',
success:function () {
$("#dataFrm")[0].reset();
url="/customer/addCustomer";
}
});
}
//打开修改的弹出层
function updateCustomer(data) {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'修改客户',
success:function () {
//清空原有的数据
$("#dataFrm")[0].reset();
//装载新的数据
form.val("dataFrm",data);
url="/customer/updateCustomer";
}
});
}
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);
});
return false;
});
//删除
function deleteCustomer(data) {
layer.confirm('你确定要删除【' + data.customername + '】这个客户吗？', {icon: 3, title: '提示'}, function (index) {
$.post("/customer/deleteCustomer", {id: data.id},function (res) {
if (res.code == 200) {
tableIns.reload({
where:"",
});
if (layEvent === 'update') {
// 编辑客户数据
layer.open({
type: 1,
area: ['600px', '600px'],
content: $('#addOrUpdateDiv'),
title: '编辑客户',
btn: ['保存', '取消'],
yes: function (index, layero) {
// 提交编辑表单
form.submit('dataFrm');
},
success: function (layero, index) {
form.val("dataFrm", data); // 填充数据
}
layer.msg(res.msg);
});
layer.close(index);
});
}
} else if (layEvent === 'delete') {
// 删除客户
layer.confirm('确定删除此客户吗？', function (index) {
// 执行删除操作
$.ajax({
url: '/customer/delete',
method: 'POST',
data: {id: data.id},
success: function (res) {
if (res.success) {
layer.msg("删除成功");
table.reload('customerTable');
} else {
layer.msg("删除失败");
}
}
});
layer.close(index);
});
}
});
});
</script>
</body>
</html>
</html>

374
src/main/resources/templates/business/sales/salesManager.html
Unescape View File

@ -17,6 +17,7 @@
<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;
@ -60,12 +61,14 @@
</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">
@ -74,6 +77,7 @@
</select>
</div>
</div>
<!-- 商品名称选择框 -->
<div class="layui-inline">
<label class="layui-form-label">商品名称</label>
<div class="layui-input-inline">
@ -82,6 +86,7 @@
</select>
</div>
</div>
<!-- 开始时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">开始时间</label>
<div class="layui-input-inline">
@ -89,6 +94,7 @@
class="layui-input input-radius">
</div>
</div>
<!-- 结束时间选择框 -->
<div class="layui-inline">
<label class="layui-form-label">结束时间</label>
<div class="layui-input-inline">
@ -98,6 +104,7 @@
</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>查询
@ -109,14 +116,16 @@
</div>
</form>
<!--数据表格-->
<!-- 数据表格展示区域 -->
<div>
<table class="layui-hide" id="salesTable" lay-filter="salesTable"></table>
<!-- 操作工具栏 -->
<div id="salesToolBar" style="display: none">
<button type="button" lay-event="add" shiro:hasPermission="sales: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="salesRowBar" style="display: none;">
<button type="button" lay-event="update" shiro:hasPermission="sales:update" class="layui-btn layui-btn-sm layui-btn-radius"><i
class="layui-icon layui-icon-edit"></i>编辑
@ -130,7 +139,7 @@
</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">
@ -154,6 +163,7 @@
</div>
</div>
<div class="layui-form-item">
<!-- 销售数量输入框 -->
<div class="layui-inline">
<label class="layui-form-label">销售数量</label>
<div class="layui-input-block">
@ -161,6 +171,7 @@
<input type="text" name="number" lay-verify="required|number" autocomplete="off" class="layui-input input-radius" placeholder="请输入销售数量">
</div>
</div>
<!-- 销售价格输入框 -->
<div class="layui-inline">
<label class="layui-form-label">销售价格</label>
<div class="layui-input-block">
@ -169,372 +180,71 @@
</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="银联">
<input type="radio" name="paytype" value="1" title="现金" checked>
<input type="radio" name="paytype" value="2" title="支付宝">
<input type="radio" name="paytype" value="3" title="微信">
</div>
</div>
</div>
<div class="layui-form-item">
<!-- 备注输入框 -->
<div class="layui-inline">
<label class="layui-form-label">销售备注</label>
<label class="layui-form-label">备注</label>
<div class="layui-input-block">
<textarea name="remark" placeholder="请输入销售备注" class="layui-textarea" cols="200" rows="8"></textarea>
<textarea placeholder="请输入备注" class="layui-textarea" name="remarks"></textarea>
</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 class="layui-input-block" style="text-align: center;padding-right: 10%;">
<button class="layui-btn layui-btn-radius layui-btn-normal" lay-submit="" lay-filter="addOrUpdate">确认</button>
<button type="button" class="layui-btn layui-btn-radius layui-btn-danger" id="cancelBtn" onclick="parent.layer.close(index)">取消</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 id="backDiv" style="display: none;padding: 10px;padding-right: 5%">
<form action="" method="post" class="layui-form" id="backFrm" lay-filter="backFrm">
<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="text" name="number" lay-verify="required|checkNumber" autocomplete="off" class="layui-input input-radius" placeholder="请输入退货数量">
<input type="text" name="backnumber" lay-verify="required|number" 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>
<label class="layui-form-label">备注</label>
<div class="layui-input-block">
<textarea name="remark" placeholder="请输入退货备注" class="layui-textarea" cols="200" rows="8"></textarea>
<textarea placeholder="请输入备注" class="layui-textarea" name="remarks"></textarea>
</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>
<button type="reset" class="layui-btn layui-btn-radius layui-btn-warm"><i
class="layui-icon layui-icon-refresh"></i><span>重置</span>
</button>
<div class="layui-input-block" style="text-align: center;padding-right: 10%;">
<button class="layui-btn layui-btn-radius layui-btn-normal" lay-submit="" lay-filter="back">确认</button>
<button type="button" class="layui-btn layui-btn-radius layui-btn-danger" id="cancelBtn" onclick="parent.layer.close(index)">取消</button>
</div>
</div>
</form>
</div>
<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 () {
var $ = layui.jquery;
var form = layui.form;
var layer = layui.layer;
var table = layui.table;
var laydate = layui.laydate;
//初始化时间选择器
laydate.render({
elem: '#startTime',
type: 'datetime'
});
laydate.render({
elem: '#endTime',
type: 'datetime'
})
//初始化表格 加载数据
tableIns = table.render({
elem: "#salesTable",
title: "销售数据表格",
url: "/sales/loadAllSales",
toolbar: "#salesToolBar",
page: true,
height: "full-180",
cols: [ [
{field: 'id', title: 'ID', align: 'center',width:'50'},
{field: 'customername', title: '客户名称', align: 'center',width:'100'},
{field: 'goodsname', title: '商品名称', align: 'center',width:'150'},
{field: 'paytype', title: '支付类型', align: 'center',width:'90'},
{field: 'salestime', title: '销售时间', align: 'center',width:'170'},
{field: 'operateperson', title: '操作员', align: 'center',width:'130'},
{field: 'number', title: '销售数量', align: 'center',width:'100'},
{field: 'size', title: '商品规格', align: 'center',width:'100'},
{field: 'saleprice', title: '销售价格', align: 'center',width:'120'},
{field: 'remark', title: '备注', align: 'center',width:'120'},
{fixed: 'right', title: '操作', toolbar: '#salesRowBar', align: 'center',width:'260'}
] ],
done: function (data, curr, count) {
//不是第一页时，如果当前返回的数据为0那么就返回上一页
if (data.data.length == 0 && curr != 1) {
tableIns.reload({
page: {
curr: curr - 1
}
})
}
}
});
//监控模糊查询按钮事件
form.on("submit(doSearch)", function (data) {
tableIns.reload({
where: data.field,
page: {
curr: 1
}
});
return false;
});
//监控工具条事件
table.on("toolbar(salesTable)", function (obj) {
switch (obj.event) {
case 'add':
openAddLayer();
break;
};
});
//监控行工具条事件
table.on("tool(salesTable)", function (obj) {
//获取当前行数据
var data = obj.data;
switch (obj.event) {
case 'delete':
deleteSales(data);
break;
case 'update':
updateSales(data);
break;
case 'back':
backSales(data);
break;
};
});
//初始化客户名称的下拉列表
$.get("/customer/loadAllCustomerForSelect",function (res) {
var data = res.data;
var dom = $("#select_customerid");
var html = '<option value="0">请选择客户</option>';
$.each(data,function (index, item) {
html += '<option value="'+item.id+'">'+item.customername+'</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");
});
var mainIndex;
var url;
//打开添加弹出层
function openAddLayer() {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'添加销售',
success:function () {
$("#dataFrm")[0].reset();
//初始化客户名称的下拉列表
initCustomerSelect();
//使该div隐藏
$(".mydiv").hide();
url="/sales/addSales";
}
});
}
//打开修改的弹出层
function updateSales(data) {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['700px','500px'],
title:'修改商品销售',
success:function () {
//清空原有的数据
$("#dataFrm")[0].reset();
//装载新的数据
form.val("dataFrm",data);
//客户进行反选
initCustomerSelect(data.customerid);
//商品下拉列表的回显
$.get("/goods/loadAllGoodsForSelect",function(res){
var redata=res.data;
var dom=$("#goodsid");
var html='<option value="0">请选择供应商</option>'
$.each(redata,function(index,item){
if (data.goodsid===item.id){
html+='<option value="'+item.id+'" selected>'+item.goodsname+'</option>'
}else {
html+='<option value="'+item.id+'">'+item.goodsname+'</option>'
}
});
dom.html(html);
form.render("select");
});
//禁用供应商和商品的下拉列表
$(".mydiv").show();
url="/sales/updateSales";
}
});
}
//初始化添加和修改页面的下拉列表
function initCustomerSelect(customerid) {
//重置商品的下拉列表
var dom = $("#goodsid");
dom.html("");
$.get("/customer/loadAllCustomerForSelect",function (res) {
var data = res.data;
var dom = $("#customerid");
var html = '<option value="0">请选择客户</option>';
$.each(data,function (index, item) {
html += '<option value="'+item.id+'">'+item.customername+'</option>';
});
dom.html(html);
//如果customerid有值就进行反选
if (customerid!=undefined){
dom.val(customerid);
}
//重新渲染下拉列表
form.render("select");
});
};
//监听客户的下拉列表的事件
form.on('select(customerid)',function (data) {
var customerid = data.value;
initGoodsSelect(customerid);
});
//加载商品的下拉列表
function initGoodsSelect(goodsid) {
$.get("/goods/loadAllGoodsForSelect",function (res) {
var data = res.data;
var dom = $("#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);
//如果goodsid有值就进行反选
if (goodsid!=undefined){
dom.val(goodsid);
}
//重新渲染下拉列表
form.render("select");
});
}
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);
});
return false;
});
//删除
function deleteSales(data) {
layer.confirm('你确定要删除这条销售信息吗？', {icon: 3, title: '提示'}, function (index) {
$.post("/sales/deleteSales", {id: data.id},function (res) {
if (res.code == 200) {
tableIns.reload({
where:"",
});
}
layer.msg(res.msg);
});
layer.close(index);
});
}
//打开退货的弹出层
function backSales(data) {
mainIndex = layer.open({
type:1,
content:$("#backGoodsDiv"),
area:['600px','400px'],
title:'商品销售退货',
success:function () {
//清空原有的数据
$("#dataFrmBack")[0].reset();
//装载新的数据 获得销售的ID以及当前销售单的销售数量
form.val("dataFrmBack",{id:data.id,currentNumber:data.number});
}
});
}
//自定义验证规则
form.verify({
checkNumber: function (value) {
var currentNumber = $("#currentNumber").val();
//value为退货的数量 currentNumber为当前销售单的数量
if (parseInt(value)>currentNumber||parseInt(value)<1){
return '退货数量只能在【0】-【'+currentNumber+'】之间';
}
}
});
//退货提交
form.on("submit(doBackSubmit)",function (data) {
$.post("/salesback/addSalesback",data.field,function (res) {
if (res.code==200){
//重新加载表格数据
tableIns.reload();
//关闭退货弹出层
layer.close(mainIndex);
}
layer.msg(res.msg);
});
return false;
})
<script src="resources/layui/layui.js"></script>
<script>
layui.use(['form', 'table', 'laydate'], function () {
var form = layui.form, table = layui.table, laydate = layui.laydate;
// 这里可以添加更多的功能脚本
});
</script>
</body>
</html>
</html>

264
src/main/resources/templates/system/menu/menuRight.html
Unescape View File

@ -167,40 +167,20 @@
{field: 'title', title: '菜单名称', align: 'center',width:'150'},
{field: 'href', title: '菜单地址', align: 'center',width:'200'},
{field: 'icon', title: '菜单图标', align: 'center',width:'90',templet:function (d) {
return '<font class="layui-icon">'+d.icon+'</font>';
}},
return '<font class="layui-icon">'+d.icon+'</font>';
}},
{field: 'available', title: '是否可用', align: 'center',width:'100',templet:function (d) {
return d.available==1?'<font color="blue">可用</font>':'<font color="red">不可用</font>';
}},
return d.available==1?'<font color="blue">可用</font>':'<font color="red">不可用</font>';
}},
{field: 'open', title: '是否展开', align: 'center',width:'100',templet:function (d) {
return d.open==1?'<font color="blue">展开</font>':'<font color="red">不展开</font>';
}},
{field: 'ordernum', title: '排序码', align: 'center',width:'80'},
{field: 'target', title: 'TARGET', align: 'center',width:'80',hide:true},
{fixed: 'right', title: '操作', toolbar: '#menuRowBar', align: 'center',width:'180'}
] ],
done: function (data, curr, count) {
//不是第一页时，如果当前返回的数据为0那么就返回上一页
if (data.data.length == 0 && curr != 1) {
tableIns.reload({
page: {
curr: curr - 1
}
})
}
/*//当是第一页时，如果当前返回的数据为0并且当前为第一页 给一个空的查询条件，并给curr赋初值为1
if (data.data.length==0 && curr==1){
tableIns.reload({
where: "",
page:{
curr:1
}
})
}*/
}
return d.open==1?'<font color="blue">展开</font>':'<font color="red">不展开</font>';
}},
{field: 'ordernum', title: '排序码', align: 'center',width:'100'},
{fixed: 'right', title: '操作', toolbar: '#menuRowBar', width: 200}
] ]
});
//监控模糊查询按钮事件
//搜索条件：提交表单进行查询
form.on("submit(doSearch)", function (data) {
tableIns.reload({
where: data.field,
@ -211,161 +191,105 @@
return false;
});
//监控工具条事件
table.on("toolbar(menuTable)", function (obj) {
switch (obj.event) {
case 'add':
openAddLayer();
break;
};
//弹出新增菜单表单
$(".layui-btn[lay-event='add']").click(function () {
layer.open({
type: 1,
title: "添加菜单",
area: ['600px', 'auto'],
content: $("#addOrUpdateDiv")
});
$("#dataFrm")[0].reset();
$("#pid").val(0);
$("#ordernum").val(100);
});
//监控行工具条事件
table.on("tool(menuTable)", function (obj) {
//获取当前行数据
var data = obj.data;
//监听表格工具条事件
table.on('toolbar(menuTable)', function (obj) {
switch (obj.event) {
case 'delete':
deleteMenu(data);
break;
case 'update':
updateMenu(data);
break;
};
});
var mainIndex;
var url;
//打开添加弹出层
function openAddLayer() {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['800px','450px'],
title:'添加菜单',
success:function () {
$("#dataFrm")[0].reset();
//设置下拉树中父节点的值为空
$("#pid").val("");
url="/menu/addMenu";
//初始化排序码
$.get("/menu/loadMenuMaxOrderNum",function (res) {
$("#ordernum").val(res.value);
case 'add': //新增菜单
layer.open({
type: 1,
title: "添加菜单",
area: ['600px', 'auto'],
content: $("#addOrUpdateDiv")
});
//设置下拉树的value值为空
selectTree.selectVal("");
}
});
}
//打开修改的弹出层
function updateMenu(data) {
mainIndex = layer.open({
type:1,
content:$("#addOrUpdateDiv"),
area:['800px','450px'],
title:'修改菜单',
success:function () {
//清空原有的数据
$("#dataFrm")[0].reset();
//装载新的数据
form.val("dataFrm",data);
//选中之前的父级菜单 nodeId=data.pid
dtree.dataInit("menuTree",data.pid);
dtree.selectVal("menuTree");
url="/menu/updateMenu";
}
});
}
$("#pid").val(0);
$("#ordernum").val(100);
break;
}
});
form.on("submit(doSubmit)",function (data) {
$.post(url,data.field,function (res) {
if (res.code==200){
tableIns.reload();
//重新加载添加弹出层的下拉树
selectTree.reload();
//重新加载左边的菜单树
window.parent.left.menuTree.reload();
//监听行工具事件
table.on('tool(menuTable)', function (obj) {
var data = obj.data;
var layEvent = obj.event;
if (layEvent === 'update') { //编辑
$("#dataFrm")[0].reset();
//打开修改菜单弹出层
layer.open({
type: 1,
title: "编辑菜单",
area: ['600px', 'auto'],
content: $("#addOrUpdateDiv")
});
//初始化表单数据
$("#dataFrm")[0].reset();
form.val("dataFrm", {
id: data.id,
pid: data.pid,
title: data.title,
href: data.href,
icon: data.icon,
target: data.target,
available: data.available,
open: data.open,
ordernum: data.ordernum
});
dtree.render({
elem: "#menuTree",
url: "/menu/loadMenuTree",
dataStyle: "layui",
click: function (data) {
$("#pid").val(data.id);
}
});
} else if (layEvent === 'delete') { //删除
if (data.children && data.children.length > 0) {
layer.msg("该菜单有子菜单，请先删除子菜单！", {icon: 5});
return;
}
layer.msg(res.msg);
layer.close(mainIndex);
});
return false;
layer.confirm("您确定删除该菜单吗？", {icon: 3, title: '提示'}, function (index) {
$.post("/menu/delete", {id: data.id}, function (res) {
if (res.code === 200) {
layer.msg(res.msg, {icon: 1});
tableIns.reload();
} else {
layer.msg(res.msg, {icon: 5});
}
});
layer.close(index);
});
}
});
/*$("#doSubmit").click(function () {
var data = $("#dataFrm").serialize();
$.post(url,data,function (res) {
if (res.code==200){
//监听提交按钮：添加或修改菜单
form.on("submit(doSubmit)", function (data) {
$.post("/menu/saveOrUpdate", data.field, function (res) {
if (res.code === 200) {
layer.msg(res.msg, {icon: 1});
layer.closeAll();
tableIns.reload();
//重新加载添加弹出层的下拉树
selectTree.reload();
//重新加载左边的菜单树
window.parent.left.menuTree.reload();
}
layer.msg(res.msg);
layer.close(mainIndex);
});
});*/
//删除
function deleteMenu(data) {
$.post("/menu/checkMenuHasChildrenNode", {id: data.id}, function (resoult) {
if (resoult.value){
layer.msg("当前菜单节点有子菜单，请选择删除子菜单！")
}else {
layer.confirm('你确定要删除【' + data.title + '】这个菜单吗？', {icon: 3, title: '提示'}, function (index) {
$.post("/menu/deleteMenu", {id: data.id},function (res) {
if (res.code == 200) {
tableIns.reload({
where:"",
});
//刷新下拉树
selectTree.reload();
//刷新左边的菜单树
window.parent.left.menuTree.reload();
}
layer.msg(res.msg);
});
layer.close(index);
});
} else {
layer.msg(res.msg, {icon: 5});
}
});
}
//初始化下拉树
var selectTree = dtree.renderSelect({
elem: "#menuTree",
width: "100%", // 可以在这里指定树的宽度来填满div
dataStyle: "layuiStyle", //使用layui风格的数据格式
dataFormat: "list", //配置data的风格为list
response:{message:"msg",statusCode:0}, //修改response中返回数据的定义
url: "/menu/loadMenuManagerLeftTreeJson" // 使用url加载（可与data加载同时存在）
return false;
});
//监听点击的方法
dtree.on("node(menuTree)",function (obj) {
$("#pid").val(obj.param.nodeId);
console.log(obj.param.nodeId);
})
});
//给其它页面刷新当前页面数据表格的方法
function reloadTable(id) {
tableIns.reload({
where:{
id:id
},
page:{
curr:1
}
});
}
</script>
</body>
</html>
</html>

11
src/test/java/com/yeqifu/WarehouseApplicationTests.java
Unescape View File

@ -1,13 +1,14 @@
package com.yeqifu;
package com.yeqifu; // 定义该类所在的包路径
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.junit.jupiter.api.Test; // 导入 JUnit 5 的 Test 注解，用于标记测试方法
import org.springframework.boot.test.context.SpringBootTest; // 导入 Spring Boot 的测试注解，用于加载 Spring 上下文
@SpringBootTest
@SpringBootTest // 标记这个类是一个 Spring Boot 测试类，Spring 会自动加载应用上下文
class WarehouseApplicationTests {
@Test
@Test // 标记这个方法是一个测试方法
void contextLoads() {
// 该方法为空，表示只是测试 Spring 应用上下文能否成功加载
}
}

90
src/test/java/com/yeqifu/generator/CodeGenerator.java
Unescape View File

@ -1,15 +1,15 @@
package com.yeqifu.generator;
package com.yeqifu.generator; // 定义该类所在的包路径
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.apache.commons.lang3.StringUtils;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException; // 导入 MyBatisPlusException 异常类
import com.baomidou.mybatisplus.generator.AutoGenerator; // 导入 AutoGenerator 类，用于代码生成
import com.baomidou.mybatisplus.generator.config.DataSourceConfig; // 导入 DataSourceConfig 类，配置数据源
import com.baomidou.mybatisplus.generator.config.GlobalConfig; // 导入 GlobalConfig 类，全局配置
import com.baomidou.mybatisplus.generator.config.PackageConfig; // 导入 PackageConfig 类，配置包路径
import com.baomidou.mybatisplus.generator.config.StrategyConfig; // 导入 StrategyConfig 类，配置生成策略
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy; // 导入 NamingStrategy 类，设置命名策略
import org.apache.commons.lang3.StringUtils; // 导入 StringUtils 工具类，提供字符串操作
import java.util.Scanner;
import java.util.Scanner; // 导入 Scanner 类，用于读取控制台输入
/**
* mp生成器
@ -24,78 +24,74 @@ public class CodeGenerator {
* </p>
*/
public static String scanner(String tip) {
// 创建 Scanner 实例，读取控制台输入
Scanner scanner = new Scanner(System.in);
StringBuilder help = new StringBuilder();
help.append("请输入" + tip + "：");
System.out.println(help.toString());
help.append("请输入" + tip + "："); // 拼接提示信息
System.out.println(help.toString()); // 输出提示信息
if (scanner.hasNext()) {
String ipt = scanner.next();
String ipt = scanner.next(); // 获取输入内容
if (StringUtils.isNotEmpty(ipt)) {
return ipt;
return ipt; // 如果输入不为空，则返回输入的内容
}
}
// 如果输入为空，则抛出 MybatisPlusException 异常
throw new MybatisPlusException("请输入正确的" + tip + "！");
}
public static void main(String[] args) {
// 代码生成器
// 创建代码生成器实例
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
String projectPath = System.getProperty("user.dir");
gc.setOutputDir(projectPath + "/src/main/java");
gc.setAuthor("luoyi-");
gc.setOpen(false); //当代码生成完成之后是否打开代码所在的文件夹
// gc.setSwagger2(true); 实体属性 Swagger2 注解
String projectPath = System.getProperty("user.dir"); // 获取项目路径
gc.setOutputDir(projectPath + "/src/main/java"); // 设置生成代码的输出目录
gc.setAuthor("luoyi-"); // 设置作者名称
gc.setOpen(false); // 生成代码后是否打开文件夹
// gc.setSwagger2(true); // 如果需要生成 Swagger2 注解，可以启用该项
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://localhost:3306/warehouse?useUnicode=true&useSSL=false&characterEncoding=utf8");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("123456");
mpg.setDataSource(dsc);
dsc.setUrl("jdbc:mysql://localhost:3306/warehouse?useUnicode=true&useSSL=false&characterEncoding=utf8"); // 设置数据库连接 URL
// dsc.setSchemaName("public"); // 如果需要指定数据库的 schema，可以启用该项
dsc.setDriverName("com.mysql.jdbc.Driver"); // 设置数据库驱动
dsc.setUsername("root"); // 设置数据库用户名
dsc.setPassword("123456"); // 设置数据库密码
mpg.setDataSource(dsc); // 设置数据源配置
// 包配置
PackageConfig pc = new PackageConfig();
pc.setModuleName(scanner("模块名"));
pc.setParent("com.yeqifu");
pc.setXml("mapper.xml");
mpg.setPackageInfo(pc);
pc.setModuleName(scanner("模块名")); // 从控制台读取模块名
pc.setParent("com.yeqifu"); // 设置父包名
pc.setXml("mapper.xml"); // 设置生成的 XML 文件的路径
mpg.setPackageInfo(pc); // 设置包配置
// 策略配置
StrategyConfig strategy = new StrategyConfig();
//设置字段名和表名是否把下划线换成驼峰命名规则
// 设置表名和字段名是否使用下划线转驼峰命名规则
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
//设置生成的实体类继承的父类
//strategy.setSuperEntityClass("com.baomidou.ant.common.BaseEntity");
//是否启用lombok
// 是否启用 Lombok（生成 getter/setter 方法）
strategy.setEntityLombokModel(true);
//是否生成restController
// 是否生成 RestController 风格的 Controller
strategy.setRestControllerStyle(true);
// 公共父类
// strategy.setSuperControllerClass("com.baomidou.ant.common.BaseController");
// 写于父类中的公共字段
// strategy.setSuperEntityColumns("id");
//设置要生成哪些表 如果不设置就是生成所有的表
// 设置要生成的表名，如果不设置则会生成所有表
strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
// 设置是否使用驼峰命名映射 URL（如 /user-id -> /userId）
strategy.setControllerMappingHyphenStyle(true);
strategy.setTablePrefix(pc.getModuleName() + "_");
// strategy.setTablePrefix("sys_");
// 设置表前缀（可选）
strategy.setTablePrefix(pc.getModuleName() + "_"); // 可以设置模块名前缀，或者自定义表前缀
// 将策略配置设置到生成器中
mpg.setStrategy(strategy);
// 执行代码生成
mpg.execute();
}
}

Write Preview
Loading…
Cancel
Save