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

Compare commits

base: pcjs8mx7g:master
Branches Tags
pcjs8mx7g:gujian_branch
pcjs8mx7g:master
pcjs8mx7g:shaoaoqi_branch
pcjs8mx7g:liushenping_branch
pcjs8mx7g:liaobiaojie_branch
..
compare: pcjs8mx7g:liushenping_branch
Branches Tags
pcjs8mx7g:gujian_branch
pcjs8mx7g:master
pcjs8mx7g:shaoaoqi_branch
pcjs8mx7g:liushenping_branch
pcjs8mx7g:liaobiaojie_branch

15 Commits
master ... liushenpin

Author SHA1 Message Date
liushenping fbb9640df8 1234567891011
1 year ago
liushenping 452a115b6a 12345678910
1 year ago
liushenping 32b7eed5fb 123456789
1 year ago
liushenping a05c356a48 12345678
1 year ago
liushenping 5c7845eeef 12345678
1 year ago
liushenping b02fb78571 12345678
1 year ago
liushenping 1e0dec0fb8 1234567
1 year ago
liushenping 224a943e24 123456
1 year ago
liushenping b3585df2b7 12345
1 year ago
liushenping decc7e949e 1234
1 year ago
liushenping bb98d4f658 123
1 year ago
liushenping 664d307a2e 12
1 year ago
liushenping afb66d707b 1
1 year ago
liushenping 493d2c657b 123
1 year ago
liushenping 29982cf770 123
1 year ago
68 changed files with 3024 additions and 3492 deletions
Show Stats

1
README.md
Unescape View File

@ -100,4 +100,3 @@
![](https://code.educoder.net/api/pcjs8mx7g/warehouse/raw/src%2Fmain%2Fresources%2Fstatic%2Fimages%2Fsales.PNG?ref=master)
商品销售退货管理
![](https://code.educoder.net/api/pcjs8mx7g/warehouse/raw/src%2Fmain%2Fresources%2Fstatic%2Fimages%2Fsalesback.PNG?ref=master)
//这是一个测试

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"; // 返回商品销售退货管理页面的视图名称
}
}
}

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

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

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

@ -1,170 +1,151 @@
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.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; // 商品视图对象
import com.yeqifu.sys.common.AppFileUtils; // 文件操作工具类
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 com.yeqifu.sys.common.DataGridView; // 用于封装表格数据的类
import com.yeqifu.sys.common.ResultObj; // 封装操作结果的类
import org.apache.commons.lang3.StringUtils; // 字符串工具类
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 映射请求路径注解
import org.springframework.web.bind.annotation.RestController; // REST 控制器注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解
import org.springframework.web.bind.annotation.RestController; // RESTful控制器注解
import java.util.List; // Java 集合类
import java.util.List; // List集合类
/**
* 商品管理控制器
* 提供了对商品的查询、添加、修改、删除等功能
* 商品管理的前端控制器
* 提供商品的增删改查以及相关查询功能
* @author luoyi-
* @since 2019-12-06
*/
@RestController // 标注为 REST 控制器，返回 JSON 数据
@RequestMapping("/goods") // 设置请求路径的统一前缀
@RestController // 标记为RESTful控制器
@RequestMapping("/goods") // 定义请求路径前缀为"/goods"
public class GoodsController {
@Autowired // 自动注入商品服务
private IGoodsService goodsService;
@Autowired
private IGoodsService goodsService; // 自动注入商品服务
@Autowired // 自动注入供应商服务
private IProviderService providerService;
@Autowired
private IProviderService providerService; // 自动注入供应商服务
/**
* 查询商品信息
* @param goodsVo 商品视图对象，封装了查询条件
* @return 返回分页的商品信息
* 分页查询商品信息
* @param goodsVo 封装商品查询条件和分页参数
* @return 包含商品列表和总记录数的DataGridView
*/
@RequestMapping("loadAllGoods") // 请求映射到 /goods/loadAllGoods
@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()); // 按供应商 ID 查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getGoodsname()), "goodsname", goodsVo.getGoodsname()); // 按商品名称模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getProductcode()), "productcode", goodsVo.getProductcode()); // 按商品编码模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getPromitcode()), "promitcode", goodsVo.getPromitcode()); // 按促销编码模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getDescription()), "description", goodsVo.getDescription()); // 按描述模糊查询
queryWrapper.like(StringUtils.isNotBlank(goodsVo.getSize()), "size", goodsVo.getSize()); // 按尺寸模糊查询
queryWrapper.orderByDesc("id"); // 按 ID 降序排序
// 执行分页查询
// 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 查询供应商信息，并设置供应商名称
// 根据供应商ID设置供应商名称
Provider provider = providerService.getById(goods.getProviderid());
if (provider != null) {
goods.setProvidername(provider.getProvidername());
}
}
// 返回分页数据和商品记录
// 返回分页数据
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加商品
* @param goodsVo 商品视图对象
* @return 返回操作结果
* @param goodsVo 包含商品信息
* @return 操作结果
*/
@RequestMapping("addGoods") // 请求映射到 /goods/addGoods
@RequestMapping("addGoods")
public ResultObj addGoods(GoodsVo goodsVo) {
try {
System.out.println("====================================");
System.out.println(goodsVo.getGoodsimg()); // 打印上传的商品图片路径
// 如果上传的图片路径是临时文件，则重命名为正式文件
if (goodsVo.getGoodsimg() != null && goodsVo.getGoodsimg().endsWith("_temp")) {
// 重命名临时图片为正式图片
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
goodsVo.setGoodsimg(newName); // 更新图片路径
goodsVo.setGoodsimg(newName);
}
// 保存商品信息
goodsService.save(goodsVo);
// 返回添加成功的结果
return ResultObj.ADD_SUCCESS;
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.ADD_ERROR; // 返回添加失败的结果
e.printStackTrace();
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 修改商品
* @param goodsVo 商品视图对象
* @return 返回操作结果
* 修改商品信息
* @param goodsVo 包含商品修改信息
* @return 操作结果
*/
@RequestMapping("updateGoods") // 请求映射到 /goods/updateGoods
@RequestMapping("updateGoods")
public ResultObj updateGoods(GoodsVo goodsVo) {
try {
// 如果商品图片不是默认图片，则处理图片路径
if (!(goodsVo.getGoodsimg() != null && goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS))) {
// 如果商品图片不是默认图片
if (goodsVo.getGoodsimg() != null && !goodsVo.getGoodsimg().equals(Constast.DEFAULT_IMG_GOODS)) {
if (goodsVo.getGoodsimg().endsWith("_temp")) {
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg()); // 重命名图片文件
// 重命名临时图片
String newName = AppFileUtils.renameFile(goodsVo.getGoodsimg());
goodsVo.setGoodsimg(newName);
// 删除原先的图片文件
// 删除原图片文件
String oldPath = goodsService.getById(goodsVo.getId()).getGoodsimg();
AppFileUtils.removeFileByPath(oldPath);
}
}
// 更新商品信息
goodsService.updateById(goodsVo);
// 返回更新成功的结果
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.UPDATE_ERROR; // 返回更新失败的结果
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
}
}
/**
* 删除商品
* @param id 商品 ID
* @param id 商品ID
* @param goodsimg 商品图片路径
* @return 返回操作结果
* @return 操作结果
*/
@RequestMapping("deleteGoods") // 请求映射到 /goods/deleteGoods
@RequestMapping("deleteGoods")
public ResultObj deleteGoods(Integer id, String goodsimg) {
try {
// 删除商品的图片文件
// 删除商品图片
AppFileUtils.removeFileByPath(goodsimg);
// 删除商品信息
// 删除商品记录
goodsService.deleteGoodsById(id);
// 返回删除成功的结果
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
/**
* 加载所有可用的商品
* @return 返回所有可用商品的信息
* 加载所有可用商品
* @return 包含商品列表的DataGridView
*/
@RequestMapping("loadAllGoodsForSelect") // 请求映射到 /goods/loadAllGoodsForSelect
@RequestMapping("loadAllGoodsForSelect")
public DataGridView loadAllGoodsForSelect() {
// 构造查询条件，仅查询状态为可用的商品
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
// 查询商品列表
List<Goods> list = goodsService.list(queryWrapper);
for (Goods goods : list) {
// 设置供应商名称
@ -173,24 +154,19 @@ public class GoodsController {
goods.setProvidername(provider.getProvidername());
}
}
// 返回商品列表
return new DataGridView(list);
}
/**
* 根据供应商 ID 查询商品信息
* @param providerid 供应商 ID
* @return 返回该供应商的商品信息
* 根据供应商ID查询商品信息
* @param providerid 供应商ID
* @return 包含商品列表的DataGridView
*/
@RequestMapping("loadGoodsByProviderId") // 请求映射到 /goods/loadGoodsByProviderId
@RequestMapping("loadGoodsByProviderId")
public DataGridView loadGoodsByProviderId(Integer providerid) {
// 构造查询条件，仅查询状态为可用的商品
QueryWrapper<Goods> queryWrapper = new QueryWrapper<Goods>();
QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
queryWrapper.eq(providerid != null, "providerid", providerid); // 按供应商 ID 查询
// 查询商品列表
queryWrapper.eq(providerid != null, "providerid", providerid);
List<Goods> list = goodsService.list(queryWrapper);
for (Goods goods : list) {
// 设置供应商名称
@ -199,21 +175,16 @@ public class GoodsController {
goods.setProvidername(provider.getProvidername());
}
}
// 返回商品列表
return new DataGridView(list);
}
/**
* 查询所有库存预警的商品
* @return 返回库存预警商品的信息
* 加载所有库存预警的商品
* @return 包含预警商品列表的DataGridView
*/
@RequestMapping("loadAllWarningGoods") // 请求映射到 /goods/loadAllWarningGoods
@RequestMapping("loadAllWarningGoods")
public DataGridView loadAllWarningGoods() {
// 查询所有库存预警的商品
List<Goods> goods = goodsService.loadAllWarning();
// 返回预警商品的数量和列表
return new DataGridView((long) goods.size(), goods);
}
}

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

@ -1,128 +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; // 导入 Web 工具类
import com.yeqifu.sys.entity.User; // 导入用户实体类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入注解
import org.springframework.web.bind.annotation.RequestMapping; // 导入请求映射注解
import org.springframework.web.bind.annotation.RestController; // 导入 REST 控制器注解
import java.util.Date; // 导入日期类
import java.util.List; // 导入 Java 集合类
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.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; // 集合类
/**
* 商品进货管理控制器
* 提供商品进货的查询、添加、修改、删除功能
* 商品进货管理的前端控制器
* 提供进货记录的增删改查等操作
*/
@RestController // 标注为 REST 控制器，返回 JSON 数据
@RequestMapping("inport") // 设置请求路径的统一前缀
@RestController
@RequestMapping("inport") // 定义接口的基础路径
public class InportController {
@Autowired // 自动注入商品进货服务
private IInportService inportService;
@Autowired
private IInportService inportService; // 自动注入进货服务
@Autowired // 自动注入供应商服务
private IProviderService providerService;
@Autowired
private IProviderService providerService; // 自动注入供应商服务
@Autowired // 自动注入商品服务
private IGoodsService goodsService;
@Autowired
private IGoodsService goodsService; // 自动注入商品服务
/**
* 查询商品进货信息
* @param inportVo 进货视图对象，封装了查询条件
* @return 返回分页的进货信息
* 查询所有商品进货记录
* @param inportVo 包含查询条件和分页参数
* @return 分页后的商品进货数据
*/
@RequestMapping("loadAllInport") // 请求映射到 /inport/loadAllInport
@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()); // 按供应商 ID 查询
queryWrapper.eq(inportVo.getGoodsid() != null && inportVo.getGoodsid() != 0, "goodsid", inportVo.getGoodsid()); // 按商品 ID 查询
queryWrapper.ge(inportVo.getStartTime() != null, "inporttime", inportVo.getStartTime()); // 查询大于等于开始时间的数据
queryWrapper.le(inportVo.getEndTime() != null, "inporttime", inportVo.getEndTime()); // 查询小于等于结束时间的数据
queryWrapper.orderByDesc("inporttime"); // 按进货时间降序排序
IPage<Inport> page1 = inportService.page(page, queryWrapper); // 执行分页查询
List<Inport> records = page1.getRecords(); // 获取查询结果
for (Inport inport : records) { // 遍历查询结果
Provider provider = providerService.getById(inport.getProviderid()); // 根据供应商 ID 查询供应商信息
if (provider != null) { // 如果供应商信息存在
// 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");
// 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()); // 设置供应商名称
}
Goods goods = goodsService.getById(inport.getGoodsid()); // 根据商品 ID 查询商品信息
if (goods != null) { // 如果商品信息存在
Goods goods = goodsService.getById(inport.getGoodsid());
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") // 请求映射到 /inport/addInport
@RequestMapping("addInport")
public ResultObj addInport(InportVo inportVo) {
try {
User user = (User) WebUtils.getSession().getAttribute("user"); // 获取当前登录用户
inportVo.setOperateperson(user.getName()); // 设置操作人姓名
inportVo.setInporttime(new Date()); // 设置进货时间为当前时间
inportService.save(inportVo); // 保存进货信息
return ResultObj.ADD_SUCCESS; // 返回添加成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.ADD_ERROR; // 返回添加失败的结果
// 获取当前系统用户
User user = (User) WebUtils.getSession().getAttribute("user");
// 设置操作人
inportVo.setOperateperson(user.getName());
// 设置进货时间为当前时间
inportVo.setInporttime(new Date());
// 保存进货记录
inportService.save(inportVo);
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 更新进货商品
* @param inportVo 进货视图对象
* @return 返回操作结果
* 更新进货记录
* @param inportVo 包含修改后的进货信息
* @return 操作结果
*/
@RequestMapping("updateInport") // 请求映射到 /inport/updateInport
@RequestMapping("updateInport")
public ResultObj updateInport(InportVo inportVo) {
try {
inportService.updateById(inportVo); // 更新进货信息
return ResultObj.UPDATE_SUCCESS; // 返回更新成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.UPDATE_ERROR; // 返回更新失败的结果
// 更新进货记录
inportService.updateById(inportVo);
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 删除进货商品
* @param id 进货记录 ID
* @return 返回操作结果
* 删除进货记录
* @param id 要删除的进货记录ID
* @return 操作结果
*/
@RequestMapping("deleteInport") // 请求映射到 /inport/deleteInport
@RequestMapping("deleteInport")
public ResultObj deleteInport(Integer id) {
try {
inportService.removeById(id); // 删除进货记录
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
} catch (Exception e) { // 捕获异常
e.printStackTrace(); // 打印异常堆栈信息
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
// 根据ID删除进货记录
inportService.removeById(id);
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

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

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

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

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

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

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

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

@ -1,182 +1,123 @@
package com.yeqifu.bus.controller;
// 声明类所在的包
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
// 导入QueryWrapper类，用于构建查询条件
import com.baomidou.mybatisplus.core.metadata.IPage;
// 导入IPage接口，用于分页功能
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入Page类，用于创建分页对象
import com.yeqifu.bus.entity.Customer;
// 导入Customer实体类，表示客户信息
import com.yeqifu.bus.entity.Goods;
// 导入Goods实体类，表示商品信息
import com.yeqifu.bus.entity.Salesback;
// 导入Salesback实体类，表示销售退货信息
import com.yeqifu.bus.service.ICustomerService;
// 导入ICustomerService接口，用于处理客户业务逻辑
import com.yeqifu.bus.service.IGoodsService;
// 导入IGoodsService接口，用于处理商品业务逻辑
import com.yeqifu.bus.service.ISalesbackService;
// 导入ISalesbackService接口，用于处理销售退货业务逻辑
import com.yeqifu.bus.vo.SalesbackVo;
// 导入SalesbackVo类，用于封装查询参数
import com.yeqifu.sys.common.DataGridView;
// 导入DataGridView类，用于返回表格数据
import com.yeqifu.sys.common.ResultObj;
// 导入ResultObj类，用于统一返回操作结果
import org.springframework.beans.factory.annotation.Autowired;
// 导入@Autowired注解，用于自动注入服务对象
import org.springframework.web.bind.annotation.RequestMapping;
// 导入@RequestMapping注解，用于映射请求路径
import org.springframework.web.bind.annotation.RestController;
// 导入@RestController注解，标识该类为REST控制器
import java.util.List;
// 导入Java集合类List，用于处理列表数据
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 java.util.List; // 集合类
/**
* 销售退货控制器类
* 负责处理与销售退货相关的请求
* 销售退货管理前端控制器
* 提供销售退货的增删改查功能
*/
@RestController
// 标识该类为REST风格的控制器
@RequestMapping("/salesback")
// 将类的基础URL路径映射为"/salesback"
@RequestMapping("/salesback") // 定义接口基础路径
public class SalesbackController {
@Autowired
// 自动注入ISalesbackService接口的实现类
private ISalesbackService salesbackService;
private ISalesbackService salesbackService; // 自动注入销售退货服务
@Autowired
// 自动注入ICustomerService接口的实现类
private ICustomerService customerService;
private ICustomerService customerService; // 自动注入客户服务
@Autowired
// 自动注入IGoodsService接口的实现类
private IGoodsService goodsService;
private IGoodsService goodsService; // 自动注入商品服务
/**
* 添加退货信息
* @param id 退货的销售单ID
* @param number 退货数量
* @param remark 备注信息
* @return 返回操作结果
* 添加销售退货信息
* @param id 销售单ID
* @param number 退货数量
* @param remark 备注
* @return 操作结果
*/
@RequestMapping("addSalesback")
// 映射URL路径为"/salesback/addSalesback"
public ResultObj addSalesback(Integer id, Integer number, String remark) {
try {
// 调用销售退货服务，处理退货
salesbackService.addSalesback(id, number, remark);
// 调用服务层方法添加退货记录
return ResultObj.BACKINPORT_SUCCESS;
// 返回退货成功的结果对象
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")
// 映射URL路径为"/salesback/loadAllSalesback"
public DataGridView loadAllSalesback(SalesbackVo salesbackVo) {
// 1. 声明分页对象
IPage<Salesback> page = new Page<>(salesbackVo.getPage(), salesbackVo.getLimit());
// 创建分页对象，指定当前页和每页记录数
// 2. 创建查询条件构造器
QueryWrapper<Salesback> queryWrapper = new QueryWrapper<>();
// 创建QueryWrapper对象，用于构建查询条件
// 3. 根据客户ID进行查询
queryWrapper.eq(salesbackVo.getCustomerid() != null && salesbackVo.getCustomerid() != 0, "customerid", salesbackVo.getCustomerid());
// 如果客户ID不为空且不为0，添加客户ID的查询条件
// 4. 根据商品ID进行查询
queryWrapper.eq(salesbackVo.getGoodsid() != null && salesbackVo.getGoodsid() != 0, "goodsid", salesbackVo.getGoodsid());
// 如果商品ID不为空且不为0，添加商品ID的查询条件
// 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());
// 根据退货记录中的客户ID查询客户信息
if (customer != null) {
// 设置客户姓名
salesback.setCustomername(customer.getCustomername());
// 如果客户信息存在，设置客户名称
}
// 查询商品信息
Goods goods = goodsService.getById(salesback.getGoodsid());
// 根据退货记录中的商品ID查询商品信息
if (goods != null) {
// 设置商品名称和规格
salesback.setGoodsname(goods.getGoodsname());
// 如果商品信息存在，设置商品名称
salesback.setSize(goods.getSize());
// 设置商品规格
}
}
// 10. 返回分页结果
return new DataGridView(page.getTotal(), page.getRecords());
// 返回DataGridView对象，包含总记录数和分页记录列表
}
/**
* 删除商品销售退货记录
* @param id 要删除的退货记录ID
* @return 返回操作结果
* 删除商品销售退货信息
* @param id 销售退货ID
* @return 操作结果
*/
@RequestMapping("deleteSalesback")
// 映射URL路径为"/salesback/deleteSalesback"
public ResultObj deleteSalesback(Integer id) {
try {
// 调用销售退货服务，删除记录
salesbackService.removeById(id);
// 调用服务层方法，根据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表示启用）
}

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

@ -1,62 +1,60 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.ToString; // Lombok注解，自动生成toString方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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 // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，且不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_goods") // MyBatis-Plus注解，指定表名为bus_goods
@ToString // Lombok注解，自动生成toString方法
public class Goods implements Serializable { // 定义Goods类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
@TableId(value = "id", type = IdType.AUTO) // 将 id 字段设为主键，类型为自增
private Integer id; // 商品ID
private String goodsname; // 商品名称
private String produceplace; // 生产地
private String produceplace; // 商品产地
private String size; // 商品规格
private String goodspackage; // 商品包装
private String goodspackage; // 商品包装类型
private String productcode; // 商品编码
private String promitcode; // 批准文号
private String promitcode; // 促销编码
private String description; // 商品描述
private String description; // 商品描述信息
private Double price; // 商品价格
private Integer number; // 商品库存数量
private Integer dangernum; // 商品警戒库存数量
private Integer dangernum; // 商品危险库存数量（用于库存警报）
private String goodsimg; // 商品图片地址
private String goodsimg; // 商品图片的URL地址
private Integer available; // 商品是否可用，1表示可用，0表示不可用
private Integer available; // 商品是否可用（0 表示不可用，1 表示可用）
private Integer providerid; // 供应商ID，外键关联供应商表
private Integer providerid; // 供应商ID，外键关联供应商表 bus_provider
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
@TableField(exist = false) // 该字段不是数据库表中的字段，仅用于数据传输或展示
private String providername; // 供应商名称（非数据库字段，用于前端显示供应商信息）
}

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

@ -1,67 +1,65 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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 // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_inport") // MyBatis-Plus注解，指定表名为bus_inport
public class Inport implements Serializable { // 定义Inport类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 入库单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; // 供应商ID，外键关联供应商表
private Integer providerid; // 供应商ID，外键关联 `bus_provider` 表
private Integer goodsid; // 商品ID，外键关联商品表
private Integer goodsid; // 商品ID，外键关联 `bus_goods` 表
/**
* 供应商姓名
* 供应商名称，非数据库字段
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String providername; // 供应商名称，用于在前端页面显示供应商信息
/**
* 商品名称
* 商品名称，非数据库字段
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String goodsname; // 商品名称，用于在前端页面显示商品信息
/**
* 商品规格
* 商品规格，非数据库字段
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
@TableField(exist = false) // 标识该字段不是数据库表中的字段，仅用于传输或展示
private String size; // 商品规格，例如：大、中、小，用于显示
}

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

@ -1,69 +1,63 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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 // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_outport") // MyBatis-Plus注解，指定表名为bus_outport
public class Outport implements Serializable { // 定义Outport类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 出库单ID
@TableId(value = "id", type = IdType.AUTO) // 定义主键字段为自增类型
private Integer id; // 出库记录唯一标识
private Integer providerid; // 供应商ID，外键关联供应商表
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; // 商品ID，外键关联商品表
private Integer goodsid; // 商品ID，关联 `bus_goods` 表中的主键
/**
* 供应商姓名
* 供应商名称（仅用于展示）
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String providername; // 供应商名称（冗余字段，用于显示）
@TableField(exist = false) // 该字段不在数据库表中，仅用于逻辑传输和前端展示
private String providername; // 供应商的名称信息
/**
* 商品名称
* 商品名称（仅用于展示）
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
@TableField(exist = false) // 非持久化字段，仅用于业务传输
private String goodsname; // 商品的名称信息
/**
* 商品规格
* 商品规格（仅用于展示）
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
@TableField(exist = false) // 不映射到数据库表中
private String size; // 商品的规格，例如：中、大、小
}

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

@ -1,56 +1,51 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.ToString; // Lombok注解，自动生成toString方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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 // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_provider") // MyBatis-Plus注解，指定表名为bus_provider
@ToString // Lombok注解，自动生成toString方法
public class Provider implements Serializable { // 定义Provider类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 供应商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 email; // 供应商电子邮箱地址
private String fax; // 传真号码
private Integer available; // 是否可用，1表示可用，0表示不可用
private String fax; // 传真号码，供应商常用联系方式
private Integer available; // 状态标识（1 表示启用，0 表示禁用）
}

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

@ -1,67 +1,66 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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>
* 销售记录类
*
* @since 2019-12-21
* 此类与数据库中的 "bus_sales" 表关联，用于管理销售数据。
*/
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_sales") // MyBatis-Plus注解，指定表名为bus_sales
public class Sales implements Serializable { // 定义Sales类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 销售记录ID
@TableId(value = "id", type = IdType.AUTO) // 定义主键 ID，自动递增
private Integer id; // 唯一标识销售记录的编号
private Integer customerid; // 客户ID，外键关联客户表
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; // 商品ID，外键关联商品表
private Integer goodsid; // 商品的 ID，标识售出的商品
/**
* 客户名称
* 非持久化字段：客户名称
* 仅用于前端展示或查询时传输，不映射到数据库
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String customername; // 客户名称（冗余字段，用于显示）
@TableField(exist = false)
private String customername; // 客户的名称
/**
* 商品名称
* 非持久化字段：商品名称
* 仅用于结果展示
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
@TableField(exist = false)
private String goodsname; // 商品名称
/**
* 商品规格
* 非持久化字段：商品规格
* 主要用于展示商品详细规格
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
@TableField(exist = false)
private String size; // 商品规格
}

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

@ -1,67 +1,66 @@
package com.yeqifu.bus.entity; // 包名
package com.yeqifu.bus.entity;
import com.baomidou.mybatisplus.annotation.IdType; // MyBatis-Plus主键类型注解
import com.baomidou.mybatisplus.annotation.TableField; // MyBatis-Plus字段映射注解
import com.baomidou.mybatisplus.annotation.TableId; // MyBatis-Plus主键注解
import com.baomidou.mybatisplus.annotation.TableName; // MyBatis-Plus表名注解
import lombok.Data; // Lombok注解，自动生成getter和setter方法
import lombok.EqualsAndHashCode; // Lombok注解，自动生成equals和hashCode方法
import lombok.experimental.Accessors; // Lombok注解，支持链式调用
import 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>
* 销售退货记录类
*
* @since 2019-12-23
* 该类用于映射数据库中的 "bus_salesback" 表，专门存储销售退货相关数据。
*/
@Data // Lombok注解，自动生成getter和setter方法
@EqualsAndHashCode(callSuper = false) // Lombok注解，重写equals和hashCode方法，不调用父类
@Accessors(chain = true) // Lombok注解，支持链式调用
@TableName("bus_salesback") // MyBatis-Plus注解，指定表名为bus_salesback
public class Salesback implements Serializable { // 定义Salesback类，实现Serializable接口
@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) // MyBatis-Plus注解，指定主键字段id为自增类型
private Integer id; // 销售退货记录ID
@TableId(value = "id", type = IdType.AUTO) // 主键字段 id，值自动递增
private Integer id; // 唯一标识销售退货记录的主键
private Integer customerid; // 客户ID，外键关联客户表
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; // 商品ID，外键关联商品表
private Integer goodsid; // 关联商品的唯一标识符
/**
* 客户姓名
* 非数据库字段：客户名称
* 用于业务逻辑或展示数据时显示客户的名字
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String customername; // 客户名称（冗余字段，用于显示）
@TableField(exist = false)
private String customername; // 客户名称，便于展示时使用
/**
* 商品名称
* 非数据库字段：商品名称
* 在数据传输或展示时显示商品的名称
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String goodsname; // 商品名称（冗余字段，用于显示）
@TableField(exist = false)
private String goodsname; // 商品名称
/**
* 商品规格
* 非数据库字段：商品规格
* 用于前端展示具体的商品规格信息
*/
@TableField(exist = false) // MyBatis-Plus注解，表示此字段在数据库表中不存在
private String size; // 商品规格（冗余字段，用于显示）
@TableField(exist = false)
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 操作方法
}

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

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

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

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

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

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

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

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

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

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

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

@ -1,17 +1,16 @@
package com.yeqifu.bus.mapper; // 包名
package com.yeqifu.bus.mapper; // 定义该接口所在的包路径，mapper 层负责与数据库进行交互
import com.yeqifu.bus.entity.Salesback; // 导入销售退货实体类
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis-Plus核心BaseMapper接口
import com.yeqifu.bus.entity.Salesback; // 引入 Salesback 实体类，Salesback 类代表销售退货相关的数据
import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 引入 MyBatis-Plus 提供的 BaseMapper，BaseMapper 是 MyBatis-Plus 的基础接口，包含常见的 CRUD 操作方法
/**
* <p>
* 销售退货Mapper接口，提供对销售退货数据的数据库操作
* InnoDB free: 9216 kB
* InnoDB free: 9216 kB Mapper 接口
* </p>
*
* @since 2019-12-23
* @author luoyi-
* @since 2019-12-23
*/
public interface SalesbackMapper extends BaseMapper<Salesback> { // Mapper接口继承BaseMapper，自动实现通用数据操作
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删除客户的抽象方法
}

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

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

@ -1,17 +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; // 导入MyBatis-Plus提供的通用服务接口
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`)
* 商品进货服务接口
* </p>
*
* @since 2019-12-18
* @author luoyi-
*/
public interface IInportService extends IService<Inport> { // IService 是 MyBatis-Plus 提供的通用服务接口
public interface IInportService extends IService<Inport> { // 继承 IService 接口，泛型为 Inport，表示该接口提供 Inport 实体的基本业务操作
}

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

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

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

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

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

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

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

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

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

@ -1,19 +1,17 @@
package com.yeqifu.bus.vo; // 包名，定义视图层的包路径
package com.yeqifu.bus.vo; // 定义该类所在的包路径，属于视图层的对象包
import com.yeqifu.bus.entity.Goods; // 导入 Goods 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 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
*
* 数据传输对象 (VO)，用于与前端交互时携带 Goods 实体数据以及分页信息
*/
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑父类属性
public class GoodsVo extends Goods { // 继承 Goods 实体类
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class GoodsVo extends Goods { // GoodsVo 继承自 Goods，表示商品视图对象，添加了分页功能
private Integer page = 1; // 分页查询起始页码，默认为第 1 页
private Integer limit = 10; // 分页查询的限制记录数，默认为每页 10 条数据
private Integer page = 1; // 分页参数，默认为第一页
private Integer limit = 10; // 分页参数，默认为每页显示10条数据
}

34
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; // 导入 Inport 实体类
import lombok.Data; // 导入 Lombok 提供的 @Data 注解
import lombok.EqualsAndHashCode; // 导入 Lombok 提供的 @EqualsAndHashCode 注解
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import java.util.Date; // 导入 Date 类
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; // 导入日期类
/**
* @Author: 落亦-
* @Date: 2019/12/18 10:29
*
* 数据传输对象 (VO)，用于视图层与前端交互时传递 Inport 实体数据以及分页信息和时间查询条件
*/
@Data // 自动生成 getter、setter、toString 等常用方法
@EqualsAndHashCode(callSuper = false) // 生成 equals 和 hashCode 方法，且不考虑其父类属性
public class InportVo extends Inport { // 继承 Inport 实体类
private Integer page = 1; // 分页查询起始页码，默认为第 1 页
@Data // Lombok 注解，自动生成 getter、setter、toString、equals 和 hashCode 方法
@EqualsAndHashCode(callSuper = false) // Lombok 注解，自动生成 equals 和 hashCode 方法，不考虑父类的字段
public class InportVo extends Inport { // InportVo 继承自 Inport，表示进货视图对象，添加了分页和时间筛选功能
private Integer limit = 10; // 分页查询的限制记录数，默认为每页 10 条数据
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 startTime; // 开始时间，用于筛选进货记录的起始时间
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期为 yyyy-MM-dd 格式
private Date endTime; // 查询时间范围的结束时间
@DateTimeFormat(pattern = "yyyy-MM-dd") // 格式化日期字段，要求日期格式为 "yyyy-MM-dd"
private Date endTime; // 结束时间，用于筛选进货记录的结束时间
}

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

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

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

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

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

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

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

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

194
src/main/java/com/yeqifu/sys/cache/CacheAspect.java vendored
Unescape View File

@ -14,12 +14,6 @@ import org.springframework.stereotype.Component;
import java.util.Map;
/**
* 缓存切面类
*
* 通过动态缓存实现对部门和用户相关操作的分级缓存。
*
* 此类使用AOP实现与部门和用户相关操作的缓存视图分离。
*
* @Author: 落亦-
* @Date: 2019/11/27 18:42
*/
@ -29,89 +23,189 @@ import java.util.Map;
public class CacheAspect {
/**
* 日志出处。用于进行日志输出，便于跟踪缓存操作。
* 日志出处
*/
private Log log = LogFactory.getLog(CacheAspect.class);
/**
* 缓存容器。通过Map实现动态缓存，用于存储部门和用户数据。
* 声明一个缓存容器
*/
private Map<String, Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
private Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 部门操作的切面表达式
* 声明部门的切面表达式
*/
private static final String POINTCUT_DEPT_ADD = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.save(..))"; // 添加部门
private static final String POINTCUT_DEPT_UPDATE = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.updateById(..))"; // 更新部门
private static final String POINTCUT_DEPT_GET = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.getById(..))"; // 查询部门
private static final String POINTCUT_DEPT_DELETE = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.removeById(..))"; // 删除部门
private static final String POINTCUT_DEPT_ADD="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.save(..))";
private static final String POINTCUT_DEPT_UPDATE="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.updateById(..))";
private static final String POINTCUT_DEPT_GET="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.getById(..))";
private static final String POINTCUT_DEPT_DELETE="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.removeById(..))";
/**
* 缓存部门数据的前缀。
*/
private static final String CACHE_DEPT_PROFIX = "dept:";
private static final String CACHE_DEPT_PROFIX="dept:";
/**
* 添加部门切入
*
* @param joinPoint 切面链接点
* @return 操作结果
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_DEPT_ADD)
public Object cacheDeptAdd(ProceedingJoinPoint joinPoint) throws Throwable {
// 取出第一个参数
//取出第一个参数
Dept object = (Dept) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed(); // 执行原实现
if (res) {
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + object.getId(), object);
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + object.getId(),object);
}
return res;
}
/**
* 查询部门切入
*
* @param joinPoint 切面链接点
* @return 部门对象
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_DEPT_GET)
public Object cacheDeptGet(ProceedingJoinPoint joinPoint) throws Throwable {
Integer object = (Integer) joinPoint.getArgs()[0]; // 取出第一个参数作为ID
//取出第一个参数
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
Object res1 = CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + object);
if (res1 != null) {
log.info("已从缓存里面找到部门对象" + CACHE_DEPT_PROFIX + object);
return res1; // 直接返回缓存中的对象
} else {
log.info("\u672a\u4ece\u7f13\u5b58\u91CC\u627E\u5230\u90E8\u95E8\u5BF9\u8C61\uFF0C\u4ECE\u6570\u636E\u5E93\u4E2D\u67E5\u8BE2\u5E76\u653E\u5165\u7F13\u5B58");
Dept res2 = (Dept) joinPoint.proceed(); // 执行原实现
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + res2.getId(), res2);
if (res1!=null){
log.info("已从缓存里面找到部门对象"+CACHE_DEPT_PROFIX + object);
return res1;
}else {
log.info("未从缓存里面找到部门对象，从数据库中查询并放入缓存");
Dept res2 =(Dept) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX+res2.getId(),res2);
return res2;
}
}
/**
* 更新部门切入
*
* @param joinPoint 切面链接点
* @return 操作结果
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_DEPT_UPDATE)
public Object cacheDeptUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Dept deptVo = (Dept) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess) {
Dept dept = (Dept) CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + deptVo.getId());
if (null == dept) {
dept = new Dept();
if (isSuccess){
Dept dept =(Dept) CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + deptVo.getId());
if (null==dept){
dept=new Dept();
}
BeanUtils.copyProperties(deptVo, dept);
log.info("\u90E8\u95E8\u5BF9\u8C61\u7F13\u5B58\u5DF2\u66F4\u65B0" + CACHE_DEPT_PROFIX + deptVo.getId());
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + dept.getId(), dept);
BeanUtils.copyProperties(deptVo,dept);
log.info("部门对象缓存已更新"+CACHE_DEPT_PROFIX + deptVo.getId());
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX+dept.getId(),dept);
}
return isSuccess;
}
/**
* 删除部门切入
*
* @param joinPoint 切
/**
* 删除部门切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_DEPT_DELETE)
public Object cacheDeptDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_DEPT_PROFIX+id);
}
return isSuccess;
}
/**
* 声明用户的切面表达式
*/
private static final String POINTCUT_USER_UPDATE="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.updateById(..))";
private static final String POINTCUT_USER_ADD="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.updateById(..))";
private static final String POINTCUT_USER_GET="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.getById(..))";
private static final String POINTCUT_USER_DELETE="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.removeById(..))";
private static final String CACHE_USER_PROFIX="user:";
/**
* 添加用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_ADD)
public Object cacheUserAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
User object = (User) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_USER_PROFIX + object.getId(),object);
}
return res;
}
/**
* 查询用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_GET)
public Object cacheUserGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
Object res1 = CACHE_CONTAINER.get(CACHE_USER_PROFIX + object);
if (res1!=null){
log.info("已从缓存里面找到用户对象"+CACHE_USER_PROFIX + object);
return res1;
}else {
log.info("未从缓存里面找到用户对象，从数据库中查询并放入缓存");
User res2 =(User) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_USER_PROFIX+res2.getId(),res2);
return res2;
}
}
/**
* 更新用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_UPDATE)
public Object cacheUserUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
User userVo = (User) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
User user =(User) CACHE_CONTAINER.get(CACHE_USER_PROFIX + userVo.getId());
if (null==user){
user=new User();
}
BeanUtils.copyProperties(userVo,user);
log.info("用户对象缓存已更新"+CACHE_USER_PROFIX + userVo.getId());
CACHE_CONTAINER.put(CACHE_USER_PROFIX+user.getId(),user);
}
return isSuccess;
}
/**
* 删除用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_DELETE)
public Object cacheUserDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_USER_PROFIX+id);
}
return isSuccess;
}
}

60
src/main/java/com/yeqifu/sys/cache/CachePool.java vendored
Unescape View File

@ -17,86 +17,72 @@ import java.util.List;
import java.util.Map;
/**
* CachePool 类用于处理缓存操作，模拟类似 Redis 的缓存管理功能。
* 提供了添加缓存、删除缓存、清空缓存和同步缓存等功能。
* 主要用于缓存部门、用户、客户、供应商、商品等信息。
*
* @Author: 落亦-
* @Date: 2019/12/20 18:05
*/
public class CachePool {
/**
* 缓存容器，用于存放所有缓存数据，键值对存储。
* 这个容器类似于 Redis，存储了不同实体的缓存数据。
* 所有的缓存数据放到这个CACHE_CONTAINER 类似于redis
*/
public static volatile Map<String, Object> CACHE_CONTAINER = new HashMap<>();
public static volatile Map<String,Object> CACHE_CONTAINER = new HashMap<>();
/**
* 根据指定的键删除缓存数据。
*
* @param key 键，缓存的唯一标识符
* 根据KEY删除缓存
* @param key 键
*/
public static void removeCacheByKey(String key) {
// 判断缓存容器中是否包含指定的键
if (CACHE_CONTAINER.containsKey(key)) {
// 删除指定键的缓存数据
public static void removeCacheByKey(String key){
if (CACHE_CONTAINER.containsKey(key)){
CACHE_CONTAINER.remove(key);
}
}
/**
* 清空所有缓存数据。
* 该方法会清除缓存容器中的所有条目。
* 清空所有缓存
*/
public static void removeAll() {
// 清空缓存容器
public static void removeAll(){
CACHE_CONTAINER.clear();
}
/**
* 同步数据到缓存。
* 从数据库中获取部门、用户、客户、供应商、商品等数据，并将其放入缓存容器。
* 同步缓存
*/
public static void syncData() {
// 同步部门数据
public static void syncData(){
//同步部门数据
DeptMapper deptMapper = SpringUtil.getBean(DeptMapper.class);
List<Dept> deptList = deptMapper.selectList(null);
for (Dept dept : deptList) {
// 将部门数据存入缓存容器
CACHE_CONTAINER.put("dept:" + dept.getId(), dept);
CACHE_CONTAINER.put("dept:"+dept.getId(),dept);
}
// 同步用户数据
//同步用户数据
UserMapper userMapper = SpringUtil.getBean(UserMapper.class);
List<User> userList = userMapper.selectList(null);
for (User user : userList) {
// 将用户数据存入缓存容器
CACHE_CONTAINER.put("user:" + user.getId(), user);
CACHE_CONTAINER.put("user:"+user.getId(),user);
}
// 同步客户数据
//同步客户数据
CustomerMapper customerMapper = SpringUtil.getBean(CustomerMapper.class);
List<Customer> customerList = customerMapper.selectList(null);
for (Customer customer : customerList) {
// 将客户数据存入缓存容器
CACHE_CONTAINER.put("customer:" + customer.getId(), customer);
CACHE_CONTAINER.put("customer:"+customer.getId(),customer);
}
// 同步供应商数据
//同步供应商数据
ProviderMapper providerMapper = SpringUtil.getBean(ProviderMapper.class);
List<Provider> providerList = providerMapper.selectList(null);
for (Provider provider : providerList) {
// 将供应商数据存入缓存容器
CACHE_CONTAINER.put("provider:" + provider.getId(), provider);
CACHE_CONTAINER.put("provider:"+provider.getId(),provider);
}
// 同步商品数据
//同步商品数据
GoodsMapper goodsMapper = SpringUtil.getBean(GoodsMapper.class);
List<Goods> goodsList = goodsMapper.selectList(null);
for (Goods goods : goodsList) {
// 将商品数据存入缓存容器
CACHE_CONTAINER.put("goods:" + goods.getId(), goods);
CACHE_CONTAINER.put("goods:"+goods.getId(),goods);
}
}
}

102
src/main/java/com/yeqifu/sys/common/AppFileUtils.java
Unescape View File

@ -13,111 +13,97 @@ import java.io.InputStream;
import java.util.Properties;
/**
* AppFileUtils 类提供了与文件相关的工具方法，包括文件上传、下载、重命名和删除操作。
* 它主要用于处理文件的存储路径、生成文件的唯一名称，并支持文件的下载和删除操作。
*
* @Author: 落亦-
* @Date: 2019/12/15 23:44
*/
public class AppFileUtils {
/**
* 文件上传的保存路径，默认为 G:/upload/
* 在静态代码块中，如果在配置文件中指定了路径，将覆盖此默认值。
* 文件上传的保存路径 默认值
*/
public static String UPLOAD_PATH = "G:/upload/";
public static String UPLOAD_PATH="G:/upload/";
// 静态代码块，初始化文件上传路径
static {
// 通过反射的方式，读取配置文件 file.properties 中的存储地址
//通过反射的方式，读取配置文件的存储地址
InputStream stream = AppFileUtils.class.getClassLoader().getResourceAsStream("file.properties");
Properties properties = new Properties();
Properties properties=new Properties();
try {
// 加载配置文件
properties.load(stream);
} catch (IOException e) {
e.printStackTrace();
}
// 获取配置文件中的文件路径，并赋值给 UPLOAD_PATH
String property = properties.getProperty("filepath");
if (property != null) {
UPLOAD_PATH = property;
if(null!=property) {
UPLOAD_PATH=property;
}
}
/**
* 根据文件的老名字生成一个新的文件名。
* 新文件名由32位的随机UUID和文件的后缀名组成，确保文件名唯一。
*
* @param oldName 文件的老名字
* @return 新的文件名
* 根据文件老名字得到新名字
* @param oldName 文件老名字
* @return 新名字由32位随机数加图片后缀组成
*/
public static String createNewFileName(String oldName) {
// 获取文件名后缀（例如 .jpg、.png）
String stuff = oldName.substring(oldName.lastIndexOf("."), oldName.length());
// 使用UUID生成新的文件名，并与文件后缀拼接
return IdUtil.simpleUUID().toUpperCase() + stuff;
//获取文件名后缀
String stuff=oldName.substring(oldName.lastIndexOf("."), oldName.length());
//将UUID与文件名后缀进行拼接，生成新的文件名 生成的UUID为32位
return IdUtil.simpleUUID().toUpperCase()+stuff;
}
/**
* 文件下载方法。
* 根据给定的路径返回文件的响应实体，支持文件的下载功能。
*
* @param path 文件的相对路径
* @return ResponseEntity 对象，包含文件的内容和下载的响应头
* 文件下载
* @param path
* @return
*/
public static ResponseEntity<Object> createResponseEntity(String path) {
// 1. 构造文件对象
File file = new File(UPLOAD_PATH, path);
if (file.exists()) {
// 2. 如果文件存在，将文件内容封装为字节数组
byte[] bytes = null;
//1,构造文件对象
File file=new File(UPLOAD_PATH, path);
if(file.exists()) {
//将下载的文件，封装byte[]
byte[] bytes=null;
try {
bytes = FileUtil.readBytes(file);
} catch (Exception e) {
e.printStackTrace();
}
// 3. 创建响应头对象，并设置响应内容类型为 APPLICATION_OCTET_STREAM（表示二进制流数据）
HttpHeaders header = new HttpHeaders();
//创建封装响应头信息的对象
HttpHeaders header=new HttpHeaders();
//封装响应内容类型(APPLICATION_OCTET_STREAM 响应的内容不限定)
header.setContentType(MediaType.APPLICATION_OCTET_STREAM);
// 4. 创建并返回 ResponseEntity 对象，包含文件的字节数组、响应头和 HTTP 状态
ResponseEntity<Object> entity = new ResponseEntity<>(bytes, header, HttpStatus.CREATED);
//创建ResponseEntity对象
ResponseEntity<Object> entity= new ResponseEntity<Object>(bytes, header, HttpStatus.CREATED);
return entity;
}
return null; // 如果文件不存在，返回 null
return null;
}
/**
* 重命名文件，去掉文件名中的 "_temp" 部分。
*
* @param goodsImg 原文件名
* @return 新文件名
* 更该图片的名字 去掉_temp
* @param goodsImg
* @return
*/
public static String renameFile(String goodsImg) {
// 构造文件对象
File file = new File(UPLOAD_PATH, goodsImg);
// 将文件名中的 "_temp" 替换为空
String replace = goodsImg.replace("_temp", "");
// 如果文件存在，执行重命名操作
if (file.exists()) {
file.renameTo(new File(UPLOAD_PATH, replace));
File file = new File(UPLOAD_PATH,goodsImg);
String replace = goodsImg.replace("_temp","");
if (file.exists()){
file.renameTo(new File(UPLOAD_PATH,replace));
}
return replace; // 返回重命名后的文件名
return replace;
}
/**
* 根据文件的旧路径删除文件。
* 删除文件时，避免删除默认的商品图片。
*
* @param oldPath 文件的旧路径
* 根据老路径删除图片
* @param oldPath
*/
public static void removeFileByPath(String oldPath) {
// 如果旧路径不是默认商品图片的路径，则删除文件
if (!oldPath.equals(Constast.DEFAULT_IMG_GOODS)) {
File file = new File(UPLOAD_PATH, oldPath);
if (file.exists()) {
file.delete(); // 删除文件
//图片的路径不是默认图片的路径
if (!oldPath.equals(Constast.DEFAULT_IMG_GOODS)){
File file = new File(UPLOAD_PATH,oldPath);
if (file.exists()){
file.delete();
}
}
}
}

38
src/main/java/com/yeqifu/sys/common/PinyinUtils.java
Unescape View File

@ -9,7 +9,6 @@ import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombi
/**
* 拼音工具类
* 该类用于将中文字符串转换为拼音格式，并可定制拼音输出的格式。
*
* @Author: 落亦-
* @Date: 2019/12/3 10:29
@ -17,51 +16,38 @@ import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombi
public class PinyinUtils {
/**
* 将输入的中文字符串转换为拼音字符串，且首字母大写，拼音不带声调。
*
* @param inputString 输入的中文字符串
* @return 拼音字符串（首字母大写且没有声调），如果输入为空或无效，返回 "*"
* 返回一个拼音字符串，并且首字母大写
*/
public static String getPingYin(String inputString) {
// 设置拼音输出的格式
HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
format.setCaseType(HanyuPinyinCaseType.LOWERCASE); // 设置拼音的大小写为小写
format.setToneType(HanyuPinyinToneType.WITHOUT_TONE); // 设置拼音不带音调
format.setVCharType(HanyuPinyinVCharType.WITH_V); // 设置拼音中的v字符使用“v”而非“u”
format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
format.setVCharType(HanyuPinyinVCharType.WITH_V);
String output = "";
// 判断输入字符串是否有效
if (inputString != null && inputString.length() > 0 && !"null".equals(inputString)) {
char[] input = inputString.trim().toCharArray(); // 将输入字符串转换为字符数组
char[] input = inputString.trim().toCharArray();
try {
// 遍历每个字符，如果是中文字符，则转换为拼音，否则保留原字符
for (int i = 0; i < input.length; i++) {
// 判断字符是否为汉字
if (java.lang.Character.toString(input[i]).matches("[\\u4E00-\\u9FA5]+")) {
// 获取该汉字的拼音
String[] temp = PinyinHelper.toHanyuPinyinStringArray(input[i], format);
output += temp[0]; // 拼接拼音
output += temp[0];
} else {
output += java.lang.Character.toString(input[i]); // 非汉字字符直接拼接
output += java.lang.Character.toString(input[i]);
}
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace(); // 处理拼音转换过程中可能发生的异常
e.printStackTrace();
}
} else {
return "*"; // 如果输入无效，返回 "*"
return "*";
}
return output;
}
/**
* 主函数用于测试拼音转换功能。
*
* @param args 命令行参数
*/
public static void main(String[] args) {
// 测试拼音转换
String s = getPingYin("落亦");
System.out.println(s); // 输出拼音：luo yi
System.out.println(s);
}
}

2
src/main/java/com/yeqifu/sys/common/ResultObj.java
Unescape View File

@ -44,5 +44,3 @@ public class ResultObj {
}
//测试

111
src/main/java/com/yeqifu/sys/config/ShiroAutoConfiguration.java
Unescape View File

@ -24,149 +24,144 @@ import javax.servlet.Filter;
import java.util.HashMap;
import java.util.Map;
@Configuration // 标注为配置类，Spring 会自动扫描并加载此类的配置
@ConditionalOnWebApplication(type = Type.SERVLET) // 仅在 Servlet Web 应用中启用
@ConditionalOnClass(value = { SecurityManager.class }) // 仅在 SecurityManager 类存在时启用
@ConfigurationProperties(prefix = "shiro") // 绑定配置文件中以 "shiro" 为前缀的属性
@Data // 自动生成 getter 和 setter 方法
/**
* @Author: 落亦-
* @Date: 2019/11/21 21:01
*/
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(value = { SecurityManager.class })
@ConfigurationProperties(prefix = "shiro")
@Data
public class ShiroAutoConfiguration {
private static final String SHIRO_DIALECT = "shiroDialect"; // Thymeleaf Shiro 标签名常量
private static final String SHIRO_FILTER = "shiroFilter"; // Shiro 过滤器名常量
private static final String SHIRO_DIALECT = "shiroDialect";
private static final String SHIRO_FILTER = "shiroFilter";
/**
* 配置默认的密码加密算法（MD5）
* 加密方式
*/
private String hashAlgorithmName = "md5";
/**
* 设置散列次数（默认从常量类中读取）
* 散列次数
*/
private int hashIterations = Constast.HASHITERATIONS;
/**
* 登录页面 URL（未认证时的跳转页面）
* 默认的登陆页面
*/
private String loginUrl = "/index.html";
/**
* Shiro 权限控制的路径集合
* anonUrls - 允许匿名访问的路径
* logOutUrl - 登出路径
* authcUlrs - 需要登录认证的路径
*/
private String[] anonUrls;
private String logOutUrl;
private String[] authcUlrs;
/**
* 1. 配置凭证匹配器（密码加密规则）
* 使用 MD5 算法进行密码验证，结合指定的散列次数。
* 声明凭证匹配器
*/
@Bean("credentialsMatcher")
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
credentialsMatcher.setHashAlgorithmName(hashAlgorithmName); // 设置加密算法
credentialsMatcher.setHashIterations(hashIterations); // 设置散列次数
credentialsMatcher.setHashAlgorithmName(hashAlgorithmName);
credentialsMatcher.setHashIterations(hashIterations);
return credentialsMatcher;
}
/**
* 2. 配置自定义 Realm
* 用于定义用户的身份认证和权限校验逻辑。
* 声明userRealm
*/
@Bean("userRealm")
public UserRealm userRealm(CredentialsMatcher credentialsMatcher) {
UserRealm userRealm = new UserRealm();
userRealm.setCredentialsMatcher(credentialsMatcher); // 注入凭证匹配器
// 注入凭证匹配器
userRealm.setCredentialsMatcher(credentialsMatcher);
return userRealm;
}
/**
* 3. 配置核心安全管理器 SecurityManager
* 负责管理用户认证、授权等操作。
* 配置SecurityManager
*/
@Bean("securityManager")
public SecurityManager securityManager(UserRealm userRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(userRealm); // 注入自定义 Realm
// 注入userRealm
securityManager.setRealm(userRealm);
return securityManager;
}
/**
* 4. 配置 Shiro 的过滤器工厂
* ShiroFilterFactoryBean 负责设置过滤规则和登录 URL。
* 配置shiro的过滤器
*/
@Bean(SHIRO_FILTER)
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
factoryBean.setSecurityManager(securityManager); // 设置安全管理器
factoryBean.setLoginUrl(loginUrl); // 设置未认证时的跳转页面
// 1. 配置过滤器链定义映射
// 设置安全管理器
factoryBean.setSecurityManager(securityManager);
// 设置未登陆的时要跳转的页面
factoryBean.setLoginUrl(loginUrl);
Map<String, String> filterChainDefinitionMap = new HashMap<>();
// 配置匿名访问路径（无需登录）
// 设置放行的路径
if (anonUrls != null && anonUrls.length > 0) {
for (String anon : anonUrls) {
filterChainDefinitionMap.put(anon, "anon");
}
}
// 配置登出路径
if (logOutUrl != null) {
// 设置登出的路径
if (null != logOutUrl) {
filterChainDefinitionMap.put(logOutUrl, "logout");
}
// 配置需要登录认证的路径
// 设置拦截的路径
if (authcUlrs != null && authcUlrs.length > 0) {
for (String authc : authcUlrs) {
filterChainDefinitionMap.put(authc, "authc");
}
}
// 2. 注入自定义过滤器（如果有）
Map<String, Filter> filters = new HashMap<>();
Map<String, Filter> filters=new HashMap<>();
// filters.put("authc", new ShiroLoginFilter());
//配置过滤器
factoryBean.setFilters(filters);
// 3. 设置过滤器链定义映射
factoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return factoryBean;
}
/**
* 5. 注册 Shiro 的委托过滤器
* 在 Spring Boot 中等效于 web.xml 的配置。
* 注册shiro的委托过滤器，相当于之前在web.xml里面配置的
*
* @return
*/
@Bean
public FilterRegistrationBean<DelegatingFilterProxy> delegatingFilterProxy() {
FilterRegistrationBean<DelegatingFilterProxy> filterRegistrationBean = new FilterRegistrationBean<>();
FilterRegistrationBean<DelegatingFilterProxy> filterRegistrationBean = new FilterRegistrationBean<DelegatingFilterProxy>();
DelegatingFilterProxy proxy = new DelegatingFilterProxy();
proxy.setTargetFilterLifecycle(true); // 由 Spring 管理生命周期
proxy.setTargetBeanName(SHIRO_FILTER); // 关联 Shiro 过滤器
proxy.setTargetFilterLifecycle(true);
proxy.setTargetBeanName(SHIRO_FILTER);
filterRegistrationBean.setFilter(proxy);
return filterRegistrationBean;
}
/* 加入注解的使用，不加入这个注解不生效--开始 */
/**
* 6. 开启 Shiro 注解支持（如 @RequiresRoles 和 @RequiresPermissions）
*
* @param securityManager
* @return
*/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager); // 注入 SecurityManager
return advisor;
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
/**
* 7. 启用自动代理类，支持权限注解的解析
*/
@Bean
public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
advisorAutoProxyCreator.setProxyTargetClass(true); // 使用 CGLIB 代理类
advisorAutoProxyCreator.setProxyTargetClass(true);
return advisorAutoProxyCreator;
}
/* 加入注解的使用，不加入这个注解不生效--结束 */
/**
* 8. 配置 Thymeleaf Shiro 标签支持
* 允许在 HTML 页面中使用 Shiro 标签（如 shiro:hasPermission）。
* 这里是为了能在html页面引用shiro标签，上面两个函数必须添加，不然会报错
*
* @return
*/
@Bean(name = SHIRO_DIALECT)
public ShiroDialect shiroDialect() {

68
src/main/java/com/yeqifu/sys/controller/CacheController.java
Unescape View File

@ -16,70 +16,62 @@ import java.util.Map;
import java.util.Set;
/**
* 缓存管理控制器类
* 该控制器提供了缓存管理的功能，包括查询所有缓存、删除缓存、清空缓存和同步缓存。
*
* 缓存管理控制器
* @Author: 落亦-
* @Date: 2019/12/20 18:36
*/
@Api(description = "缓存管理") // Swagger注解，用于描述API功能
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("cache") // 定义基础请求路径为 "cache"
@Api(description = "缓存管理")
@RestController
@RequestMapping("cache")
public class CacheController {
/**
* 缓存容器
* 使用CachePool提供的静态缓存容器，存储所有缓存项。
* 使用volatile关键字保证多线程环境下的可见性。
*/
private static volatile Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
private static volatile Map<String,Object> CACHE_CONTAINER= CachePool.CACHE_CONTAINER;
/**
* 查询所有缓存
* @return DataGridView 返回所有缓存项的列表，用于前端显示。
* @return
*/
@ApiOperation(value = "查询所有缓存", notes = "查询所有缓存") // Swagger注解，用于描述接口的功能
@RequestMapping(value = "loadAllCache", method = RequestMethod.GET) // 映射GET请求到该方法
public DataGridView loadAllCache() {
List<CacheBean> list = new ArrayList<>(); // 用于存储缓存项的列表
@ApiOperation(value = "查询所有缓存",notes = "查询所有缓存")
@RequestMapping(value = "loadAllCache",method = RequestMethod.GET)
public DataGridView loadAllCache(){
List<CacheBean> list = new ArrayList<>();
// 遍历缓存容器的所有键值对
Set<Map.Entry<String, Object>> entrySet = CACHE_CONTAINER.entrySet();
for (Map.Entry<String, Object> entry : entrySet) {
// 将每个键值对封装为CacheBean对象并添加到列表中
list.add(new CacheBean(entry.getKey(), entry.getValue()));
list.add(new CacheBean(entry.getKey(),entry.getValue()));
}
return new DataGridView(list); // 将列表封装为DataGridView对象返回
return new DataGridView(list);
}
/**
* 删除指定缓存
* @param key 缓存的键
* @return ResultObj 返回操作结果，表示删除是否成功。
* 删除缓存
* @param key
* @return
*/
@RequestMapping("deleteCache") // 映射请求路径为 "deleteCache"
public ResultObj deleteCache(String key) {
CachePool.removeCacheByKey(key); // 调用CachePool的方法删除指定缓存
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
@RequestMapping("deleteCache")
public ResultObj deleteCache(String key){
CachePool.removeCacheByKey(key);
return ResultObj.DELETE_SUCCESS;
}
/**
* 清空所有缓存
* @return ResultObj 返回操作结果，表示清空是否成功。
* @return
*/
@RequestMapping("removeAllCache") // 映射请求路径为 "removeAllCache"
public ResultObj removeAllCache() {
CachePool.removeAll(); // 调用CachePool的方法清空所有缓存
return ResultObj.DELETE_SUCCESS; // 返回清空成功的结果
@RequestMapping("removeAllCache")
public ResultObj removeAllCache(){
CachePool.removeAll();
return ResultObj.DELETE_SUCCESS;
}
/**
* 同步缓存
* @return ResultObj 返回操作结果，表示同步是否成功。
* @return
*/
@RequestMapping("syncCache") // 映射请求路径为 "syncCache"
public ResultObj syncCache() {
CachePool.syncData(); // 调用CachePool的方法同步缓存
return ResultObj.SYNCCACHE_SUCCESS; // 返回同步成功的结果
@RequestMapping("syncCache")
public ResultObj syncCache(){
CachePool.syncData();
return ResultObj.SYNCCACHE_SUCCESS;
}
}

149
src/main/java/com/yeqifu/sys/controller/DeptController.java
Unescape View File

@ -1,5 +1,6 @@
package com.yeqifu.sys.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@ -17,144 +18,148 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* 部门管理控制器
* 提供了部门数据的CRUD（增删改查）以及相关功能，包括树形结构加载、排序码获取等。
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @Author: 落亦-
* @Since: 2019-11-26
* @author luoyi-
* @since 2019-11-26
*/
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("/dept") // 定义基础请求路径为 "/dept"
@RestController
@RequestMapping("/dept")
public class DeptController {
@Autowired
private IDeptService deptService; // 自动注入部门服务接口
private IDeptService deptService;
/**
* 加载部门左侧的菜单树
* 将部门数据组装为树形结构（JSON格式），供前端展示。
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含树形节点的数据
* 加载部门左边的菜单树
* @param deptVo
* @return
*/
@RequestMapping("loadDeptManagerLeftTreeJson")
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo) {
// 查询所有部门数据
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo){
//查询出所有的部门，存放进list中
// QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
// queryWrapper.eq('1');
List<Dept> list = deptService.list();
List<TreeNode> treeNodes = new ArrayList<>();
// 遍历部门数据，将每个部门封装为树形节点
//将部门放入treeNodes中，组装成json
for (Dept dept : list) {
Boolean open = dept.getOpen() == 1; // 根据部门状态设置节点是否展开
treeNodes.add(new TreeNode(dept.getId(), dept.getPid(), dept.getName(), open));
Boolean open = dept.getOpen()==1?true:false;
treeNodes.add(new TreeNode(dept.getId(),dept.getPid(),dept.getName(),open));
}
return new DataGridView(treeNodes); // 返回树形节点数据
return new DataGridView(treeNodes);
}
/**
* 查询所有部门数据（带分页和模糊查询）
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含分页后的部门数据
* 查询所有部门数据
* @param deptVo
* @return
*/
@RequestMapping("loadAllDept")
public DataGridView loadAllDept(DeptVo deptVo) {
IPage<Dept> page = new Page<>(deptVo.getPage(), deptVo.getLimit()); // 创建分页对象
public DataGridView loadAllDept(DeptVo deptVo){
IPage<Dept> page = new Page<>(deptVo.getPage(),deptVo.getLimit());
//进行模糊查询
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
// 添加模糊查询条件
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()), "name", deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()), "remark", deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()), "address", deptVo.getAddress());
queryWrapper.eq(deptVo.getId() != null, "id", deptVo.getId())
.or().eq(deptVo.getId() != null, "pid", deptVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序码升序排列
deptService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords()); // 返回分页数据
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()),"name",deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()),"remark",deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()),"address",deptVo.getAddress());
queryWrapper.eq(deptVo.getId()!=null,"id",deptVo.getId()).or().eq(deptVo.getId()!=null,"pid",deptVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
deptService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加部门
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
* @param deptVo
* @return
*/
@RequestMapping("addDept")
public ResultObj addDept(DeptVo deptVo) {
public ResultObj addDept(DeptVo deptVo){
try {
deptVo.setCreatetime(new Date()); // 设置创建时间
deptService.save(deptVo); // 保存部门数据
return ResultObj.ADD_SUCCESS; // 返回成功结果
deptVo.setCreatetime(new Date());
deptService.save(deptVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR; // 返回失败结果
return ResultObj.ADD_ERROR;
}
}
/**
* 加载部门排序码（获取最大的排序码加1）
* @return Map 包含新的排序码
* 加载排序码
* @return
*/
@RequestMapping("loadDeptMaxOrderNum")
public Map<String, Object> loadDeptMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> loadDeptMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum"); // 按排序码降序排列
IPage<Dept> page = new Page<>(1, 1); // 只查询一条记录
List<Dept> list = deptService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 获取最大排序码+1
} else {
map.put("value", 1); // 如果无记录，排序码为1
queryWrapper.orderByDesc("ordernum");
IPage<Dept> page = new Page<>(1,1);
List<Dept> list = deptService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
}
return map;
}
/**
* 更新部门信息
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
* 更新部门
* @param deptVo
* @return
*/
@RequestMapping("updateDept")
public ResultObj updateDept(DeptVo deptVo) {
public ResultObj updateDept(DeptVo deptVo){
try {
deptService.updateById(deptVo); // 根据ID更新部门数据
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
deptService.updateById(deptVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR; // 返回失败结果
return ResultObj.UPDATE_ERROR;
}
}
/**
* 检查当前部门是否有子部门
* @param deptVo 部门数据封装类
* @return Map 包含布尔值，表示是否有子部门
* @param deptVo
* @return
*/
@RequestMapping("checkDeptHasChildrenNode")
public Map<String, Object> checkDeptHasChildrenNode(DeptVo deptVo) {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> checkDeptHasChildrenNode(DeptVo deptVo){
Map<String,Object> map = new HashMap<String, Object>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid", deptVo.getId()); // 根据父ID查询
queryWrapper.eq("pid",deptVo.getId());
List<Dept> list = deptService.list(queryWrapper);
map.put("value", !list.isEmpty()); // 如果有子部门，返回true，否则返回false
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
return map;
}
/**
* 删除部门
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
* @param deptVo
* @return
*/
@RequestMapping("deleteDept")
public ResultObj deleteDept(DeptVo deptVo) {
public ResultObj deleteDept(DeptVo deptVo){
try {
deptService.removeById(deptVo.getId()); // 根据ID删除部门
return ResultObj.DELETE_SUCCESS; // 返回成功结果
deptService.removeById(deptVo.getId());
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR; // 返回失败结果
return ResultObj.DELETE_ERROR;
}
}
}

70
src/main/java/com/yeqifu/sys/controller/FileController.java
Unescape View File

@ -14,79 +14,57 @@ import java.util.HashMap;
import java.util.Map;
/**
* 文件控制器
* 提供文件上传和图片下载的功能。
*
* @Author: 落亦-
* @Date: 2019/12/15 23:46
*/
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("file") // 定义基础请求路径为 "/file"
@RestController
@RequestMapping("file")
public class FileController {
/**
* 文件上传
* @param mf 上传的文件（前端传递的MultipartFile对象）
* @return Map 包含文件保存路径的响应信息
* @param mf
* @return
*/
@RequestMapping("uploadFile")
public Map<String, Object> uploadFile(MultipartFile mf) {
// 1. 获取原始文件名
public Map<String,Object> uploadFile(MultipartFile mf) {
//1.得到文件名
String oldName = mf.getOriginalFilename();
// 2. 生成新的文件名（避免重复文件名）
String newName = AppFileUtils.createNewFileName(oldName);
// 3. 获取当前日期并格式化为 "yyyy-MM-dd" 字符串
String dirName = DateUtil.format(new Date(), "yyyy-MM-dd");
// 4. 构造保存文件的目录
File dirFile = new File(AppFileUtils.UPLOAD_PATH, dirName);
// 5. 检查目录是否存在，若不存在则创建
if (!dirFile.exists()) {
//2.根据旧的文件名生成新的文件名
String newName=AppFileUtils.createNewFileName(oldName);
//3.得到当前日期的字符串
String dirName= DateUtil.format(new Date(), "yyyy-MM-dd");
//4.构造文件夹
File dirFile=new File(AppFileUtils.UPLOAD_PATH,dirName);
//5.判断当前文件夹是否存在
if(!dirFile.exists()) {
//如果不存在则创建新文件夹
dirFile.mkdirs();
}
// 6. 创建目标文件对象，文件名后加 "_temp" 表示临时文件
File file = new File(dirFile, newName + "_temp");
// 7. 将文件内容写入到目标文件中
//6.构造文件对象
File file=new File(dirFile, newName+"_temp");
//7.把mf里面的图片信息写入file
try {
mf.transferTo(file);
} catch (IllegalStateException | IOException e) {
e.printStackTrace(); // 打印异常信息
e.printStackTrace();
}
// 8. 返回文件的保存路径（供前端调用）
Map<String, Object> map = new HashMap<>();
map.put("path", dirName + "/" + newName + "_temp");
Map<String,Object> map=new HashMap<String, Object>();
map.put("path",dirName+"/"+newName+"_temp");
return map;
}
/**
* 图片下载
* 根据文件路径返回图片的字节数据，供前端显示。
*
* @param path 文件相对路径
* @return ResponseEntity 响应图片数据
*/
@RequestMapping("showImageByPath")
public ResponseEntity<byte[]> showImageByPath(String path) {
// **注意：未完成的功能，以下是解释和可能的逻辑建议**
// 1. 规范路径，防止路径穿越漏洞
// 规范路径，防止路径穿越
Path normalizedPath = Paths.get(AppFileUtils.UPLOAD_PATH, path).normalize();
// 2. 验证路径是否在允许的上传目录内
if (!normalizedPath.startsWith(AppFileUtils.UPLOAD_PATH)) {
// 如果路径越界，则返回403（禁止访问）状态响应
// 如果路径越界，则返回错误响应
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
// 3. 从路径加载文件（逻辑未完成）
// - 需要检查文件是否存在
// - 需要读取文件的字节内容
// - 使用 `ResponseEntity` 返回字节数据和适当的 Content-Type 头
}
}

86
src/main/java/com/yeqifu/sys/controller/LoginController.java
Unescape View File

@ -24,86 +24,68 @@ import java.io.IOException;
import java.util.Date;
/**
* 登录前端控制器
* 负责处理用户登录请求和验证码生成。
*
* 登陆前端控制器
* @Author: 落亦-
* @Date: 2019/11/21 21:33
*/
@RestController // 表示该类是一个Rest风格的控制器，直接返回JSON数据
@RequestMapping("login") // 定义基础请求路径为 "/login"
@RestController
@RequestMapping("login")
public class LoginController {
@Autowired
private ILoginfoService loginfoService; // 自动注入日志服务，用于记录登录日志
private ILoginfoService loginfoService;
/**
* 用户登录
* @param userVo 用户提交的登录数据
* @param code 用户输入的验证码
* @param session 当前会话，用于获取存储的验证码
* @return ResultObj 包含登录结果的响应信息
*/
@RequestMapping("login")
public ResultObj login(UserVo userVo, String code, HttpSession session) {
// 从Session中获取之前生成的验证码
String sessionCode = (String) session.getAttribute("code");
// 验证用户输入的验证码是否正确
if (code != null && sessionCode.equals(code)) {
Subject subject = SecurityUtils.getSubject(); // 获取当前用户的Shiro Subject
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(), userVo.getPwd()); // 创建用户认证令牌
public ResultObj login(UserVo userVo,String code,HttpSession session){
//获得存储在session中的验证码
String sessionCode = (String) session.getAttribute("code");
if (code!=null&&sessionCode.equals(code)){
Subject subject = SecurityUtils.getSubject();
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(),userVo.getPwd());
try {
// 执行用户认证登录
//对用户进行认证登陆
subject.login(token);
// 通过认证后获取活动用户信息
//通过subject获取以认证活动的user
ActiverUser activerUser = (ActiverUser) subject.getPrincipal();
// 将用户信息存储到Session中
WebUtils.getSession().setAttribute("user", activerUser.getUser());
// 创建登录日志对象
//将user存储到session中
WebUtils.getSession().setAttribute("user",activerUser.getUser());
//记录登陆日志
Loginfo entity = new Loginfo();
entity.setLoginname(activerUser.getUser().getName() + "-" + activerUser.getUser().getLoginname()); // 登录名称
entity.setLoginip(WebUtils.getRequest().getRemoteAddr()); // 获取用户IP地址
entity.setLogintime(new Date()); // 设置登录时间
loginfoService.save(entity); // 保存登录日志
entity.setLoginname(activerUser.getUser().getName()+"-"+activerUser.getUser().getLoginname());
entity.setLoginip(WebUtils.getRequest().getRemoteAddr());
entity.setLogintime(new Date());
loginfoService.save(entity);
return ResultObj.LOGIN_SUCCESS; // 返回登录成功结果
return ResultObj.LOGIN_SUCCESS;
} catch (AuthenticationException e) {
e.printStackTrace();
return ResultObj.LOGIN_ERROR_PASS; // 用户名或密码错误
return ResultObj.LOGIN_ERROR_PASS;
}
} else {
return ResultObj.LOGIN_ERROR_CODE; // 验证码错误
}else {
return ResultObj.LOGIN_ERROR_CODE;
}
}
/**
* 获取登录验证码
* 生成并返回图片验证码，同时将验证码存储到Session中。
*
* @param response Http响应对象，用于返回验证码图片
* @param session 当前会话，用于存储验证码
* 得到登陆验证码
* @param response
* @param session
* @throws IOException
*/
@RequestMapping("getCode")
public void getCode(HttpServletResponse response, HttpSession session) throws IOException {
// 创建图形验证码，指定宽、高、字符数和干扰线数
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36, 4, 5);
// 将验证码内容存储到Session中
session.setAttribute("code", lineCaptcha.getCode());
public void getCode(HttpServletResponse response, HttpSession session) throws IOException{
//定义图形验证码的长和宽
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36,4,5);
session.setAttribute("code",lineCaptcha.getCode());
try {
// 获取响应输出流，将验证码图片写入响应
ServletOutputStream outputStream = response.getOutputStream();
lineCaptcha.write(outputStream);
outputStream.close(); // 关闭输出流
outputStream.close();
} catch (IOException e) {
e.printStackTrace(); // 捕获并打印IO异常
e.printStackTrace();
}
}
}

93
src/main/java/com/yeqifu/sys/controller/LoginfoController.java
Unescape View File

@ -1,8 +1,10 @@
package com.yeqifu.sys.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.sun.org.apache.regexp.internal.RE;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import com.yeqifu.sys.entity.Loginfo;
@ -11,6 +13,7 @@ import com.yeqifu.sys.vo.LoginfoVo;
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.io.Serializable;
@ -18,92 +21,76 @@ import java.util.ArrayList;
import java.util.Collection;
/**
* 日志管理前端控制器
* 提供查询登录日志、删除单条日志以及批量删除日志的接口。
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @Author: luoyi-
* @Since: 2019-11-23
* @author luoyi-
* @since 2019-11-23
*/
@RestController // 标注为Rest风格的控制器，方法直接返回JSON格式数据
@RequestMapping("loginfo") // 定义基础请求路径为 "/loginfo"
@RestController
@RequestMapping("loginfo")
public class LoginfoController {
@Autowired
private ILoginfoService loginfoService; // 自动注入日志服务接口，负责日志数据的业务逻辑处理
private ILoginfoService loginfoService;
/**
* 查询所有登录日志的信息
* 支持分页、模糊查询和时间范围筛选。
*
* @param loginfoVo 日志查询条件封装类，包含分页参数和查询条件
* @return 包含日志总条数和分页数据的对象
* 查询所有登陆日志的信息
* @param loginfoVo
* @return
*/
@RequestMapping("loadAllLoginfo")
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo) {
// 创建分页对象，指定当前页和每页条数
IPage<Loginfo> page = new Page<>(loginfoVo.getPage(), loginfoVo.getLimit());
// 构造查询条件
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<>();
// 根据登录名进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()), "loginname", loginfoVo.getLoginname());
// 根据登录IP进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()), "loginip", loginfoVo.getLoginip());
// 筛选登录时间大于等于开始时间
queryWrapper.ge(loginfoVo.getStartTime() != null, "logintime", loginfoVo.getStartTime());
// 筛选登录时间小于等于结束时间
queryWrapper.le(loginfoVo.getEndTime() != null, "logintime", loginfoVo.getEndTime());
// 按登录时间降序排列
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo){
IPage<Loginfo> page = new Page<Loginfo>(loginfoVo.getPage(),loginfoVo.getLimit());
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<Loginfo>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()),"loginname",loginfoVo.getLoginname());
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()),"loginip",loginfoVo.getLoginip());
//数据库中登陆时间要大于用户输入的开始时间且小于用户登陆的结束时间
queryWrapper.ge(loginfoVo.getStartTime()!=null,"logintime",loginfoVo.getStartTime());
queryWrapper.le(loginfoVo.getEndTime()!=null,"logintime",loginfoVo.getEndTime());
//根据登陆时间进行降序排序
queryWrapper.orderByDesc("logintime");
// 分页查询日志数据
loginfoService.page(page, queryWrapper);
// 返回包含总条数和当前页数据的结果
return new DataGridView(page.getTotal(), page.getRecords());
loginfoService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 删除单条日志
* 根据日志ID删除指定的日志记录。
*
* @param id 日志记录的唯一标识
* @return 删除操作的结果信息
* @param id
* @return
*/
@RequestMapping("deleteLoginfo")
public ResultObj deleteLoginfo(Integer id) {
public ResultObj deleteLoginfo(Integer id){
try {
// 根据ID删除日志
loginfoService.removeById(id);
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
return ResultObj.DELETE_ERROR;
}
}
/**
* 批量删除日志
* 根据多个日志ID删除指定的日志记录。
*
* @param loginfoVo 封装了多个日志ID的对象
* @return 删除操作的结果信息
* 批量删除
* @param loginfoVo
* @return
*/
@RequestMapping("batchDeleteLoginfo")
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo) {
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo){
try {
// 创建集合存储需要删除的日志ID
Collection<Serializable> idList = new ArrayList<>();
// 遍历日志ID数组，将其添加到集合中
Collection<Serializable> idList = new ArrayList<Serializable>();
for (Integer id : loginfoVo.getIds()) {
idList.add(id);
}
// 批量删除日志
this.loginfoService.removeByIds(idList);
return ResultObj.DELETE_SUCCESS; // 返回批量删除成功的结果
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR; // 返回批量删除失败的结果
return ResultObj.DELETE_ERROR;
}
}
}

171
src/main/java/com/yeqifu/sys/controller/MenuController.java
Unescape View File

@ -21,8 +21,6 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* 菜单管理控制器
*
* @Author: 落亦-
* @Date: 2019/11/22 15:35
*/
@ -39,97 +37,119 @@ public class MenuController {
@Autowired
private IRoleService roleService;
/**
* 加载首页左侧菜单数据
* @param permissionVo
* @return 返回树形结构的菜单数据
*/
@RequestMapping("loadIndexLeftMenuJson")
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo) {
// 查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.eq("available", Constast.AVAILABLE_TRUE); // 菜单必须可用
// 获取当前用户信息
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo){
//查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
//设置查询条件
//查询的必须是菜单，不能是crud的权限
queryWrapper.eq("type",Constast.TYPE_MENU);
//菜单必须可用
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
//获得用户 判断用户的类型
User user = (User) WebUtils.getSession().getAttribute("user");
List<Permission> list;
if (user.getType().equals(Constast.USER_TYPE_SUPER)) {
// 超级管理员查询所有菜单
List<Permission> list = null;
if (user.getType().equals(Constast.USER_TYPE_SUPER)){
//用户类型为超级管理员
list = permissionService.list(queryWrapper);
} else {
// 普通用户根据角色和权限查询菜单
}else {
//用户类型为 普通用户
//根据用户ID+角色+权限去查询
Integer userId = user.getId();
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId); // 获取用户角色ID
//1.根据用户ID查询角色
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId);
//2.根据角色ID查询菜单ID和权限ID
//使用set去重
Set<Integer> pids = new HashSet<>();
for (Integer rid : currentUserRoleIds) {
pids.addAll(roleService.queryRolePermissionIdsByRid(rid)); // 根据角色ID查询权限ID
//根据角色ID查询菜单ID和权限ID
List<Integer> permissionIds = roleService.queryRolePermissionIdsByRid(rid);
//将菜单ID和权限ID放入Set中去重
pids.addAll(permissionIds);
}
if (!pids.isEmpty()) {
queryWrapper.in("id", pids); // 根据权限ID查询菜单
//3.根据角色ID查询权限
if (pids.size()>0){
queryWrapper.in("id",pids);
list = permissionService.list(queryWrapper);
} else {
list = new ArrayList<>();
}else {
list=new ArrayList<>();
}
}
// 构造树节点列表
List<TreeNode> treeNodes = new ArrayList<>();
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
for (Permission p : list) {
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE);
treeNodes.add(new TreeNode(p.getId(), p.getPid(), p.getTitle(), p.getIcon(), p.getHref(), spread));
Integer id =p.getId();
Integer pid = p.getPid();
String title = p.getTitle();
String icon = p.getIcon();
String href = p.getHref();
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE)?true:false;
treeNodes.add(new TreeNode(id,pid,title,icon,href,spread));
}
// 构造层级菜单树
return new DataGridView(TreeNodeBuilder.build(treeNodes, 1));
//构造层级关系
List<TreeNode> list2 = TreeNodeBuilder.build(treeNodes,1);
return new DataGridView(list2);
}
/************************菜单管理*********************************/
/**
* 加载菜单管理左侧菜单树
* 加载菜单左边的菜单树
* @param permissionVo
* @return 返回树形结构的菜单数据
* @return
*/
@RequestMapping("loadMenuManagerLeftTreeJson")
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo) {
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo){
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
List<Permission> list = permissionService.list(queryWrapper); // 查询所有菜单
queryWrapper.eq("type",Constast.TYPE_MENU);
//查询出所有的菜单，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
List<TreeNode> treeNodes = new ArrayList<>();
//将菜单放入treeNodes中，组装成json
for (Permission menu : list) {
Boolean open = menu.getOpen() == 1; // 判断是否展开
treeNodes.add(new TreeNode(menu.getId(), menu.getPid(), menu.getTitle(), open));
Boolean open = menu.getOpen()==1?true:false;
treeNodes.add(new TreeNode(menu.getId(),menu.getPid(),menu.getTitle(),open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有菜单
* 查询所有菜单数据
* @param permissionVo
* @return 返回分页后的菜单数据
* @return
*/
@RequestMapping("loadAllMenu")
public DataGridView loadAllMenu(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
public DataGridView loadAllMenu(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(permissionVo.getId() != null, "id", permissionVo.getId())
.or().eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum"); // 根据排序码升序排列
permissionService.page(page, queryWrapper); // 分页查询
return new DataGridView(page.getTotal(), page.getRecords());
queryWrapper.eq(permissionVo.getId()!=null,"id",permissionVo.getId()).or().eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
//只能查询菜单
queryWrapper.eq("type",Constast.TYPE_MENU);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加菜单
* @param permissionVo
* @return 操作结果
* @return
*/
@RequestMapping("addMenu")
public ResultObj addMenu(PermissionVo permissionVo) {
public ResultObj addMenu(PermissionVo permissionVo){
try {
permissionVo.setType(Constast.TYPE_MENU); // 设置类型为菜单
//设置添加类型为 menu
permissionVo.setType(Constast.TYPE_MENU);
permissionService.save(permissionVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -139,27 +159,31 @@ public class MenuController {
}
/**
* 加载菜单的最大排序码
* @return 返回最大排序码
* 加载排序码
* @return
*/
@RequestMapping("loadMenuMaxOrderNum")
public Map<String, Object> loadMenuMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> loadMenuMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1, 1);
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
map.put("value", list.isEmpty() ? 1 : list.get(0).getOrdernum() + 1);
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
}
return map;
}
/**
* 更新菜单
* @param permissionVo
* @return 操作结果
* @return
*/
@RequestMapping("updateMenu")
public ResultObj updateMenu(PermissionVo permissionVo) {
public ResultObj updateMenu(PermissionVo permissionVo){
try {
permissionService.updateById(permissionVo);
return ResultObj.UPDATE_SUCCESS;
@ -170,26 +194,31 @@ public class MenuController {
}
/**
* 检查菜单是否有子菜单
* 检查当前菜单是否有子菜单
* @param permissionVo
* @return 返回是否有子菜单
* @return
*/
@RequestMapping("checkMenuHasChildrenNode")
public Map<String, Object> checkMenuHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> checkMenuHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid", permissionVo.getId()); // 查询是否有子菜单
map.put("value", !permissionService.list(queryWrapper).isEmpty());
queryWrapper.eq("pid",permissionVo.getId());
List<Permission> list = permissionService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
return map;
}
/**
* 删除菜单
* @param permissionVo
* @return 操作结果
* @return
*/
@RequestMapping("deleteMenu")
public ResultObj deleteMenu(PermissionVo permissionVo) {
public ResultObj deleteMenu(PermissionVo permissionVo){
try {
permissionService.removeById(permissionVo.getId());
return ResultObj.DELETE_SUCCESS;
@ -198,4 +227,6 @@ public class MenuController {
return ResultObj.DELETE_ERROR;
}
}
}

81
src/main/java/com/yeqifu/sys/controller/NoticeController.java
Unescape View File

@ -37,51 +37,48 @@ public class NoticeController {
private INoticeService noticeService;
/**
* 查询公告列表
* 根据条件（标题、操作人、创建时间范围）分页查询公告，并按创建时间降序排序。
*
* @param noticeVo 包含查询条件的对象
* @return 包含公告数据和总记录数的DataGridView对象
* 公告的查询
* @param noticeVo
* @return
*/
@RequestMapping("loadAllNotice")
public DataGridView loadAllNotice(NoticeVo noticeVo) {
// 分页和条件查询
IPage<Notice> page = new Page<>(noticeVo.getPage(), noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()), "title", noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()), "opername", noticeVo.getOpername());
queryWrapper.ge(noticeVo.getStartTime() != null, "createtime", noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime() != null, "createtime", noticeVo.getEndTime());
public DataGridView loadAllNotice(NoticeVo noticeVo){
IPage<Notice> page = new Page<Notice>(noticeVo.getPage(),noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<Notice>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()),"title",noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()),"opername",noticeVo.getOpername());
//公告创建时间应该大于搜索开始时间小于搜索结束时间
queryWrapper.ge(noticeVo.getStartTime()!=null,"createtime",noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime()!=null,"createtime",noticeVo.getEndTime());
//根据公告创建时间进行排序
queryWrapper.orderByDesc("createtime");
noticeService.page(page, queryWrapper);
return new DataGridView(page.getTotal(), page.getRecords());
noticeService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 根据公告ID查询单条公告
*
* @param id 公告ID
* @return 包含公告数据的DataGridView对象
* 根据公告ID查询一条公告
* @param id 公告ID
* @return
*/
@RequestMapping("loadNoticeById")
public DataGridView loadNoticeById(Integer id) {
public DataGridView loadNoticeById(Integer id){
Notice notice = noticeService.getById(id);
return new DataGridView(notice);
}
/**
* 添加公告
* 自动填充创建时间和操作人信息。
*
* @param noticeVo 包含公告信息的对象
* @return 操作结果（成功或失败）
* @param noticeVo
* @return
*/
@RequestMapping("addNotice")
public ResultObj addNotice(NoticeVo noticeVo) {
public ResultObj addNotice(NoticeVo noticeVo){
try {
noticeVo.setCreatetime(new Date()); // 设置创建时间
noticeVo.setCreatetime(new Date());
User user = (User) WebUtils.getSession().getAttribute("user");
noticeVo.setOpername(user.getName()); // 设置操作人
noticeVo.setOpername(user.getName());
noticeService.save(noticeVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -92,12 +89,11 @@ public class NoticeController {
/**
* 修改公告
*
* @param noticeVo 包含修改后公告信息的对象
* @return 操作结果（成功或失败）
* @param noticeVo
* @return
*/
@RequestMapping("updateNotice")
public ResultObj updateNotice(NoticeVo noticeVo) {
public ResultObj updateNotice(NoticeVo noticeVo){
try {
noticeService.updateById(noticeVo);
return ResultObj.UPDATE_SUCCESS;
@ -108,13 +104,12 @@ public class NoticeController {
}
/**
* 删除单条公告
*
* @param noticeVo 包含要删除公告ID的对象
* @return 操作结果（成功或失败）
* 删除公告
* @param noticeVo
* @return
*/
@RequestMapping("deleteNotice")
public ResultObj deleteNotice(NoticeVo noticeVo) {
public ResultObj deleteNotice(NoticeVo noticeVo){
try {
noticeService.removeById(noticeVo);
return ResultObj.DELETE_SUCCESS;
@ -126,22 +121,24 @@ public class NoticeController {
/**
* 批量删除公告
*
* @param noticeVo 包含要删除公告ID集合的对象
* @return 操作结果（成功或失败）
* @param noticeVo
* @return
*/
@RequestMapping("batchDeleteNotice")
public ResultObj batchDeleteNotice(NoticeVo noticeVo) {
public ResultObj batchDeleteNotice(NoticeVo noticeVo){
try {
Collection<Serializable> idList = new ArrayList<>();
for (Integer id : noticeVo.getIds()) {
idList.add(id); // 将ID加入集合
idList.add(id);
}
noticeService.removeByIds(idList); // 批量删除
noticeService.removeByIds(idList);
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

145
src/main/java/com/yeqifu/sys/controller/PermissionController.java
Unescape View File

@ -22,66 +22,74 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
/@RestController
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-11-22
*/
@RestController
@RequestMapping("permission")
public class PermissionController {
@Autowired
private IPermissionService permissionService;
/**
* 加载权限管理左侧的权限树
* 将所有菜单类型的权限以树形结构的形式返回。
*
* @param permissionVo 包含请求参数的对象
* @return 包含树形结构权限数据的DataGridView对象
* 加载权限左边的权限树
* @param permissionVo
* @return
*/
@RequestMapping("loadPermissionManagerLeftTreeJson")
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo) {
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 查询类型为菜单的权限
List<Permission> list = permissionService.list(queryWrapper); // 查询权限列表
List<TreeNode> treeNodes = new ArrayList<>();
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo){
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
queryWrapper.eq("type", Constast.TYPE_MENU);
//查询出所有的权限，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
//将权限放入treeNodes中，组装成json
for (Permission permission : list) {
// 创建树节点，设置是否展开
Boolean open = permission.getOpen() == 1 ? true : false;
treeNodes.add(new TreeNode(permission.getId(), permission.getPid(), permission.getTitle(), open));
Boolean open = permission.getOpen()==1?true:false;
treeNodes.add(new TreeNode(permission.getId(),permission.getPid(),permission.getTitle(),open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有权限数据
* 按条件（权限类型、标题、权限码、父ID）进行模糊查询并排序，支持分页。
*
* @param permissionVo 包含查询条件和分页参数的对象
* @return 包含权限数据和总记录数的DataGridView对象
* @param permissionVo
* @return
*/
@RequestMapping("loadAllPermission")
public DataGridView loadAllPermission(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
public DataGridView loadAllPermission(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_PERMISSION); // 仅查询权限类型
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()), "percode", permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序号升序排序
permissionService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords());
//只能查询权限
queryWrapper.eq("type",Constast.TYPE_PERMISSION);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()),"percode",permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
}
/**
* 添加权限
* 将新权限保存到数据库中，并设置其类型为“权限”。
*
* @param permissionVo 包含权限数据的对象
* @return 操作结果（成功或失败）
* @param permissionVo
* @return
*/
@RequestMapping("addPermission")
public ResultObj addPermission(PermissionVo permissionVo) {
public ResultObj addPermission(PermissionVo permissionVo){
try {
permissionVo.setType(Constast.TYPE_PERMISSION); // 设置类型为权限
permissionService.save(permissionVo); // 保存权限
//设置添加类型为 permission
permissionVo.setType(Constast.TYPE_PERMISSION);
permissionService.save(permissionVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -90,37 +98,33 @@ public class PermissionController {
}
/**
* 加载权限的最大排序号
* 返回当前权限的最大排序号+1，用于新增权限时自动设置排序号。
*
* @return 包含最大排序号的Map对象
* 加载排序码
* @return
*/
@RequestMapping("loadPermissionMaxOrderNum")
public Map<String, Object> loadPermissionMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> loadPermissionMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum"); // 按排序号降序查询
IPage<Permission> page = new Page<>(1, 1); // 查询第一页的第一条记录
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 最大排序号+1
} else {
map.put("value", 1); // 如果没有记录，设置排序号为1
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
}
return map;
}
/**
* 更新权限
* 根据ID更新权限信息。
*
* @param permissionVo 包含更新数据的对象
* @return 操作结果（成功或失败）
* @param permissionVo
* @return
*/
@RequestMapping("updatePermission")
public ResultObj updatePermission(PermissionVo permissionVo) {
public ResultObj updatePermission(PermissionVo permissionVo){
try {
permissionService.updateById(permissionVo); // 根据ID更新权限
permissionService.updateById(permissionVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -129,37 +133,40 @@ public class PermissionController {
}
/**
* 检查权限是否有子权限
* 根据父ID查询是否存在子权限，返回结果为true或false。
*
* @param permissionVo 包含父ID的对象
* @return 包含检查结果的Map对象
* 检查当前权限是否有子权限
* @param permissionVo
* @return
*/
@RequestMapping("checkPermissionHasChildrenNode")
public Map<String, Object> checkPermissionHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
public Map<String,Object> checkPermissionHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid", permissionVo.getId()); // 根据父ID查询
queryWrapper.eq("pid",permissionVo.getId());
List<Permission> list = permissionService.list(queryWrapper);
map.put("value", !list.isEmpty()); // 如果有子权限，返回true；否则返回false
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
return map;
}
/**
* 删除权限
* 根据ID删除权限。
*
* @param permissionVo 包含要删除权限ID的对象
* @return 操作结果（成功或失败）
* @param permissionVo
* @return
*/
@RequestMapping("deletePermission")
public ResultObj deletePermission(PermissionVo permissionVo) {
public ResultObj deletePermission(PermissionVo permissionVo){
try {
permissionService.removeById(permissionVo.getId()); // 根据ID删除权限
permissionService.removeById(permissionVo.getId());
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

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>

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

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

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

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

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

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

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