代码同步

main
张博文 5 months ago
parent d1566d07c6
commit 0f4b94db80

87
.gitignore vendored

@ -1,26 +1,75 @@
# ---> Java
# Compiled class file # 查看更多 .gitignore 配置 -> https://help.github.com/articles/ignoring-files/
target/
!.mvn/wrapper/maven-wrapper.jar
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
*.class *.class
target/*
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
/build/
# Log file
*.log
# BlueJ files ### admin-web ###
*.ctxt
# Mobile Tools for Java (J2ME) # dependencies
.mtj.tmp/ **/node_modules
# roadhog-api-doc ignore
/src/utils/request-temp.js
_roadhog-api-doc
# production
/dist
/.vscode
# misc
.DS_Store
npm-debug.log*
yarn-error.log
/coverage
.idea
yarn.lock
package-lock.json
*bak
.vscode
# visual studio code
.history
*.log
# Package Files # functions/mock
*.jar .temp/**
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml # umi
hs_err_pid* .umi
replay_pid* .umi-production
# screenshot
screenshot
.firebase
sessionStore
**/bootstrap-local.yaml
bootstrap-local.yaml

@ -1,3 +1,307 @@
# trace ## 🐶 新手必读
溯源后端服务 * 演示地址:<http://dashboard.yudao.iocoder.cn>
* 启动文档:<https://cloud.iocoder.cn/quick-start/>
* 视频教程:<https://cloud.iocoder.cn/video/>
![架构图](https://static.iocoder.cn/yudao-cloud-architecture.png)
* 管理后台的 Vue3 版本采用 [vue-element-plus-admin](https://gitee.com/kailong110120130/vue-element-plus-admin) Vue2 版本采用 [vue-element-admin](https://github.com/PanJiaChen/vue-element-admin)
* 管理后台的移动端采用 [uni-app](https://github.com/dcloudio/uni-app) 方案,一份代码多终端适配,同时支持 APP、小程序、H5
* 后端采用 Spring Cloud Alibaba 微服务架构,注册中心 + 配置中心 Nacos消息队列 RocketMQ定时任务 XXL-Job服务保障 Sentinel服务网关 Gateway分布式事务 Seata
* 数据库可使用 MySQL、Oracle、PostgreSQL、SQL Server、MariaDB、国产达梦 DM、TiDB 等,基于 MyBatis Plus、Redis + Redisson 操作
* 权限认证使用 Spring Security & Token & Redis支持多终端、多种用户的认证系统支持 SSO 单点登录
* 支持加载动态权限菜单,按钮级别权限控制,本地缓存提升性能
* 支持 SaaS 多租户系统,可自定义每个租户的权限,提供透明化的多租户底层封装
* 工作流使用 Flowable支持动态表单、在线设计流程、会签 / 或签、多种任务分配方式
* 高效率开发,使用代码生成器可以一键生成前后端代码 + 单元测试 + Swagger 接口文档 + Validator 参数校验
* 集成微信小程序、微信公众号、企业微信、钉钉等三方登陆,集成支付宝、微信等支付与退款
* 集成阿里云、腾讯云等短信渠道,集成 MinIO、阿里云、腾讯云、七牛云等云存储服务
* 集成报表设计器、大屏设计器,通过拖拽即可生成酷炫的报表与大屏
| 项目名 | 说明 | 传送门 |
|----------------------|------------------------|------------------------------------------------------------------------------------------------------------------------------------|
| `ruoyi-vue-pro` | Spring Boot 多模块 | **[Gitee](https://gitee.com/zhijiantianya/ruoyi-vue-pro)** &nbsp;&nbsp;&nbsp; [Github](https://github.com/YunaiV/ruoyi-vue-pro) |
| `yudao-cloud` | Spring Cloud 微服务 | **[Gitee](https://gitee.com/zhijiantianya/yudao-cloud)** &nbsp;&nbsp;&nbsp; [Github](https://github.com/YunaiV/yudao-cloud) |
| `Spring-Boot-Labs` | Spring Boot & Cloud 入门 | **[Gitee](https://gitee.com/yudaocode/SpringBoot-Labs)** &nbsp;&nbsp;&nbsp; [Github](https://github.com/yudaocode/SpringBoot-Labs) |
| `ruoyi-vue-pro-mini` | 精简版:移除工作流、支付等模块 | **[Gitee](https://gitee.com/zhijiantianya/ruoyi-vue-pro/tree/mini)** |
## 😎 开源协议
**为什么推荐使用本项目?**
① 本项目采用比 Apache 2.0 更宽松的 [MIT License](https://gitee.com/zhijiantianya/ruoyi-vue-pro/blob/master/LICENSE) 开源协议,个人与企业可 100% 免费使用不用保留类作者、Copyright 信息。
② 代码全部开源,不会像其他项目一样,只开源部分代码,让你无法了解整个项目的架构设计。[国产开源项目对比](https://www.yuque.com/xiatian-bsgny/lm0ec1/wqf8mn)
![开源项目对比](https://static.iocoder.cn/project-vs.png?imageView2/2/format/webp/w/1280)
③ 代码整洁、架构整洁,遵循《阿里巴巴 Java 开发手册》规范代码注释详细57000 行 Java 代码22000 行代码注释。
## 🤝 项目外包
我们也是接外包滴,如果你有项目想要外包,可以微信联系【**Aix9975**】。
团队包含专业的项目经理、架构师、前端工程师、后端工程师、测试工程师、运维工程师,可以提供全流程的外包服务。
项目可以是商城、SCRM 系统、OA 系统、物流系统、ERP 系统、CMS 系统、HIS 系统、支付系统、IM 聊天、微信公众号、微信小程序等等。
## 🐼 内置功能
系统内置多种多种业务功能,可以用于快速你的业务系统:
![功能分层](https://static.iocoder.cn/ruoyi-vue-pro-biz.png)
* 系统功能
* 基础设施
* 工作流程
* 支付系统
* 会员中心
* 数据报表
* 商城系统
* 微信公众号
> 友情提示:本项目基于 RuoYi-Vue 修改,**重构优化**后端的代码,**美化**前端的界面。
>
> * 额外新增的功能,我们使用 🚀 标记。
> * 重新实现的功能,我们使用 ⭐️ 标记。
🙂 所有功能,都通过 **单元测试** 保证高质量。
### 系统功能
| | 功能 | 描述 |
|-----|-------|---------------------------------|
| | 用户管理 | 用户是系统操作者,该功能主要完成系统用户配置 |
| ⭐️ | 在线用户 | 当前系统中活跃用户状态监控,支持手动踢下线 |
| | 角色管理 | 角色菜单权限分配、设置角色按机构进行数据范围权限划分 |
| | 菜单管理 | 配置系统菜单、操作权限、按钮权限标识等,本地缓存提供性能 |
| | 部门管理 | 配置系统组织机构(公司、部门、小组),树结构展现支持数据权限 |
| | 岗位管理 | 配置系统用户所属担任职务 |
| 🚀 | 租户管理 | 配置系统租户,支持 SaaS 场景下的多租户功能 |
| 🚀 | 租户套餐 | 配置租户套餐,自定每个租户的菜单、操作、按钮的权限 |
| | 字典管理 | 对系统中经常使用的一些较为固定的数据进行维护 |
| 🚀 | 短信管理 | 短信渠道、短息模板、短信日志,对接阿里云、腾讯云等主流短信平台 |
| 🚀 | 邮件管理 | 邮箱账号、邮件模版、邮件发送日志,支持所有邮件平台 |
| 🚀 | 站内信 | 系统内的消息通知,提供站内信模版、站内信消息 |
| 🚀 | 操作日志 | 系统正常操作日志记录和查询,集成 Swagger 生成日志内容 |
| ⭐️ | 登录日志 | 系统登录日志记录查询,包含登录异常 |
| 🚀 | 错误码管理 | 系统所有错误码的管理,可在线修改错误提示,无需重启服务 |
| | 通知公告 | 系统通知公告信息发布维护 |
| 🚀 | 敏感词 | 配置系统敏感词,支持标签分组 |
| 🚀 | 应用管理 | 管理 SSO 单点登录的应用,支持多种 OAuth2 授权方式 |
| 🚀 | 地区管理 | 展示省份、城市、区镇等城市信息,支持 IP 对应城市 |
### 工作流程
| | 功能 | 描述 |
|-----|-------|----------------------------------------|
| 🚀 | 流程模型 | 配置工作流的流程模型,支持文件导入与在线设计流程图,提供 7 种任务分配规则 |
| 🚀 | 流程表单 | 拖动表单元素生成相应的工作流表单,覆盖 Element UI 所有的表单组件 |
| 🚀 | 用户分组 | 自定义用户分组,可用于工作流的审批分组 |
| 🚀 | 我的流程 | 查看我发起的工作流程,支持新建、取消流程等操作,高亮流程图、审批时间线 |
| 🚀 | 待办任务 | 查看自己【未】审批的工作任务,支持通过、不通过、转发、委派、退回等操作 |
| 🚀 | 已办任务 | 查看自己【已】审批的工作任务,未来会支持回退操作 |
| 🚀 | OA 请假 | 作为业务自定义接入工作流的使用示例,只需创建请求对应的工作流程,即可进行审批 |
### 支付系统
| | 功能 | 描述 |
|-----|------|---------------------------|
| 🚀 | 商户信息 | 管理商户信息,支持 Saas 场景下的多商户功能 |
| 🚀 | 应用信息 | 配置商户的应用信息,对接支付宝、微信等多个支付渠道 |
| 🚀 | 支付订单 | 查看用户发起的支付宝、微信等的【支付】订单 |
| 🚀 | 退款订单 | 查看用户发起的支付宝、微信等的【退款】订单 |
ps核心功能已经实现正在对接微信小程序中...
### 基础设施
| | 功能 | 描述 |
|-----|----------|----------------------------------------------|
| 🚀 | 代码生成 | 前后端代码的生成Java、Vue、SQL、单元测试支持 CRUD 下载 |
| 🚀 | 系统接口 | 基于 Swagger 自动生成相关的 RESTful API 接口文档 |
| 🚀 | 数据库文档 | 基于 Screw 自动生成数据库文档,支持导出 Word、HTML、MD 格式 |
| | 表单构建 | 拖动表单元素生成相应的 HTML 代码,支持导出 JSON、Vue 文件 |
| 🚀 | 配置管理 | 对系统动态配置常用参数,支持 SpringBoot 加载 |
| ⭐️ | 定时任务 | 在线(添加、修改、删除)任务调度包含执行结果日志 |
| 🚀 | 文件服务 | 支持将文件存储到 S3MinIO、阿里云、腾讯云、七牛云、本地、FTP、数据库等 |
| 🚀 | API 日志 | 包括 RESTful API 访问日志、异常日志两部分,方便排查 API 相关的问题 |
| | MySQL 监控 | 监视当前系统数据库连接池状态可进行分析SQL找出系统性能瓶颈 |
| | Redis 监控 | 监控 Redis 数据库的使用情况,使用的 Redis Key 管理 |
| 🚀 | 消息队列 | 基于 Redis 实现消息队列Stream 提供集群消费Pub/Sub 提供广播消费 |
| 🚀 | Java 监控 | 基于 Spring Boot Admin 实现 Java 应用的监控 |
| 🚀 | 链路追踪 | 接入 SkyWalking 组件,实现链路追踪 |
| 🚀 | 日志中心 | 接入 SkyWalking 组件,实现日志中心 |
| 🚀 | 分布式锁 | 基于 Redis 实现分布式锁,满足并发场景 |
| 🚀 | 幂等组件 | 基于 Redis 实现幂等组件,解决重复请求问题 |
| 🚀 | 服务保障 | 基于 Resilience4j 实现服务的稳定性,包括限流、熔断等功能 |
| 🚀 | 日志服务 | 轻量级日志中心,查看远程服务器的日志 |
| 🚀 | 单元测试 | 基于 JUnit + Mockito 实现单元测试,保证功能的正确性、代码的质量等 |
### 数据报表
| | 功能 | 描述 |
|-----|----------|----------------------------------------------|
| 🚀 | 报表设计器 | 支持数据报表、图形报表、打印设计等 |
| 🚀 | 大屏设计器 | 拖拽生成数据大屏,内置几十种图表组件 |
### 微信公众号
| | 功能 | 描述 |
|-----|--------|-------------------------------|
| 🚀 | 账号管理 | 配置接入的微信公众号,可支持多个公众号 |
| 🚀 | 数据统计 | 统计公众号的用户增减、累计用户、消息概况、接口分析等数据 |
| 🚀 | 粉丝管理 | 查看已关注、取关的粉丝列表,可对粉丝进行同步、打标签等操作 |
| 🚀 | 消息管理 | 查看粉丝发送的消息列表,可主动回复粉丝消息 |
| 🚀 | 自动回复 | 自动回复粉丝发送的消息,支持关注回复、消息回复、关键字回复 |
| 🚀 | 标签管理 | 对公众号的标签进行创建、查询、修改、删除等操作 |
| 🚀 | 菜单管理 | 自定义公众号的菜单,也可以从公众号同步菜单 |
| 🚀 | 素材管理 | 管理公众号的图片、语音、视频等素材,支持在线播放语音、视频 |
| 🚀 | 图文草稿箱 | 新增常用的图文素材到草稿箱,可发布到公众号 |
| 🚀 | 图文发表记录 | 查看已发布成功的图文素材,支持删除操作 |
### 商城系统
建设中...
![功能图](http://static.iocoder.cn/mall%20%E5%8A%9F%E8%83%BD%E5%9B%BE-min.png)
![GIF 图-耐心等待](https://raw.githubusercontent.com/YunaiV/Blog/master/Mall/onemall-admin-min.gif)
![GIF 图-耐心等待](https://raw.githubusercontent.com/YunaiV/Blog/master/Mall/onemall-h5-min.gif)
### 会员中心
和「商城系统」一起开发
## 🐨 技术栈
| 项目 | 说明 |
|--------------------------------------------------------------------------|--------------------|
| `yudao-dependencies` | Maven 依赖版本管理 |
| `yudao-framework` | Java 框架拓展 |
| `yudao-server` | 管理后台 + 用户 APP 的服务端 |
| `yudao-module-system` | 系统功能的 Module 模块 |
| `yudao-module-member` | 会员中心的 Module 模块 |
| `yudao-module-infra` | 基础设施的 Module 模块 |
| `yudao-module-bpm` | 工作流程的 Module 模块 |
| `yudao-module-pay` | 支付系统的 Module 模块 |
| `yudao-module-mall` | 商城系统的 Module 模块 |
| `yudao-module-mp` | 微信公众号的 Module 模块 |
| `yudao-module-report` | 大屏报表 Module 模块 |
> 前端项目的地址:
>
> * [`yudao-ui-admin-vue3`](https://gitee.com/yudaocode/yudao-ui-admin-vue3):基于 Vue3 + element-plus 实现的管理后台
> * `yudao-ui-admin`:基于 Vue2 + element-ui 实现的管理后台
> * [`yudao-ui-go-view`](https://gitee.com/yudaocode/yudao-ui-go-view):基于 Vue3 + naive-ui 实现的大屏报表
> * `yudao-ui-admin-uniapp`:基于 uni-app + uni-ui 实现的管理后台的小程序
> * `yudao-ui-app`:基于 uni-app + uview 实现的用户 App
### 后端
| 框架 | 说明 | 版本 | 学习指南 |
|---------------------------------------------------------------------------------------------|------------------|-------------|---------------------------------------------------------------------|
| [Spring Cloud Alibaba](https://github.com/alibaba/spring-cloud-alibaba) | 微服务框架 | 2021.0.4.0 | [文档](https://github.com/YunaiV/SpringBoot-Labs) |
| [Nacos](https://github.com/alibaba/nacos) | 配置中心 & 注册中心 | 2.0.4 | [文档](https://www.iocoder.cn/categories/Nacos/?yudao) |
| [RocketMQ](https://github.com/apache/rocketmq) | 消息队列 | 4.9.4 | [文档](https://www.iocoder.cn/categories/RocketMQ/?yudao) |
| [Sentinel](https://github.com/alibaba/sentinel) | 服务保障 | 1.8.6 | [文档](https://www.iocoder.cn/categories/Sentinel/?yudao) |
| [XXL Job](https://github.com/xuxueli/xxl-job) | 定时任务 | 2.3.1 | [文档](https://www.iocoder.cn/XXL-JOB/good-collection/?yudao) |
| [Spring Cloud Gateway](https://github.com/spring-cloud/spring-cloud-gateway) | 服务网关 | 3.4.1 | [文档](https://www.iocoder.cn/categories/Spring-Cloud-Gateway/?yudao) |
| [Seata](https://github.com/seata/seata) | 分布式事务 | 1.6.1 | [文档](https://www.iocoder.cn/categories/Seata/?yudao) |
| [MySQL](https://www.mysql.com/cn/) | 数据库服务器 | 5.7 / 8.0+ | |
| [Druid](https://github.com/alibaba/druid) | JDBC 连接池、监控组件 | 1.2.15 | [文档](http://www.iocoder.cn/Spring-Boot/datasource-pool/?yudao) |
| [MyBatis Plus](https://mp.baomidou.com/) | MyBatis 增强工具包 | 3.5.3.1 | [文档](http://www.iocoder.cn/Spring-Boot/MyBatis/?yudao) |
| [Dynamic Datasource](https://dynamic-datasource.com/) | 动态数据源 | 3.6.0 | [文档](http://www.iocoder.cn/Spring-Boot/datasource-pool/?yudao) |
| [Redis](https://redis.io/) | key-value 数据库 | 5.0 / 6.0 | |
| [Redisson](https://github.com/redisson/redisson) | Redis 客户端 | 3.18.0 | [文档](http://www.iocoder.cn/Spring-Boot/Redis/?yudao) |
| [Spring MVC](https://github.com/spring-projects/spring-framework/tree/master/spring-webmvc) | MVC 框架 | 5.3.24 | [文档](http://www.iocoder.cn/SpringMVC/MVC/?yudao) |
| [Spring Security](https://github.com/spring-projects/spring-security) | Spring 安全框架 | 5.7.5 | [文档](http://www.iocoder.cn/Spring-Boot/Spring-Security/?yudao) |
| [Hibernate Validator](https://github.com/hibernate/hibernate-validator) | 参数校验组件 | 6.2.5 | [文档](http://www.iocoder.cn/Spring-Boot/Validation/?yudao) |
| [Flowable](https://github.com/flowable/flowable-engine) | 工作流引擎 | 6.7.2 | [文档](https://doc.iocoder.cn/bpm/) |
| [Knife4j](https://gitee.com/xiaoym/knife4j) | Swagger 增强 UI 实现 | 4.0.0 | [文档](http://www.iocoder.cn/Spring-Boot/Swagger/?yudao) |
| [SkyWalking](https://skywalking.apache.org/) | 分布式应用追踪系统 | 8.12.0 | [文档](http://www.iocoder.cn/Spring-Boot/SkyWalking/?yudao) |
| [Spring Boot Admin](https://github.com/codecentric/spring-boot-admin) | Spring Boot 监控平台 | 2.7.10 | [文档](http://www.iocoder.cn/Spring-Boot/Admin/?yudao) |
| [Jackson](https://github.com/FasterXML/jackson) | JSON 工具库 | 2.13.3 | |
| [MapStruct](https://mapstruct.org/) | Java Bean 转换 | 1.5.3.Final | [文档](http://www.iocoder.cn/Spring-Boot/MapStruct/?yudao) |
| [Lombok](https://projectlombok.org/) | 消除冗长的 Java 代码 | 1.18.24 | [文档](http://www.iocoder.cn/Spring-Boot/Lombok/?yudao) |
| [JUnit](https://junit.org/junit5/) | Java 单元测试框架 | 5.8.2 | - |
| [Mockito](https://github.com/mockito/mockito) | Java Mock 框架 | 4.8.0 | - |
### [管理后台 Vue2 前端](./yudao-ui-admin)
| 框架 | 说明 | 版本 |
|------------------------------------------------------------------------------|---------------|--------|
| [Vue](https://cn.vuejs.org/index.html) | JavaScript 框架 | 2.7.14 |
| [Vue Element Admin](https://panjiachen.github.io/vue-element-admin-site/zh/) | 后台前端解决方案 | - |
### [管理后台 uni-app 跨端](./yudao-ui-admin-uniapp)
| 框架 | 说明 | 版本 |
|-------------------------------------------------|--------------------|--------|
| [uni-app](hhttps://github.com/dcloudio/uni-app) | 跨平台框架 | 2.0.0 |
| [uni-ui](https://github.com/dcloudio/uni-ui) | 基于 uni-app 的 UI 框架 | 1.4.20 |
## 🐷 演示图
### 系统功能
| 模块 | biu | biu | biu |
|------------|--------------------------------------------------------------------|------------------------------------------------------------------|------------------------------------------------------------------|
| 登录 & 首页 | ![登录](https://static.iocoder.cn/images/ruoyi-vue-pro/登录.jpg?imageView2/2/format/webp/w/1280) | ![首页](https://static.iocoder.cn/images/ruoyi-vue-pro/首页.jpg?imageView2/2/format/webp/w/1280) | ![个人中心](https://static.iocoder.cn/images/ruoyi-vue-pro/个人中心.jpg?imageView2/2/format/webp/w/1280) |
| 用户 & 应用 | ![用户管理](https://static.iocoder.cn/images/ruoyi-vue-pro/用户管理.jpg?imageView2/2/format/webp/w/1280) | ![令牌管理](https://static.iocoder.cn/images/ruoyi-vue-pro/令牌管理.jpg?imageView2/2/format/webp/w/1280) | ![应用管理](https://static.iocoder.cn/images/ruoyi-vue-pro/应用管理.jpg?imageView2/2/format/webp/w/1280) |
| 租户 & 套餐 | ![租户管理](https://static.iocoder.cn/images/ruoyi-vue-pro/租户管理.jpg?imageView2/2/format/webp/w/1280) | ![租户套餐](https://static.iocoder.cn/images/ruoyi-vue-pro/租户套餐.png) | - |
| 部门 & 岗位 | ![部门管理](https://static.iocoder.cn/images/ruoyi-vue-pro/部门管理.jpg?imageView2/2/format/webp/w/1280) | ![岗位管理](https://static.iocoder.cn/images/ruoyi-vue-pro/岗位管理.jpg?imageView2/2/format/webp/w/1280) | - |
| 菜单 & 角色 | ![菜单管理](https://static.iocoder.cn/images/ruoyi-vue-pro/菜单管理.jpg?imageView2/2/format/webp/w/1280) | ![角色管理](https://static.iocoder.cn/images/ruoyi-vue-pro/角色管理.jpg?imageView2/2/format/webp/w/1280) | - |
| 审计日志 | ![操作日志](https://static.iocoder.cn/images/ruoyi-vue-pro/操作日志.jpg?imageView2/2/format/webp/w/1280) | ![登录日志](https://static.iocoder.cn/images/ruoyi-vue-pro/登录日志.jpg?imageView2/2/format/webp/w/1280) | - |
| 短信 | ![短信渠道](https://static.iocoder.cn/images/ruoyi-vue-pro/短信渠道.jpg?imageView2/2/format/webp/w/1280) | ![短信模板](https://static.iocoder.cn/images/ruoyi-vue-pro/短信模板.jpg?imageView2/2/format/webp/w/1280) | ![短信日志](https://static.iocoder.cn/images/ruoyi-vue-pro/短信日志.jpg?imageView2/2/format/webp/w/1280) |
| 字典 & 敏感词 | ![字典类型](https://static.iocoder.cn/images/ruoyi-vue-pro/字典类型.jpg?imageView2/2/format/webp/w/1280) | ![字典数据](https://static.iocoder.cn/images/ruoyi-vue-pro/字典数据.jpg?imageView2/2/format/webp/w/1280) | ![敏感词](https://static.iocoder.cn/images/ruoyi-vue-pro/敏感词.jpg?imageView2/2/format/webp/w/1280) |
| 错误码 & 通知 | ![错误码管理](https://static.iocoder.cn/images/ruoyi-vue-pro/错误码管理.jpg?imageView2/2/format/webp/w/1280) | ![通知公告](https://static.iocoder.cn/images/ruoyi-vue-pro/通知公告.jpg?imageView2/2/format/webp/w/1280) | - |
### 工作流程
| 模块 | biu | biu | biu |
|---------|------------------------------------------------------------------------|------------------------------------------------------------------------|------------------------------------------------------------------------|
| 流程模型 | ![流程模型-列表](https://static.iocoder.cn/images/ruoyi-vue-pro/流程模型-列表.jpg?imageView2/2/format/webp/w/1280) | ![流程模型-设计](https://static.iocoder.cn/images/ruoyi-vue-pro/流程模型-设计.jpg?imageView2/2/format/webp/w/1280) | ![流程模型-定义](https://static.iocoder.cn/images/ruoyi-vue-pro/流程模型-定义.jpg?imageView2/2/format/webp/w/1280) |
| 表单 & 分组 | ![流程表单](https://static.iocoder.cn/images/ruoyi-vue-pro/流程表单.jpg?imageView2/2/format/webp/w/1280) | ![用户分组](https://static.iocoder.cn/images/ruoyi-vue-pro/用户分组.jpg?imageView2/2/format/webp/w/1280) | - |
| 我的流程 | ![我的流程-列表](https://static.iocoder.cn/images/ruoyi-vue-pro/我的流程-列表.jpg?imageView2/2/format/webp/w/1280) | ![我的流程-发起](https://static.iocoder.cn/images/ruoyi-vue-pro/我的流程-发起.jpg?imageView2/2/format/webp/w/1280) | ![我的流程-详情](https://static.iocoder.cn/images/ruoyi-vue-pro/我的流程-详情.jpg?imageView2/2/format/webp/w/1280) |
| 待办 & 已办 | ![任务列表-审批](https://static.iocoder.cn/images/ruoyi-vue-pro/任务列表-审批.jpg?imageView2/2/format/webp/w/1280) | ![任务列表-待办](https://static.iocoder.cn/images/ruoyi-vue-pro/任务列表-待办.jpg?imageView2/2/format/webp/w/1280) | ![任务列表-已办](https://static.iocoder.cn/images/ruoyi-vue-pro/任务列表-已办.jpg?imageView2/2/format/webp/w/1280) |
| OA 请假 | ![OA请假-列表](https://static.iocoder.cn/images/ruoyi-vue-pro/OA请假-列表.jpg?imageView2/2/format/webp/w/1280) | ![OA请假-发起](https://static.iocoder.cn/images/ruoyi-vue-pro/OA请假-发起.jpg?imageView2/2/format/webp/w/1280) | ![OA请假-详情](https://static.iocoder.cn/images/ruoyi-vue-pro/OA请假-详情.jpg?imageView2/2/format/webp/w/1280) |
### 基础设施
| 模块 | biu | biu | biu |
|---------------|----------------------------------------------------------------------|--------------------------------------------------------------------|------------------------------------------------------------------|
| 代码生成 | ![代码生成](https://static.iocoder.cn/images/ruoyi-vue-pro/代码生成.jpg?imageView2/2/format/webp/w/1280) | ![生成效果](https://static.iocoder.cn/images/ruoyi-vue-pro/生成效果.jpg?imageView2/2/format/webp/w/1280) | - |
| 文档 | ![系统接口](https://static.iocoder.cn/images/ruoyi-vue-pro/系统接口.jpg?imageView2/2/format/webp/w/1280) | ![数据库文档](https://static.iocoder.cn/images/ruoyi-vue-pro/数据库文档.jpg?imageView2/2/format/webp/w/1280) | - |
| 文件 & 配置 | ![文件配置](https://static.iocoder.cn/images/ruoyi-vue-pro/文件配置.jpg?imageView2/2/format/webp/w/1280) | ![文件管理](https://static.iocoder.cn/images/ruoyi-vue-pro/文件管理2.jpg?imageView2/2/format/webp/w/1280) | ![配置管理](https://static.iocoder.cn/images/ruoyi-vue-pro/配置管理.jpg?imageView2/2/format/webp/w/1280) |
| 定时任务 | ![定时任务](https://static.iocoder.cn/images/ruoyi-vue-pro/定时任务.jpg?imageView2/2/format/webp/w/1280) | ![任务日志](https://static.iocoder.cn/images/ruoyi-vue-pro/任务日志.jpg?imageView2/2/format/webp/w/1280) | - |
| API 日志 | ![访问日志](https://static.iocoder.cn/images/ruoyi-vue-pro/访问日志.jpg?imageView2/2/format/webp/w/1280) | ![错误日志](https://static.iocoder.cn/images/ruoyi-vue-pro/错误日志.jpg?imageView2/2/format/webp/w/1280) | - |
| MySQL & Redis | ![MySQL](https://static.iocoder.cn/images/ruoyi-vue-pro/MySQL.jpg?imageView2/2/format/webp/w/1280) | ![Redis](https://static.iocoder.cn/images/ruoyi-vue-pro/Redis.jpg?imageView2/2/format/webp/w/1280) | - |
| 监控平台 | ![Java监控](https://static.iocoder.cn/images/ruoyi-vue-pro/Java监控.jpg?imageView2/2/format/webp/w/1280) | ![链路追踪](https://static.iocoder.cn/images/ruoyi-vue-pro/链路追踪.jpg?imageView2/2/format/webp/w/1280) | ![日志中心](https://static.iocoder.cn/images/ruoyi-vue-pro/日志中心.jpg?imageView2/2/format/webp/w/1280) |
### 支付系统
| 模块 | biu | biu | biu |
|---------|------------------------------------------------------------------|------------------------------------------------------------------------|------------------------------------------------------------------------|
| 商家 & 应用 | ![商户信息](https://static.iocoder.cn/images/ruoyi-vue-pro/商户信息.jpg?imageView2/2/format/webp/w/1280) | ![应用信息-列表](https://static.iocoder.cn/images/ruoyi-vue-pro/应用信息-列表.jpg?imageView2/2/format/webp/w/1280) | ![应用信息-编辑](https://static.iocoder.cn/images/ruoyi-vue-pro/应用信息-编辑.jpg?imageView2/2/format/webp/w/1280) |
| 支付 & 退款 | ![支付订单](https://static.iocoder.cn/images/ruoyi-vue-pro/支付订单.jpg?imageView2/2/format/webp/w/1280) | ![退款订单](https://static.iocoder.cn/images/ruoyi-vue-pro/退款订单.jpg?imageView2/2/format/webp/w/1280) | --- |
### 数据报表
| 模块 | biu | biu | biu |
|---------|------------------------------------------------------------------|------------------------------------------------------------------------|------------------------------------------------------------------------|
| 报表设计器 | ![数据报表](https://static.iocoder.cn/images/ruoyi-vue-pro/报表设计器-数据报表.jpg?imageView2/2/format/webp/w/1280) | ![图形报表](https://static.iocoder.cn/images/ruoyi-vue-pro/报表设计器-图形报表.jpg?imageView2/2/format/webp/w/1280) | ![报表设计器-打印设计](https://static.iocoder.cn/images/ruoyi-vue-pro/报表设计器-打印设计.jpg?imageView2/2/format/webp/w/1280) |
| 大屏设计器 | ![大屏列表](https://static.iocoder.cn/images/ruoyi-vue-pro/大屏设计器-列表.jpg?imageView2/2/format/webp/w/1280) | ![大屏预览](https://static.iocoder.cn/images/ruoyi-vue-pro/大屏设计器-预览.jpg?imageView2/2/format/webp/w/1280) | ![大屏编辑](https://static.iocoder.cn/images/ruoyi-vue-pro/大屏设计器-编辑.jpg?imageView2/2/format/webp/w/1280) |
### 移动端(管理后台)
| biu | biu | biu |
|------------------------------------------------------------------|------------------------------------------------------------------------|------------------------------------------------------------------------|
| ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/01.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/02.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/03.png?imageView2/2/format/webp) |
| ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/04.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/05.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/06.png?imageView2/2/format/webp) |
| ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/07.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/08.png?imageView2/2/format/webp) | ![](https://static.iocoder.cn/images/ruoyi-vue-pro/admin-uniapp/09.png?imageView2/2/format/webp) |
目前已经实现登录、我的、工作台、编辑资料、头像修改、密码修改、常见问题、关于我们等基础功能。

@ -36,11 +36,17 @@ public interface UniTemplateApi {
@OperateLog(enable = false) // 不记录操作日志 @OperateLog(enable = false) // 不记录操作日志
CommonResult<Boolean> delUniTemplate(Long uniTemplateId) ; CommonResult<Boolean> delUniTemplate(Long uniTemplateId) ;
@PostMapping(PREFIX + "/getDefaultTemplate") @PostMapping(PREFIX + "/getTemplateById")
@PermitAll // 无需登陆
@ApiOperation("根据ID获取小程序模板")
@ApiImplicitParam(name = "id", value = "模板ID", required = true, example = "1", dataTypeClass = Long.class)
@OperateLog(enable = false) // 不记录操作日志
CommonResult<UniTemplateDTO> getTemplateById(@RequestParam("id") Long id);
@GetMapping(PREFIX + "/getDefaultTemplate")
@PermitAll // 无需登陆 @PermitAll // 无需登陆
@ApiOperation("获取默认小程序模板") @ApiOperation("获取默认小程序模板")
@ApiImplicitParam(name = "businessInfoId", value = "商户ID", required = true, example = "1", dataTypeClass = Long.class)
@OperateLog(enable = false) // 不记录操作日志 @OperateLog(enable = false) // 不记录操作日志
CommonResult<UniTemplateDTO> getDefaultTemplate(@RequestParam("businessInfoId") Long businessInfoId) ; CommonResult<UniTemplateDTO> getDefaultTemplate();
} }

@ -1,76 +1,64 @@
package cn.iocoder.yudao.module.configure.api.uniTemplate.dto; package cn.iocoder.yudao.module.configure.api.uniTemplate.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data; import lombok.Data;
import java.util.Date;
import java.util.List;
@Data @Data
public class UniTemplateDTO { public class UniTemplateDTO {
/** @ApiModelProperty(value = "编号")
*
*/
private Long id; private Long id;
/**
* id @ApiModelProperty(value = "是否显示商品详情")
*/ private Boolean showGoodsDetail;
private String templateId;
/** @ApiModelProperty(value = "商品详情图标")
* private String goodsDetailIconUrl;
*/
@ApiModelProperty(value = "是否显示ai")
private Boolean showAi;
@ApiModelProperty(value = "ai图标")
private String aiIconUrl;
@ApiModelProperty(value = "是否显示商城")
private Boolean showShop;
@ApiModelProperty(value = "商城图标")
private String shopIconUrl;
@ApiModelProperty(value = "模板名称")
private String templateName; private String templateName;
/**
* @ApiModelProperty(value = "模板类型: 1)标准模板; 2)定制模板")
*/ private Integer templateType;
private String bgPhotoUrl;
/** @ApiModelProperty(value = "背景图片")
* logo private String bgUrl;
*/
private String logoPhotoUrl; @ApiModelProperty(value = "字体颜色 标准模板时有效")
/**
* logo
*/
private Boolean showLogo;
/**
*
*/
private Boolean showFlow;
/**
*
*/
private String verifyHint;
/**
*
*/
private Integer scanMostNum;
/**
*
*/
private String bgColor;
/**
*
*/
private String bgColorThreshold;
/**
*
*/
private String fontColor; private String fontColor;
/**
* @ApiModelProperty(value = "是否为默认模板")
*/
private Boolean showScanRecord;
/**
*
*/
private Boolean onlyShowJob;
/**
*
*/
private Boolean defaultTemplate; private Boolean defaultTemplate;
/**
* id @ApiModelProperty(value = "是否显示扫码弹窗")
*/ private Boolean showPop;
private Long belongBusinessId;
/** @ApiModelProperty(value = "是否显示扫码记录")
* private Boolean showScanRecord;
*/
private String belongBusinessName; @ApiModelProperty(value = "扫码记录图标")
private String scanRecordIconUrl;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "环节模板列表")
private List<UniTemplateItemDTO> templateItemList;
} }

@ -0,0 +1,29 @@
package cn.iocoder.yudao.module.configure.api.uniTemplate.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class UniTemplateItemDTO {
@ApiModelProperty(value = "编号")
private Long id;
@ApiModelProperty(value = "图标图片")
private String iconUrl;
@ApiModelProperty(value = "x轴百分比(相对图片)")
private BigDecimal x;
@ApiModelProperty(value = "y轴百分比(相对图片)")
private BigDecimal y;
@ApiModelProperty(value = "宽")
private BigDecimal width;
@ApiModelProperty(value = "高")
private BigDecimal height;
}

@ -52,12 +52,12 @@ public interface ErrorCodeConstants {
*/ */
ErrorCode UNI_TEMPLATE_NOT_EXISTS = new ErrorCode(1011003001, "小程序模板不存在"); ErrorCode UNI_TEMPLATE_NOT_EXISTS = new ErrorCode(1011003001, "小程序模板不存在");
ErrorCode UNI_TEMPLATE_NAME_IS_SAME_EXISTS = new ErrorCode(1011003002, "存在相同的小程序模板名"); ErrorCode UNI_TEMPLATE_NAME_IS_SAME_EXISTS = new ErrorCode(1011003002, "存在相同的小程序模板名");
ErrorCode DEFAULT_UNI_TEMPLATE_DISABLE_DEL = new ErrorCode(1011003003, "不可删除默认小程序模板"); ErrorCode UNI_TEMPLATE_ITEM_NOT_EXISTS = new ErrorCode(1011003003, "小程序模板环节配置明细不存在");
ErrorCode UNI_TEMPLATE_FAIL_CREATE = new ErrorCode(1011003004, "小程序模板创建失败"); ErrorCode UNI_TEMPLATE_SCAN_RECORD_ICON_NOT_BE_NULL = new ErrorCode(1011003004, "扫码记录图标不能为空");
ErrorCode UNI_TEMPLATE_FAIL_UPDATE = new ErrorCode(1011003005, "小程序模板更新失败"); ErrorCode UNI_TEMPLATE_GOODS_DETAIL_ICON_NOT_BE_NULL = new ErrorCode(1011003005, "商品详情图标不能为空");
ErrorCode UNI_TEMPLATE_LOGO_URL_IS_EMPTY = new ErrorCode(1011003006, "logo图为空"); ErrorCode UNI_TEMPLATE_AI_ICON_NOT_BE_NULL = new ErrorCode(1011003006, "AI图标不能为空");
ErrorCode DEFAULT_UNI_TEMPLATE_MUST_EXISTS = new ErrorCode(1011003007, "不可将默认小程序模板更改为非默认,每个商户必须拥有一个默认小程序模板"); ErrorCode UNI_TEMPLATE_SHOP_ICON_NOT_BE_NULL = new ErrorCode(1011003007, "商城图标不能为空");
ErrorCode DEFAULT_UNI_TEMPLATE_IS_EXISTS = new ErrorCode(1011003008, "默认小程序模板已存在");
/** /**
* 004 * 004
**/ **/
@ -67,6 +67,12 @@ public interface ErrorCodeConstants {
* 005 * 005
**/ **/
ErrorCode DEVICE_ENV_TYPE_NOT_EXISTS = new ErrorCode(1011005001, "小程序设备环境类型配置不存在"); ErrorCode DEVICE_ENV_TYPE_NOT_EXISTS = new ErrorCode(1011005001, "小程序设备环境类型配置不存在");
/**
* 006
**/
ErrorCode MATERIAL_MANAGEMENT_NOT_EXISTS = new ErrorCode(1011006001, "素材不存在");
ErrorCode MATERIAL_GROUP_NOT_EXISTS = new ErrorCode(1011006101, "素材分组不存在");
ErrorCode MATERIAL_GROUP_EXISTS_RELATED = new ErrorCode(1011006101, "素材分组存在关联素材");
// 模块 flow 错误码区间 [1-012-000-000] // 模块 flow 错误码区间 [1-012-000-000]
// 模块 product 错误码区间 [1-013-000-000] // 模块 product 错误码区间 [1-013-000-000]
// 模块 identity 错误码区间 [1-014-000-000] // 模块 identity 错误码区间 [1-014-000-000]

@ -0,0 +1,33 @@
package cn.iocoder.yudao.module.configure.enums;
import cn.iocoder.yudao.framework.common.core.IntArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
/**
*
*/
@Getter
@AllArgsConstructor
public enum UniTemplateTypeEnum implements IntArrayValuable {
STANDARD(1, "标准模板"),
CUSTOMIZE(2, "自定义模板"),
;
public static final int[] ARRAYS = Arrays.stream(values()).mapToInt(UniTemplateTypeEnum::getType).toArray();
/**
*
*/
private final Integer type;
private final String name;
@Override
public int[] array() {
return ARRAYS;
}
}

@ -6,6 +6,7 @@ import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.module.configure.api.uniTemplate.dto.UniTemplateCreateDTO; import cn.iocoder.yudao.module.configure.api.uniTemplate.dto.UniTemplateCreateDTO;
import cn.iocoder.yudao.module.configure.api.uniTemplate.dto.UniTemplateDTO; import cn.iocoder.yudao.module.configure.api.uniTemplate.dto.UniTemplateDTO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateCreateReqVO; import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO; import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import cn.iocoder.yudao.module.configure.service.unitemplate.UniTemplateService; import cn.iocoder.yudao.module.configure.service.unitemplate.UniTemplateService;
import org.apache.dubbo.config.annotation.DubboService; import org.apache.dubbo.config.annotation.DubboService;
@ -39,13 +40,18 @@ public class UniTemplateApiImpl implements UniTemplateApi {
} }
@Override @Override
public CommonResult<UniTemplateDTO> getDefaultTemplate(Long businessInfoId) { public CommonResult<UniTemplateDTO> getTemplateById(Long id) {
UniTemplateDO uniTemplateDO = uniTemplateService.getDefaultTemplate(businessInfoId); UniTemplateRespVO uniTemplate = uniTemplateService.getUniTemplate(id);
if (uniTemplateDO != null) { UniTemplateDTO result = new UniTemplateDTO();
UniTemplateDTO uniTemplateDTO = new UniTemplateDTO(); BeanUtil.copyProperties(uniTemplate, result);
BeanUtil.copyProperties(uniTemplateDO, uniTemplateDTO); return CommonResult.success(result);
return CommonResult.success(uniTemplateDTO);
} }
return CommonResult.success(null);
@Override
public CommonResult<UniTemplateDTO> getDefaultTemplate() {
UniTemplateDO templateDO = uniTemplateService.getDefaultUniTemplate();
UniTemplateDTO result = new UniTemplateDTO();
BeanUtil.copyProperties(templateDO, result);
return CommonResult.success(result);
} }
} }

@ -0,0 +1,93 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupPageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupRespVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupUpdateReqVO;
import cn.iocoder.yudao.module.configure.convert.materialgroup.MaterialGroupConvert;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup.MaterialGroupDO;
import cn.iocoder.yudao.module.configure.service.materialgroup.MaterialGroupService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.Collection;
import java.util.List;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Api(tags = "管理后台 - 素材管理分组")
@RestController
@RequestMapping("/configure/material-group")
@Validated
public class MaterialGroupController {
@Resource
private MaterialGroupService materialGroupService;
@PostMapping("/create")
@ApiOperation("创建素材管理分组")
@PreAuthorize("@ss.hasPermission('configure:material-group:create')")
public CommonResult<Long> createMaterialGroup(@Valid @RequestBody MaterialGroupCreateReqVO createReqVO) {
return success(materialGroupService.createMaterialGroup(createReqVO));
}
@PutMapping("/update")
@ApiOperation("更新素材管理分组")
@PreAuthorize("@ss.hasPermission('configure:material-group:update')")
public CommonResult<Boolean> updateMaterialGroup(@Valid @RequestBody MaterialGroupUpdateReqVO updateReqVO) {
materialGroupService.updateMaterialGroup(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@ApiOperation("删除素材管理分组")
@ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('configure:material-group:delete')")
public CommonResult<Boolean> deleteMaterialGroup(@RequestParam("id") Long id) {
materialGroupService.deleteMaterialGroup(id);
return success(true);
}
@GetMapping("/get")
@ApiOperation("获得素材管理分组")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('configure:material-group:query')")
public CommonResult<MaterialGroupRespVO> getMaterialGroup(@RequestParam("id") Long id) {
MaterialGroupDO materialGroup = materialGroupService.getMaterialGroup(id);
return success(MaterialGroupConvert.INSTANCE.convert(materialGroup));
}
@GetMapping("/list/ids")
@ApiOperation("获得素材管理分组列表")
@ApiImplicitParam(name = "ids", value = "编号列表", required = true, example = "1024,2048", dataTypeClass = List.class)
@PreAuthorize("@ss.hasPermission('configure:material-group:query')")
public CommonResult<List<MaterialGroupRespVO>> getMaterialGroupListByIds(@RequestParam("ids") Collection<Long> ids) {
List<MaterialGroupDO> list = materialGroupService.getMaterialGroupListByids(ids);
return success(MaterialGroupConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@ApiOperation("获得素材管理分组分页")
@PreAuthorize("@ss.hasPermission('configure:material-group:query')")
public CommonResult<PageResult<MaterialGroupRespVO>> getMaterialGroupPage(@Valid MaterialGroupPageReqVO pageVO) {
PageResult<MaterialGroupDO> pageResult = materialGroupService.getMaterialGroupPage(pageVO);
return success(MaterialGroupConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/list")
@ApiOperation("获得素材管理分组列表")
@PreAuthorize("@ss.hasPermission('configure:material-group:query')")
public CommonResult<List<MaterialGroupRespVO>> getMaterialGroupList(@Valid MaterialGroupPageReqVO pageVO) {
List<MaterialGroupDO> list = materialGroupService.getMaterialGroupList(pageVO);
return success(MaterialGroupConvert.INSTANCE.convertList(list));
}
}

@ -0,0 +1,22 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class MaterialGroupBaseVO {
@ApiModelProperty(value = "分组名称", required = true)
@NotNull(message = "分组名称不能为空")
@Length(max = 12, message = "分组名称不能超过12个字符")
private String groupName;
}

@ -0,0 +1,14 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import javax.validation.constraints.*;
@ApiModel("管理后台 - 素材管理分组创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialGroupCreateReqVO extends MaterialGroupBaseVO {
}

@ -0,0 +1,24 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@ApiModel("管理后台 - 素材管理分组分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialGroupPageReqVO extends PageParam {
@ApiModelProperty(value = "分组名称")
private String groupName;
@ApiModelProperty(value = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private Date[] createTime;
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo;
import lombok.*;
import io.swagger.annotations.*;
import java.util.Date;
@ApiModel("管理后台 - 素材管理分组 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialGroupRespVO extends MaterialGroupBaseVO {
@ApiModelProperty(value = "编号", required = true)
private Long id;
@ApiModelProperty(value = "创建时间")
private Date createTime;
}

@ -0,0 +1,18 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import javax.validation.constraints.*;
@ApiModel("管理后台 - 素材管理分组更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialGroupUpdateReqVO extends MaterialGroupBaseVO {
@ApiModelProperty(value = "编号", required = true)
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,100 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.*;
import cn.iocoder.yudao.module.configure.convert.materialmanagement.MaterialManagementConvert;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
import cn.iocoder.yudao.module.configure.service.materialmanagement.MaterialManagementService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.Collection;
import java.util.List;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Api(tags = "管理后台 - 素材管理")
@RestController
@RequestMapping("/configure/material-management")
@Validated
public class MaterialManagementController {
@Resource
private MaterialManagementService materialManagementService;
@PostMapping("/create")
@ApiOperation("创建素材管理")
@PreAuthorize("@ss.hasPermission('configure:material-management:create')")
public CommonResult<Boolean> createMaterialManagement(@Valid @RequestBody List<MaterialManagementCreateReqVO> createReqVO) {
return success(materialManagementService.createMaterialManagement(createReqVO));
}
@PutMapping("/update")
@ApiOperation("更新素材管理")
@PreAuthorize("@ss.hasPermission('configure:material-management:update')")
public CommonResult<Boolean> updateMaterialManagement(@Valid @RequestBody MaterialManagementUpdateReqVO updateReqVO) {
materialManagementService.updateMaterialManagement(updateReqVO);
return success(true);
}
@PutMapping("/update/batchGroup")
@ApiOperation("批量移动素材管理分组")
@PreAuthorize("@ss.hasPermission('configure:material-management:update')")
public CommonResult<Boolean> updateMaterialManagementGroupBatch(@Valid @RequestBody MaterialManagementGroupUpdate materialManagementGroupUpdate) {
materialManagementService.updateMaterialManagementGroupBatch(materialManagementGroupUpdate);
return success(true);
}
@DeleteMapping("/delete")
@ApiOperation("删除素材管理")
@ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('configure:material-management:delete')")
public CommonResult<Boolean> deleteMaterialManagement(@RequestParam("id") Long id) {
materialManagementService.deleteMaterialManagement(id);
return success(true);
}
@DeleteMapping("/delete/batch")
@ApiOperation("批量删除素材管理")
@ApiImplicitParam(name = "ids", value = "编号列表", required = true, example = "1024,2048", dataTypeClass = List.class)
@PreAuthorize("@ss.hasPermission('configure:material-management:delete')")
public CommonResult<Boolean> deleteMaterialManagementBatch(@RequestParam("ids") List<Long> ids) {
materialManagementService.deleteMaterialManagementBatch(ids);
return success(true);
}
@GetMapping("/get")
@ApiOperation("获得素材管理")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('configure:material-management:query')")
public CommonResult<MaterialManagementRespVO> getMaterialManagement(@RequestParam("id") Long id) {
MaterialManagementDO materialManagement = materialManagementService.getMaterialManagement(id);
return success(MaterialManagementConvert.INSTANCE.convert(materialManagement));
}
@GetMapping("/list")
@ApiOperation("获得素材管理列表")
@ApiImplicitParam(name = "ids", value = "编号列表", required = true, example = "1024,2048", dataTypeClass = List.class)
@PreAuthorize("@ss.hasPermission('configure:material-management:query')")
public CommonResult<List<MaterialManagementRespVO>> getMaterialManagementList(@RequestParam("ids") Collection<Long> ids) {
List<MaterialManagementDO> list = materialManagementService.getMaterialManagementList(ids);
return success(MaterialManagementConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@ApiOperation("获得素材管理分页")
@PreAuthorize("@ss.hasPermission('configure:material-management:query')")
public CommonResult<PageResult<MaterialManagementRespVO>> getMaterialManagementPage(@Valid MaterialManagementPageReqVO pageVO) {
PageResult<MaterialManagementDO> pageResult = materialManagementService.getMaterialManagementPage(pageVO);
return success(MaterialManagementConvert.INSTANCE.convertPage(pageResult));
}
}

@ -0,0 +1,30 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class MaterialManagementBaseVO {
@ApiModelProperty(value = "分组id", required = true)
@NotNull(message = "分组id不能为空")
private Long groupId;
@ApiModelProperty(value = "素材名称", required = true)
@NotNull(message = "素材名称不能为空")
@Length(max = 64, message = "素材名称不能超过64个字符")
private String materialName;
@ApiModelProperty(value = "素材地址", required = true)
@NotNull(message = "素材地址不能为空")
private String materialUrl;
}

@ -0,0 +1,14 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import javax.validation.constraints.*;
@ApiModel("管理后台 - 素材管理创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialManagementCreateReqVO extends MaterialManagementBaseVO {
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotNull;
import java.util.List;
@Data
public class MaterialManagementGroupUpdate {
@ApiModelProperty(value = "编号列表", required = true)
@NotNull(message = "编号列表不能为空")
private List<Long> ids;
@ApiModelProperty(value = "分组id", required = true)
@NotNull(message = "分组id不能为空")
private Long groupId;
}

@ -0,0 +1,30 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@ApiModel("管理后台 - 素材管理分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialManagementPageReqVO extends PageParam {
@ApiModelProperty(value = "分组id")
private Long groupId;
@ApiModelProperty(value = "素材名称")
private String materialName;
@ApiModelProperty(value = "素材地址")
private String materialUrl;
@ApiModelProperty(value = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private Date[] createTime;
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import lombok.*;
import io.swagger.annotations.*;
import java.util.Date;
@ApiModel("管理后台 - 素材管理 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MaterialManagementRespVO extends MaterialManagementBaseVO {
@ApiModelProperty(value = "编号", required = true)
private Long id;
@ApiModelProperty(value = "创建时间")
private Date createTime;
}

@ -0,0 +1,29 @@
package cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.*;
@ApiModel("管理后台 - 素材管理更新 Request VO")
@Data
@ToString(callSuper = true)
public class MaterialManagementUpdateReqVO {
@ApiModelProperty(value = "编号", required = true)
@NotNull(message = "编号不能为空")
private Long id;
@ApiModelProperty(value = "分组id", required = true)
private Long groupId;
@ApiModelProperty(value = "素材名称", required = true)
@Length(max = 64, message = "素材名称不能超过64个字符")
private String materialName;
@ApiModelProperty(value = "素材地址", required = true)
private String materialUrl;
}

@ -1,31 +1,21 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate;
import org.springframework.web.bind.annotation.*; import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import javax.annotation.Resource; import cn.iocoder.yudao.framework.common.pojo.PageResult;
import org.springframework.validation.annotation.Validated; import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*;
import cn.iocoder.yudao.module.configure.service.unitemplate.UniTemplateService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.annotations.*; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.*; import javax.annotation.Resource;
import javax.validation.*; import javax.validation.Valid;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success; import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.operatelog.core.annotations.OperateLog;
import static cn.iocoder.yudao.framework.operatelog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import cn.iocoder.yudao.module.configure.convert.unitemplate.UniTemplateConvert;
import cn.iocoder.yudao.module.configure.service.unitemplate.UniTemplateService;
@Api(tags = "管理后台 - 小程序模板") @Api(tags = "管理后台 - 小程序模板")
@RestController @RestController
@RequestMapping("/configure/uni-template") @RequestMapping("/configure/uni-template")
@ -35,21 +25,37 @@ public class UniTemplateController {
@Resource @Resource
private UniTemplateService uniTemplateService; private UniTemplateService uniTemplateService;
@PostMapping("/create") @PostMapping("/createStandardTemplate")
@ApiOperation("创建小程序模板") @ApiOperation("创建标准小程序模板")
@PreAuthorize("@ss.hasPermission('configure:uni-template:create')") @PreAuthorize("@ss.hasPermission('configure:uni-template:create')")
public CommonResult<Long> createUniTemplate(@Valid @RequestBody UniTemplateCreateReqVO createReqVO) { public CommonResult<Long> createUniTemplate(@Valid @RequestBody UniTemplateCreateReqVO createReqVO) {
return success(uniTemplateService.createUniTemplate(createReqVO)); return success(uniTemplateService.createUniTemplate(createReqVO));
} }
@PutMapping("/update") @PostMapping("/createCustomizeTemplate")
@ApiOperation("更新小程序模板") @ApiOperation("创建自定义小程序模板")
@PreAuthorize("@ss.hasPermission('configure:uni-template:create')")
public CommonResult<Long> createCustomizeTemplate(@Valid @RequestBody UniTemplateCreateCustomizeReqVO createReqVO) {
return success(uniTemplateService.createUniTemplate(createReqVO));
}
@PutMapping("/updateStandardTemplate")
@ApiOperation("更新标准小程序模板")
@PreAuthorize("@ss.hasPermission('configure:uni-template:update')") @PreAuthorize("@ss.hasPermission('configure:uni-template:update')")
public CommonResult<Boolean> updateUniTemplate(@Valid @RequestBody UniTemplateUpdateReqVO updateReqVO) { public CommonResult<Boolean> updateUniTemplate(@Valid @RequestBody UniTemplateUpdateReqVO updateReqVO) {
uniTemplateService.updateUniTemplate(updateReqVO); uniTemplateService.updateUniTemplate(updateReqVO);
return success(true); return success(true);
} }
@PutMapping("/updateCustomizeTemplate")
@ApiOperation("更新自定义小程序模板")
@PreAuthorize("@ss.hasPermission('configure:uni-template:update')")
public CommonResult<Boolean> updateCustomizeTemplate(@Valid @RequestBody UniTemplateUpdateCustomizeReqVO updateReqVO) {
uniTemplateService.updateUniTemplate(updateReqVO);
return success(true);
}
@DeleteMapping("/delete") @DeleteMapping("/delete")
@ApiOperation("删除小程序模板") @ApiOperation("删除小程序模板")
@ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class) @ApiImplicitParam(name = "id", value = "编号", required = true, dataTypeClass = Long.class)
@ -64,23 +70,14 @@ public class UniTemplateController {
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class) @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('configure:uni-template:query')") @PreAuthorize("@ss.hasPermission('configure:uni-template:query')")
public CommonResult<UniTemplateRespVO> getUniTemplate(@RequestParam("id") Long id) { public CommonResult<UniTemplateRespVO> getUniTemplate(@RequestParam("id") Long id) {
UniTemplateDO uniTemplate = uniTemplateService.getUniTemplate(id); return success(uniTemplateService.getUniTemplate(id));
return success(UniTemplateConvert.INSTANCE.convert(uniTemplate));
} }
@GetMapping("/page") @GetMapping("/page")
@ApiOperation("获得小程序模板分页") @ApiOperation("获得小程序模板分页")
@PreAuthorize("@ss.hasPermission('configure:uni-template:query')") @PreAuthorize("@ss.hasPermission('configure:uni-template:query')")
public CommonResult<PageResult<UniTemplateRespVO>> getUniTemplatePage(@Valid UniTemplatePageReqVO pageVO) { public CommonResult<PageResult<UniTemplateRespVO>> getUniTemplatePage(@Valid UniTemplatePageReqVO pageVO) {
PageResult<UniTemplateDO> pageResult = uniTemplateService.getUniTemplatePage(pageVO); return success(uniTemplateService.getUniTemplatePage(pageVO));
return success(UniTemplateConvert.INSTANCE.convertPage(pageResult));
} }
@GetMapping("/getDefaultBgPhotoUrl")
@ApiOperation("获得小程序模板默认背景、logo图片地址")
@PreAuthorize("@ss.hasPermission('configure:uni-template:query')")
public CommonResult<UniTemplatePhotoUrlVO> getDefaultBgPhotoUrl() {
UniTemplatePhotoUrlVO uniTemplateDO = uniTemplateService.getDefaultPhotoUrl();
return success(uniTemplateDO);
}
} }

@ -1,9 +1,11 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import lombok.*; import io.swagger.annotations.ApiModelProperty;
import java.util.*; import lombok.Data;
import io.swagger.annotations.*; import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.*;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/** /**
* Base VO VO 使 * Base VO VO 使
@ -12,69 +14,36 @@ import javax.validation.constraints.*;
@Data @Data
public class UniTemplateBaseVO { public class UniTemplateBaseVO {
@ApiModelProperty(value = "模板id")
private String templateId;
@ApiModelProperty(value = "模板名称", required = true) @ApiModelProperty(value = "模板名称", required = true)
@NotNull(message = "模板名称不能为空") @NotNull(message = "模板名称不能为空")
private String templateName; private String templateName;
@ApiModelProperty(value = "头部背景图", required = true) @ApiModelProperty(value = "模板类型: 1)标准模板; 2)定制模板", required = true)
@NotNull(message = "头部背景图不能为空") @NotNull(message = "模板类型: 1)标准模板; 2)定制模板不能为空")
private String bgPhotoUrl; private Integer templateType;
@ApiModelProperty(value = "logo图")
private String logoPhotoUrl;
@ApiModelProperty(value = "是否显示logo", required = true)
@NotNull(message = "是否显示logo不能为空")
private Boolean showLogo;
@ApiModelProperty(value = "是否显示经销流转信息", required = true) @ApiModelProperty(value = "背景图片", required = true)
@NotNull(message = "是否显示经销流转信息不能为空") @NotBlank(message = "背景图片不能为空")
private Boolean showFlow; private String bgUrl;
@ApiModelProperty(value = "多次验证提示文案", required = true) @ApiModelProperty(value = "字体颜色 标准模板时有效", required = true)
@NotNull(message = "多次验证提示文案不能为空") @NotBlank(message = "字体颜色 标准模板时有效不能为空")
private String verifyHint; private String fontColor;
@ApiModelProperty(value = "多次验证提示阈值设置", required = true)
@NotNull(message = "多次验证提示阈值设置不能为空")
private Integer scanMostNum;
@ApiModelProperty(value = "背景颜色", required = true) @ApiModelProperty(value = "是否为默认模板", required = true)
@NotNull(message = "背景颜色不能为空") @NotNull(message = "是否为默认模板不能为空")
private String bgColor; private Boolean defaultTemplate;
@ApiModelProperty(value = "超过阈值后背景颜色", required = true) @ApiModelProperty(value = "是否显示扫码弹窗", required = true)
@NotNull(message = "超过阈值后背景颜色不能为空") @NotNull(message = "是否显示扫码弹窗不能为空")
private String bgColorThreshold; private Boolean showPop;
@ApiModelProperty(value = "是否显示扫码记录", required = true) @ApiModelProperty(value = "是否显示扫码记录", required = true)
@NotNull(message = "是否显示扫码记录不能为空") @NotNull(message = "是否显示扫码记录不能为空")
private Boolean showScanRecord; private Boolean showScanRecord;
@ApiModelProperty(value = "是否只显示农事作业", required = true) @ApiModelProperty(value = "扫码记录图标")
@NotNull(message = "是否只显示农事作业不能为空") @Length(max = 256)
private Boolean onlyShowJob; private String scanRecordIconUrl;
@ApiModelProperty(value = "是否为默认模板")
private Boolean defaultTemplate;
@ApiModelProperty(value = "所属商户id", required = true)
@NotNull(message = "所属商户id不能为空")
private Long belongBusinessId;
@ApiModelProperty(value = "所属商户名称", required = true)
@NotNull(message = "所属商户名称不能为空")
private String belongBusinessName;
@ApiModelProperty(value = "多次验证提示字体颜色", required = true)
@NotNull(message = "多次验证提示字体颜色不能为空")
private String fontColor;
@ApiModelProperty(value = "扫码记录字体颜色", required = true)
@NotNull(message = "扫码记录字体颜色不能为空")
private String scanFontColor;
} }

@ -0,0 +1,49 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.UniTemplateItemBaseVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.List;
@ApiModel("管理后台 - 小程序模板创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class UniTemplateCreateCustomizeReqVO extends UniTemplateCreateReqVO {
@ApiModelProperty(value = "是否显示商品详情", required = true)
@NotNull(message = "是否显示商品详情不能为空")
private Boolean showGoodsDetail;
@ApiModelProperty(value = "商品详情图标")
@Length(max = 256)
private String goodsDetailIconUrl;
@ApiModelProperty(value = "是否显示ai", required = true)
@NotNull(message = "是否显示ai不能为空")
private Boolean showAi;
@ApiModelProperty(value = "ai图标")
@Length(max = 256)
private String aiIconUrl;
@ApiModelProperty(value = "是否显示商城", required = true)
@NotNull(message = "是否显示商城不能为空")
private Boolean showShop;
@ApiModelProperty(value = "商城图标")
@Length(max = 256)
private String shopIconUrl;
@ApiModelProperty(value = "环节模板列表")
@Valid
private List<UniTemplateItemBaseVO> templateItemList;
}

@ -1,9 +1,9 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import lombok.*; import io.swagger.annotations.ApiModel;
import java.util.*; import lombok.Data;
import io.swagger.annotations.*; import lombok.EqualsAndHashCode;
import javax.validation.constraints.*; import lombok.ToString;
@ApiModel("管理后台 - 小程序模板创建 Request VO") @ApiModel("管理后台 - 小程序模板创建 Request VO")
@Data @Data

@ -1,11 +1,10 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import cn.iocoder.yudao.framework.common.util.date.DateUtils;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import cn.iocoder.yudao.framework.common.pojo.PageParam; import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat; import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
@ApiModel("管理后台 - 小程序模板分页 Request VO") @ApiModel("管理后台 - 小程序模板分页 Request VO")
@Data @Data
@ -13,56 +12,4 @@ import org.springframework.format.annotation.DateTimeFormat;
@ToString(callSuper = true) @ToString(callSuper = true)
public class UniTemplatePageReqVO extends PageParam { public class UniTemplatePageReqVO extends PageParam {
@ApiModelProperty(value = "模板id")
private String templateId;
@ApiModelProperty(value = "模板名称")
private String templateName;
@ApiModelProperty(value = "头部背景图")
private String bgPhotoUrl;
@ApiModelProperty(value = "logo图")
private String logoPhotoUrl;
@ApiModelProperty(value = "是否显示logo")
private Boolean showLogo;
@ApiModelProperty(value = "是否显示经销流转信息")
private Boolean showFlow;
@ApiModelProperty(value = "多次验证提示文案")
private String verifyHint;
@ApiModelProperty(value = "多次验证提示阈值设置")
private Integer scanMostNum;
@ApiModelProperty(value = "背景颜色")
private String bgColor;
@ApiModelProperty(value = "超过阈值后背景颜色")
private String bgColorThreshold;
@ApiModelProperty(value = "是否显示扫码记录")
private Boolean showScanRecord;
@ApiModelProperty(value = "是否为默认模板")
private Boolean defaultTemplate;
@ApiModelProperty(value = "所属商户id")
private Long belongBusinessId;
@ApiModelProperty(value = "所属商户名称")
private String belongBusinessName;
@ApiModelProperty(value = "创建时间")
@DateTimeFormat(pattern = DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private Date[] createTime;
@ApiModelProperty(value = "多次验证提示字体颜色")
private String fontColor;
@ApiModelProperty(value = "扫码记录字体颜色")
private String scanFontColor;
} }

@ -1,9 +1,11 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.UniTemplateItemRespVO;
import lombok.*; import lombok.*;
import io.swagger.annotations.*; import io.swagger.annotations.*;
import java.util.Date; import java.util.Date;
import java.util.List;
@ApiModel("管理后台 - 小程序模板 Response VO") @ApiModel("管理后台 - 小程序模板 Response VO")
@Data @Data
@ -11,10 +13,31 @@ import java.util.Date;
@ToString(callSuper = true) @ToString(callSuper = true)
public class UniTemplateRespVO extends UniTemplateBaseVO { public class UniTemplateRespVO extends UniTemplateBaseVO {
@ApiModelProperty(value = "编号", required = true) @ApiModelProperty(value = "编号")
private Long id; private Long id;
@ApiModelProperty(value = "是否显示商品详情")
private Boolean showGoodsDetail;
@ApiModelProperty(value = "商品详情图标")
private String goodsDetailIconUrl;
@ApiModelProperty(value = "是否显示ai")
private Boolean showAi;
@ApiModelProperty(value = "ai图标")
private String aiIconUrl;
@ApiModelProperty(value = "是否显示商城")
private Boolean showShop;
@ApiModelProperty(value = "商城图标")
private String shopIconUrl;
@ApiModelProperty(value = "创建时间") @ApiModelProperty(value = "创建时间")
private Date createTime; private Date createTime;
@ApiModelProperty(value = "环节模板列表")
private List<UniTemplateItemRespVO> templateItemList;
} }

@ -0,0 +1,53 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.UniTemplateItemBaseVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.hibernate.validator.constraints.Length;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
@ApiModel("管理后台 - 小程序模板更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class UniTemplateUpdateCustomizeReqVO extends UniTemplateUpdateReqVO {
@ApiModelProperty(value = "是否显示商品详情", required = true)
@NotNull(message = "是否显示商品详情不能为空")
private Boolean showGoodsDetail;
@ApiModelProperty(value = "商品详情图标", required = true)
@NotBlank(message = "商品详情图标不能为空")
@Length(max = 256)
private String goodsDetailIconUrl;
@ApiModelProperty(value = "是否显示ai", required = true)
@NotNull(message = "是否显示ai不能为空")
private Boolean showAi;
@ApiModelProperty(value = "ai图标", required = true)
@NotBlank(message = "ai图标不能为空")
@Length(max = 256)
private String aiIconUrl;
@ApiModelProperty(value = "是否显示商城", required = true)
@NotNull(message = "是否显示商城不能为空")
private Boolean showShop;
@ApiModelProperty(value = "商城图标", required = true)
@NotBlank(message = "商城图标不能为空")
@Length(max = 256)
private String shopIconUrl;
@ApiModelProperty(value = "环节模板列表")
@Valid
private List<UniTemplateItemBaseVO> templateItemList;
}

@ -1,9 +1,12 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo; package cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo;
import lombok.*; import io.swagger.annotations.ApiModel;
import java.util.*; import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.*; import lombok.Data;
import javax.validation.constraints.*; import lombok.EqualsAndHashCode;
import lombok.ToString;
import javax.validation.constraints.NotNull;
@ApiModel("管理后台 - 小程序模板更新 Request VO") @ApiModel("管理后台 - 小程序模板更新 Request VO")
@Data @Data

@ -0,0 +1,42 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class UniTemplateItemBaseVO {
@ApiModelProperty(value = "编号")
private Long id;
@ApiModelProperty(value = "图标图片", required = true)
@NotBlank(message = "图标图片不能为空")
@Length(max = 256)
private String iconUrl;
@ApiModelProperty(value = "x轴百分比(相对图片)", required = true)
@NotNull(message = "x轴百分比不能为空")
private BigDecimal x;
@ApiModelProperty(value = "y轴百分比(相对图片)", required = true)
@NotNull(message = "y轴百分比不能为空")
private BigDecimal y;
@ApiModelProperty(value = "宽", required = true)
@NotNull(message = "宽不能为空")
private BigDecimal width;
@ApiModelProperty(value = "高", required = true)
@NotNull(message = "高不能为空")
private BigDecimal height;
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo;
import lombok.*;
import io.swagger.annotations.*;
import java.util.Date;
@ApiModel("管理后台 - 小程序模板环节配置明细 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class UniTemplateItemRespVO extends UniTemplateItemBaseVO {
@ApiModelProperty(value = "编号", required = true)
private Long id;
@ApiModelProperty(value = "创建时间")
private Date createTime;
}

@ -0,0 +1,32 @@
package cn.iocoder.yudao.module.configure.convert.materialgroup;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup.MaterialGroupDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface MaterialGroupConvert {
MaterialGroupConvert INSTANCE = Mappers.getMapper(MaterialGroupConvert.class);
MaterialGroupDO convert(MaterialGroupCreateReqVO bean);
MaterialGroupDO convert(MaterialGroupUpdateReqVO bean);
MaterialGroupRespVO convert(MaterialGroupDO bean);
List<MaterialGroupRespVO> convertList(List<MaterialGroupDO> list);
PageResult<MaterialGroupRespVO> convertPage(PageResult<MaterialGroupDO> page);
}

@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.configure.convert.materialmanagement;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface MaterialManagementConvert {
MaterialManagementConvert INSTANCE = Mappers.getMapper(MaterialManagementConvert.class);
MaterialManagementDO convert(MaterialManagementCreateReqVO bean);
MaterialManagementDO convert(MaterialManagementUpdateReqVO bean);
MaterialManagementRespVO convert(MaterialManagementDO bean);
List<MaterialManagementRespVO> convertList(List<MaterialManagementDO> list);
PageResult<MaterialManagementRespVO> convertPage(PageResult<MaterialManagementDO> page);
List<MaterialManagementDO> convertList02(List<MaterialManagementCreateReqVO> list);
}

@ -19,12 +19,6 @@ public interface UniTemplateConvert {
UniTemplateConvert INSTANCE = Mappers.getMapper(UniTemplateConvert.class); UniTemplateConvert INSTANCE = Mappers.getMapper(UniTemplateConvert.class);
UniTemplateDO convert(UniTemplateCreateReqVO bean);
UniTemplateDO convert(UniTemplateUpdateReqVO bean);
UniTemplateRespVO convert(UniTemplateDO bean);
List<UniTemplateRespVO> convertList(List<UniTemplateDO> list); List<UniTemplateRespVO> convertList(List<UniTemplateDO> list);
PageResult<UniTemplateRespVO> convertPage(PageResult<UniTemplateDO> page); PageResult<UniTemplateRespVO> convertPage(PageResult<UniTemplateDO> page);

@ -0,0 +1,33 @@
package cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("configure_material_group")
@KeySequence("configure_material_group_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MaterialGroupDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
*
*/
private String groupName;
}

@ -0,0 +1,41 @@
package cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("configure_material_management")
@KeySequence("configure_material_management_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MaterialManagementDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* id
*/
private Long groupId;
/**
*
*/
private String materialName;
/**
*
*/
private String materialUrl;
}

@ -1,9 +1,10 @@
package cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate; package cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO; import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;
/** /**
* DO * DO
@ -34,64 +35,56 @@ public class UniTemplateDO extends BaseDO {
*/ */
private String templateName; private String templateName;
/** /**
* * : 1); 2)
*/
private String bgPhotoUrl;
/**
* logo
*/
private String logoPhotoUrl;
/**
* logo
*/
private Boolean showLogo;
/**
*
*/ */
private Boolean showFlow; private Integer templateType;
/** /**
* *
*/ */
private String verifyHint; private String bgUrl;
/** /**
* *
*/ */
private Integer scanMostNum; private String fontColor;
/** /**
* *
*/ */
private String bgColor; private Boolean defaultTemplate;
/** /**
* *
*/ */
private String bgColorThreshold; private Boolean showPop;
/** /**
* *
*/ */
private Boolean showScanRecord; private Boolean showScanRecord;
/** /**
* *
*/ */
private Boolean onlyShowJob; private String scanRecordIconUrl;
/** /**
* *
*/ */
private Boolean defaultTemplate; private Boolean showGoodsDetail;
/** /**
* id *
*/ */
private Long belongBusinessId; private String goodsDetailIconUrl;
/** /**
* * ai
*/ */
private String belongBusinessName; private Boolean showAi;
/** /**
* * ai
*/ */
private String fontColor; private String aiIconUrl;
/**
*
*/
private Boolean showShop;
/** /**
* *
*/ */
private String scanFontColor; private String shopIconUrl;
} }

@ -0,0 +1,56 @@
package cn.iocoder.yudao.module.configure.dal.dataobject.unitemplateitem;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;
import java.math.BigDecimal;
/**
* DO
*
* @author
*/
@TableName("configure_uni_template_item")
@KeySequence("configure_uni_template_item_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UniTemplateItemDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* id
*/
private String templateId;
/**
*
*/
private String iconUrl;
/**
* x()
*/
private BigDecimal x;
/**
* y()
*/
private BigDecimal y;
/**
*
*/
private BigDecimal width;
/**
*
*/
private BigDecimal height;
}

@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.configure.dal.mysql.materialgroup;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup.MaterialGroupDO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface MaterialGroupMapper extends BaseMapperX<MaterialGroupDO> {
default PageResult<MaterialGroupDO> selectPage(MaterialGroupPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<MaterialGroupDO>()
.likeIfPresent(MaterialGroupDO::getGroupName, reqVO.getGroupName())
.betweenIfPresent(MaterialGroupDO::getCreateTime, reqVO.getCreateTime())
.orderByAsc(MaterialGroupDO::getId));
}
default List<MaterialGroupDO> selectList(MaterialGroupPageReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<MaterialGroupDO>()
.likeIfPresent(MaterialGroupDO::getGroupName, reqVO.getGroupName())
.betweenIfPresent(MaterialGroupDO::getCreateTime, reqVO.getCreateTime())
.orderByAsc(MaterialGroupDO::getId));
}
}

@ -0,0 +1,30 @@
package cn.iocoder.yudao.module.configure.dal.mysql.materialmanagement;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface MaterialManagementMapper extends BaseMapperX<MaterialManagementDO> {
default PageResult<MaterialManagementDO> selectPage(MaterialManagementPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<MaterialManagementDO>()
.eqIfPresent(MaterialManagementDO::getGroupId, reqVO.getGroupId())
.likeIfPresent(MaterialManagementDO::getMaterialName, reqVO.getMaterialName())
.eqIfPresent(MaterialManagementDO::getMaterialUrl, reqVO.getMaterialUrl())
.betweenIfPresent(MaterialManagementDO::getCreateTime, reqVO.getCreateTime())
.eq(MaterialManagementDO::getDeleted,0)
.orderByDesc(MaterialManagementDO::getId));
}
}

@ -1,13 +1,14 @@
package cn.iocoder.yudao.module.configure.dal.mysql.unitemplate; package cn.iocoder.yudao.module.configure.dal.mysql.unitemplate;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplatePageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO; import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*; import org.apache.ibatis.annotations.Param;
import java.util.List;
/** /**
* Mapper * Mapper
@ -17,26 +18,8 @@ import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*;
@Mapper @Mapper
public interface UniTemplateMapper extends BaseMapperX<UniTemplateDO> { public interface UniTemplateMapper extends BaseMapperX<UniTemplateDO> {
default PageResult<UniTemplateDO> selectPage(UniTemplatePageReqVO reqVO) { List<UniTemplateRespVO> selectUniTemplatePage(Page<UniTemplateRespVO> page, @Param("pageReqVO") UniTemplatePageReqVO pageReqVO);
return selectPage(reqVO, new LambdaQueryWrapperX<UniTemplateDO>()
.eqIfPresent(UniTemplateDO::getTemplateId, reqVO.getTemplateId()) UniTemplateRespVO getUniTemplateDetail(@Param("id") Long id);
.likeIfPresent(UniTemplateDO::getTemplateName, reqVO.getTemplateName())
.eqIfPresent(UniTemplateDO::getBgPhotoUrl, reqVO.getBgPhotoUrl())
.eqIfPresent(UniTemplateDO::getLogoPhotoUrl, reqVO.getLogoPhotoUrl())
.eqIfPresent(UniTemplateDO::getShowLogo, reqVO.getShowLogo())
.eqIfPresent(UniTemplateDO::getShowFlow, reqVO.getShowFlow())
.eqIfPresent(UniTemplateDO::getVerifyHint, reqVO.getVerifyHint())
.eqIfPresent(UniTemplateDO::getScanMostNum, reqVO.getScanMostNum())
.eqIfPresent(UniTemplateDO::getBgColor, reqVO.getBgColor())
.eqIfPresent(UniTemplateDO::getBgColorThreshold, reqVO.getBgColorThreshold())
.eqIfPresent(UniTemplateDO::getShowScanRecord, reqVO.getShowScanRecord())
.eqIfPresent(UniTemplateDO::getDefaultTemplate, reqVO.getDefaultTemplate())
.eqIfPresent(UniTemplateDO::getBelongBusinessId, reqVO.getBelongBusinessId())
.likeIfPresent(UniTemplateDO::getBelongBusinessName, reqVO.getBelongBusinessName())
.betweenIfPresent(UniTemplateDO::getCreateTime, reqVO.getCreateTime())
.eqIfPresent(UniTemplateDO::getFontColor, reqVO.getFontColor())
.eqIfPresent(UniTemplateDO::getScanFontColor, reqVO.getScanFontColor())
.orderByDesc(UniTemplateDO::getId));
}
} }

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.configure.dal.mysql.unitemplateitem;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplateitem.UniTemplateItemDO;
import org.apache.ibatis.annotations.Mapper;
/**
* Mapper
*
* @author
*/
@Mapper
public interface UniTemplateItemMapper extends BaseMapperX<UniTemplateItemDO> {
}

@ -0,0 +1,70 @@
package cn.iocoder.yudao.module.configure.service.materialgroup;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup.MaterialGroupDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface MaterialGroupService {
/**
*
*
* @param createReqVO
* @return
*/
Long createMaterialGroup(@Valid MaterialGroupCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateMaterialGroup(@Valid MaterialGroupUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteMaterialGroup(Long id);
/**
*
*
* @param id
* @return
*/
MaterialGroupDO getMaterialGroup(Long id);
/**
*
*
* @param ids
* @return
*/
List<MaterialGroupDO> getMaterialGroupListByids(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<MaterialGroupDO> getMaterialGroupPage(MaterialGroupPageReqVO pageReqVO);
/**
*
*
* @param pageReqVO
* @return
*/
List<MaterialGroupDO> getMaterialGroupList(MaterialGroupPageReqVO pageReqVO);
}

@ -0,0 +1,103 @@
package cn.iocoder.yudao.module.configure.service.materialgroup;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupPageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialgroup.vo.MaterialGroupUpdateReqVO;
import cn.iocoder.yudao.module.configure.convert.materialgroup.MaterialGroupConvert;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialgroup.MaterialGroupDO;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
import cn.iocoder.yudao.module.configure.dal.mysql.materialgroup.MaterialGroupMapper;
import cn.iocoder.yudao.module.configure.dal.mysql.materialmanagement.MaterialManagementMapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.MATERIAL_GROUP_EXISTS_RELATED;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.MATERIAL_GROUP_NOT_EXISTS;
/**
* Service
*
* @author
*/
@Service
@Validated
public class MaterialGroupServiceImpl implements MaterialGroupService {
@Resource
private MaterialGroupMapper materialGroupMapper;
@Resource
private MaterialManagementMapper materialManagementMapper;
@Override
public Long createMaterialGroup(MaterialGroupCreateReqVO createReqVO) {
// 插入
MaterialGroupDO materialGroup = MaterialGroupConvert.INSTANCE.convert(createReqVO);
materialGroupMapper.insert(materialGroup);
// 返回
return materialGroup.getId();
}
@Override
public void updateMaterialGroup(MaterialGroupUpdateReqVO updateReqVO) {
// 校验存在
validateMaterialGroupExists(updateReqVO.getId());
// 更新
MaterialGroupDO updateObj = MaterialGroupConvert.INSTANCE.convert(updateReqVO);
materialGroupMapper.updateById(updateObj);
}
@Override
public void deleteMaterialGroup(Long id) {
// 校验存在
validateMaterialGroupExists(id);
// 校验是否存在关联素材
if (
materialManagementMapper.exists(new LambdaQueryWrapperX<MaterialManagementDO>()
.eq(MaterialManagementDO::getGroupId, id)
.eq(MaterialManagementDO::getDeleted, 0)
)
) {
throw exception(MATERIAL_GROUP_EXISTS_RELATED);
}
// 删除
materialGroupMapper.update(null, new LambdaUpdateWrapper<MaterialGroupDO>()
.set(MaterialGroupDO::getDeleted, 1)
.eq(MaterialGroupDO::getId, id)
);
}
private void validateMaterialGroupExists(Long id) {
if (materialGroupMapper.selectById(id) == null) {
throw exception(MATERIAL_GROUP_NOT_EXISTS);
}
}
@Override
public MaterialGroupDO getMaterialGroup(Long id) {
return materialGroupMapper.selectById(id);
}
@Override
public List<MaterialGroupDO> getMaterialGroupListByids(Collection<Long> ids) {
return materialGroupMapper.selectBatchIds(ids);
}
@Override
public PageResult<MaterialGroupDO> getMaterialGroupPage(MaterialGroupPageReqVO pageReqVO) {
return materialGroupMapper.selectPage(pageReqVO);
}
@Override
public List<MaterialGroupDO> getMaterialGroupList(MaterialGroupPageReqVO pageReqVO) {
return materialGroupMapper.selectList(pageReqVO);
}
}

@ -0,0 +1,80 @@
package cn.iocoder.yudao.module.configure.service.materialmanagement;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementGroupUpdate;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementPageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementUpdateReqVO;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
import javax.validation.Valid;
import java.util.Collection;
import java.util.List;
/**
* Service
*
* @author
*/
public interface MaterialManagementService {
/**
*
*
* @param createReqVO
* @return
*/
Boolean createMaterialManagement(@Valid List<MaterialManagementCreateReqVO> createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateMaterialManagement(@Valid MaterialManagementUpdateReqVO updateReqVO);
/**
*
*
*/
void updateMaterialManagementGroupBatch(MaterialManagementGroupUpdate materialManagementGroupUpdate);
/**
*
*
* @param id
*/
void deleteMaterialManagement(Long id);
/**
*
*
* @param ids
*/
void deleteMaterialManagementBatch(List<Long> ids);
/**
*
*
* @param id
* @return
*/
MaterialManagementDO getMaterialManagement(Long id);
/**
*
*
* @param ids
* @return
*/
List<MaterialManagementDO> getMaterialManagementList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<MaterialManagementDO> getMaterialManagementPage(MaterialManagementPageReqVO pageReqVO);
}

@ -0,0 +1,109 @@
package cn.iocoder.yudao.module.configure.service.materialmanagement;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementGroupUpdate;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementPageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.materialmanagement.vo.MaterialManagementUpdateReqVO;
import cn.iocoder.yudao.module.configure.convert.materialmanagement.MaterialManagementConvert;
import cn.iocoder.yudao.module.configure.dal.dataobject.materialmanagement.MaterialManagementDO;
import cn.iocoder.yudao.module.configure.dal.mysql.materialmanagement.MaterialManagementMapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class MaterialManagementServiceImpl implements MaterialManagementService {
@Resource
private MaterialManagementMapper materialManagementMapper;
@Override
public Boolean createMaterialManagement(List<MaterialManagementCreateReqVO> createReqVO) {
// 插入
List<MaterialManagementDO> materialManagements = MaterialManagementConvert.INSTANCE.convertList02(createReqVO);
materialManagementMapper.insertBatch(materialManagements);
// 返回
return Boolean.TRUE;
}
@Override
public void updateMaterialManagement(MaterialManagementUpdateReqVO updateReqVO) {
// 校验存在
validateMaterialManagementExists(updateReqVO.getId());
// 更新
MaterialManagementDO updateObj = MaterialManagementConvert.INSTANCE.convert(updateReqVO);
materialManagementMapper.updateById(updateObj);
}
@Override
public void updateMaterialManagementGroupBatch(MaterialManagementGroupUpdate materialManagementGroupUpdate) {
if (materialManagementMapper.selectBatchIds(materialManagementGroupUpdate.getIds()).size() !=
materialManagementGroupUpdate.getIds().size()
) {
throw exception(MATERIAL_GROUP_NOT_EXISTS);
}
materialManagementMapper.update(null, new LambdaUpdateWrapper<MaterialManagementDO>()
.set(MaterialManagementDO::getGroupId, materialManagementGroupUpdate.getGroupId())
.in(MaterialManagementDO::getId, materialManagementGroupUpdate.getIds())
);
}
@Override
public void deleteMaterialManagement(Long id) {
// 校验存在
validateMaterialManagementExists(id);
// 删除
// materialManagementMapper.deleteById(id);
materialManagementMapper.update(null, new LambdaUpdateWrapper<MaterialManagementDO>()
.set(MaterialManagementDO::getDeleted, 1)
.eq(MaterialManagementDO::getId, id)
);
}
@Override
public void deleteMaterialManagementBatch(List<Long> ids) {
if (materialManagementMapper.selectBatchIds(ids).size() != ids.size()) {
throw exception(MATERIAL_GROUP_NOT_EXISTS);
}
materialManagementMapper.update(null, new LambdaUpdateWrapper<MaterialManagementDO>()
.set(MaterialManagementDO::getDeleted, 1)
.in(MaterialManagementDO::getId, ids)
);
}
private void validateMaterialManagementExists(Long id) {
if (materialManagementMapper.selectById(id) == null) {
throw exception(MATERIAL_MANAGEMENT_NOT_EXISTS);
}
}
@Override
public MaterialManagementDO getMaterialManagement(Long id) {
return materialManagementMapper.selectById(id);
}
@Override
public List<MaterialManagementDO> getMaterialManagementList(Collection<Long> ids) {
return materialManagementMapper.selectBatchIds(ids);
}
@Override
public PageResult<MaterialManagementDO> getMaterialManagementPage(MaterialManagementPageReqVO pageReqVO) {
return materialManagementMapper.selectPage(pageReqVO);
}
}

@ -1,10 +1,10 @@
package cn.iocoder.yudao.module.configure.service.unitemplate; package cn.iocoder.yudao.module.configure.service.unitemplate;
import java.util.*; import cn.iocoder.yudao.framework.common.pojo.PageResult;
import javax.validation.*;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*; import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO; import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import javax.validation.Valid;
/** /**
* Service * Service
@ -19,14 +19,14 @@ public interface UniTemplateService {
* @param createReqVO * @param createReqVO
* @return * @return
*/ */
Long createUniTemplate(@Valid UniTemplateCreateReqVO createReqVO); <T extends UniTemplateCreateReqVO> Long createUniTemplate(@Valid T createReqVO);
/** /**
* *
* *
* @param updateReqVO * @param updateReqVO
*/ */
void updateUniTemplate(@Valid UniTemplateUpdateReqVO updateReqVO); <T extends UniTemplateUpdateReqVO> void updateUniTemplate(@Valid T updateReqVO);
/** /**
* *
@ -41,7 +41,7 @@ public interface UniTemplateService {
* @param id * @param id
* @return * @return
*/ */
UniTemplateDO getUniTemplate(Long id); UniTemplateRespVO getUniTemplate(Long id);
/** /**
* *
@ -49,20 +49,8 @@ public interface UniTemplateService {
* @param pageReqVO * @param pageReqVO
* @return * @return
*/ */
PageResult<UniTemplateDO> getUniTemplatePage(UniTemplatePageReqVO pageReqVO); PageResult<UniTemplateRespVO> getUniTemplatePage(UniTemplatePageReqVO pageReqVO);
/** UniTemplateDO getDefaultUniTemplate();
* ID
* @param businessInfoId ID
* @return
*/
UniTemplateDO getDefaultTemplate(Long businessInfoId);
/**
* logo
*
* @param
* @return logo
*/
UniTemplatePhotoUrlVO getDefaultPhotoUrl();
} }

@ -1,28 +1,30 @@
package cn.iocoder.yudao.module.configure.service.unitemplate; package cn.iocoder.yudao.module.configure.service.unitemplate;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.enums.CodeEnum; import cn.iocoder.yudao.framework.common.enums.CodeEnum;
import cn.iocoder.yudao.framework.common.pojo.PageResult; import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateCreateReqVO; import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.*;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplatePageReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplatePhotoUrlVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateUpdateReqVO;
import cn.iocoder.yudao.module.configure.convert.unitemplate.UniTemplateConvert;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO; import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplateitem.UniTemplateItemDO;
import cn.iocoder.yudao.module.configure.dal.mysql.unitemplate.UniTemplateMapper; import cn.iocoder.yudao.module.configure.dal.mysql.unitemplate.UniTemplateMapper;
import cn.iocoder.yudao.module.configure.dal.mysql.unitemplateitem.UniTemplateItemMapper;
import cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants;
import cn.iocoder.yudao.module.configure.enums.UniTemplateTypeEnum;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.util.Collection; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception; import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.*;
/** /**
* Service * Service
@ -31,36 +33,53 @@ import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.*;
*/ */
@Service @Service
@Validated @Validated
@Transactional
public class UniTemplateServiceImpl implements UniTemplateService { public class UniTemplateServiceImpl implements UniTemplateService {
@Resource @Resource
private UniTemplateMapper uniTemplateMapper; private UniTemplateMapper uniTemplateMapper;
@Resource
private UniTemplateItemMapper uniTemplateItemMapper;
@Override @Override
public Long createUniTemplate(UniTemplateCreateReqVO createReqVO) { @Transactional
//校验是否存在相同的小程序模板名字 public <T extends UniTemplateCreateReqVO> Long createUniTemplate(T createReqVO) {
validateTemplateNameIsSameExists(createReqVO.getTemplateName(), (long) 0); UniTemplateDO uniTemplate = new UniTemplateDO();
//校验LOGO图是否为空 List<UniTemplateItemDO> itemList = new ArrayList<>();
if(createReqVO.getShowLogo() && createReqVO.getLogoPhotoUrl().isEmpty()){
throw exception(UNI_TEMPLATE_LOGO_URL_IS_EMPTY); BeanUtil.copyProperties(createReqVO, uniTemplate);
} // 校验重名
// 插入 this.validateSameName(null, uniTemplate.getTemplateName());
UniTemplateDO uniTemplate = UniTemplateConvert.INSTANCE.convert(createReqVO);
uniTemplate.setTemplateId(CodeEnum.UNI_TEMPLATE_CODE.getCode()); uniTemplate.setTemplateId(CodeEnum.UNI_TEMPLATE_CODE.getCode());
this.verifyIconAndSetIcon(uniTemplate);
if (createReqVO.getDefaultTemplate()) {
List<UniTemplateDO> uniTemplateDO = uniTemplateMapper.selectList(new LambdaQueryWrapperX<UniTemplateDO>().eq(UniTemplateDO::getBelongBusinessId, createReqVO.getBelongBusinessId()) if (createReqVO instanceof UniTemplateCreateCustomizeReqVO) {
.eq(UniTemplateDO::getDefaultTemplate, true)); // 该模板为自定义模板
if (!uniTemplateDO.isEmpty()) { uniTemplate.setTemplateType(UniTemplateTypeEnum.CUSTOMIZE.getType());
throw exception(DEFAULT_UNI_TEMPLATE_IS_EXISTS); // 转换为自定义类型的模板
UniTemplateCreateCustomizeReqVO customize = ((UniTemplateCreateCustomizeReqVO) createReqVO);
if (customize.getTemplateItemList() != null) {
customize.getTemplateItemList().forEach(item -> {
UniTemplateItemDO templateItem = new UniTemplateItemDO();
BeanUtil.copyProperties(item, templateItem);
templateItem.setTemplateId(uniTemplate.getTemplateId());
itemList.add(templateItem);
});
} }
} else {
uniTemplate.setTemplateType(UniTemplateTypeEnum.STANDARD.getType());
this.setDefaultForStandard(uniTemplate);
} }
try {
uniTemplateMapper.insert(uniTemplate); uniTemplateMapper.insert(uniTemplate);
} catch (Exception e) { if (uniTemplate.getDefaultTemplate()) {
throw exception(UNI_TEMPLATE_FAIL_CREATE); // 更新旧的默认模板为非默认
uniTemplateMapper.update(new UniTemplateDO().setDefaultTemplate(Boolean.FALSE),
new LambdaQueryWrapper<UniTemplateDO>().ne(UniTemplateDO::getId, uniTemplate.getId()));
}
if (itemList.isEmpty()) {
uniTemplateItemMapper.insertBatch(itemList);
} }
// 返回 // 返回
@ -68,99 +87,156 @@ public class UniTemplateServiceImpl implements UniTemplateService {
} }
@Override @Override
@Transactional(rollbackFor = Exception.class) //数据保持一致性 @Transactional
public void updateUniTemplate(UniTemplateUpdateReqVO updateReqVO) { public <T extends UniTemplateUpdateReqVO> void updateUniTemplate(T updateReqVO) {
//校验是否存在相同的小程序模板名字
validateTemplateNameIsSameExists(updateReqVO.getTemplateName(), updateReqVO.getId());
//校验LOGO图是否为空
if(updateReqVO.getShowLogo() && updateReqVO.getLogoPhotoUrl().isEmpty()){
throw exception(UNI_TEMPLATE_LOGO_URL_IS_EMPTY);
}
//设置模板为非默认模板时,校验该默认模板是否为默认模板
if(!updateReqVO.getDefaultTemplate() && uniTemplateMapper.selectOne(UniTemplateDO::getId,updateReqVO.getId()).getDefaultTemplate()){
throw exception(DEFAULT_UNI_TEMPLATE_MUST_EXISTS);
}
// 校验存在 // 校验存在
validateUniTemplateExists(updateReqVO.getId()); UniTemplateDO templateDO = this.validateUniTemplateExists(updateReqVO.getId());
// 更新 // 获取原本存在的环节信息
UniTemplateDO updateObj = UniTemplateConvert.INSTANCE.convert(updateReqVO); List<UniTemplateItemDO> itemDBList = uniTemplateItemMapper.selectList(new LambdaQueryWrapper<UniTemplateItemDO>()
.eq(UniTemplateItemDO::getTemplateId, templateDO.getTemplateId()));
try { // 校验重名
if (updateReqVO.getDefaultTemplate()) { this.validateSameName(updateReqVO.getId(), updateReqVO.getTemplateName());
List<UniTemplateDO> uniTemplateDOS = uniTemplateMapper.selectList(new LambdaQueryWrapperX<UniTemplateDO>() UniTemplateDO update = new UniTemplateDO();
.eq(UniTemplateDO::getBelongBusinessId, updateObj.getBelongBusinessId()) List<UniTemplateItemDO> createItemList = new ArrayList<>();
.ne(UniTemplateDO::getId, updateObj.getId())); List<UniTemplateItemDO> updateItemList = new ArrayList<>();
if (!uniTemplateDOS.isEmpty()) { List<Long> deleteItemIds = new ArrayList<>();
uniTemplateDOS.forEach(uniTemplateDO -> {
uniTemplateDO.setDefaultTemplate(false); BeanUtil.copyProperties(updateReqVO, update);
this.verifyIconAndSetIcon(update);
if (updateReqVO instanceof UniTemplateUpdateCustomizeReqVO) {
// 该模板为自定义模板
update.setTemplateType(UniTemplateTypeEnum.CUSTOMIZE.getType());
// 转换为自定义类型的模板
UniTemplateUpdateCustomizeReqVO customize = ((UniTemplateUpdateCustomizeReqVO) updateReqVO);
List<Long> DBIds = itemDBList.stream().map(UniTemplateItemDO::getId).collect(Collectors.toList());
if (customize.getTemplateItemList() != null) {
List<Long> reqIds = new ArrayList<>();
customize.getTemplateItemList().forEach(item -> {
UniTemplateItemDO templateItem = new UniTemplateItemDO();
BeanUtil.copyProperties(item, templateItem);
if (templateItem.getId() == null) {
templateItem.setTemplateId(templateDO.getTemplateId());
createItemList.add(templateItem);
} else {
if (!DBIds.contains(item.getId())) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_ITEM_NOT_EXISTS);
}
updateItemList.add(templateItem);
reqIds.add(item.getId());
}
}); });
uniTemplateMapper.updateBatch(uniTemplateDOS, Integer.MAX_VALUE);
deleteItemIds.addAll(CollUtil.subtract(DBIds, reqIds));
}
} else {
update.setTemplateType(UniTemplateTypeEnum.STANDARD.getType());
this.setDefaultForStandard(update);
if (!itemDBList.isEmpty()) {
deleteItemIds.addAll(itemDBList.stream().map(UniTemplateItemDO::getId).collect(Collectors.toList()));
} }
} }
uniTemplateMapper.updateById(updateObj);
} catch (Exception e) { uniTemplateMapper.updateById(update);
// 数据库回滚操作 if (update.getDefaultTemplate()) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); // 更新旧的默认模板为非默认
e.printStackTrace(); uniTemplateMapper.update(new UniTemplateDO().setDefaultTemplate(Boolean.FALSE),
throw exception(UNI_TEMPLATE_FAIL_UPDATE); new LambdaQueryWrapper<UniTemplateDO>().ne(UniTemplateDO::getId, update.getId()));
}
if (!createItemList.isEmpty()) {
uniTemplateItemMapper.insertBatch(createItemList);
} }
if (!updateItemList.isEmpty()) {
uniTemplateItemMapper.updateBatch(updateItemList, updateItemList.size());
}
if (!deleteItemIds.isEmpty()) {
uniTemplateMapper.deleteBatchIds(deleteItemIds);
}
}
private void verifyIconAndSetIcon(UniTemplateDO templateDO) {
if (templateDO.getShowScanRecord() && StringUtils.isBlank(templateDO.getScanRecordIconUrl())) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_SCAN_RECORD_ICON_NOT_BE_NULL);
} else if (!templateDO.getShowScanRecord()) {
templateDO.setScanRecordIconUrl("");
}
if (templateDO.getTemplateType().equals(UniTemplateTypeEnum.CUSTOMIZE.getType())) {
if (templateDO.getShowGoodsDetail() && StringUtils.isBlank(templateDO.getGoodsDetailIconUrl())) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_GOODS_DETAIL_ICON_NOT_BE_NULL);
} else if (!templateDO.getShowGoodsDetail()) {
templateDO.setGoodsDetailIconUrl("");
}
if (templateDO.getShowAi() && StringUtils.isBlank(templateDO.getAiIconUrl())) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_AI_ICON_NOT_BE_NULL);
} else if (!templateDO.getShowAi()) {
templateDO.setAiIconUrl("");
}
if (templateDO.getShowShop() && StringUtils.isBlank(templateDO.getShopIconUrl())) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_SHOP_ICON_NOT_BE_NULL);
} else if (!templateDO.getShowShop()) {
templateDO.setShopIconUrl("");
}
}
}
private void setDefaultForStandard(UniTemplateDO templateDO) {
templateDO.setShowGoodsDetail(Boolean.TRUE);
templateDO.setGoodsDetailIconUrl("");
templateDO.setShowAi(Boolean.TRUE);
templateDO.setAiIconUrl("");
templateDO.setShowShop(Boolean.TRUE);
templateDO.setShopIconUrl("");
} }
@Override @Override
public void deleteUniTemplate(Long id) { public void deleteUniTemplate(Long id) {
// 校验存在 // 校验存在
validateUniTemplateExists(id); this.validateUniTemplateExists(id);
if (uniTemplateMapper.selectById(id).getDefaultTemplate()) {
throw exception(DEFAULT_UNI_TEMPLATE_DISABLE_DEL);
}
// 删除 // 删除
uniTemplateMapper.deleteById(id); uniTemplateMapper.deleteById(id);
} }
private void validateUniTemplateExists(Long id) { private UniTemplateDO validateUniTemplateExists(Long id) {
if (uniTemplateMapper.selectById(id) == null) { UniTemplateDO templateDO = uniTemplateMapper.selectById(id);
throw exception(UNI_TEMPLATE_NOT_EXISTS); if (templateDO == null) {
throw exception(ErrorCodeConstants.UNI_TEMPLATE_NOT_EXISTS);
} }
return templateDO;
} }
private void validateTemplateNameIsSameExists(String templateName, Long id) { private void validateSameName(Long id, String name) {
if (uniTemplateMapper.selectOne(new LambdaQueryWrapperX<UniTemplateDO>() UniTemplateDO templateDO = uniTemplateMapper.selectOne(new LambdaQueryWrapperX<UniTemplateDO>()
.eq(UniTemplateDO::getTemplateName, templateName) .eq(UniTemplateDO::getTemplateName, name).neIfPresent(UniTemplateDO::getId, id));
.ne(UniTemplateDO::getId, id)) != null) { if (templateDO != null) {
throw exception(UNI_TEMPLATE_NAME_IS_SAME_EXISTS); throw exception(ErrorCodeConstants.UNI_TEMPLATE_NAME_IS_SAME_EXISTS);
}
} }
@Override
public UniTemplateDO getUniTemplate(Long id) {
return uniTemplateMapper.selectById(id);
} }
@Override @Override
public PageResult<UniTemplateDO> getUniTemplatePage(UniTemplatePageReqVO pageReqVO) { public UniTemplateRespVO getUniTemplate(Long id) {
return uniTemplateMapper.selectPage(pageReqVO); return uniTemplateMapper.getUniTemplateDetail(id);
} }
@Override @Override
public UniTemplateDO getDefaultTemplate(Long businessInfoId) { public PageResult<UniTemplateRespVO> getUniTemplatePage(UniTemplatePageReqVO pageReqVO) {
return uniTemplateMapper.selectOne(new LambdaQueryWrapperX<UniTemplateDO>().eq(UniTemplateDO::getBelongBusinessId, businessInfoId) Page<UniTemplateRespVO> page = new Page<>(pageReqVO.getPageNo(), pageReqVO.getPageSize());
.eq(UniTemplateDO::getDefaultTemplate, Boolean.TRUE)); List<UniTemplateRespVO> result = uniTemplateMapper.selectUniTemplatePage(page, pageReqVO);
return new PageResult<>(result, page.getTotal());
} }
/**
* logo
*
* @return
*/
@Override @Override
public UniTemplatePhotoUrlVO getDefaultPhotoUrl() { public UniTemplateDO getDefaultUniTemplate() {
String bgPhotoUrl = "https://zft-agriculture.oss-cn-hangzhou.aliyuncs.com/2023/05/17/2bdcb2d1f4889b40bfc192175964fb781f2cf668a7d43d2ec3dcd5d9e2788d78.jpg"; return uniTemplateMapper.selectOne(new LambdaQueryWrapperX<UniTemplateDO>().eq(UniTemplateDO::getDefaultTemplate, Boolean.TRUE));
String logoPhotoUrl = "https://zft-agriculture.oss-cn-hangzhou.aliyuncs.com/2023/05/17/2b5b0ac2ec8b272746c79c86f7c7f9ee09f5da2ede87e5938358d35b4162fd99.jpg";
UniTemplatePhotoUrlVO uniTemplateDO = new UniTemplatePhotoUrlVO();
uniTemplateDO.setBgPhotoUrl(bgPhotoUrl);
uniTemplateDO.setLogoPhotoUrl(logoPhotoUrl);
return uniTemplateDO;
} }
} }

@ -0,0 +1,10 @@
package cn.iocoder.yudao.module.configure.service.unitemplateitem;
/**
* Service
*
* @author
*/
public interface UniTemplateItemService {
}

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.configure.service.unitemplateitem;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* Service
*
* @author
*/
@Service
@Validated
public class UniTemplateItemServiceImpl implements UniTemplateItemService {
}

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.configure.dal.mysql.materialgroup.MaterialGroupMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.configure.dal.mysql.materialmanagement.MaterialManagementMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -9,4 +9,19 @@
文档可见https://www.iocoder.cn/MyBatis/x-plugins/ 文档可见https://www.iocoder.cn/MyBatis/x-plugins/
--> -->
<resultMap id="uniTemplateDetailMap" type="cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO">
<collection property="templateItemList" column="template_id=template_id" select="getItemList"></collection>
</resultMap>
<select id="getUniTemplateDetail" resultMap="uniTemplateDetailMap">
select * from configure_uni_template where id = #{id}
</select>
<select id="getItemList" resultType="cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.UniTemplateItemRespVO">
select * from configure_uni_template_item where template_id = #{template_id}
</select>
<select id="selectUniTemplatePage" resultMap="uniTemplateDetailMap">
select * from configure_uni_template order by id desc
</select>
</mapper> </mapper>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.configure.dal.mysql.unitemplateitem.UniTemplateItemMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,98 @@
package cn.iocoder.yudao.module.configure.service.unitemplate;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateUpdateReqVO;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import cn.iocoder.yudao.module.configure.dal.mysql.unitemplate.UniTemplateMapper;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Import;
import javax.annotation.Resource;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertPojoEquals;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomLongId;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.UNI_TEMPLATE_NOT_EXISTS;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
/**
* {@link UniTemplateServiceImpl}
*
* @author
*/
@Import(UniTemplateServiceImpl.class)
public class UniTemplateServiceImplTest extends BaseDbUnitTest {
@Resource
private UniTemplateServiceImpl uniTemplateService;
@Resource
private UniTemplateMapper uniTemplateMapper;
@Test
public void testCreateUniTemplate_success() {
// 准备参数
UniTemplateCreateReqVO reqVO = randomPojo(UniTemplateCreateReqVO.class);
// 调用
Long uniTemplateId = uniTemplateService.createUniTemplate(reqVO);
// 断言
assertNotNull(uniTemplateId);
// 校验记录的属性是否正确
UniTemplateDO uniTemplate = uniTemplateMapper.selectById(uniTemplateId);
assertPojoEquals(reqVO, uniTemplate);
}
@Test
public void testUpdateUniTemplate_success() {
// mock 数据
UniTemplateDO dbUniTemplate = randomPojo(UniTemplateDO.class);
uniTemplateMapper.insert(dbUniTemplate);// @Sql: 先插入出一条存在的数据
// 准备参数
UniTemplateUpdateReqVO reqVO = randomPojo(UniTemplateUpdateReqVO.class, o -> {
o.setId(dbUniTemplate.getId()); // 设置更新的 ID
});
// 调用
uniTemplateService.updateUniTemplate(reqVO);
// 校验是否更新正确
UniTemplateDO uniTemplate = uniTemplateMapper.selectById(reqVO.getId()); // 获取最新的
assertPojoEquals(reqVO, uniTemplate);
}
@Test
public void testUpdateUniTemplate_notExists() {
// 准备参数
UniTemplateUpdateReqVO reqVO = randomPojo(UniTemplateUpdateReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> uniTemplateService.updateUniTemplate(reqVO), UNI_TEMPLATE_NOT_EXISTS);
}
@Test
public void testDeleteUniTemplate_success() {
// mock 数据
UniTemplateDO dbUniTemplate = randomPojo(UniTemplateDO.class);
uniTemplateMapper.insert(dbUniTemplate);// @Sql: 先插入出一条存在的数据
// 准备参数
Long id = dbUniTemplate.getId();
// 调用
uniTemplateService.deleteUniTemplate(id);
// 校验数据不存在了
assertNull(uniTemplateMapper.selectById(id));
}
@Test
public void testDeleteUniTemplate_notExists() {
// 准备参数
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> uniTemplateService.deleteUniTemplate(id), UNI_TEMPLATE_NOT_EXISTS);
}
}

@ -0,0 +1,206 @@
package cn.iocoder.yudao.module.configure.service.unitemplateitem;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import javax.annotation.Resource;
import cn.iocoder.yudao.framework.test.core.ut.BaseDbUnitTest;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.*;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplateitem.UniTemplateItemDO;
import cn.iocoder.yudao.module.configure.dal.mysql.unitemplateitem.UniTemplateItemMapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import javax.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static cn.iocoder.yudao.module.configure.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.*;
import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.*;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.*;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link UniTemplateItemServiceImpl}
*
* @author
*/
@Import(UniTemplateItemServiceImpl.class)
public class UniTemplateItemServiceImplTest extends BaseDbUnitTest {
@Resource
private UniTemplateItemServiceImpl uniTemplateItemService;
@Resource
private UniTemplateItemMapper uniTemplateItemMapper;
@Test
public void testCreateUniTemplateItem_success() {
// 准备参数
UniTemplateItemCreateReqVO reqVO = randomPojo(UniTemplateItemCreateReqVO.class);
// 调用
Long uniTemplateItemId = uniTemplateItemService.createUniTemplateItem(reqVO);
// 断言
assertNotNull(uniTemplateItemId);
// 校验记录的属性是否正确
UniTemplateItemDO uniTemplateItem = uniTemplateItemMapper.selectById(uniTemplateItemId);
assertPojoEquals(reqVO, uniTemplateItem);
}
@Test
public void testUpdateUniTemplateItem_success() {
// mock 数据
UniTemplateItemDO dbUniTemplateItem = randomPojo(UniTemplateItemDO.class);
uniTemplateItemMapper.insert(dbUniTemplateItem);// @Sql: 先插入出一条存在的数据
// 准备参数
UniTemplateItemUpdateReqVO reqVO = randomPojo(UniTemplateItemUpdateReqVO.class, o -> {
o.setId(dbUniTemplateItem.getId()); // 设置更新的 ID
});
// 调用
uniTemplateItemService.updateUniTemplateItem(reqVO);
// 校验是否更新正确
UniTemplateItemDO uniTemplateItem = uniTemplateItemMapper.selectById(reqVO.getId()); // 获取最新的
assertPojoEquals(reqVO, uniTemplateItem);
}
@Test
public void testUpdateUniTemplateItem_notExists() {
// 准备参数
UniTemplateItemUpdateReqVO reqVO = randomPojo(UniTemplateItemUpdateReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> uniTemplateItemService.updateUniTemplateItem(reqVO), UNI_TEMPLATE_ITEM_NOT_EXISTS);
}
@Test
public void testDeleteUniTemplateItem_success() {
// mock 数据
UniTemplateItemDO dbUniTemplateItem = randomPojo(UniTemplateItemDO.class);
uniTemplateItemMapper.insert(dbUniTemplateItem);// @Sql: 先插入出一条存在的数据
// 准备参数
Long id = dbUniTemplateItem.getId();
// 调用
uniTemplateItemService.deleteUniTemplateItem(id);
// 校验数据不存在了
assertNull(uniTemplateItemMapper.selectById(id));
}
@Test
public void testDeleteUniTemplateItem_notExists() {
// 准备参数
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> uniTemplateItemService.deleteUniTemplateItem(id), UNI_TEMPLATE_ITEM_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetUniTemplateItemPage() {
// mock 数据
UniTemplateItemDO dbUniTemplateItem = randomPojo(UniTemplateItemDO.class, o -> { // 等会查询到
o.setTemplateId(null);
o.setIconUrl(null);
o.setPosition(null);
o.setWidth(null);
o.setHeight(null);
o.setBelongBusinessId(null);
o.setBelongBusinessName(null);
o.setCreateTime(null);
});
uniTemplateItemMapper.insert(dbUniTemplateItem);
// 测试 templateId 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setTemplateId(null)));
// 测试 iconUrl 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setIconUrl(null)));
// 测试 position 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setPosition(null)));
// 测试 width 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setWidth(null)));
// 测试 height 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setHeight(null)));
// 测试 belongBusinessId 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setBelongBusinessId(null)));
// 测试 belongBusinessName 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setBelongBusinessName(null)));
// 测试 createTime 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setCreateTime(null)));
// 准备参数
UniTemplateItemPageReqVO reqVO = new UniTemplateItemPageReqVO();
reqVO.setTemplateId(null);
reqVO.setIconUrl(null);
reqVO.setPosition(null);
reqVO.setWidth(null);
reqVO.setHeight(null);
reqVO.setBelongBusinessId(null);
reqVO.setBelongBusinessName(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
PageResult<UniTemplateItemDO> pageResult = uniTemplateItemService.getUniTemplateItemPage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbUniTemplateItem, pageResult.getList().get(0));
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetUniTemplateItemList() {
// mock 数据
UniTemplateItemDO dbUniTemplateItem = randomPojo(UniTemplateItemDO.class, o -> { // 等会查询到
o.setTemplateId(null);
o.setIconUrl(null);
o.setPosition(null);
o.setWidth(null);
o.setHeight(null);
o.setBelongBusinessId(null);
o.setBelongBusinessName(null);
o.setCreateTime(null);
});
uniTemplateItemMapper.insert(dbUniTemplateItem);
// 测试 templateId 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setTemplateId(null)));
// 测试 iconUrl 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setIconUrl(null)));
// 测试 position 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setPosition(null)));
// 测试 width 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setWidth(null)));
// 测试 height 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setHeight(null)));
// 测试 belongBusinessId 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setBelongBusinessId(null)));
// 测试 belongBusinessName 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setBelongBusinessName(null)));
// 测试 createTime 不匹配
uniTemplateItemMapper.insert(cloneIgnoreId(dbUniTemplateItem, o -> o.setCreateTime(null)));
// 准备参数
UniTemplateItemExportReqVO reqVO = new UniTemplateItemExportReqVO();
reqVO.setTemplateId(null);
reqVO.setIconUrl(null);
reqVO.setPosition(null);
reqVO.setWidth(null);
reqVO.setHeight(null);
reqVO.setBelongBusinessId(null);
reqVO.setBelongBusinessName(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
List<UniTemplateItemDO> list = uniTemplateItemService.getUniTemplateItemList(reqVO);
// 断言
assertEquals(1, list.size());
assertPojoEquals(dbUniTemplateItem, list.get(0));
}
}

@ -9,4 +9,19 @@
文档可见https://www.iocoder.cn/MyBatis/x-plugins/ 文档可见https://www.iocoder.cn/MyBatis/x-plugins/
--> -->
<resultMap id="uniTemplateDetailMap" type="cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO">
<collection property="templateItemList" column="template_id=template_id" select="getItemList"></collection>
</resultMap>
<select id="getUniTemplateDetail" resultMap="uniTemplateDetailMap">
select * from configure_uni_template where id = #{id}
</select>
<select id="getItemList" resultType="cn.iocoder.yudao.module.configure.controller.admin.unitemplateitem.vo.UniTemplateItemRespVO">
select * from configure_uni_template_item where template_id = #{template_id}
</select>
<select id="selectUniTemplatePage" resultMap="uniTemplateDetailMap">
select * from configure_uni_template order by id desc
</select>
</mapper> </mapper>

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class DeviceEnvTypeConvertImpl implements DeviceEnvTypeConvert { public class DeviceEnvTypeConvertImpl implements DeviceEnvTypeConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:09+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InspectionItemConvertImpl implements InspectionItemConvert { public class InspectionItemConvertImpl implements InspectionItemConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InspectionTemplateConvertImpl implements InspectionTemplateConvert { public class InspectionTemplateConvertImpl implements InspectionTemplateConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class TraceCertConvertImpl implements TraceCertConvert { public class TraceCertConvertImpl implements TraceCertConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:09+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class TraceLinkConvertImpl implements TraceLinkConvert { public class TraceLinkConvertImpl implements TraceLinkConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class TraceLinkItemConvertImpl implements TraceLinkItemConvert { public class TraceLinkItemConvertImpl implements TraceLinkItemConvert {

@ -16,7 +16,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class TraceTemplateConvertImpl implements TraceTemplateConvert { public class TraceTemplateConvertImpl implements TraceTemplateConvert {

@ -1,9 +1,7 @@
package cn.iocoder.yudao.module.configure.convert.unitemplate; package cn.iocoder.yudao.module.configure.convert.unitemplate;
import cn.iocoder.yudao.framework.common.pojo.PageResult; import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateCreateReqVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO; import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateRespVO;
import cn.iocoder.yudao.module.configure.controller.admin.unitemplate.vo.UniTemplateUpdateReqVO;
import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO; import cn.iocoder.yudao.module.configure.dal.dataobject.unitemplate.UniTemplateDO;
import java.time.ZoneOffset; import java.time.ZoneOffset;
import java.util.ArrayList; import java.util.ArrayList;
@ -13,103 +11,11 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-07-12T09:16:08+0800", date = "2024-12-20T10:37:04+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class UniTemplateConvertImpl implements UniTemplateConvert { public class UniTemplateConvertImpl implements UniTemplateConvert {
@Override
public UniTemplateDO convert(UniTemplateCreateReqVO bean) {
if ( bean == null ) {
return null;
}
UniTemplateDO.UniTemplateDOBuilder uniTemplateDO = UniTemplateDO.builder();
uniTemplateDO.templateId( bean.getTemplateId() );
uniTemplateDO.templateName( bean.getTemplateName() );
uniTemplateDO.bgPhotoUrl( bean.getBgPhotoUrl() );
uniTemplateDO.logoPhotoUrl( bean.getLogoPhotoUrl() );
uniTemplateDO.showLogo( bean.getShowLogo() );
uniTemplateDO.showFlow( bean.getShowFlow() );
uniTemplateDO.verifyHint( bean.getVerifyHint() );
uniTemplateDO.scanMostNum( bean.getScanMostNum() );
uniTemplateDO.bgColor( bean.getBgColor() );
uniTemplateDO.bgColorThreshold( bean.getBgColorThreshold() );
uniTemplateDO.showScanRecord( bean.getShowScanRecord() );
uniTemplateDO.onlyShowJob( bean.getOnlyShowJob() );
uniTemplateDO.defaultTemplate( bean.getDefaultTemplate() );
uniTemplateDO.belongBusinessId( bean.getBelongBusinessId() );
uniTemplateDO.belongBusinessName( bean.getBelongBusinessName() );
uniTemplateDO.fontColor( bean.getFontColor() );
uniTemplateDO.scanFontColor( bean.getScanFontColor() );
return uniTemplateDO.build();
}
@Override
public UniTemplateDO convert(UniTemplateUpdateReqVO bean) {
if ( bean == null ) {
return null;
}
UniTemplateDO.UniTemplateDOBuilder uniTemplateDO = UniTemplateDO.builder();
uniTemplateDO.id( bean.getId() );
uniTemplateDO.templateId( bean.getTemplateId() );
uniTemplateDO.templateName( bean.getTemplateName() );
uniTemplateDO.bgPhotoUrl( bean.getBgPhotoUrl() );
uniTemplateDO.logoPhotoUrl( bean.getLogoPhotoUrl() );
uniTemplateDO.showLogo( bean.getShowLogo() );
uniTemplateDO.showFlow( bean.getShowFlow() );
uniTemplateDO.verifyHint( bean.getVerifyHint() );
uniTemplateDO.scanMostNum( bean.getScanMostNum() );
uniTemplateDO.bgColor( bean.getBgColor() );
uniTemplateDO.bgColorThreshold( bean.getBgColorThreshold() );
uniTemplateDO.showScanRecord( bean.getShowScanRecord() );
uniTemplateDO.onlyShowJob( bean.getOnlyShowJob() );
uniTemplateDO.defaultTemplate( bean.getDefaultTemplate() );
uniTemplateDO.belongBusinessId( bean.getBelongBusinessId() );
uniTemplateDO.belongBusinessName( bean.getBelongBusinessName() );
uniTemplateDO.fontColor( bean.getFontColor() );
uniTemplateDO.scanFontColor( bean.getScanFontColor() );
return uniTemplateDO.build();
}
@Override
public UniTemplateRespVO convert(UniTemplateDO bean) {
if ( bean == null ) {
return null;
}
UniTemplateRespVO uniTemplateRespVO = new UniTemplateRespVO();
uniTemplateRespVO.setTemplateId( bean.getTemplateId() );
uniTemplateRespVO.setTemplateName( bean.getTemplateName() );
uniTemplateRespVO.setBgPhotoUrl( bean.getBgPhotoUrl() );
uniTemplateRespVO.setLogoPhotoUrl( bean.getLogoPhotoUrl() );
uniTemplateRespVO.setShowLogo( bean.getShowLogo() );
uniTemplateRespVO.setShowFlow( bean.getShowFlow() );
uniTemplateRespVO.setVerifyHint( bean.getVerifyHint() );
uniTemplateRespVO.setScanMostNum( bean.getScanMostNum() );
uniTemplateRespVO.setBgColor( bean.getBgColor() );
uniTemplateRespVO.setBgColorThreshold( bean.getBgColorThreshold() );
uniTemplateRespVO.setShowScanRecord( bean.getShowScanRecord() );
uniTemplateRespVO.setOnlyShowJob( bean.getOnlyShowJob() );
uniTemplateRespVO.setDefaultTemplate( bean.getDefaultTemplate() );
uniTemplateRespVO.setBelongBusinessId( bean.getBelongBusinessId() );
uniTemplateRespVO.setBelongBusinessName( bean.getBelongBusinessName() );
uniTemplateRespVO.setFontColor( bean.getFontColor() );
uniTemplateRespVO.setScanFontColor( bean.getScanFontColor() );
uniTemplateRespVO.setId( bean.getId() );
if ( bean.getCreateTime() != null ) {
uniTemplateRespVO.setCreateTime( Date.from( bean.getCreateTime().toInstant( ZoneOffset.UTC ) ) );
}
return uniTemplateRespVO;
}
@Override @Override
public List<UniTemplateRespVO> convertList(List<UniTemplateDO> list) { public List<UniTemplateRespVO> convertList(List<UniTemplateDO> list) {
if ( list == null ) { if ( list == null ) {
@ -118,7 +24,7 @@ public class UniTemplateConvertImpl implements UniTemplateConvert {
List<UniTemplateRespVO> list1 = new ArrayList<UniTemplateRespVO>( list.size() ); List<UniTemplateRespVO> list1 = new ArrayList<UniTemplateRespVO>( list.size() );
for ( UniTemplateDO uniTemplateDO : list ) { for ( UniTemplateDO uniTemplateDO : list ) {
list1.add( convert( uniTemplateDO ) ); list1.add( uniTemplateDOToUniTemplateRespVO( uniTemplateDO ) );
} }
return list1; return list1;
@ -137,4 +43,33 @@ public class UniTemplateConvertImpl implements UniTemplateConvert {
return pageResult; return pageResult;
} }
protected UniTemplateRespVO uniTemplateDOToUniTemplateRespVO(UniTemplateDO uniTemplateDO) {
if ( uniTemplateDO == null ) {
return null;
}
UniTemplateRespVO uniTemplateRespVO = new UniTemplateRespVO();
uniTemplateRespVO.setTemplateName( uniTemplateDO.getTemplateName() );
uniTemplateRespVO.setTemplateType( uniTemplateDO.getTemplateType() );
uniTemplateRespVO.setBgUrl( uniTemplateDO.getBgUrl() );
uniTemplateRespVO.setFontColor( uniTemplateDO.getFontColor() );
uniTemplateRespVO.setDefaultTemplate( uniTemplateDO.getDefaultTemplate() );
uniTemplateRespVO.setShowPop( uniTemplateDO.getShowPop() );
uniTemplateRespVO.setShowScanRecord( uniTemplateDO.getShowScanRecord() );
uniTemplateRespVO.setScanRecordIconUrl( uniTemplateDO.getScanRecordIconUrl() );
uniTemplateRespVO.setId( uniTemplateDO.getId() );
uniTemplateRespVO.setShowGoodsDetail( uniTemplateDO.getShowGoodsDetail() );
uniTemplateRespVO.setGoodsDetailIconUrl( uniTemplateDO.getGoodsDetailIconUrl() );
uniTemplateRespVO.setShowAi( uniTemplateDO.getShowAi() );
uniTemplateRespVO.setAiIconUrl( uniTemplateDO.getAiIconUrl() );
uniTemplateRespVO.setShowShop( uniTemplateDO.getShowShop() );
uniTemplateRespVO.setShopIconUrl( uniTemplateDO.getShopIconUrl() );
if ( uniTemplateDO.getCreateTime() != null ) {
uniTemplateRespVO.setCreateTime( Date.from( uniTemplateDO.getCreateTime().toInstant( ZoneOffset.UTC ) ) );
}
return uniTemplateRespVO;
}
} }

@ -9,4 +9,14 @@
文档可见https://www.iocoder.cn/MyBatis/x-plugins/ 文档可见https://www.iocoder.cn/MyBatis/x-plugins/
--> -->
<select id="getListByBatchIds" resultType="cn.iocoder.yudao.module.identity.dal.dataobject.code.CodeDO">
SELECT ic.*
FROM identity_code ic
LEFT JOIN identity_generate_record igr ON igr.generate_record_id = ic.generate_record_id
WHERE igr.deleted = 0 AND ic.deleted = 0 AND ic.batch_id IN
<foreach collection="batchIdList" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</select>
</mapper> </mapper>

@ -9,4 +9,23 @@
文档可见https://www.iocoder.cn/MyBatis/x-plugins/ 文档可见https://www.iocoder.cn/MyBatis/x-plugins/
--> -->
<select id="getPageList" resultType="cn.iocoder.yudao.module.identity.controller.admin.generaterecord.vo.GenerateRecordRespVO">
SELECT
igr.*, igb.batch_id, phb.goods_name
FROM identity_generate_record igr
LEFT JOIN identity_generate_batch igb ON igr.generate_record_id = igb.generate_record_id
LEFT JOIN product_harvest_batch phb ON phb.harvest_batch_id = igb.batch_id
<where>
igr.deleted = 0
<if test="pageReqVO.generateRecordId != null">and igr.generate_record_id = #{pageReqVO.generateRecordId}</if>
<if test="pageReqVO.codeRuleFormat != null and pageReqVO.codeRuleFormat != ''">and igr.code_rule_format like concat('%',#{pageReqVO.codeRuleFormat},'%') ESCAPE '/'</if>
<if test="pageReqVO.belongBusinessName != null and pageReqVO.belongBusinessName != ''">and igr.belong_business_name like concat('%',#{pageReqVO.belongBusinessName},'%') ESCAPE '/'</if>
<if test="pageReqVO.createTime != null and pageReqVO.createTime.size() == 2">
and igr.belong_business_name BETWEEN #{pageReqVO.createTime[0]} AND #{pageReqVO.createTime[1]}
</if>
<if test="pageReqVO.batchId != null and pageReqVO.batchId != ''">and igb.batch_id = #{pageReqVO.batchId}</if>
</where>
order by igr.create_time desc
</select>
</mapper> </mapper>

@ -103,7 +103,7 @@ public interface ErrorCodeConstants {
ErrorCode BLOCK_STATE_IS_FREEZE = new ErrorCode(1013007010, "采收批次已冻结"); ErrorCode BLOCK_STATE_IS_FREEZE = new ErrorCode(1013007010, "采收批次已冻结");
ErrorCode FARMING_CONFIG_HAS_ON_CHAIN = new ErrorCode(1013007011, "该农事活动配置已上链"); ErrorCode FARMING_CONFIG_HAS_ON_CHAIN = new ErrorCode(1013007011, "该农事活动配置已上链");
// ErrorCode CAN_NOT_CREATE_WHEN_FARMING_CONFIG_HAS_ON_CHAIN = new ErrorCode(1013007011, "该农事活动配置已上链,无法进行新增操作"); // ErrorCode CAN_NOT_CREATE_WHEN_FARMING_CONFIG_HAS_ON_CHAIN = new ErrorCode(1013007011, "该农事活动配置已上链,无法进行新增操作");
ErrorCode CAN_NOT_FIND_DEFAULT_UNI_TEMPLATE = new ErrorCode(1013007012, "该商户未配置默认小程序模板"); ErrorCode CAN_NOT_FIND_DEFAULT_UNI_TEMPLATE = new ErrorCode(1013007012, "未配置默认小程序模板");
ErrorCode JOB_OPERATE_TYPE_CAN_NOT_BE_NULL = new ErrorCode(1013007013, "农事作业操作类型不能为空"); ErrorCode JOB_OPERATE_TYPE_CAN_NOT_BE_NULL = new ErrorCode(1013007013, "农事作业操作类型不能为空");
ErrorCode CONFIG_IS_NOT_EXISTS = new ErrorCode(1013007014, "配置信息不存在"); ErrorCode CONFIG_IS_NOT_EXISTS = new ErrorCode(1013007014, "配置信息不存在");
ErrorCode INSPECTION_ITEM_OPERATE_TYPE_CAN_NOT_BE_NULL = new ErrorCode(1013007015, "检测项目操作类型不能为空"); ErrorCode INSPECTION_ITEM_OPERATE_TYPE_CAN_NOT_BE_NULL = new ErrorCode(1013007015, "检测项目操作类型不能为空");

@ -62,8 +62,7 @@ public class HarvestBatchController {
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class) @ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('product:harvest-batch:query')") @PreAuthorize("@ss.hasPermission('product:harvest-batch:query')")
public CommonResult<HarvestBatchRespVO> getHarvestBatch(@RequestParam("id") Long id) { public CommonResult<HarvestBatchRespVO> getHarvestBatch(@RequestParam("id") Long id) {
HarvestBatchDO harvestBatch = harvestBatchService.getHarvestBatch(id); return CommonResult.success(harvestBatchService.getHarvestBatchDetail(id));
return CommonResult.success(HarvestBatchConvert.INSTANCE.convert(harvestBatch));
} }
@GetMapping("/getAllBatchCode") @GetMapping("/getAllBatchCode")
@ -255,4 +254,12 @@ public class HarvestBatchController {
return CommonResult.success(Boolean.TRUE); return CommonResult.success(Boolean.TRUE);
} }
@PostMapping("/initHarvestBatchConfig")
@ApiOperation("初始化采收批次配置")
@PreAuthorize("@ss.hasPermission('product:harvest-batch:init-config')")
public CommonResult<Boolean> initHarvestBatchConfig() {
harvestBatchService.initHarvestBatchConfig();
return CommonResult.success(Boolean.TRUE);
}
} }

@ -46,12 +46,6 @@ public class HarvestBatchBaseVO {
@NotNull(message = "批次上链状态 0未上链 1激活状态 2冻结状态不能为空") @NotNull(message = "批次上链状态 0未上链 1激活状态 2冻结状态不能为空")
private Integer blockState; private Integer blockState;
@ApiModelProperty(value = "溯源模板名称")
private String templateName;
@ApiModelProperty(value = "溯源模板id")
private String templateId;
@ApiModelProperty(value = "采收批次说明") @ApiModelProperty(value = "采收批次说明")
private String remarks; private String remarks;

@ -23,4 +23,10 @@ public class HarvestBatchRespVO extends HarvestBatchBaseVO {
@ApiModelProperty(value = "商品规格") @ApiModelProperty(value = "商品规格")
private String goodsSpecs; private String goodsSpecs;
@ApiModelProperty(value = "语言类型ID")
private Long languageTypeId;
@ApiModelProperty(value = "模板配置ID")
private Long templateId;
} }

@ -0,0 +1,14 @@
package cn.iocoder.yudao.module.product.controller.admin.harvestbatchconfig;
import io.swagger.annotations.Api;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Api(tags = "管理后台 - 采收批次小程序显示配置")
@RestController
@RequestMapping("/product/harvest-batch-config")
@Validated
public class HarvestBatchConfigController {
}

@ -0,0 +1,27 @@
package cn.iocoder.yudao.module.product.controller.admin.harvestbatchconfig.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotNull;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class HarvestBatchConfigBaseVO {
@ApiModelProperty(value = "采收批次ID", required = true)
@NotNull(message = "采收批次ID不能为空")
private String harvestBatchId;
@ApiModelProperty(value = "语言类型ID", required = true)
@NotNull(message = "语言类型ID不能为空")
private Long languageTypeId;
@ApiModelProperty(value = "模板ID", required = true)
@NotNull(message = "模板ID不能为空")
private Long templateId;
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.product.controller.admin.harvestbatchconfig.vo;
import lombok.*;
import io.swagger.annotations.*;
import java.util.Date;
@ApiModel("管理后台 - 采收批次小程序显示配置 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class HarvestBatchConfigRespVO extends HarvestBatchConfigBaseVO {
@ApiModelProperty(value = "ID", required = true)
private Long id;
@ApiModelProperty(value = "创建时间")
private Date createTime;
}

@ -0,0 +1,16 @@
package cn.iocoder.yudao.module.product.convert.harvestbatchconfig;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* Convert
*
* @author
*/
@Mapper
public interface HarvestBatchConfigConvert {
HarvestBatchConfigConvert INSTANCE = Mappers.getMapper(HarvestBatchConfigConvert.class);
}

@ -64,14 +64,6 @@ public class HarvestBatchDO extends BaseDO {
* 0 1 2 * 0 1 2
*/ */
private Integer blockState; private Integer blockState;
/**
*
*/
private String templateName;
/**
* id
*/
private String templateId;
/** /**
* *
*/ */

@ -0,0 +1,42 @@
package cn.iocoder.yudao.module.product.dal.dataobject.harvestbatchconfig;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;
/**
* DO
*
* @author
*/
@TableName("product_harvest_batch_config")
@KeySequence("product_harvest_batch_config_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class HarvestBatchConfigDO extends BaseDO {
/**
* ID
*/
@TableId
private Long id;
/**
* ID
*/
private String harvestBatchId;
/**
* ID
*/
private Long languageTypeId;
/**
* ID
*/
private Long templateId;
}

@ -5,6 +5,7 @@ import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.GoodsHarvestBatchIdsRespVO; import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.GoodsHarvestBatchIdsRespVO;
import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.HarvestBatchPageReqVO; import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.HarvestBatchPageReqVO;
import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.HarvestBatchRespVO;
import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatch.HarvestBatchDO; import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatch.HarvestBatchDO;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
@ -30,5 +31,10 @@ public interface HarvestBatchMapper extends BaseMapperX<HarvestBatchDO> {
.orderByDesc(HarvestBatchDO::getId)); .orderByDesc(HarvestBatchDO::getId));
} }
/**
*
*/
HarvestBatchRespVO getHarvestBatchDetail(@Param("id") Long id, @Param("harvestBatchId") String harvestBatchId, @Param("languageTypeId") Long languageTypeId);
List<GoodsHarvestBatchIdsRespVO> getBatchIdsByGoodsId(@Param("goodsIds") List<String> goodsIds, @Param("businessId") Long businessId, @Param("blockState") Integer blockState); List<GoodsHarvestBatchIdsRespVO> getBatchIdsByGoodsId(@Param("goodsIds") List<String> goodsIds, @Param("businessId") Long businessId, @Param("blockState") Integer blockState);
} }

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.product.dal.mysql.harvestbatchconfig;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatchconfig.HarvestBatchConfigDO;
import org.apache.ibatis.annotations.Mapper;
/**
* Mapper
*
* @author
*/
@Mapper
public interface HarvestBatchConfigMapper extends BaseMapperX<HarvestBatchConfigDO> {
}

@ -23,12 +23,12 @@ public class DeviceMqttCallback implements MqttCallback {
@Override @Override
public void connectionLost(Throwable throwable) { public void connectionLost(Throwable throwable) {
// 连接丢失后,一般在这里面进行重连 // 连接丢失后,一般在这里面进行重连
log.info("MQTT连接断开发起重连"); // log.info("MQTT连接断开发起重连");
while (true) { while (true) {
try { try {
Thread.sleep(10000); Thread.sleep(10000);
mqttClient.connect(); mqttClient.connect();
log.info("MQTT重新连接成功。"); // log.info("MQTT重新连接成功。");
break; break;
} catch (Exception e) { } catch (Exception e) {
log.error("连接MQTT服务器失败{}", e.getMessage(), e); log.error("连接MQTT服务器失败{}", e.getMessage(), e);

@ -65,7 +65,7 @@ public class DeviceMqttClient {
// 这里一直保持链接的是传感器数据的主题 // 这里一直保持链接的是传感器数据的主题
client.subscribe(config.getSensorTopic(), config.getQos()); client.subscribe(config.getSensorTopic(), config.getQos());
log.info("MQTT服务器连接成功"); // log.info("MQTT服务器连接成功");
connecting = false; connecting = false;
} catch (Exception ex) { } catch (Exception ex) {
connecting = false; connecting = false;

@ -15,6 +15,7 @@ import cn.iocoder.yudao.module.flow.api.outbound.OutboundApi;
import cn.iocoder.yudao.module.identity.api.scanrecord.ScanRecordApi; import cn.iocoder.yudao.module.identity.api.scanrecord.ScanRecordApi;
import cn.iocoder.yudao.module.infra.api.file.FileApi; import cn.iocoder.yudao.module.infra.api.file.FileApi;
import cn.iocoder.yudao.module.system.api.dict.DictDataApi; import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
import cn.iocoder.yudao.module.system.api.languagetype.LanguageTypeApi;
import org.springframework.cloud.openfeign.EnableFeignClients; import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
@ -35,6 +36,7 @@ import org.springframework.context.annotation.Configuration;
ScanRecordApi.class, ScanRecordApi.class,
FileApi.class, FileApi.class,
DeviceEnvTypeApi.class, DeviceEnvTypeApi.class,
LanguageTypeApi.class,
}) })
public class RpcConfiguration { public class RpcConfiguration {
} }

@ -34,7 +34,7 @@ public interface HarvestBatchService {
* @param id * @param id
* @return * @return
*/ */
HarvestBatchDO getHarvestBatch(Long id); HarvestBatchRespVO getHarvestBatchDetail(Long id);
List<String> getAllBatchCode(); List<String> getAllBatchCode();
@ -161,4 +161,7 @@ public interface HarvestBatchService {
* @param saveReqVO * @param saveReqVO
*/ */
void updateHarvestBatchConfig(@Valid HarvestBatchConfigSaveReqVO saveReqVO); void updateHarvestBatchConfig(@Valid HarvestBatchConfigSaveReqVO saveReqVO);
void initHarvestBatchConfig();
} }

@ -28,10 +28,14 @@ import cn.iocoder.yudao.module.product.controller.admin.envtype.vo.EnvTypeConfig
import cn.iocoder.yudao.module.product.controller.admin.envtype.vo.EnvTypeDeviceConfigRespVO; import cn.iocoder.yudao.module.product.controller.admin.envtype.vo.EnvTypeDeviceConfigRespVO;
import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.*; import cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.*;
import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatch.HarvestBatchDO; import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatch.HarvestBatchDO;
import cn.iocoder.yudao.module.product.dal.dataobject.harvestbatchconfig.HarvestBatchConfigDO;
import cn.iocoder.yudao.module.product.dal.mysql.harvestbatch.HarvestBatchMapper; import cn.iocoder.yudao.module.product.dal.mysql.harvestbatch.HarvestBatchMapper;
import cn.iocoder.yudao.module.product.dal.mysql.harvestbatchconfig.HarvestBatchConfigMapper;
import cn.iocoder.yudao.module.product.enums.ErrorCodeConstants; import cn.iocoder.yudao.module.product.enums.ErrorCodeConstants;
import cn.iocoder.yudao.module.product.service.envtype.EnvTypeService; import cn.iocoder.yudao.module.product.service.envtype.EnvTypeService;
import cn.iocoder.yudao.module.product.service.landplan.LandPlanService; import cn.iocoder.yudao.module.product.service.landplan.LandPlanService;
import cn.iocoder.yudao.module.system.api.languagetype.LanguageTypeApi;
import cn.iocoder.yudao.module.system.api.languagetype.dto.LanguageTypeRespDTO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.seata.spring.annotation.GlobalTransactional; import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -54,6 +58,9 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Resource @Resource
private HarvestBatchMapper harvestBatchMapper; private HarvestBatchMapper harvestBatchMapper;
@Resource
private HarvestBatchConfigMapper harvestBatchConfigMapper;
@Resource @Resource
private LandPlanService landPlanService; private LandPlanService landPlanService;
@ -81,6 +88,9 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Resource @Resource
private DeviceEnvTypeApi deviceEnvTypeApi; private DeviceEnvTypeApi deviceEnvTypeApi;
@Resource
private LanguageTypeApi languageTypeApi;
@Override @Override
public void deleteHarvestBatch(Long id) { public void deleteHarvestBatch(Long id) {
// 校验存在 // 校验存在
@ -106,8 +116,8 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
} }
@Override @Override
public HarvestBatchDO getHarvestBatch(Long id) { public HarvestBatchRespVO getHarvestBatchDetail(Long id) {
return harvestBatchMapper.selectById(id); return harvestBatchMapper.getHarvestBatchDetail(id, null, null);
} }
@Override @Override
@ -133,7 +143,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
public GoodsConfigRespVO getGoodsConfig(Long id) { public GoodsConfigRespVO getGoodsConfig(Long id) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = this.verifyHarvestBatch(id); HarvestBatchRespVO harvestBatch = this.verifyHarvestBatch(id, null);
GoodsConfigRespVO result = new GoodsConfigRespVO(); GoodsConfigRespVO result = new GoodsConfigRespVO();
BeanUtil.copyProperties(harvestBatch, result); BeanUtil.copyProperties(harvestBatch, result);
@ -334,9 +344,9 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
return goodsInfos.get(0); return goodsInfos.get(0);
} }
private HarvestBatchDO verifyHarvestBatch(Long id) { private HarvestBatchRespVO verifyHarvestBatch(Long id, Long languageTypeId) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = harvestBatchMapper.selectById(id); HarvestBatchRespVO harvestBatch = harvestBatchMapper.getHarvestBatchDetail(id, null, languageTypeId);
if(harvestBatch == null) { if(harvestBatch == null) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.HARVEST_BATCH_NOT_EXISTS); throw ServiceExceptionUtil.exception(ErrorCodeConstants.HARVEST_BATCH_NOT_EXISTS);
} }
@ -579,7 +589,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
} }
} }
private void setBlockCertificate(BlockCertificateCreateReqDTO blockCertificate, Integer operateType, String operateName, HarvestBatchDO harvestBatch, private void setBlockCertificate(BlockCertificateCreateReqDTO blockCertificate, Integer operateType, String operateName, HarvestBatchRespVO harvestBatch,
BlockCertificateSaveReqVO saveReqVO) { BlockCertificateSaveReqVO saveReqVO) {
blockCertificate.setChainOperateId(CodeEnum.CHAIN_OPERATE_CODE.getCode()); blockCertificate.setChainOperateId(CodeEnum.CHAIN_OPERATE_CODE.getCode());
blockCertificate.setOperateType(operateType); // 操作类型 blockCertificate.setOperateType(operateType); // 操作类型
@ -619,15 +629,15 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
operateDetail.setId(null);// 不管页面传不传这里重置成null operateDetail.setId(null);// 不管页面传不传这里重置成null
operateDetail.setChainOperateId(blockCertificate.getChainOperateId()); operateDetail.setChainOperateId(blockCertificate.getChainOperateId());
operateDetail.setOperateInfo(BatchTypeEnum.HARVEST_BATCH.getName()); operateDetail.setOperateInfo(BatchTypeEnum.HARVEST_BATCH.getName());
this.verifyFieldAndSetOperateDetail(detail, operateDetail, blockCertificate); this.verifyFieldAndSetOperateDetail(detail, operateDetail);
operateDetail.setBelongBusinessId(blockCertificate.getBelongBusinessId()); operateDetail.setBelongBusinessId(blockCertificate.getBelongBusinessId());
operateDetail.setBelongBusinessName(blockCertificate.getBelongBusinessName()); operateDetail.setBelongBusinessName(blockCertificate.getBelongBusinessName());
} }
private void verifyFieldAndSetOperateDetail(OperateDetailSaveReqVO detail, OperateDetailSaveReqDTO operateDetail, BlockCertificateBaseReqDTO blockCertificate) { private void verifyFieldAndSetOperateDetail(OperateDetailSaveReqVO detail, OperateDetailSaveReqDTO operateDetail) {
// 校验标题内容 // 校验标题内容
if(!detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_TEXT.getType()) && !detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_LONG_TEXT.getType()) if(!detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_TEXT.getType()) && !detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_LONG_TEXT.getType())
&& !detail.getType().equals(OperateDetailTypeEnum.BIG_IMAGE.getType()) && (detail.getTitle() == null || detail.getTitle().equals(""))) { && !detail.getType().equals(OperateDetailTypeEnum.BIG_IMAGE.getType()) && (detail.getTitle() == null || detail.getTitle().isEmpty())) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.OPERATE_TITLE_CAN_NOT_BE_NULL); throw ServiceExceptionUtil.exception(ErrorCodeConstants.OPERATE_TITLE_CAN_NOT_BE_NULL);
} }
if(!detail.getType().equals(OperateDetailTypeEnum.TEXT.getType()) && !detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_TEXT.getType())) { if(!detail.getType().equals(OperateDetailTypeEnum.TEXT.getType()) && !detail.getType().equals(OperateDetailTypeEnum.NO_TITLE_TEXT.getType())) {
@ -651,7 +661,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
public LinkConfigRespVO getLinkConfig(Long id) { public LinkConfigRespVO getLinkConfig(Long id) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = this.verifyHarvestBatch(id); HarvestBatchRespVO harvestBatch = this.verifyHarvestBatch(id, null);
LinkConfigRespVO result = new LinkConfigRespVO(); LinkConfigRespVO result = new LinkConfigRespVO();
BeanUtil.copyProperties(harvestBatch, result); BeanUtil.copyProperties(harvestBatch, result);
@ -678,7 +688,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@GlobalTransactional(rollbackFor = Exception.class) @GlobalTransactional(rollbackFor = Exception.class)
public void updateLinkConfig(LinkConfigSaveReqVO updateReqVO) { public void updateLinkConfig(LinkConfigSaveReqVO updateReqVO) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = this.verifyHarvestBatch(updateReqVO.getId()); HarvestBatchRespVO harvestBatch = this.verifyHarvestBatch(updateReqVO.getId(), null);
// 查询环节信息 // 查询环节信息
BlockCertificateReqDTO blockCertificateDTO = new BlockCertificateReqDTO(); BlockCertificateReqDTO blockCertificateDTO = new BlockCertificateReqDTO();
@ -744,7 +754,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
operateDetail.setType(detail.getType()); operateDetail.setType(detail.getType());
operateDetail.setTitle(detail.getTitle()); operateDetail.setTitle(detail.getTitle());
operateDetail.setContent(detail.getContent()); operateDetail.setContent(detail.getContent());
this.verifyFieldAndSetOperateDetail(detail, operateDetail, blockCertificate); this.verifyFieldAndSetOperateDetail(detail, operateDetail);
operateDetails.add(operateDetail); operateDetails.add(operateDetail);
willUpdateDetailIds.add(detail.getId()); willUpdateDetailIds.add(detail.getId());
@ -825,7 +835,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
public FarmingConfigRespVO getFarmingConfig(Long id) { public FarmingConfigRespVO getFarmingConfig(Long id) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = this.verifyHarvestBatch(id); HarvestBatchRespVO harvestBatch = this.verifyHarvestBatch(id, null);
// if(harvestBatch.getBlockState().equals(BlockStateEnum.FREEZE.getBlockState())) { // if(harvestBatch.getBlockState().equals(BlockStateEnum.FREEZE.getBlockState())) {
// throw ServiceExceptionUtil.exception(ErrorCodeConstants.BLOCK_STATE_IS_FREEZE); // throw ServiceExceptionUtil.exception(ErrorCodeConstants.BLOCK_STATE_IS_FREEZE);
// } // }
@ -852,11 +862,11 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
Map<String, List<BlockCertificateRespDTO>> jobRespMap = new HashMap<>(); Map<String, List<BlockCertificateRespDTO>> jobRespMap = new HashMap<>();
jobRespDTOs.forEach(resp -> { jobRespDTOs.forEach(resp -> {
List<BlockCertificateRespDTO> list = jobRespMap.get(resp.getParentOperateId()); List<BlockCertificateRespDTO> list = jobRespMap.get(resp.getParentOperateId());
if(resp.getParentOperateId() != null && !resp.getParentOperateId().equals("") && list == null) { if(resp.getParentOperateId() != null && !resp.getParentOperateId().isEmpty() && list == null) {
list = new ArrayList<>(); list = new ArrayList<>();
list.add(resp); list.add(resp);
jobRespMap.put(resp.getParentOperateId(), list); jobRespMap.put(resp.getParentOperateId(), list);
} else if(resp.getParentOperateId() != null && !resp.getParentOperateId().equals("")) { } else if(resp.getParentOperateId() != null && !resp.getParentOperateId().isEmpty()) {
list.add(resp); list.add(resp);
jobRespMap.put(resp.getParentOperateId(), list); jobRespMap.put(resp.getParentOperateId(), list);
} }
@ -1168,7 +1178,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
public PreviewRespVO getPreviewData(String harvestBatchId, Long languageTypeId) { public PreviewRespVO getPreviewData(String harvestBatchId, Long languageTypeId) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = harvestBatchMapper.selectOne(new LambdaQueryWrapperX<HarvestBatchDO>().eq(HarvestBatchDO::getHarvestBatchId, harvestBatchId)); HarvestBatchRespVO harvestBatch = harvestBatchMapper.getHarvestBatchDetail(null, harvestBatchId, languageTypeId);
if(harvestBatch == null) { if(harvestBatch == null) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.HARVEST_BATCH_NOT_EXISTS); throw ServiceExceptionUtil.exception(ErrorCodeConstants.HARVEST_BATCH_NOT_EXISTS);
} }
@ -1176,21 +1186,19 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
PreviewRespVO previewResp = new PreviewRespVO(); PreviewRespVO previewResp = new PreviewRespVO();
previewResp.setBlockState(harvestBatch.getBlockState()); previewResp.setBlockState(harvestBatch.getBlockState());
// 查询模板 // 查询模板
UniTemplateDTO uniTemplateDTO = uniTemplateApi.getDefaultTemplate(harvestBatch.getBelongBusinessId()).getData(); UniTemplateDTO uniTemplateDTO = uniTemplateApi.getTemplateById(harvestBatch.getTemplateId()).getData();
if(uniTemplateDTO == null) { if(uniTemplateDTO == null) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.CAN_NOT_FIND_DEFAULT_UNI_TEMPLATE); throw ServiceExceptionUtil.exception(ErrorCodeConstants.CAN_NOT_FIND_DEFAULT_UNI_TEMPLATE);
} }
previewResp.setUniTemplate(uniTemplateDTO); previewResp.setUniTemplate(uniTemplateDTO);
this.getAndSetBlockCertificateData(harvestBatch, previewResp, uniTemplateDTO.getOnlyShowJob(), Boolean.FALSE, languageTypeId); this.getAndSetBlockCertificateData(harvestBatch, previewResp, Boolean.FALSE, languageTypeId);
return previewResp; return previewResp;
} }
private void getAndSetBlockCertificateData(HarvestBatchDO harvestBatch, PreviewRespVO previewResp, Boolean onlyShowJob, Boolean showAll, Long languageTypeId) { private void getAndSetBlockCertificateData(HarvestBatchRespVO harvestBatch, PreviewRespVO previewResp, Boolean showAll, Long languageTypeId) {
// 所有采收批次的类型 // 所有采收批次的类型
BlockCertificateReqDTO blockCertificateDTO = new BlockCertificateReqDTO(); BlockCertificateReqDTO blockCertificateDTO = new BlockCertificateReqDTO();
// blockCertificateDTO.setChainState(ChainStateEnum.ON_CHAIN.getState());
// blockCertificateDTO.setChainStatus(ChainStatusEnum.ACTIVE.getStatus());
blockCertificateDTO.setBatchType(BatchTypeEnum.HARVEST_BATCH.getType());// 查询类型为采收批次的类型 blockCertificateDTO.setBatchType(BatchTypeEnum.HARVEST_BATCH.getType());// 查询类型为采收批次的类型
blockCertificateDTO.setBatchId(harvestBatch.getHarvestBatchId()); blockCertificateDTO.setBatchId(harvestBatch.getHarvestBatchId());
blockCertificateDTO.setLanguageTypeId(languageTypeId); blockCertificateDTO.setLanguageTypeId(languageTypeId);
@ -1232,7 +1240,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
List<OperateDetailSaveReqVO> details = this.getOperateDetails(respDTO.getOperateDetails()); List<OperateDetailSaveReqVO> details = this.getOperateDetails(respDTO.getOperateDetails());
farmingPlantReqVO.setOperateDetails(details); farmingPlantReqVO.setOperateDetails(details);
farmingPlans.add(farmingPlantReqVO); farmingPlans.add(farmingPlantReqVO);
} else if ((respDTO.getOperateType().equals(OperateTypeEnum.JOB.getType()) || respDTO.getOperateType().equals(OperateTypeEnum.JOB_INPUT.getType())) && onlyShowJob) { } else if ((respDTO.getOperateType().equals(OperateTypeEnum.JOB.getType()) || respDTO.getOperateType().equals(OperateTypeEnum.JOB_INPUT.getType()))) {
// 农事作业 // 农事作业
BeanUtil.copyProperties(respDTO, blockCertificate); BeanUtil.copyProperties(respDTO, blockCertificate);
List<OperateDetailSaveReqVO> details = this.getOperateDetails(respDTO.getOperateDetails()); List<OperateDetailSaveReqVO> details = this.getOperateDetails(respDTO.getOperateDetails());
@ -1341,7 +1349,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
@GlobalTransactional(rollbackFor = Exception.class) @GlobalTransactional(rollbackFor = Exception.class)
public void updateChainStatus(Long id, Integer state) { public void updateChainStatus(Long id, Integer state) {
HarvestBatchDO harvestBatchDO = this.verifyHarvestBatch(id); HarvestBatchRespVO harvestBatchDO = this.verifyHarvestBatch(id, null);
List<UpdateStatusReqDTO> batchsReqDTOS = new ArrayList<>(); List<UpdateStatusReqDTO> batchsReqDTOS = new ArrayList<>();
UpdateStatusReqDTO harvestReqDTO = new UpdateStatusReqDTO(); UpdateStatusReqDTO harvestReqDTO = new UpdateStatusReqDTO();
@ -1362,11 +1370,11 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
@Override @Override
public HarvestBatchConfigRespVO getHarvestBatchConfig(Long id, Long languageTypeId) { public HarvestBatchConfigRespVO getHarvestBatchConfig(Long id, Long languageTypeId) {
// 根据批次id 查询该采收批次信息 // 根据批次id 查询该采收批次信息
HarvestBatchDO harvestBatch = this.verifyHarvestBatch(id); HarvestBatchRespVO harvestBatch = this.verifyHarvestBatch(id, languageTypeId);
HarvestBatchConfigRespVO result = new HarvestBatchConfigRespVO(); HarvestBatchConfigRespVO result = new HarvestBatchConfigRespVO();
PreviewRespVO previewRespVO = new PreviewRespVO(); PreviewRespVO previewRespVO = new PreviewRespVO();
this.getAndSetBlockCertificateData(harvestBatch, previewRespVO, Boolean.TRUE, Boolean.TRUE, languageTypeId); this.getAndSetBlockCertificateData(harvestBatch, previewRespVO, Boolean.TRUE, languageTypeId);
BeanUtil.copyProperties(previewRespVO, result); BeanUtil.copyProperties(previewRespVO, result);
BeanUtil.copyProperties(harvestBatch, result); BeanUtil.copyProperties(harvestBatch, result);
// 商品和企业信息是否为空, 如果是空的填充默认值进去。。。 // 商品和企业信息是否为空, 如果是空的填充默认值进去。。。
@ -1380,7 +1388,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
public void updateHarvestBatchConfig(HarvestBatchConfigSaveReqVO saveReqVO) { public void updateHarvestBatchConfig(HarvestBatchConfigSaveReqVO saveReqVO) {
// 获得数据库已有的配置信息 // 获得数据库已有的配置信息
HarvestBatchConfigRespVO configRespVO = this.getHarvestBatchConfig(saveReqVO.getId(), saveReqVO.getLanguageTypeId()); HarvestBatchConfigRespVO configRespVO = this.getHarvestBatchConfig(saveReqVO.getId(), saveReqVO.getLanguageTypeId());
HarvestBatchDO harvestBatch = new HarvestBatchDO(); HarvestBatchRespVO harvestBatch = new HarvestBatchRespVO();
BeanUtil.copyProperties(configRespVO, harvestBatch); BeanUtil.copyProperties(configRespVO, harvestBatch);
// 获取环境配置 // 获取环境配置
List<EnvTypeDeviceConfigRespVO> envTypeConfigs = envTypeService.getEnvTypeConfigGroupByLandId(harvestBatch.getBelongBusinessId()); List<EnvTypeDeviceConfigRespVO> envTypeConfigs = envTypeService.getEnvTypeConfigGroupByLandId(harvestBatch.getBelongBusinessId());
@ -1710,7 +1718,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
operateDetail.setType(detail.getType()); operateDetail.setType(detail.getType());
operateDetail.setTitle(detail.getTitle()); operateDetail.setTitle(detail.getTitle());
operateDetail.setContent(detail.getContent()); operateDetail.setContent(detail.getContent());
this.verifyFieldAndSetOperateDetail(detail, operateDetail, blockCertificate); this.verifyFieldAndSetOperateDetail(detail, operateDetail);
operateDetails.add(operateDetail); operateDetails.add(operateDetail);
willUpdateDetailIds.add(detail.getId()); willUpdateDetailIds.add(detail.getId());
@ -1901,7 +1909,7 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
operateDetail.setTitle(detail.getTitle()); operateDetail.setTitle(detail.getTitle());
operateDetail.setContent(detail.getContent()); operateDetail.setContent(detail.getContent());
operateDetail.setLinkText(detail.getLinkText()); operateDetail.setLinkText(detail.getLinkText());
this.verifyFieldAndSetOperateDetail(detail, operateDetail, inspectionDTO); this.verifyFieldAndSetOperateDetail(detail, operateDetail);
operateDetails.add(operateDetail); operateDetails.add(operateDetail);
willUpdateDetailIds.add(detail.getId()); willUpdateDetailIds.add(detail.getId());
@ -2080,6 +2088,52 @@ public class HarvestBatchServiceImpl implements HarvestBatchService {
} }
} }
@Override
public void initHarvestBatchConfig() {
// 查询所有的批次配置
List<HarvestBatchConfigDO> configList = harvestBatchConfigMapper.selectList();
// 查询所有的语言类型
List<LanguageTypeRespDTO> languageTypeList = languageTypeApi.getAllLanguageType().getData();
// 查询所有的批次
List<HarvestBatchDO> harvestBatchList = this.harvestBatchMapper.selectList();
if (languageTypeList.isEmpty() || harvestBatchList.isEmpty()) {
return;
}
// 获取默认模板
UniTemplateDTO templateDTO = uniTemplateApi.getDefaultTemplate().getData();
if (templateDTO == null) {
throw ServiceExceptionUtil.exception(ErrorCodeConstants.CAN_NOT_FIND_DEFAULT_UNI_TEMPLATE);
}
Map<String, HarvestBatchConfigDO> configMap = new HashMap<>();
configList.forEach(config -> {
String key = "batchId:" + config.getHarvestBatchId() + ";typeId:" + config.getLanguageTypeId();
configMap.put(key, config);
});
List<HarvestBatchConfigDO> createList = new ArrayList<>();
languageTypeList.forEach(languageType -> {
harvestBatchList.forEach(batch -> {
String key = "batchId:" + batch.getHarvestBatchId() + ";typeId:" + languageType.getId();
HarvestBatchConfigDO config = configMap.get(key);
if (config == null) {
config = new HarvestBatchConfigDO();
config.setLanguageTypeId(languageType.getId());
config.setHarvestBatchId(batch.getHarvestBatchId());
config.setTemplateId(templateDTO.getId());
createList.add(config);
}
});
});
if (!createList.isEmpty()) {
harvestBatchConfigMapper.insertBatch(createList);
}
}
private void setOperateDetailsForUpdate(BlockCertificateSaveReqVO saveReqVO, List<OperateDetailSaveReqDTO> createOperateDetails, private void setOperateDetailsForUpdate(BlockCertificateSaveReqVO saveReqVO, List<OperateDetailSaveReqDTO> createOperateDetails,
List<Long> willUpdateIds, BlockCertificateUpdateReqDTO updateReqDTO) { List<Long> willUpdateIds, BlockCertificateUpdateReqDTO updateReqDTO) {

@ -0,0 +1,10 @@
package cn.iocoder.yudao.module.product.service.harvestbatchconfig;
/**
* Service
*
* @author
*/
public interface HarvestBatchConfigService {
}

@ -0,0 +1,15 @@
package cn.iocoder.yudao.module.product.service.harvestbatchconfig;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* Service
*
* @author
*/
@Service
@Validated
public class HarvestBatchConfigServiceImpl implements HarvestBatchConfigService {
}

@ -38,4 +38,18 @@
</where> </where>
</select> </select>
<select id="getHarvestBatchDetail" resultType="cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.HarvestBatchRespVO">
select
phb.*, phbc.language_type_id, phbc.template_id
from
product_harvest_batch phb
left join product_harvest_batch_config phbc on phbc.harvest_batch_id = phb.harvest_batch_id
<where>
<if test="id != null"> and phb.id = #{id}</if>
<if test="harvestBatchId != null"> and phb.harvest_batch_id = #{harvestBatchId}</if>
<if test="languageTypeId != null"> and phbc.language_type_id = #{languageTypeId}</if>
</where>
group by phb.id
</select>
</mapper> </mapper>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.product.dal.mysql.harvestbatchconfig.HarvestBatchConfigMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -38,4 +38,18 @@
</where> </where>
</select> </select>
<select id="getHarvestBatchDetail" resultType="cn.iocoder.yudao.module.product.controller.admin.harvestbatch.vo.HarvestBatchRespVO">
select
phb.*, phbc.language_type_id, phbc.template_id
from
product_harvest_batch phb
left join product_harvest_batch_config phbc on phbc.harvest_batch_id = phb.harvest_batch_id
<where>
<if test="id != null"> and phb.id = #{id}</if>
<if test="harvestBatchId != null"> and phb.harvest_batch_id = #{harvestBatchId}</if>
<if test="languageTypeId != null"> and phbc.language_type_id = #{languageTypeId}</if>
</where>
group by phb.id
</select>
</mapper> </mapper>

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class DeviceInfoConvertImpl implements DeviceInfoConvert { public class DeviceInfoConvertImpl implements DeviceInfoConvert {

@ -12,7 +12,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class DeviceOperateLogConvertImpl implements DeviceOperateLogConvert { public class DeviceOperateLogConvertImpl implements DeviceOperateLogConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:28+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class EnvDataConvertImpl implements EnvDataConvert { public class EnvDataConvertImpl implements EnvDataConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:31+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class EnvTypeConvertImpl implements EnvTypeConvert { public class EnvTypeConvertImpl implements EnvTypeConvert {

@ -18,7 +18,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:28+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class HarvestBatchConvertImpl implements HarvestBatchConvert { public class HarvestBatchConvertImpl implements HarvestBatchConvert {
@ -41,8 +41,6 @@ public class HarvestBatchConvertImpl implements HarvestBatchConvert {
harvestBatchDO.blockChainId( bean.getBlockChainId() ); harvestBatchDO.blockChainId( bean.getBlockChainId() );
harvestBatchDO.blockChainBlockIdentity( bean.getBlockChainBlockIdentity() ); harvestBatchDO.blockChainBlockIdentity( bean.getBlockChainBlockIdentity() );
harvestBatchDO.blockState( bean.getBlockState() ); harvestBatchDO.blockState( bean.getBlockState() );
harvestBatchDO.templateName( bean.getTemplateName() );
harvestBatchDO.templateId( bean.getTemplateId() );
harvestBatchDO.remarks( bean.getRemarks() ); harvestBatchDO.remarks( bean.getRemarks() );
harvestBatchDO.belongBusinessId( bean.getBelongBusinessId() ); harvestBatchDO.belongBusinessId( bean.getBelongBusinessId() );
harvestBatchDO.belongBusinessName( bean.getBelongBusinessName() ); harvestBatchDO.belongBusinessName( bean.getBelongBusinessName() );
@ -67,8 +65,6 @@ public class HarvestBatchConvertImpl implements HarvestBatchConvert {
harvestBatchRespVO.setBlockChainId( bean.getBlockChainId() ); harvestBatchRespVO.setBlockChainId( bean.getBlockChainId() );
harvestBatchRespVO.setBlockChainBlockIdentity( bean.getBlockChainBlockIdentity() ); harvestBatchRespVO.setBlockChainBlockIdentity( bean.getBlockChainBlockIdentity() );
harvestBatchRespVO.setBlockState( bean.getBlockState() ); harvestBatchRespVO.setBlockState( bean.getBlockState() );
harvestBatchRespVO.setTemplateName( bean.getTemplateName() );
harvestBatchRespVO.setTemplateId( bean.getTemplateId() );
harvestBatchRespVO.setRemarks( bean.getRemarks() ); harvestBatchRespVO.setRemarks( bean.getRemarks() );
harvestBatchRespVO.setBelongBusinessId( bean.getBelongBusinessId() ); harvestBatchRespVO.setBelongBusinessId( bean.getBelongBusinessId() );
harvestBatchRespVO.setBelongBusinessName( bean.getBelongBusinessName() ); harvestBatchRespVO.setBelongBusinessName( bean.getBelongBusinessName() );
@ -116,8 +112,6 @@ public class HarvestBatchConvertImpl implements HarvestBatchConvert {
harvestBatchDTO.setBlockChainId( bean.getBlockChainId() ); harvestBatchDTO.setBlockChainId( bean.getBlockChainId() );
harvestBatchDTO.setBlockChainBlockIdentity( bean.getBlockChainBlockIdentity() ); harvestBatchDTO.setBlockChainBlockIdentity( bean.getBlockChainBlockIdentity() );
harvestBatchDTO.setBlockState( bean.getBlockState() ); harvestBatchDTO.setBlockState( bean.getBlockState() );
harvestBatchDTO.setTemplateName( bean.getTemplateName() );
harvestBatchDTO.setTemplateId( bean.getTemplateId() );
harvestBatchDTO.setRemarks( bean.getRemarks() ); harvestBatchDTO.setRemarks( bean.getRemarks() );
if ( bean.getCreateTime() != null ) { if ( bean.getCreateTime() != null ) {
harvestBatchDTO.setCreateTime( Date.from( bean.getCreateTime().toInstant( ZoneOffset.UTC ) ) ); harvestBatchDTO.setCreateTime( Date.from( bean.getCreateTime().toInstant( ZoneOffset.UTC ) ) );

@ -14,7 +14,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class HarvestInfoConvertImpl implements HarvestInfoConvert { public class HarvestInfoConvertImpl implements HarvestInfoConvert {

@ -16,7 +16,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:28+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InputsBatchConvertImpl implements InputsBatchConvert { public class InputsBatchConvertImpl implements InputsBatchConvert {

@ -16,7 +16,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InputsBuyConvertImpl implements InputsBuyConvert { public class InputsBuyConvertImpl implements InputsBuyConvert {

@ -14,7 +14,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:28+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InspectionConvertImpl implements InspectionConvert { public class InspectionConvertImpl implements InspectionConvert {

@ -12,7 +12,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class InspectionItemConvertImpl implements InspectionItemConvert { public class InspectionItemConvertImpl implements InspectionItemConvert {

@ -13,7 +13,7 @@ import javax.annotation.Generated;
@Generated( @Generated(
value = "org.mapstruct.ap.MappingProcessor", value = "org.mapstruct.ap.MappingProcessor",
date = "2024-08-30T10:13:32+0800", date = "2024-12-20T15:58:27+0800",
comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)" comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_291 (Oracle Corporation)"
) )
public class LandBlockStateConvertImpl implements LandBlockStateConvert { public class LandBlockStateConvertImpl implements LandBlockStateConvert {

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save