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

Merge branch 'main' of https://bdgit.educoder.net/py3me6qac/warehouse

Browse Source
zhangnian
LinTiee 9 months ago
parent a0a1de8030 6a27a555a6
commit a2eb7836a8
47 changed files with 1804 additions and 606 deletions
Show Stats Download Patch File Download Diff File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -13,34 +13,65 @@ import java.io.InputStream;
import java.util.Properties;
/**
* @Author: 落亦-
* @Date: 2019/12/15 23:44
*@Author zup
*@Date: 2024/12/15
*/
public class AppFileUtils {
/**
* 文件上传的保存路径 默认值
* 文件上传的保存路径 默认值
*/
public static String UPLOAD_PATH="src/main/resources/static/upload/";
public static String UPLOAD_PATH;
static {
//通过反射的方式，读取配置文件的存储地址
InputStream stream = AppFileUtils.class.getClassLoader().getResourceAsStream("file.properties");
Properties properties = new Properties();
try {
properties.load(stream);
try (InputStream stream = AppFileUtils.class.getClassLoader().getResourceAsStream("file.properties")) {
Properties properties = new Properties();
if (stream != null) {
properties.load(stream);
}
// 从配置文件中获取路径
String property = properties.getProperty("filepath");
// 如果配置了路径，使用配置的路径，否则使用默认路径
if (property != null && !property.isEmpty()) {
UPLOAD_PATH = property;
} else {
String userHome = System.getProperty("user.home");
// 设置上传路径为当前操作系统用户的 Documents 文件夹下的 WebFile 文件夹
String defaultPath = userHome + File.separator + "Documents" + File.separator + "WebFile";
// 创建了 File 对象
File uploadDir = new File(defaultPath);
// 将路径赋值给静态变量 UPLOAD_PATH
UPLOAD_PATH = uploadDir.getAbsolutePath();
}
File dir = new File(UPLOAD_PATH);
System.out.println(dir.getAbsolutePath());
// 如果目录不存在，则创建
if (!dir.exists()) {
if (!dir.mkdirs()) {
throw new RuntimeException("无法创建上传路径：" + dir.getAbsolutePath());
}
}
// 检查上传路径是否可读写
if (!dir.canRead() || !dir.canWrite()) {
throw new RuntimeException("上传路径不可读写：" + dir.getAbsolutePath());
}
} catch (IOException e) {
// 处理配置文件加载时的异常
e.printStackTrace();
throw new RuntimeException("加载文件上传的保存路径配置失败！", e);
}
String property = properties.getProperty("filepath");
if(property != null && !property.isEmpty()) {
UPLOAD_PATH = property;
}
}
/**
* 根据文件老名字得到新名字
* @param oldName 文件老名字
* 根据文件原始名字得到新名字
* @param oldName 原始名
* @return 新名字由32位随机数加图片后缀组成
*/
public static String createNewFileName(String oldName) {
@ -50,60 +81,77 @@ public class AppFileUtils {
return IdUtil.simpleUUID().toUpperCase() + stuff;
}
/**
* 文件下载
* @param path
* @return
*/
public static ResponseEntity<Object> createResponseEntity(String path) {
//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();
}
//创建封装响应头信息的对象
HttpHeaders header = new HttpHeaders();
//封装响应内容类型(APPLICATION_OCTET_STREAM 响应的内容不限定)
header.setContentType(MediaType.APPLICATION_OCTET_STREAM);
//创建ResponseEntity对象
ResponseEntity<Object> entity= new ResponseEntity<Object>(bytes, header, HttpStatus.CREATED);
return entity;
}
return null;
}
// /**
// * 文件下载
// * @param path
// * @return
// */
// public static ResponseEntity<Object> createResponseEntity(String path) {
// //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();
// }
// //创建封装响应头信息的对象
// HttpHeaders header = new HttpHeaders();
// //封装响应内容类型(APPLICATION_OCTET_STREAM 响应的内容不限定)
// header.setContentType(MediaType.APPLICATION_OCTET_STREAM);
// //创建ResponseEntity对象
// ResponseEntity<Object> entity= new ResponseEntity<Object>(bytes, header, HttpStatus.CREATED);
// return entity;
// }
// return null;
// }
/**
* 更该图片的名字 去掉_temp
* 更改图片的名字 去掉_temp
* @param nameImg 图片名
* @return
* @return String
*/
public static String renameFile(String nameImg) {
File file = new File(UPLOAD_PATH, nameImg);
String replace = nameImg.replace("_temp","");
String newNameImg = nameImg.replace("_temp", "");
if (file.exists()){
file.renameTo(new File(UPLOAD_PATH,replace));
File newFile = new File(UPLOAD_PATH, newNameImg);
boolean success = file.renameTo(newFile);
if (!success) {
throw new RuntimeException("重命名文件失败：" + file.getAbsolutePath() + " -> "
+ newFile.getAbsolutePath());
}
}
return replace;
return newNameImg;
}
/**
* 根据老路径删除图片
* @param oldPath
* 根据旧路径删除图片
* @param oldPath 图片路径
*/
public static void removeFileByPath(String oldPath) {
//图片的路径不是默认图片的路径
if (!oldPath.endsWith(Constast.DEFAULT_IMG_GOODS) && !oldPath.endsWith(Constast.DEFAULT_IMG_USER)){
File file = new File(UPLOAD_PATH,oldPath);
public static boolean removeFileByPath(String oldPath) {
// 图片的路径是默认用户头像则不执行删除操作
if (oldPath != null && oldPath.endsWith(Constast.DEFAULT_IMG_USER)) {
return true;
} else {
assert oldPath != null;
File file = new File(UPLOAD_PATH, oldPath);
// 文件存在则删除
if (file.exists()) {
file.delete();
if (file.delete()) {
return true;
} else {
throw new RuntimeException("文件删除失败: " + file.getAbsolutePath());
}
} else {
// 文件不存在
return false;
}
}
}
}
}

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

@ -2,9 +2,12 @@ package com.yeqifu.sys.controller;
import cn.hutool.core.date.DateUtil;
import com.yeqifu.sys.common.AppFileUtils;
import com.yeqifu.sys.common.Constast;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.http.HttpStatus;
@ -19,8 +22,8 @@ import java.util.HashMap;
import java.util.Map;
/**
* @Author: 落亦-
* @Date: 2019/12/15 23:46
*@Author zup
*@Date: 2024/12/16
*/
@RestController
@RequestMapping("file")
@ -28,45 +31,77 @@ public class FileController {
/**
* 图片上传
* @param mf
* @return
* @param mf 上传的文件
* @return 上传结果
*/
@RequestMapping("uploadImage")
public Map<String, Object> uploadImage(MultipartFile mf) {
// 1. 得到文件名
Map<String, Object> map = new HashMap<>();
// 检查 MultipartFile 是否为空
if (mf == null || mf.isEmpty()) {
map.put("error", "上传文件为空");
return map;
}
// 得到文件名原始名
String oldName = mf.getOriginalFilename();
// 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();
// 检查文件名是否为空
if (oldName == null || oldName.trim().isEmpty()) {
map.put("error", "文件名为空");
return map;
}
// 6. 构造文件对象
File file = new File(dirFile, newName + "_temp");
// 7. 把 mf 里面的图片信息写入 file
try {
// 根据旧的文件名生成新的文件名
String newName = AppFileUtils.createNewFileName(oldName);
// 得到当前日期的字符串
String dirName = DateUtil.format(new Date(), "yyyy-MM-dd");
// 构造文件夹路径
File dirFile = new File(AppFileUtils.UPLOAD_PATH, dirName);
// 判断当前文件夹是否存在
if (!dirFile.exists()) {
// 如果不存在则创建新文件夹
if (!dirFile.mkdirs()) {
map.put("error", "无法创建上传路径：" + dirFile.getAbsolutePath());
return map;
}
}
// 构造文件对象
File file = new File(dirFile, newName + "_temp");
// 把 mf 里面的图片信息写入 file
mf.transferTo(file);
} catch (IllegalStateException | IOException e) {
map.put("path", dirName + "/" + newName + "_temp");
} catch (IOException e) {
e.printStackTrace();
map.put("error", "文件上传失败：" + e.getMessage());
} catch (RuntimeException e) {
e.printStackTrace();
map.put("error", "上传过程发生运行时异常：" + e.getMessage());
}
Map<String, Object> map = new HashMap<>();
map.put("path", dirName + "/" + newName + "_temp");
return map;
}
/**
* 图片下载
* @param path 图片路径
* return
* @return 文件内容或错误信息
*/
@RequestMapping("showImageByPath")
public ResponseEntity<byte[]> downloadImage(String path) {
public ResponseEntity<byte[]> downloadImage(@RequestParam String path) {
// 如果是默认图片，直接返回
if (path.equals(Constast.DEFAULT_IMG_USER) || path.equals(Constast.DEFAULT_IMG_GOODS)) {
return getDefaultImage(path);
}
// 规范路径，防止路径穿越
Path normalizedPath = Paths.get(AppFileUtils.UPLOAD_PATH, path).normalize();
@ -74,7 +109,6 @@ public class FileController {
if (!normalizedPath.startsWith(AppFileUtils.UPLOAD_PATH)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build(); // 如果路径越界，返回403 Forbidden
}
// 检查文件是否存在
File file = normalizedPath.toFile();
if (!file.exists() || !file.isFile()) {
@ -103,4 +137,21 @@ public class FileController {
}
}
/**
* 获取默认图片内容
*/
private ResponseEntity<byte[]> getDefaultImage(String path) {
// 返回一个 302 重定向响应，重定向到默认图片的 URL
if (path.equals(Constast.DEFAULT_IMG_USER)) {
return ResponseEntity.status(HttpStatus.FOUND)
.header(HttpHeaders.LOCATION, Constast.DEFAULT_IMG_USER) // 图片的 URL 路径
.build();
} else if (path.equals(Constast.DEFAULT_IMG_GOODS)) {
return ResponseEntity.status(HttpStatus.FOUND)
.header(HttpHeaders.LOCATION, Constast.DEFAULT_IMG_GOODS) // 图片的 URL 路径
.build();
}
return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
}
}

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

@ -22,6 +22,7 @@ import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.Date;
import java.util.Objects;
/**
* 登陆前端控制器
@ -36,43 +37,46 @@ public class LoginController {
private ILoginfoService loginfoService;
@RequestMapping("login")
public ResultObj login(UserVo userVo,String code,HttpSession session){
public ResultObj login(UserVo userVo, String code, HttpSession session) {
//获得存储在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();
//将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());
entity.setLogintime(new Date());
loginfoService.save(entity);
return ResultObj.LOGIN_SUCCESS;
} catch (AuthenticationException e) {
e.printStackTrace();
return ResultObj.LOGIN_ERROR_PASS;
}
}else {
return ResultObj.LOGIN_ERROR_CODE;
if (!Objects.equals(sessionCode, code)) {
return ResultObj.LOGIN_ERROR_CODE; // 验证码错误
}
// 验证码使用后清除
session.removeAttribute("code");
Subject subject = SecurityUtils.getSubject();
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(), userVo.getPwd());
try {
// 用户认证
subject.login(token);
ActiverUser activerUser = (ActiverUser) subject.getPrincipal();
// 存储用户信息到 session
WebUtils.getSession().setAttribute("user", activerUser.getUser());
// 记录登录日志
Loginfo entity = new Loginfo();
entity.setLoginname(activerUser.getUser().getName() + "-" + activerUser.getUser().getLoginname());
entity.setLoginip(WebUtils.getRequest().getRemoteAddr());
entity.setLogintime(new Date());
loginfoService.save(entity);
return ResultObj.LOGIN_SUCCESS;
} catch (AuthenticationException e) { // 其他认证错误
e.printStackTrace();
return ResultObj.LOGIN_ERROR_PASS;
}
}
/**
* 得到登陆验证码
* @param response
* @param session
* @throws IOException
*/
@RequestMapping("getCode")
public void getCode(HttpServletResponse response, HttpSession session) throws IOException{

51
src/main/java/com/yeqifu/sys/controller/UserController.java
Unescape View File

@ -1,6 +1,5 @@
package com.yeqifu.sys.controller;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@ -17,12 +16,16 @@ import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* <p>
@ -231,7 +234,7 @@ public class UserController {
// Ensure that the user trying to reset is an admin
if (!currentUser.isAdmin()) {
return new DataGridView("403", "权限不足，无法重置其他用户密码");
return new DataGridView(403, "权限不足，无法重置其他用户密码");
}
// Reset password logic
@ -241,9 +244,8 @@ public class UserController {
// Save the updated user
userService.updateById(targetUser);
return new DataGridView("200", "用户密码重置成功");
return new DataGridView(200, "用户密码重置成功");
}
}
/**
* 根据用户id查询角色并选中已拥有的角色
@ -343,30 +345,45 @@ public class UserController {
* @return
*/
@RequestMapping("updateUserInfo")
public ResultObj updateUserInfo(UserVo userVo){
public ResultObj updateUserInfo(UserVo userVo) {
try {
//用户头像不是默认图片
if (!(userVo.getImgpath()!=null&&userVo.getImgpath().equals(Constast.DEFAULT_IMG_GOODS))){
if (userVo.getImgpath().endsWith("_temp")){
String newName = AppFileUtils.renameFile(userVo.getImgpath());
userVo.setImgpath(newName);
//删除原先的图片
String oldPath = userService.getById(userVo.getId()).getImgpath();
AppFileUtils.removeFileByPath(oldPath);
//获取存储在session中的user并重新设置user中的图片地址
if (userVo.getImgpath().endsWith("_temp")) {
// 获取当前用户的旧图片路径
String oldPath = userService.getById(userVo.getId()).getImgpath();
// 删除原先的图片
boolean fileDeleted = AppFileUtils.removeFileByPath(oldPath);
// 文件不存在删除失败，设为默认头像
if (!fileDeleted) {
User user = (User) WebUtils.getSession().getAttribute("user");
user.setImgpath(newName);
//重新设置user
WebUtils.getSession().setAttribute("user",user);
user.setImgpath(Constast.DEFAULT_IMG_USER);
return ResultObj.UPDATE_ERROR_SetDefaultImg;
}
// 重命名文件
String newName = AppFileUtils.renameFile(userVo.getImgpath());
userVo.setImgpath(newName);
// 获取存储在session中的user并重新设置user中的头像路径
User user = (User) WebUtils.getSession().getAttribute("user");
user.setImgpath(newName);
// 重新设置user到session中
WebUtils.getSession().setAttribute("user", user);
}
// 更新用户信息
userService.updateById(userVo);
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
}
}
}

971
src/main/resources/static/resources/layui/lay/modules/table.js
View File

File diff suppressed because one or more lines are too long

296
warehouse.sql
Unescape View File

@ -113,10 +113,6 @@ INSERT INTO `bus_inport` VALUES (4, '银联', '2018-05-07 00:00:00', '张三', 1
INSERT INTO `bus_inport` VALUES (5, '银联', '2018-05-07 00:00:00', '张三', 100, '无', 1, 3, 1);
INSERT INTO `bus_inport` VALUES (6, '银联', '2018-05-07 00:00:00', '张三', 100, '1231', 2.5, 1, 2);
INSERT INTO `bus_inport` VALUES (8, '支付宝', '2018-05-07 00:00:00', '张三', 100, '', 1, 3, 1);
INSERT INTO `bus_inport` VALUES (10, '支付宝', '2018-08-07 17:17:57', '超级管理员', 100, 'sadfasfdsa', 1.5, 3, 1);
INSERT INTO `bus_inport` VALUES (11, '支付宝', '2018-09-17 16:12:25', '超级管理员', 21, '21', 21, 1, 3);
INSERT INTO `bus_inport` VALUES (12, '微信', '2018-12-25 16:48:24', '超级管理员', 100, '123213213', 12321321, 3, 1);
-- ----------------------------
-- Table structure for bus_outport
-- ----------------------------
@ -271,273 +267,6 @@ INSERT INTO `sys_loginfo` VALUES (18, '落亦--luoyi', '127.0.0.1', '2019-11-25
INSERT INTO `sys_loginfo` VALUES (19, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 08:32:41');
INSERT INTO `sys_loginfo` VALUES (20, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 09:18:06');
INSERT INTO `sys_loginfo` VALUES (21, '超级管理员-system', '0:0:0:0:0:0:0:1', '2019-11-26 09:59:19');
INSERT INTO `sys_loginfo` VALUES (22, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 10:48:05');
INSERT INTO `sys_loginfo` VALUES (23, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 15:15:03');
INSERT INTO `sys_loginfo` VALUES (24, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 15:42:02');
INSERT INTO `sys_loginfo` VALUES (25, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 16:56:54');
INSERT INTO `sys_loginfo` VALUES (26, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 18:07:44');
INSERT INTO `sys_loginfo` VALUES (27, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 18:08:08');
INSERT INTO `sys_loginfo` VALUES (28, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 19:23:12');
INSERT INTO `sys_loginfo` VALUES (29, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 20:46:57');
INSERT INTO `sys_loginfo` VALUES (30, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 21:17:48');
INSERT INTO `sys_loginfo` VALUES (31, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-26 21:21:16');
INSERT INTO `sys_loginfo` VALUES (32, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-27 20:13:56');
INSERT INTO `sys_loginfo` VALUES (33, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-27 20:29:17');
INSERT INTO `sys_loginfo` VALUES (34, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-27 20:30:38');
INSERT INTO `sys_loginfo` VALUES (35, '落亦--luoyi', '127.0.0.1', '2019-11-27 20:32:36');
INSERT INTO `sys_loginfo` VALUES (36, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-27 20:33:47');
INSERT INTO `sys_loginfo` VALUES (37, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 08:52:02');
INSERT INTO `sys_loginfo` VALUES (38, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:09:14');
INSERT INTO `sys_loginfo` VALUES (39, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:09:23');
INSERT INTO `sys_loginfo` VALUES (40, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:10:00');
INSERT INTO `sys_loginfo` VALUES (41, '落亦--luoyi', '127.0.0.1', '2019-11-28 09:10:53');
INSERT INTO `sys_loginfo` VALUES (42, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:17:06');
INSERT INTO `sys_loginfo` VALUES (43, '落亦--luoyi', '127.0.0.1', '2019-11-28 09:18:25');
INSERT INTO `sys_loginfo` VALUES (44, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:19:19');
INSERT INTO `sys_loginfo` VALUES (45, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:43:12');
INSERT INTO `sys_loginfo` VALUES (46, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:55:00');
INSERT INTO `sys_loginfo` VALUES (47, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:56:54');
INSERT INTO `sys_loginfo` VALUES (48, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 09:59:18');
INSERT INTO `sys_loginfo` VALUES (49, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 10:28:42');
INSERT INTO `sys_loginfo` VALUES (50, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 10:35:39');
INSERT INTO `sys_loginfo` VALUES (51, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 14:46:07');
INSERT INTO `sys_loginfo` VALUES (52, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 14:56:34');
INSERT INTO `sys_loginfo` VALUES (53, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 14:57:11');
INSERT INTO `sys_loginfo` VALUES (54, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 20:37:00');
INSERT INTO `sys_loginfo` VALUES (55, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 21:29:07');
INSERT INTO `sys_loginfo` VALUES (56, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 21:35:40');
INSERT INTO `sys_loginfo` VALUES (57, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 21:38:15');
INSERT INTO `sys_loginfo` VALUES (58, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-28 21:39:56');
INSERT INTO `sys_loginfo` VALUES (59, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 08:34:49');
INSERT INTO `sys_loginfo` VALUES (60, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 09:15:39');
INSERT INTO `sys_loginfo` VALUES (61, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 09:24:44');
INSERT INTO `sys_loginfo` VALUES (62, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 09:29:50');
INSERT INTO `sys_loginfo` VALUES (63, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 10:13:31');
INSERT INTO `sys_loginfo` VALUES (64, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 10:45:24');
INSERT INTO `sys_loginfo` VALUES (65, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 10:51:44');
INSERT INTO `sys_loginfo` VALUES (66, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 11:07:38');
INSERT INTO `sys_loginfo` VALUES (67, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 21:52:58');
INSERT INTO `sys_loginfo` VALUES (68, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:00:53');
INSERT INTO `sys_loginfo` VALUES (69, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:13:18');
INSERT INTO `sys_loginfo` VALUES (70, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:23:34');
INSERT INTO `sys_loginfo` VALUES (71, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:28:58');
INSERT INTO `sys_loginfo` VALUES (72, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:30:01');
INSERT INTO `sys_loginfo` VALUES (73, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:37:01');
INSERT INTO `sys_loginfo` VALUES (74, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:37:47');
INSERT INTO `sys_loginfo` VALUES (75, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 22:45:21');
INSERT INTO `sys_loginfo` VALUES (76, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 23:05:59');
INSERT INTO `sys_loginfo` VALUES (77, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 23:14:08');
INSERT INTO `sys_loginfo` VALUES (78, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 23:19:56');
INSERT INTO `sys_loginfo` VALUES (79, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-29 23:29:39');
INSERT INTO `sys_loginfo` VALUES (80, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 11:24:06');
INSERT INTO `sys_loginfo` VALUES (81, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 11:40:39');
INSERT INTO `sys_loginfo` VALUES (82, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 11:42:36');
INSERT INTO `sys_loginfo` VALUES (83, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 11:47:08');
INSERT INTO `sys_loginfo` VALUES (84, '落亦--luoyi', '127.0.0.1', '2019-11-30 11:59:23');
INSERT INTO `sys_loginfo` VALUES (85, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 12:03:46');
INSERT INTO `sys_loginfo` VALUES (86, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 12:18:12');
INSERT INTO `sys_loginfo` VALUES (87, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 12:58:59');
INSERT INTO `sys_loginfo` VALUES (88, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-11-30 18:29:39');
INSERT INTO `sys_loginfo` VALUES (89, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-01 09:37:38');
INSERT INTO `sys_loginfo` VALUES (90, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-01 11:46:14');
INSERT INTO `sys_loginfo` VALUES (91, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 10:39:07');
INSERT INTO `sys_loginfo` VALUES (92, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 10:42:01');
INSERT INTO `sys_loginfo` VALUES (93, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 10:44:22');
INSERT INTO `sys_loginfo` VALUES (94, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 10:49:58');
INSERT INTO `sys_loginfo` VALUES (95, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 18:40:27');
INSERT INTO `sys_loginfo` VALUES (96, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 18:41:44');
INSERT INTO `sys_loginfo` VALUES (97, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 18:51:51');
INSERT INTO `sys_loginfo` VALUES (98, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-02 19:44:13');
INSERT INTO `sys_loginfo` VALUES (99, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 08:40:06');
INSERT INTO `sys_loginfo` VALUES (100, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 09:17:34');
INSERT INTO `sys_loginfo` VALUES (101, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 09:49:33');
INSERT INTO `sys_loginfo` VALUES (102, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 09:49:54');
INSERT INTO `sys_loginfo` VALUES (103, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 10:46:23');
INSERT INTO `sys_loginfo` VALUES (104, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 10:52:24');
INSERT INTO `sys_loginfo` VALUES (105, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 11:12:01');
INSERT INTO `sys_loginfo` VALUES (106, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 13:52:12');
INSERT INTO `sys_loginfo` VALUES (107, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:04:33');
INSERT INTO `sys_loginfo` VALUES (108, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:09:36');
INSERT INTO `sys_loginfo` VALUES (109, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:12:28');
INSERT INTO `sys_loginfo` VALUES (110, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:13:55');
INSERT INTO `sys_loginfo` VALUES (111, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:20:36');
INSERT INTO `sys_loginfo` VALUES (112, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:21:06');
INSERT INTO `sys_loginfo` VALUES (113, '苏北旦-subeidan', '0:0:0:0:0:0:0:1', '2019-12-03 14:27:37');
INSERT INTO `sys_loginfo` VALUES (114, '旦素一-dansuyi', '0:0:0:0:0:0:0:1', '2019-12-03 14:27:54');
INSERT INTO `sys_loginfo` VALUES (115, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 15:04:21');
INSERT INTO `sys_loginfo` VALUES (116, '李九-lijiu', '0:0:0:0:0:0:0:1', '2019-12-03 15:47:02');
INSERT INTO `sys_loginfo` VALUES (117, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-03 15:47:25');
INSERT INTO `sys_loginfo` VALUES (118, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 08:36:54');
INSERT INTO `sys_loginfo` VALUES (119, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 09:18:26');
INSERT INTO `sys_loginfo` VALUES (120, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 09:40:35');
INSERT INTO `sys_loginfo` VALUES (121, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 10:14:43');
INSERT INTO `sys_loginfo` VALUES (122, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 10:27:12');
INSERT INTO `sys_loginfo` VALUES (123, '李约素-liyuesu', '0:0:0:0:0:0:0:1', '2019-12-04 10:28:12');
INSERT INTO `sys_loginfo` VALUES (124, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-04 10:28:20');
INSERT INTO `sys_loginfo` VALUES (125, '赵六-zhaoliu', '0:0:0:0:0:0:0:1', '2019-12-04 10:28:28');
INSERT INTO `sys_loginfo` VALUES (126, '王五-wangwu', '0:0:0:0:0:0:0:1', '2019-12-04 10:28:40');
INSERT INTO `sys_loginfo` VALUES (127, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 10:28:51');
INSERT INTO `sys_loginfo` VALUES (128, '苏北旦-subeidan', '0:0:0:0:0:0:0:1', '2019-12-04 10:30:00');
INSERT INTO `sys_loginfo` VALUES (129, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 10:30:16');
INSERT INTO `sys_loginfo` VALUES (130, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-04 11:13:42');
INSERT INTO `sys_loginfo` VALUES (131, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-04 11:15:22');
INSERT INTO `sys_loginfo` VALUES (132, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-04 11:16:03');
INSERT INTO `sys_loginfo` VALUES (133, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 10:27:27');
INSERT INTO `sys_loginfo` VALUES (134, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 10:32:11');
INSERT INTO `sys_loginfo` VALUES (135, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 10:39:49');
INSERT INTO `sys_loginfo` VALUES (136, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 10:43:26');
INSERT INTO `sys_loginfo` VALUES (137, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 10:44:41');
INSERT INTO `sys_loginfo` VALUES (138, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 15:35:56');
INSERT INTO `sys_loginfo` VALUES (139, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 15:53:28');
INSERT INTO `sys_loginfo` VALUES (140, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 16:02:42');
INSERT INTO `sys_loginfo` VALUES (141, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 16:50:28');
INSERT INTO `sys_loginfo` VALUES (142, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 17:20:01');
INSERT INTO `sys_loginfo` VALUES (143, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 17:22:13');
INSERT INTO `sys_loginfo` VALUES (144, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 17:23:19');
INSERT INTO `sys_loginfo` VALUES (145, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 17:23:51');
INSERT INTO `sys_loginfo` VALUES (146, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 17:38:39');
INSERT INTO `sys_loginfo` VALUES (147, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 20:38:28');
INSERT INTO `sys_loginfo` VALUES (148, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-05 21:05:55');
INSERT INTO `sys_loginfo` VALUES (149, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-05 21:06:49');
INSERT INTO `sys_loginfo` VALUES (150, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-05 21:07:39');
INSERT INTO `sys_loginfo` VALUES (151, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-05 21:10:07');
INSERT INTO `sys_loginfo` VALUES (152, '苏北旦-subeidan', '0:0:0:0:0:0:0:1', '2019-12-05 21:11:47');
INSERT INTO `sys_loginfo` VALUES (153, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 21:11:58');
INSERT INTO `sys_loginfo` VALUES (154, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 22:54:31');
INSERT INTO `sys_loginfo` VALUES (155, '苏北旦-subeidan', '0:0:0:0:0:0:0:1', '2019-12-05 22:55:00');
INSERT INTO `sys_loginfo` VALUES (156, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 22:57:38');
INSERT INTO `sys_loginfo` VALUES (157, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 22:59:18');
INSERT INTO `sys_loginfo` VALUES (158, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-05 22:59:38');
INSERT INTO `sys_loginfo` VALUES (159, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:36:42');
INSERT INTO `sys_loginfo` VALUES (160, '苏北旦-subeidan', '0:0:0:0:0:0:0:1', '2019-12-06 08:42:18');
INSERT INTO `sys_loginfo` VALUES (161, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:42:46');
INSERT INTO `sys_loginfo` VALUES (162, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-06 08:45:31');
INSERT INTO `sys_loginfo` VALUES (163, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:47:03');
INSERT INTO `sys_loginfo` VALUES (164, '李四-lisi', '0:0:0:0:0:0:0:1', '2019-12-06 08:47:41');
INSERT INTO `sys_loginfo` VALUES (165, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:48:00');
INSERT INTO `sys_loginfo` VALUES (166, '王五-wangwu', '0:0:0:0:0:0:0:1', '2019-12-06 08:48:52');
INSERT INTO `sys_loginfo` VALUES (167, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:49:12');
INSERT INTO `sys_loginfo` VALUES (168, '上单-shangdan', '0:0:0:0:0:0:0:1', '2019-12-06 08:51:36');
INSERT INTO `sys_loginfo` VALUES (169, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:51:52');
INSERT INTO `sys_loginfo` VALUES (170, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 08:53:36');
INSERT INTO `sys_loginfo` VALUES (171, '上单-shangdan', '0:0:0:0:0:0:0:1', '2019-12-06 08:55:07');
INSERT INTO `sys_loginfo` VALUES (172, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 09:31:52');
INSERT INTO `sys_loginfo` VALUES (173, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 22:30:06');
INSERT INTO `sys_loginfo` VALUES (174, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:00:14');
INSERT INTO `sys_loginfo` VALUES (175, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:19:13');
INSERT INTO `sys_loginfo` VALUES (176, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:22:29');
INSERT INTO `sys_loginfo` VALUES (177, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:24:33');
INSERT INTO `sys_loginfo` VALUES (178, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:26:13');
INSERT INTO `sys_loginfo` VALUES (179, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2019-12-06 23:32:24');
INSERT INTO `sys_loginfo` VALUES (180, '超级管理员-system', '0:0:0:0:0:0:0:1', '2019-12-09 16:14:07');
INSERT INTO `sys_loginfo` VALUES (181, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-01-21 03:02:00');
INSERT INTO `sys_loginfo` VALUES (182, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-01-21 03:13:25');
INSERT INTO `sys_loginfo` VALUES (183, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-01-21 03:17:40');
INSERT INTO `sys_loginfo` VALUES (184, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-01-21 03:23:43');
INSERT INTO `sys_loginfo` VALUES (185, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-01-21 03:28:21');
INSERT INTO `sys_loginfo` VALUES (186, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-06 02:28:24');
INSERT INTO `sys_loginfo` VALUES (187, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-06 03:02:00');
INSERT INTO `sys_loginfo` VALUES (188, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-07 07:54:49');
INSERT INTO `sys_loginfo` VALUES (189, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-08 06:23:55');
INSERT INTO `sys_loginfo` VALUES (190, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-09 07:45:00');
INSERT INTO `sys_loginfo` VALUES (191, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 03:01:19');
INSERT INTO `sys_loginfo` VALUES (192, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:08:23');
INSERT INTO `sys_loginfo` VALUES (193, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:16:36');
INSERT INTO `sys_loginfo` VALUES (194, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:20:26');
INSERT INTO `sys_loginfo` VALUES (195, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:23:37');
INSERT INTO `sys_loginfo` VALUES (196, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:25:52');
INSERT INTO `sys_loginfo` VALUES (197, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:34:37');
INSERT INTO `sys_loginfo` VALUES (198, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:36:25');
INSERT INTO `sys_loginfo` VALUES (199, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:39:03');
INSERT INTO `sys_loginfo` VALUES (200, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:42:08');
INSERT INTO `sys_loginfo` VALUES (201, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:43:07');
INSERT INTO `sys_loginfo` VALUES (202, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:44:12');
INSERT INTO `sys_loginfo` VALUES (203, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-12 04:44:54');
INSERT INTO `sys_loginfo` VALUES (204, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:09:37');
INSERT INTO `sys_loginfo` VALUES (205, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:11:53');
INSERT INTO `sys_loginfo` VALUES (206, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:13:10');
INSERT INTO `sys_loginfo` VALUES (207, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:14:13');
INSERT INTO `sys_loginfo` VALUES (208, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:19:38');
INSERT INTO `sys_loginfo` VALUES (209, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:22:05');
INSERT INTO `sys_loginfo` VALUES (210, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:26:19');
INSERT INTO `sys_loginfo` VALUES (211, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 06:30:35');
INSERT INTO `sys_loginfo` VALUES (212, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 07:16:07');
INSERT INTO `sys_loginfo` VALUES (213, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 07:30:52');
INSERT INTO `sys_loginfo` VALUES (214, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 08:05:43');
INSERT INTO `sys_loginfo` VALUES (215, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 08:23:39');
INSERT INTO `sys_loginfo` VALUES (216, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 08:58:01');
INSERT INTO `sys_loginfo` VALUES (217, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 09:06:30');
INSERT INTO `sys_loginfo` VALUES (218, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-14 09:52:11');
INSERT INTO `sys_loginfo` VALUES (219, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 07:33:16');
INSERT INTO `sys_loginfo` VALUES (220, '李月素-liyuesu', '0:0:0:0:0:0:0:1', '2020-02-24 07:39:04');
INSERT INTO `sys_loginfo` VALUES (221, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 07:40:26');
INSERT INTO `sys_loginfo` VALUES (222, '李月素-liyuesu', '0:0:0:0:0:0:0:1', '2020-02-24 07:47:07');
INSERT INTO `sys_loginfo` VALUES (223, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 07:47:40');
INSERT INTO `sys_loginfo` VALUES (224, '落亦--luoyi', '127.0.0.1', '2020-02-24 07:55:53');
INSERT INTO `sys_loginfo` VALUES (225, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 08:09:22');
INSERT INTO `sys_loginfo` VALUES (226, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 08:53:10');
INSERT INTO `sys_loginfo` VALUES (227, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 08:57:15');
INSERT INTO `sys_loginfo` VALUES (228, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:04:42');
INSERT INTO `sys_loginfo` VALUES (229, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:24:06');
INSERT INTO `sys_loginfo` VALUES (230, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:26:52');
INSERT INTO `sys_loginfo` VALUES (231, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:32:45');
INSERT INTO `sys_loginfo` VALUES (232, '落亦--luoyi', '127.0.0.1', '2020-02-24 09:35:36');
INSERT INTO `sys_loginfo` VALUES (233, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:38:13');
INSERT INTO `sys_loginfo` VALUES (234, '李月素-liyuesu', '0:0:0:0:0:0:0:1', '2020-02-24 09:42:05');
INSERT INTO `sys_loginfo` VALUES (235, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:42:47');
INSERT INTO `sys_loginfo` VALUES (236, '李月素-liyuesu', '0:0:0:0:0:0:0:1', '2020-02-24 09:43:05');
INSERT INTO `sys_loginfo` VALUES (237, '李月素-liyuesu', '0:0:0:0:0:0:0:1', '2020-02-24 09:43:42');
INSERT INTO `sys_loginfo` VALUES (238, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:44:05');
INSERT INTO `sys_loginfo` VALUES (239, '李四-lisi', '0:0:0:0:0:0:0:1', '2020-02-24 09:44:47');
INSERT INTO `sys_loginfo` VALUES (240, '李四-lisi', '0:0:0:0:0:0:0:1', '2020-02-24 09:45:14');
INSERT INTO `sys_loginfo` VALUES (241, '王五-wangwu', '0:0:0:0:0:0:0:1', '2020-02-24 09:45:35');
INSERT INTO `sys_loginfo` VALUES (242, '赵六-zhaoliu', '0:0:0:0:0:0:0:1', '2020-02-24 09:45:55');
INSERT INTO `sys_loginfo` VALUES (243, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-02-24 09:46:32');
INSERT INTO `sys_loginfo` VALUES (244, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-01 09:46:24');
INSERT INTO `sys_loginfo` VALUES (245, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 02:28:15');
INSERT INTO `sys_loginfo` VALUES (246, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 02:42:09');
INSERT INTO `sys_loginfo` VALUES (247, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 03:02:07');
INSERT INTO `sys_loginfo` VALUES (248, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 03:06:11');
INSERT INTO `sys_loginfo` VALUES (249, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 03:12:35');
INSERT INTO `sys_loginfo` VALUES (250, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 03:28:54');
INSERT INTO `sys_loginfo` VALUES (251, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 03:53:25');
INSERT INTO `sys_loginfo` VALUES (252, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-06 12:58:05');
INSERT INTO `sys_loginfo` VALUES (253, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 03:11:53');
INSERT INTO `sys_loginfo` VALUES (254, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 03:50:55');
INSERT INTO `sys_loginfo` VALUES (255, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 04:13:39');
INSERT INTO `sys_loginfo` VALUES (256, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 04:16:53');
INSERT INTO `sys_loginfo` VALUES (257, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 04:23:31');
INSERT INTO `sys_loginfo` VALUES (258, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 04:25:49');
INSERT INTO `sys_loginfo` VALUES (259, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 04:34:00');
INSERT INTO `sys_loginfo` VALUES (260, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 07:24:46');
INSERT INTO `sys_loginfo` VALUES (261, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 07:44:40');
INSERT INTO `sys_loginfo` VALUES (262, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 07:50:38');
INSERT INTO `sys_loginfo` VALUES (263, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 07:52:28');
INSERT INTO `sys_loginfo` VALUES (264, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 07:59:44');
INSERT INTO `sys_loginfo` VALUES (265, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 08:10:44');
INSERT INTO `sys_loginfo` VALUES (266, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-07 08:13:23');
INSERT INTO `sys_loginfo` VALUES (267, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 03:37:14');
INSERT INTO `sys_loginfo` VALUES (268, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 03:39:03');
INSERT INTO `sys_loginfo` VALUES (269, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 03:41:25');
INSERT INTO `sys_loginfo` VALUES (270, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 03:43:31');
INSERT INTO `sys_loginfo` VALUES (271, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 03:56:23');
INSERT INTO `sys_loginfo` VALUES (272, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 04:17:22');
INSERT INTO `sys_loginfo` VALUES (273, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 04:29:46');
INSERT INTO `sys_loginfo` VALUES (274, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 09:53:15');
INSERT INTO `sys_loginfo` VALUES (275, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:07:53');
INSERT INTO `sys_loginfo` VALUES (276, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:30:36');
INSERT INTO `sys_loginfo` VALUES (277, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:32:45');
INSERT INTO `sys_loginfo` VALUES (278, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:36:43');
INSERT INTO `sys_loginfo` VALUES (279, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:50:53');
INSERT INTO `sys_loginfo` VALUES (280, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:52:45');
INSERT INTO `sys_loginfo` VALUES (281, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:53:31');
INSERT INTO `sys_loginfo` VALUES (282, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:54:57');
INSERT INTO `sys_loginfo` VALUES (283, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:55:39');
INSERT INTO `sys_loginfo` VALUES (284, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 10:57:06');
INSERT INTO `sys_loginfo` VALUES (285, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 11:00:54');
INSERT INTO `sys_loginfo` VALUES (286, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 11:04:41');
INSERT INTO `sys_loginfo` VALUES (287, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-08 11:08:39');
INSERT INTO `sys_loginfo` VALUES (288, '落亦--luoyi', '0:0:0:0:0:0:0:1', '2020-03-09 08:36:06');
-- ----------------------------
-- Table structure for sys_notice
@ -835,19 +564,18 @@ CREATE TABLE `sys_user` (
-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES (1, '超级管理员', 'system', '532ac00e86893901af5f0be6b704dbc7', '系统深处的男人', 1, '超级管理员', 1, '2018-06-25 11:06:34', NULL, 1, 1, 0, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (2, '落亦-', 'luoyi', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '超级管理员', 1, '2019-11-23 20:52:16', NULL, 1, 2, 0, '2020-03-08/0F8C9E01C1DF4A60BB0E2747F67D03BF.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (3, '李月素', 'liyuesu', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '否', 2, '2020-02-12 12:22:23', 5, 1, 3, 1, '2020-02-24/BF25CC186DA14E89BDA0FB061404E527.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (4, '李四', 'lisi', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '普通用户', 3, '2020-02-09 15:46:55', 3, 1, 4, 1, '2020-02-24/795D8302F654489C8FA3E06F0DA8C141.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (5, '王五', 'wangwu', '532ac00e86893901af5f0be6b704dbc7', '上海', 1, '普通用户', 5, '2019-12-02 18:57:42', 4, 1, 5, 1, '2020-02-24/014938189D454F95BAEB3AC439CD6703.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (6, '赵六', 'zhaoliu', '532ac00e86893901af5f0be6b704dbc7', '广州', 1, '普通用户', 5, '2019-12-02 18:59:05', 5, 1, 6, 1, '2020-02-24/25E8E9C743844A5185BCE55D52CF7141.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (7, '陈七', 'chengqi', '532ac00e86893901af5f0be6b704dbc7', '深圳', 1, '普遍用户', 4, '2019-12-03 09:52:18', 3, 1, 7, 1, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user` VALUES (10, '苏北旦', 'subeidan', 'b661f48dc70d448773be54874198788c', '猎户座旋臂', 0, '将军', 3, '2019-12-03 00:00:00', 3, 1, 9, 1, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '950289EBDBA24C7789E392E1D0254635');
INSERT INTO `sys_user` VALUES (11, '斯嘉丽约翰逊', 'sijialiyuehanxun', 'f8408d1ccc3f83e4f035de3896569b76', '美国', 0, '演员', 7, '2019-12-03 14:23:35', 10, 1, 10, 1, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '85DB5F84987146559A75B4B0DCB7DE4F');
INSERT INTO `sys_user` VALUES (12, '托尼', 'tuoni', '1403e113a2936d4509e9c13b8849f4b5', '美国', 1, '钢铁侠', 7, '2019-12-03 00:00:00', 11, 1, 11, 1, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '571059AF59E64A7D92FECB93FA1B0AEF');
INSERT INTO `sys_user` VALUES (13, '贾维斯', 'jiaweisi', '98f28b861888f4274cb423345dce4bcc', '美国', 1, '人工智能', 3, '2019-12-03 00:00:00', 12, 1, 12, 1, '2020-02-24/8258FCECC0D64A1DB3B457E7D51D6AB5.jpg', '7258E2D93A3F429085B34BBD8E345CE7');
INSERT INTO `sys_user` VALUES (14, '李九', 'lijiu', '9356d33c67f21e23b448d6198e414f77', '九江', 1, '测试', 4, '2020-03-05 16:00:00', 10, 1, 13, 1, '/images/defaultusertitle.jpg', 'D3FBF5E33F4D42FDACE85178FE84E95A');
INSERT INTO `sys_user` VALUES (17, '张十', 'zhangshi', 'e99ddd2f81f17319e7a767573c674975', '南昌', 1, '测试', 4, '2020-03-06 03:30:12', 11, 1, 14, 1, '/images/defaultUserTitle.jpg', '5C6E7D2E2D8C4A8CB9DD4A9DF64DDB57');
INSERT INTO `sys_user`
VALUES (1, '超级管理员', 'system', '532ac00e86893901af5f0be6b704dbc7', '系统深处的男人', 1, '超级管理员', 1,
'2018-06-25 11:06:34', NULL, 1, 1, 0, '/resources/images/face.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user`
VALUES (2, '落亦-', 'luoyi', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '超级管理员', 1, '2019-11-23 20:52:16',
NULL, 1, 2, 0, '/resources/images/face.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user`
VALUES (3, '李月素', 'liyuesu', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '否', 2, '2020-02-12 12:22:23', 5, 1, 3,
1, '/resources/images/face.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
INSERT INTO `sys_user`
VALUES (4, '李四', 'lisi', '532ac00e86893901af5f0be6b704dbc7', '九江', 1, '普通用户', 3, '2020-02-09 15:46:55', 3, 1, 4,
1, '/resources/images/face.jpg', '04A93C74C8294AA09A8B974FD1F4ECBB');
-- ----------------------------
-- Table structure for sys_user_role

Write Preview
Loading…
Cancel
Save