微服务版后端初始化

This commit is contained in:
yaoyn
2025-02-08 17:51:37 +08:00
parent 54af6be188
commit da009a7cc4
1897 changed files with 429541 additions and 81 deletions

View File

@ -0,0 +1,16 @@
# 基础镜像
FROM nexus.gdyditc.com:8082/openjdk:11-arm64
# author
MAINTAINER xjrsoft
# 挂载目录
VOLUME /home/xjrsoft
# 创建目录
RUN mkdir -p /home/xjrsoft
# 指定路径
WORKDIR /home/xjrsoft
# 复制jar文件到路径
RUN ls
COPY ./target/xjrsoft-service-form.jar /home/xjrsoft/xjrsoft-service-form.jar
# 启动认证服务
ENTRYPOINT ["java","-Dfile.encoding=utf-8","--add-opens","java.base/java.lang.reflect=ALL-UNNAMED","-jar","xjrsoft-service-form.jar"]

View File

@ -0,0 +1,106 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>xjrsoft-service</artifactId>
<groupId>com.xjrsoft</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>xjrsoft-service-form</artifactId>
<properties>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-common-core</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-service-form-api</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-service-system-api</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-service-organization-api</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-service-magicapi-api</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-service-app-api</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-common-mybatis</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</dependency>
<dependency>
<groupId>com.xjrsoft</groupId>
<artifactId>xjrsoft-common-advice</artifactId>
<version>${xjrsoft.framework.version}</version>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

View File

@ -0,0 +1,24 @@
package com.xjrsoft.form;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.ComponentScan;
/**
* @Author: tzx
* @Date: 2023/10/10 17:16
*/
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = "com.xjrsoft")
@MapperScan(value = "com.xjrsoft.**.mapper")
@ComponentScan(value = "com.xjrsoft")
public class FormApplication {
public static void main(String[] args) {
SpringApplication.run(FormApplication.class, args);
}
}

View File

@ -0,0 +1,82 @@
package com.xjrsoft.form.client;
import cn.hutool.db.Entity;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.page.PageOutput;
import com.xjrsoft.common.generate.model.QueryConfig;
import com.xjrsoft.desktop.dto.*;
import com.xjrsoft.form.service.IFormExecuteService;
import com.xjrsoft.form.vo.DeskFormReleaseVo;
import com.xjrsoft.form.vo.DeskTableInfoVo;
import io.swagger.v3.oas.annotations.Hidden;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @Author: tzx
* @Date: 2023/10/10 16:51
*/
@Hidden
@RestController
@AllArgsConstructor
public class FormExecuteClient implements IFormExecuteClient {
private final IFormExecuteService formExecuteService;
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME+ "/complexAddFeign")
public boolean complexAddFeign(AddDeskComplexDto dto) {
return formExecuteService.complexAdd(dto);
}
@Override
@PutMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/complexUpdateFeign")
public boolean complexUpdateFeign(UpdateDeskComplexDto dto) {
return formExecuteService.complexUpdate(dto);
}
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/complexDeleteFeign")
public boolean complexDeleteFeign(DeleteDeskComplexDto dto) {
return formExecuteService.complexDelete(dto);
}
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME+ "/complexInfoFeign")
public Object complexInfoFeign(DeskComplexInfoDto dto) {
return formExecuteService.complexInfo(dto);
}
@Override
@GetMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/getReleaseInfoFeign")
public List<DeskFormReleaseVo> getReleaseInfoFeign(Long formId) {
return formExecuteService.getReleaseInfo(formId);
}
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/complexQueryFeign")
public List<QueryConfig> complexQueryFeign(ComplexQueryDto dto) {
return formExecuteService.complexQuery(dto);
}
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/complexPageFeign")
public PageOutput<Entity> complexPageFeign(ComplexPageDto dto) {
return formExecuteService.complexPage(dto);
}
@Override
@GetMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/getTableInfoFeign")
public DeskTableInfoVo getTableInfoFeign(Long formId) {
return formExecuteService.getTableInfo(formId);
}
}

View File

@ -0,0 +1,47 @@
package com.xjrsoft.form.client;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.service.IFormTemplateService;
import io.swagger.v3.oas.annotations.Hidden;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @Author: tzx
* @Date: 2023/10/11 9:35
*/
@Hidden
@RestController
@AllArgsConstructor
public class FormTemplateClient implements IFormTemplateClient {
private final IFormTemplateService formTemplateService;
@Override
@GetMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/getFormTemplateByIdFeign")
public FormTemplate getFormTemplateByIdFeign(Long id) {
return formTemplateService.getById(id);
}
@Override
@GetMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/getFormTemplateListByIdsFeign")
public List<FormTemplate> getFormTemplateListByIdsFeign(List<Long> ids) {
return formTemplateService.list(Wrappers.lambdaQuery(FormTemplate.class).in(ids.size() > 0, FormTemplate::getId, ids));
}
@Override
@PostMapping(GlobalConstant.CLIENT_API_PRE + GlobalConstant.MODULE_FORM_NAME + "/formTemplateSaveOrUpdateFeign")
public FormTemplate formTemplateSaveOrUpdateFeign(@RequestBody FormTemplate template) {
formTemplateService.saveOrUpdate(template);
return template;
}
}

View File

@ -0,0 +1,377 @@
package com.xjrsoft.form.controller;
import cn.hutool.core.util.StrUtil;
import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import cn.hutool.json.JSONUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.generator.ComponentConfig;
import com.xjrsoft.common.core.domain.result.R;
import com.xjrsoft.common.core.exception.MyException;
import com.xjrsoft.common.core.uitls.DateUtils;
import com.xjrsoft.common.generate.model.ColumnConfig;
import com.xjrsoft.common.generate.model.TableConfig;
import com.xjrsoft.common.mybatis.utils.DatasourceUtil;
import com.xjrsoft.common.mybatis.utils.LocalDateTimeUtil;
import com.xjrsoft.form.dto.*;
import com.xjrsoft.form.entity.FormDesignConfig;
import com.xjrsoft.form.entity.FormRelease;
import com.xjrsoft.form.entity.FormReleaseConfig;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.handler.FormContentStyleStrategy;
import com.xjrsoft.form.service.IFormExecuteService;
import com.xjrsoft.form.service.IFormReleaseService;
import com.xjrsoft.form.service.IFormTemplateService;
import com.xjrsoft.generate.constant.ComponentTypeConstant;
import com.xjrsoft.generate.utils.GeneratorUtil;
import com.xjrsoft.system.dto.BatchSetDataAuthDto;
import com.xjrsoft.system.utils.ExcelUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import oracle.sql.INTERVALDS;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.validation.Valid;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.sql.Date;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 自定义表单 执行控制器
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@RestController
@RequestMapping(GlobalConstant.FORM_MODULE_PREFIX + "/execute")
@Tag(name = GlobalConstant.FORM_MODULE_PREFIX + "/execute", description = "自定义表单统一执行接口")
@AllArgsConstructor
public class FormExecuteController {
private final IFormExecuteService formExecuteService;
private final IFormReleaseService formReleaseService;
private final IFormTemplateService formTemplateService;
/**
* 自定义表单 根据配置获取列表数据 不分页
*
* @param dto
*/
@PostMapping(value = "/list")
@Operation(summary = "自定义表单根据配置获取列表数据 不分页")
public R list(@Valid @RequestBody FormExecuteListDto dto) {
return R.ok(formExecuteService.list(dto));
}
/**
* 自定义表单 根据配置获取列表数据 不分页
*
* @param dto
*/
@PostMapping(value = "/app/list")
@Operation(summary = "App 自定义表单根据配置获取列表数据 不分页")
public R appList(@Valid @RequestBody AppFormExecuteListDto dto) {
return R.ok(formExecuteService.appList(dto));
}
/**
* 自定义表单 根据配置获取列表数据 分页
*
* @param dto
*/
@PostMapping(value = "/page")
@Operation(summary = "自定义表单根据配置获取列表数据 分页")
public R page(@Valid @RequestBody FormExecutePageDto dto) {
return R.ok(formExecuteService.page(dto));
}
/**
* App 自定义表单 根据配置获取列表数据 分页
*
* @param dto
*/
@PostMapping(value = "/app/page")
@Operation(summary = "App 自定义表单根据配置获取列表数据 分页")
public R appPage(@Valid @RequestBody AppFormExecutePageDto dto) {
return R.ok(formExecuteService.appPage(dto));
}
/**
* 自定义表单 根据配置获取 表单数据
*
* @param dto 发布表id
*/
@PostMapping(value = "/info")
@Operation(summary = "表单数据")
public R info(@Valid @RequestBody FormExecuteInfoDto dto) {
return R.ok(formExecuteService.info(dto));
}
/**
* app 自定义表单 根据配置获取 表单数据
*
* @param dto
*/
@PostMapping(value = "/app/info")
@Operation(summary = "app 表单数据")
public R appInfo(@Valid @RequestBody AppFormExecuteInfoDto dto) {
return R.ok(formExecuteService.appInfo(dto));
}
/**
* 自定义表单 根据配置获取 新增 表单数据
*
*/
@PostMapping(value = "/add")
@Operation(summary = "新增")
public R add(@Valid @RequestBody FormExecuteAddOrUpdateDto dto) {
return R.ok(formExecuteService.add(dto));
}
/**
* app 自定义表单 根据配置获取 新增 表单数据
*
*/
@PostMapping(value = "/app/add")
@Operation(summary = "app 新增")
public R appAdd(@Valid @RequestBody AppFormExecuteAddOrUpdateDto dto) {
return R.ok(formExecuteService.appAdd(dto));
}
/**
* 自定义表单 根据配置获取 修改 表单数据
*
*/
@PostMapping(value = "/update")
@Operation(summary = "修改")
public R update(@Valid @RequestBody FormExecuteAddOrUpdateDto dto) {
return R.ok(formExecuteService.update(dto));
}
/**
* app 自定义表单 根据配置获取 修改 表单数据
*
*/
@PostMapping(value = "/app/update")
@Operation(summary = "app 修改")
public R appUpdate(@Valid @RequestBody AppFormExecuteAddOrUpdateDto dto) {
return R.ok(formExecuteService.appUpdate(dto));
}
/**
* 自定义表单 根据配置获取 删除 表单数据
*
*/
@PostMapping(value = "/delete")
@Operation(summary = "删除")
public R delete(@Valid @RequestBody FormExecuteDeleteDto dto) {
return R.ok(formExecuteService.delete(dto));
}
/**
* app 自定义表单 根据配置获取 删除 表单数据
*
*/
@PostMapping(value = "/app/delete")
@Operation(summary = "app 删除")
public R appDelete(@Valid @RequestBody AppFormExecuteDeleteDto dto) {
return R.ok(formExecuteService.appDelete(dto));
}
/**
* 工作流模块 使用 自定义表单 根据配置获取 表单数据
*
* @param dto
*/
@PostMapping(value = "/workflow/info")
@Operation(summary = "表单数据")
public R workFlowInfo(@Valid @RequestBody FormExecuteWorkflowInfoDto dto) {
return R.ok(formExecuteService.workFlowInfo(dto));
}
@PostMapping(value = "/export")
@Operation(summary = "导出")
public ResponseEntity<byte[]> export(@Valid @RequestBody FormExecuteListDto dto) {
FormRelease formRelease = formReleaseService.getById(dto.getReleaseId());
FormReleaseConfig formReleaseConfig = JSONUtil.toBean(formRelease.getConfigJson(), FormReleaseConfig.class);
// 配置excel第一行字段名
List<List<String>> head = new ArrayList<>();
List<ColumnConfig> columnConfigs = formReleaseConfig.getListConfig().getColumnConfigs();
FormTemplate formTemplate = formTemplateService.getById(formRelease.getFormId());
//自定义表单配置
FormDesignConfig formDesignConfig = JSONUtil.toBean(formTemplate.getFormJson(), FormDesignConfig.class);
List<ComponentConfig> componentConfigList = GeneratorUtil.getFormComponentListWithMain(formDesignConfig.getFormJson().getList());
List<ComponentConfig> columnComponentConfigList = new ArrayList<>();
for (ColumnConfig config : columnConfigs) {
String columnName = config.getColumnName();
for (ComponentConfig componentConfig : componentConfigList) {
if (StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindField())
|| StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindStartTime())
|| StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindEndTime())) {
String label = config.getLabel();
// 如果是必填,导出列头名称加上必填标识
if (MapUtils.getBoolean(componentConfig.getOptions(), "required", false)) {
label = label + GlobalConstant.EXPORT_REQUIRED_SUFFIX;
}
head.add(Collections.singletonList(label));
columnComponentConfigList.add(componentConfig);
break;
}
}
}
List<Map<Integer, Object>> exportList = new ArrayList<>();
if (!dto.getIsTemplate()) {
// 构建导出数据格式
dto.setIsTrans(false);
// Boolean isPage = formReleaseConfig.getListConfig().getIsPage();
List<Entity> entityList = formExecuteService.list(dto);
// if (isPage) {
// dataList = formExecuteService.page(dto).getList();
// } else {
// dataList = formExecuteService.list(BeanUtil.toBean(dto, FormExecuteListDto.class));
// }
List<Map<String, Object>> dataList = entityList.stream().map(entity -> (Map<String, Object>) entity).collect(Collectors.toList());
ExcelUtil.transExcelData((List<Map<String, Object>>)dataList, columnComponentConfigList, false);
// 时间日期格式转换
for (Map<String, Object> data : dataList) {
Map<Integer, Object> exportData = new HashMap<>(data.size());
for (int i = 0; i < columnConfigs.size(); i++) {
ColumnConfig config = columnConfigs.get(i);
Object value = data.get(config.getColumnName());
String componentType = config.getComponentType();
// 日期时间字段格式化
if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE, componentType)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE_RANGE, componentType)
|| (StrUtil.equalsIgnoreCase(ComponentTypeConstant.INFO, componentType)
&& MapUtils.getIntValue(config.getComponentProps(), "infoType") == 2)) {
String format = LocalDateTimeUtil.convertFontFormat(StringUtils.defaultIfEmpty(config.getFormat(), DateUtils.DATE_TIME_PATTERN));
LocalDateTime dateTime = null;
if (value instanceof Date) {
dateTime = ((Date) value).toLocalDate().atStartOfDay();
} else if (value instanceof Timestamp) {
dateTime = ((Timestamp)value).toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}
value = LocalDateTimeUtil.format(dateTime, format);
} else if ((StrUtil.equalsIgnoreCase(ComponentTypeConstant.TIME, componentType)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.TIME_RANGE, componentType))) {
LocalTime time = null;
if (value instanceof Time) {
time = ((Time) value).toLocalTime();
} else if (value instanceof INTERVALDS) {
time = LocalDateTimeUtil.convertIntervalToLocalTime((INTERVALDS)value);
}
value = LocalDateTimeUtil.format(time);
}
exportData.put(i, value);
}
exportList.add(exportData);
}
}
ByteArrayOutputStream bot = new ByteArrayOutputStream();
EasyExcel.write(bot).head(head).automaticMergeHead(false)
.registerWriteHandler(new FormContentStyleStrategy())
.excelType(ExcelTypeEnum.XLSX).sheet().doWrite(exportList);
ByteArrayOutputStream resultBot = ExcelUtil.renderExportRequiredHead(bot);
return R.fileStream(resultBot.toByteArray(), formReleaseConfig.getMenuConfig().getName() + ExcelTypeEnum.XLSX.getValue());
}
@PostMapping("/import")
@Operation(summary = "导入")
public R importData(@RequestParam String releaseId, @RequestParam MultipartFile file) throws IOException {
FormRelease formRelease = formReleaseService.getById(releaseId);
FormReleaseConfig formReleaseConfig = JSONUtil.toBean(formRelease.getConfigJson(), FormReleaseConfig.class);
FormTemplate formTemplate = formTemplateService.getById(formRelease.getFormId());
//自定义表单配置
FormDesignConfig formDesignConfig = JSONUtil.toBean(formTemplate.getFormJson(), FormDesignConfig.class);
List<ComponentConfig> componentConfigList = GeneratorUtil.getFormComponentListWithMain(formDesignConfig.getFormJson().getList());
List<ComponentConfig> columnComponentConfigList = new ArrayList<>();
// 配置excel第一行字段名
List<List<String>> head = new ArrayList<>();
List<ColumnConfig> columnConfigs = formReleaseConfig.getListConfig().getColumnConfigs();
for (ColumnConfig config : columnConfigs) {
head.add(Collections.singletonList(config.getLabel()));
for (ComponentConfig componentConfig : componentConfigList) {
String columnName = config.getColumnName();
if (StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindField())
|| StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindStartTime())
|| StrUtil.equalsIgnoreCase(columnName, componentConfig.getBindEndTime())) {
String label = config.getLabel();
// 如果是必填,导出列头名称加上必填标识
if (MapUtils.getBoolean(componentConfig.getOptions(), "required", false)) {
label = label + GlobalConstant.EXPORT_REQUIRED_SUFFIX;
}
head.add(Collections.singletonList(label));
columnComponentConfigList.add(componentConfig);
break;
}
}
}
List<Map<Integer, Object>> dataList = EasyExcel.read(file.getInputStream()).head(head).sheet().doReadSync();
// 构建保存数据
List<Map<String, Object>> savedDataList = new ArrayList<>(dataList.size());
for (Map<Integer, Object> data : dataList) {
Map<String, Object> saveData = new HashMap<>(data.size());
for (int i = 0; i < columnConfigs.size(); i++) {
ColumnConfig columnConfig = columnConfigs.get(i);
saveData.put(columnConfig.getColumnName(), data.get(i));
}
savedDataList.add(saveData);
}
ExcelUtil.transExcelData(savedDataList, columnComponentConfigList, true);
formExecuteService.saveMainBatch(formRelease.getFormId(), savedDataList);
return R.ok();
}
@PutMapping("/data-auth")
@Operation(summary = "批量设置权限所属人")
public R setDataAuth(@RequestBody BatchSetDataAuthDto dto, @RequestParam String releaseId){
FormRelease formRelease = formReleaseService.getById(releaseId);
FormTemplate template = formTemplateService.getById(formRelease.getFormId());
String formJson = template.getFormJson();
//自定义表单配置
FormDesignConfig formDesignConfig = JSONUtil.toBean(formJson, FormDesignConfig.class);
//表关系配置
List<TableConfig> tableConfigs = formDesignConfig.getTableConfigs();
//主表
Optional<TableConfig> mainTable = tableConfigs.stream().filter(TableConfig::getIsMain).findFirst();
String tableName = mainTable.get().getTableName();
// 修改的数据
Entity entity = Entity.create(tableName).set(GlobalConstant.AUTH_USER_ID, dto.getUserIdList().get(0));
Entity where = Entity.create(tableName).set(mainTable.get().getPkField(), dto.getDataIdList());
try {
Db.use(DatasourceUtil.getDataSource(formDesignConfig.getDatabaseId())).update(entity, where);
} catch (SQLException e) {
throw new MyException("批量设置权限所属人失败!");
}
return R.ok();
}
}

View File

@ -0,0 +1,83 @@
package com.xjrsoft.form.controller;
import cn.hutool.core.bean.BeanUtil;
import com.github.yulichang.toolkit.MPJWrappers;
import com.xjrsoft.common.core.annotation.XjrLog;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.result.R;
import com.xjrsoft.common.core.uitls.VoToColumnUtil;
import com.xjrsoft.form.dto.FormHistoryChangeDto;
import com.xjrsoft.form.entity.FormHistory;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.service.IFormHistoryService;
import com.xjrsoft.form.vo.FormHistoryListVo;
import com.xjrsoft.form.vo.FormTemplateVo;
import com.xjrsoft.organization.entity.User;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;
/**
* <p>
* 自定义表单历史表 每次修改自定义表单会新增一条数据 前端控制器
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@RestController
@RequestMapping(GlobalConstant.FORM_MODULE_PREFIX + "/history")
@Tag(name = GlobalConstant.FORM_MODULE_PREFIX + "/history", description = "自定义表单历史表")
@AllArgsConstructor
public class FormHistoryController {
private final IFormHistoryService formHistoryService;
@GetMapping(value = "/list")
@Operation(summary = "历史记录")
@XjrLog(value = "自定义表单历史记录")
public R list(@RequestParam Long formId) {
List<FormHistoryListVo> formHistoryListVos = formHistoryService.selectJoinList(FormHistoryListVo.class,
MPJWrappers.<FormHistory>lambdaJoin()
.eq(FormHistory::getFormId, formId)
.select(FormHistory::getId)
.select(FormHistory.class, x -> VoToColumnUtil.fieldsToColumns(FormHistoryListVo.class).contains(x.getProperty()))
.selectAs(User::getName, FormHistoryListVo::getCreateUserName)
.leftJoin(User.class, User::getId, FormHistory::getCreateUserId)
.orderByDesc(FormTemplate::getCreateDate)
);
List<FormHistoryListVo> listVos = BeanUtil.copyToList(formHistoryListVos, FormHistoryListVo.class);
return R.ok(listVos);
}
@PutMapping("/set-version")
@Operation(summary = "代码生成,更新到此版本")
public R change(@Valid @RequestBody FormHistoryChangeDto dto) {
return R.ok(formHistoryService.change(dto));
}
@GetMapping("/preview")
@Operation(summary = "历史记录的xml")
public R preview(@RequestParam Long historyId){
FormHistory history = formHistoryService.getById(historyId);
return R.ok(history.getFormJson());
}
@GetMapping(value = "/info")
@Operation(summary = "表单设计模板详情")
@XjrLog(value = "表单设计模板详情")
public R info(@RequestParam Long id) {
FormHistory history = formHistoryService.getById(id);
if (history == null) {
return R.error("找不到此数据!");
}
return R.ok(BeanUtil.toBean(history, FormTemplateVo.class));
}
}

View File

@ -0,0 +1,105 @@
package com.xjrsoft.form.controller;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.github.yulichang.toolkit.MPJWrappers;
import com.xjrsoft.common.core.annotation.XjrLog;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.page.PageOutput;
import com.xjrsoft.common.core.domain.result.R;
import com.xjrsoft.common.core.uitls.VoToColumnUtil;
import com.xjrsoft.common.mybatis.utils.ConventPage;
import com.xjrsoft.form.dto.AddFormReleaseDto;
import com.xjrsoft.form.dto.FormReleasePageDto;
import com.xjrsoft.form.dto.UpdateFormReleaseDto;
import com.xjrsoft.form.entity.FormRelease;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.service.IFormReleaseService;
import com.xjrsoft.form.vo.FormReleasePageVo;
import com.xjrsoft.form.vo.FormReleaseVo;
import com.xjrsoft.system.entity.Menu;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;
/**
* <p>
* 自定义表单 发布表 前端控制器
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@RestController
@RequestMapping(GlobalConstant.FORM_MODULE_PREFIX + "/release")
@Tag(name = GlobalConstant.FORM_MODULE_PREFIX + "/release", description = "自定义表单发布")
@AllArgsConstructor
public class FormReleaseController {
private final IFormReleaseService formReleaseService;
@GetMapping(value = "/page")
@Operation(summary = "表单发布列表(分页)")
@XjrLog(value = "获取表单发布列表")
public R page(@Valid FormReleasePageDto dto) {
//因为多表关联 会有多个表都使用了id字段 所以必须专门指定主表的Id
IPage<FormReleasePageVo> page = formReleaseService.selectJoinListPage(ConventPage.getPage(dto), FormReleasePageVo.class,
MPJWrappers.<FormRelease>lambdaJoin()
.and(StrUtil.isNotBlank(dto.getKeyword()),
wrapper -> wrapper.like(Menu::getName, dto.getKeyword())
.or().like(FormTemplate::getName, dto.getKeyword()))
.select(FormRelease::getId)
.select(FormRelease.class, x -> VoToColumnUtil.fieldsToColumns(FormReleasePageVo.class).contains(x.getProperty()))
.selectAs(Menu::getTitle,FormReleasePageVo::getMenuName)
.selectAs(FormTemplate::getName, FormReleasePageVo::getFormName)
.leftJoin(Menu.class, Menu::getId, FormRelease::getMenuId)
.leftJoin(FormTemplate.class, FormTemplate::getId, FormRelease::getFormId)
.orderByDesc(FormRelease::getCreateDate));
PageOutput<FormReleasePageVo> pageOutput = ConventPage.getPageOutput(page);
return R.ok(pageOutput);
}
@PostMapping
@Operation(summary = "自定义表单发布")
@XjrLog(value = "自定义表单发布")
public R add(@Valid @RequestBody AddFormReleaseDto dto) {
return R.ok(formReleaseService.addFormRelease(dto));
}
@PutMapping
@Operation(summary = "修改自定义表单发布")
@XjrLog(value = "自定义表单发布" )
public R update(@Valid @RequestBody UpdateFormReleaseDto dto) {
return R.ok(formReleaseService.updateFormRelease(dto));
}
@GetMapping(value = "/info")
@Operation(summary = "表单发布详情")
public R info(@RequestParam Long id) {
//因为多表关联 会有多个表都使用了id字段 所以必须专门指定主表的Id
FormRelease release = formReleaseService.getById(id);
if (release == null) {
return R.error("表单发布数据不存在");
}
return R.ok(BeanUtil.toBean(release, FormReleaseVo.class));
}
@DeleteMapping
@Operation(summary = "删除")
@XjrLog(value = "删除")
public R delete(@Valid @RequestBody List<Long> ids) {
return R.ok(formReleaseService.removeBatchByIds(ids));
}
}

View File

@ -0,0 +1,294 @@
package com.xjrsoft.form.controller;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.github.yulichang.toolkit.MPJWrappers;
import com.xjrsoft.common.core.annotation.XjrLog;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.generator.FormConfig;
import com.xjrsoft.common.core.domain.page.PageOutput;
import com.xjrsoft.common.core.domain.result.R;
import com.xjrsoft.common.core.enums.YesOrNoEnum;
import com.xjrsoft.common.core.uitls.VoToColumnUtil;
import com.xjrsoft.common.generate.model.ListConfig;
import com.xjrsoft.common.generate.model.TableConfig;
import com.xjrsoft.common.mybatis.utils.ConventPage;
import com.xjrsoft.form.dto.*;
import com.xjrsoft.form.entity.FormHistory;
import com.xjrsoft.form.entity.FormRelease;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.entity.MenuConfig;
import com.xjrsoft.form.service.IFormHistoryService;
import com.xjrsoft.form.service.IFormReleaseService;
import com.xjrsoft.form.service.IFormTemplateService;
import com.xjrsoft.form.vo.FormTemplateListVo;
import com.xjrsoft.form.vo.FormTemplatePageVo;
import com.xjrsoft.form.vo.FormTemplateVo;
import com.xjrsoft.generate.client.IGenerateClient;
import com.xjrsoft.generate.dto.DataFirstPreviewDto;
import com.xjrsoft.organization.entity.User;
import com.xjrsoft.system.client.IMenuClient;
import com.xjrsoft.system.entity.CodeSchema;
import com.xjrsoft.system.entity.DictionaryDetail;
import com.xjrsoft.system.entity.Menu;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 表单设计模板 前端控制器
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@RestController
@RequestMapping(GlobalConstant.FORM_MODULE_PREFIX + "/template")
@Tag(name = GlobalConstant.FORM_MODULE_PREFIX + "/template", description = "自定义表单-代码生成器 模板设计")
@AllArgsConstructor
public class FormTemplateController {
private final IFormTemplateService formTemplateService;
private final IFormHistoryService formHistoryService;
private final IFormReleaseService formReleaseService;
private final IGenerateClient generateClient;
private final IMenuClient menuClient;
@GetMapping(value = "/list")
@Operation(summary = "表单设计模板(不分页)")
@XjrLog(value = "表单设计模板")
public R list(@Valid FormTemplateListDto dto) {
List<FormTemplate> list = formTemplateService.list(Wrappers.lambdaQuery(FormTemplate.class)
.eq(FormTemplate::getFormType, dto.getType())
.eq(dto.getCategory() != 0, FormTemplate::getCategory, dto.getCategory())
.like(StrUtil.isNotBlank(dto.getKeyword()), FormTemplate::getName, dto.getKeyword())
.orderByDesc(FormTemplate::getCreateDate)
.select(FormTemplate.class, x -> VoToColumnUtil.fieldsToColumns(FormTemplateListVo.class).contains(x.getProperty())));
List<FormTemplateListVo> formTemplateListVos = BeanUtil.copyToList(list, FormTemplateListVo.class);
return R.ok(formTemplateListVos);
}
@GetMapping(value = "/page")
@Operation(summary = "表单设计模板(分页),过滤未启用数据")
@XjrLog(value = "表单设计模板")
public R page(@Valid FormTemplatePageDto dto) {
//因为多表关联 会有多个表都使用了id字段 所以必须专门指定主表的Id
IPage<FormTemplatePageVo> page = formTemplateService.selectJoinListPage(ConventPage.getPage(dto), FormTemplatePageVo.class,
MPJWrappers.<FormTemplate>lambdaJoin().disableSubLogicDel()
.orderByDesc(FormTemplate::getCreateDate)
.like(StrUtil.isNotBlank(dto.getKeyword()), FormTemplate::getName, dto.getKeyword())
.eq(FormTemplate::getFormType, dto.getType())
.eq(ObjectUtil.isNotNull(dto.getCategory()) && dto.getCategory() != 0, FormTemplate::getCategory, dto.getCategory())
.eq(FormTemplate::getEnabledMark, YesOrNoEnum.YES.getCode())
.select(FormTemplate::getId)
.selectAs(User::getName, FormTemplatePageVo::getCreateUserName)
.select(FormTemplate.class, x -> VoToColumnUtil.fieldsToColumns(FormTemplatePageVo.class).contains(x.getProperty()))
.selectAs(DictionaryDetail::getName, FormTemplatePageVo::getCategoryName)
.leftJoin(DictionaryDetail.class, DictionaryDetail::getId, FormTemplate::getCategory)
.leftJoin(User.class, User::getId, FormTemplate::getCreateUserId)
.leftJoin(Menu.class, on->on.eq(Menu::getFormId, FormTemplate::getId).eq(Menu::getDeleteMark, YesOrNoEnum.NO.getCode()))
.selectAs(Menu::getId, FormTemplatePageVo::getMenuId)
.selectAs(Menu::getComponent, FormTemplatePageVo::getMenuComponent)
.isNotNull(Menu::getId)//只有发布为菜单的表单,才可以绑定流程,从而过滤掉已删除功能或不发布的表单
);
//系统表单需要多返回一些数据
List<FormTemplatePageVo> records = page.getRecords().stream().filter(x -> x.getFormType() == YesOrNoEnum.NO.getCode()).collect(Collectors.toList());;
if (records.size() > 0){
List<Menu> allMenuListFeign = menuClient.getAllMenuListFeign();
for (FormTemplatePageVo record : records) {
//去menu表里面找道对应的功能名称和功能模块名称
Menu menu = allMenuListFeign.stream().filter(x->ObjectUtil.isNotEmpty(x.getFormId()) && x.getFormId().equals(record.getId())).findFirst().orElse(new Menu());
if (menu != null && ObjectUtil.isNotEmpty(menu.getId())) {
String[] split = menu.getComponent().split(StringPool.SLASH);
record.setFunctionalModule(split[1]);
record.setFunctionName(split[2]);
}
}
}
PageOutput<FormTemplatePageVo> pageOutput = ConventPage.getPageOutput(page);
return R.ok(pageOutput);
}
@GetMapping(value = "/enabled-page")
@Operation(summary = "表单设计模板(分页),不过滤未启用数据")
@XjrLog(value = "表单设计模板")
public R pageEnabled(@Valid FormTemplatePageDto dto) {
//因为多表关联 会有多个表都使用了id字段 所以必须专门指定主表的Id
IPage<FormTemplatePageVo> page = formTemplateService.selectJoinListPage(ConventPage.getPage(dto), FormTemplatePageVo.class,
MPJWrappers.<FormTemplate>lambdaJoin().disableSubLogicDel()
.orderByDesc(FormTemplate::getCreateDate)
.like(StrUtil.isNotBlank(dto.getKeyword()), FormTemplate::getName, dto.getKeyword())
.eq(FormTemplate::getFormType, dto.getType())
.eq(ObjectUtil.isNotNull(dto.getCategory()) && dto.getCategory() != 0, FormTemplate::getCategory, dto.getCategory())
.select(FormTemplate::getId)
.selectAs(User::getName, FormTemplatePageVo::getCreateUserName)
.select(FormTemplate.class, x -> VoToColumnUtil.fieldsToColumns(FormTemplatePageVo.class).contains(x.getProperty()))
.selectAs(DictionaryDetail::getName, FormTemplatePageVo::getCategoryName)
.leftJoin(DictionaryDetail.class, DictionaryDetail::getId, FormTemplate::getCategory)
.leftJoin(User.class, User::getId, FormTemplate::getCreateUserId));
PageOutput<FormTemplatePageVo> pageOutput = ConventPage.getPageOutput(page);
return R.ok(pageOutput);
}
@GetMapping(value = "/info")
@Operation(summary = "表单设计模板详情")
@XjrLog(value = "表单设计模板详情")
public R info(@RequestParam Long id) {
FormTemplate template = formTemplateService.getById(id);
if (template == null) {
return R.error("找不到此数据!");
}
FormTemplateVo formTemplateVo = BeanUtil.toBean(template, FormTemplateVo.class);
if (template.getFormType() == YesOrNoEnum.NO.getCode()){//系统表单
//去menu表里面找道对应的功能名称和功能模块名称
List<Menu> allMenuListFeign = menuClient.getAllMenuListFeign();
Menu menu = allMenuListFeign.stream().filter(x -> ObjectUtil.isNotEmpty(x.getFormId()) && x.getFormId().equals(template.getId())).findFirst().orElse(new Menu());
if (menu != null && ObjectUtil.isNotEmpty(menu.getId())) {
String[] split = menu.getComponent().split(StringPool.SLASH);
formTemplateVo.setFunctionalModule(split[1]);
formTemplateVo.setFunctionName(split[2]);
}else {
return R.error("找不到对应的系统表单功能名称和功能模块名称");
}
}
return R.ok(formTemplateVo);
}
@GetMapping(value = "/info/multi")
@Operation(summary = "表单设计模板详情(批量查询)")
@XjrLog(value = "表单设计模板详情(批量查询)")
public R multiInfo(@RequestParam String id) {
List<FormTemplate> formTemplates = formTemplateService.listByIds(Arrays.asList(id.split(StringPool.COMMA)));
List<FormTemplateVo> formTemplateVos = BeanUtil.copyToList(formTemplates, FormTemplateVo.class);
return R.ok(formTemplateVos);
}
@PutMapping("/status")
@Operation(summary = "修改表单状态")
@XjrLog(value = "修改表单状态")
public R updateEnabled(@Valid @RequestBody UpdateTemplateStatusDto dto) {
//根据id修改表单enabledMark
return R.ok(formTemplateService.update(Wrappers.<FormTemplate>update().lambda().set(FormTemplate::getEnabledMark, dto.getEnabledMark()).eq(FormTemplate::getId, dto.getId())));
}
@PostMapping(value = "/data-first")
@Operation(summary = "数据优先 新增")
@XjrLog(value = "数据优先新增")
public R addDataFirst(@Valid @RequestBody AddFormDataFirstDto dto) {
return R.ok(formTemplateService.addDataFirst(dto));
}
@PostMapping(value = "/code-first")
@Operation(summary = "界面优先 或者 简易模板 新增")
@XjrLog(value = "界面优先 或者 简易模板新增")
public R addCodeFirst(@Valid @RequestBody AddFormCodeFirstDto dto) throws Exception {
return R.ok(formTemplateService.addCodeFirst(dto));
}
@PutMapping(value = "/data-first")
@Operation(summary = "修改数据优先")
@XjrLog(value = "修改数据优先")
public R updateDataFirst(@Valid @RequestBody UpdateFormDataFirstDto dto) throws JsonProcessingException {
return R.ok(formTemplateService.updateDataFirst(dto));
}
@PutMapping(value = "/code-first")
@Operation(summary = "修改界面优先")
@XjrLog(value = "修改界面优先")
public R updateCodeFirst(@Valid @RequestBody UpdateFormCodeFirstDto dto) throws Exception {
return R.ok(formTemplateService.updateCodeFirst(dto));
}
@DeleteMapping
@Operation(summary = "删除")
public R delete(@Valid @RequestBody List<Long> ids) {
formHistoryService.remove(Wrappers.lambdaQuery(FormHistory.class).in(FormHistory::getFormId, ids));
return R.ok(formTemplateService.removeBatchByIds(ids));
}
@PostMapping(value = "/test-code")
@Operation(summary = "表单测试代码生成器")
@XjrLog(value = "测试表单预览代码生成器")
public R test(@Valid @RequestBody DateTestDto dto){
FormRelease formRelease = formReleaseService.getById(dto.getFormReleaseId());
FormTemplate formTemplate = formTemplateService.getById(dto.getFormTemplateId());
JSONObject configJson = JSON.parseObject(formRelease.getConfigJson());
JSONObject formJson = JSON.parseObject(formTemplate.getFormJson());
dto.setDatabaseId(formJson.get("databaseId").toString());
dto.setTableConfigs(JSONObject.parseArray(formJson.getString("tableConfigs"), TableConfig.class));
dto.setFormJson(JSON.parseObject(formJson.getString("formJson"), FormConfig.class));
dto.setListConfig(JSON.parseObject(configJson.getString("listConfig"), ListConfig.class));
dto.setMenuConfig(JSON.parseObject(configJson.getString("menuConfig"), MenuConfig.class));
dto.setOutputConfig(dto.getOutputConfig());
return R.ok(generateClient.getPreviewCodesFeign(BeanUtil.toBean(dto, DataFirstPreviewDto.class)));
}
@GetMapping(value = "/desk-form-page")
@Operation(summary = "桌面设计-复杂列表页使用(分页),过滤未启用数据")
@XjrLog(value = "表单设计模板")
public R deskFormPage(@Valid FormTemplateDeskPageDto dto) {
//只需要已发布的,和系统表单的数据
List<Long> releaseIds = formReleaseService.list().stream().map(FormRelease::getFormId).collect(Collectors.toList());
//因为多表关联 会有多个表都使用了id字段 所以必须专门指定主表的Id
IPage<FormTemplatePageVo> page = formTemplateService.selectJoinListPage(ConventPage.getPage(dto), FormTemplatePageVo.class,
MPJWrappers.<FormTemplate>lambdaJoin().disableSubLogicDel()
.orderByDesc(FormTemplate::getCreateDate)
.like(StrUtil.isNotBlank(dto.getKeyword()), FormTemplate::getName, dto.getKeyword())
.eq(FormTemplate::getFormType, dto.getType())
.eq(ObjectUtil.isNotNull(dto.getCategory()) && dto.getCategory() != 0, FormTemplate::getCategory, dto.getCategory())
.eq(FormTemplate::getEnabledMark,YesOrNoEnum.YES.getCode())
.in(dto.getType() == YesOrNoEnum.YES.getCode() && CollectionUtil.isNotEmpty(releaseIds),FormTemplate::getId,releaseIds) //自定义表单需要过滤出来已发布的数据
.select(FormTemplate::getId)
.selectAs(User::getName, FormTemplatePageVo::getCreateUserName)
.select(FormTemplate.class, x -> VoToColumnUtil.fieldsToColumns(FormTemplatePageVo.class).contains(x.getProperty()))
.selectAs(DictionaryDetail::getName, FormTemplatePageVo::getCategoryName)
.leftJoin(DictionaryDetail.class, DictionaryDetail::getId, FormTemplate::getCategory)
.leftJoin(User.class, User::getId, FormTemplate::getCreateUserId));
List<FormTemplatePageVo> records = page.getRecords();
if (records.size() > 0){
List<Menu> allMenuListFeign = menuClient.getAllMenuListFeign();
for (FormTemplatePageVo record : records) {
if (record.getFormType() == YesOrNoEnum.NO.getCode()){//如果是系统表单的数据,需要返回给你类名等数据
//去menu表里面找道对应的功能名称和功能模块名称
Menu menu = allMenuListFeign.stream().filter(x->ObjectUtil.isNotEmpty(x.getFormId()) && x.getFormId().equals(record.getId())).findFirst().orElse(new Menu());
if (menu != null && ObjectUtil.isNotEmpty(menu.getId())) {
String[] split = menu.getComponent().split(StringPool.SLASH);
record.setFunctionalModule(split[1]);
record.setFunctionName(split[2]);
}
}
}
}
PageOutput<FormTemplatePageVo> pageOutput = ConventPage.getPageOutput(page);
return R.ok(pageOutput);
}
}

View File

@ -0,0 +1,34 @@
package com.xjrsoft.form.handler;
import com.alibaba.excel.metadata.Head;
import com.alibaba.excel.metadata.data.DataFormatData;
import com.alibaba.excel.write.metadata.style.WriteCellStyle;
import com.alibaba.excel.write.style.AbstractVerticalCellStyleStrategy;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
public class FormContentStyleStrategy extends AbstractVerticalCellStyleStrategy {
// private List<String> columnTypeList;
//
// public FormContentStyleStrategy(List<String> columnTypeList) {
// this.columnTypeList = columnTypeList;
// }
@Override
protected WriteCellStyle contentCellStyle(Head head) {
WriteCellStyle style = new WriteCellStyle();
// for (int i = 0; i < columnTypeList.size(); i++) {
// if (head.getColumnIndex() == i) {
// }
// }
DataFormatData dataFormatData = new DataFormatData();
dataFormatData.setIndex((short)49);
style.setDataFormatData(dataFormatData);
return style;
}
}

View File

@ -0,0 +1,183 @@
package com.xjrsoft.form.service;
import cn.hutool.db.Entity;
import cn.hutool.db.Session;
import com.xjrsoft.common.core.domain.page.PageOutput;
import com.xjrsoft.common.generate.model.QueryConfig;
import com.xjrsoft.desktop.dto.*;
import com.xjrsoft.form.dto.*;
import com.xjrsoft.form.vo.DeskFormReleaseVo;
import com.xjrsoft.form.vo.DeskTableInfoVo;
import org.apache.commons.lang3.tuple.Triple;
import java.util.List;
import java.util.Map;
/**
* @Author: tzx
* @Date: 2022/5/11 14:57
*/
public interface IFormExecuteService {
/**
* 获取自定义表单不分页列表数据
* @param dto
* @return
*/
List<Entity> list(FormExecuteListDto dto);
/**
* App 获取自定义表单不分页列表数据
* @param dto
* @return
*/
List<Entity> appList(AppFormExecuteListDto dto);
/**
* 获取自定义表单分页列表数据
* @param dto
* @return
*/
PageOutput<Entity> page(FormExecutePageDto dto);
/**
* App 获取自定义表单分页列表数据
* @param dto
* @return
*/
PageOutput<Entity> appPage(AppFormExecutePageDto dto);
/**
* 获取自定义表单 表单数据
* @return
*/
Object info(FormExecuteInfoDto dto);
/**
* App 获取自定义表单 表单数据
* @return
*/
Object appInfo(AppFormExecuteInfoDto dto);
/**
* 自定义表单 新增
* @param dto
* @return
*/
Boolean add(FormExecuteAddOrUpdateDto dto);
/**
* App 自定义表单 新增
* @param dto
* @return
*/
Boolean appAdd(AppFormExecuteAddOrUpdateDto dto);
/**
* 自定义表单 修改
* @param dto
* @return
*/
Boolean update(FormExecuteAddOrUpdateDto dto);
/**
* app 自定义表单 修改
* @param dto
* @return
*/
Boolean appUpdate(AppFormExecuteAddOrUpdateDto dto);
/**
* 自定义表单 删除
* @param dto
* @return
*/
Boolean delete(FormExecuteDeleteDto dto);
/**
* app 自定义表单 删除
* @param dto
* @return
*/
Boolean appDelete(AppFormExecuteDeleteDto dto);
/**
* 工作流调用 自定义表单 新增
* @param dto
* @return
*/
Triple<Session, Long, Long> workflowAdd(FormExecuteWorkflowAddDto dto);
/**
* 工作流调用 自定义表单 修改
* @param dto
* @return
*/
Triple<Session, Long, Long> workflowUpdate(FormExecuteWorkflowUpdateDto dto);
/**
* 工作流调用 自定义表单 新增或者修改
* @param dto
* @return
*/
Triple<Session, Boolean, Long> workflowAddOrUpdate(FormExecuteWorkflowUpdateDto dto);
/**
* 获取自定义表单 表单数据
* @return
*/
Object workFlowInfo(FormExecuteWorkflowInfoDto dto);
/**
* 批量新增主表数据
* @return
*/
Boolean saveMainBatch(Long formTemplateId, List<Map<String, Object>> dataList);
/**
* 桌面设计调用新增
* @param dto
* @return
*/
boolean complexAdd(AddDeskComplexDto dto);
/**
* 桌面设计调用编辑
* @param dto
* @return
*/
boolean complexUpdate(UpdateDeskComplexDto dto);
/**
* 桌面设计调用删除
* @param dto
* @return
*/
boolean complexDelete(DeleteDeskComplexDto dto);
/**
* 桌面设计调用删除
* @param dto
* @return
*/
Object complexInfo(DeskComplexInfoDto dto);
/**
* 桌面设计调用自定义表单获取发布id
* @param formId
* @return
*/
List<DeskFormReleaseVo> getReleaseInfo(Long formId);
List<QueryConfig> complexQuery(ComplexQueryDto dto);
/**
* 桌面设计-复杂列表页-获取列表数据 分页
* @param dto
* @return
*/
PageOutput<Entity> complexPage(ComplexPageDto dto);
DeskTableInfoVo getTableInfo(Long formId);
}

View File

@ -0,0 +1,18 @@
package com.xjrsoft.form.service;
import com.github.yulichang.base.MPJBaseService;
import com.xjrsoft.form.dto.FormHistoryChangeDto;
import com.xjrsoft.form.entity.FormHistory;
/**
* <p>
* 自定义表单历史表 每次修改自定义表单会新增一条数据 服务类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
public interface IFormHistoryService extends MPJBaseService<FormHistory> {
Boolean change(FormHistoryChangeDto dto);
}

View File

@ -0,0 +1,30 @@
package com.xjrsoft.form.service;
import com.github.yulichang.base.MPJBaseService;
import com.xjrsoft.form.dto.AddFormReleaseDto;
import com.xjrsoft.form.dto.UpdateFormReleaseDto;
import com.xjrsoft.form.entity.FormRelease;
/**
* <p>
* 自定义表单 发布表 服务类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
public interface IFormReleaseService extends MPJBaseService<FormRelease> {
/**
* 自定义表单发布
* @param dto
* @return
*/
Boolean addFormRelease(AddFormReleaseDto dto);
/**
* 修改自定义表单发布
* @param dto
* @return
*/
Boolean updateFormRelease(UpdateFormReleaseDto dto);
}

View File

@ -0,0 +1,52 @@
package com.xjrsoft.form.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.github.yulichang.base.MPJBaseService;
import com.xjrsoft.form.dto.AddFormCodeFirstDto;
import com.xjrsoft.form.dto.AddFormDataFirstDto;
import com.xjrsoft.form.dto.UpdateFormCodeFirstDto;
import com.xjrsoft.form.dto.UpdateFormDataFirstDto;
import com.xjrsoft.form.entity.FormTemplate;
/**
* <p>
* 表单设计模板 服务类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
public interface IFormTemplateService extends MPJBaseService<FormTemplate> {
/**
* 新增 数据优先 表单模板
* @param dto
* @return
*/
Boolean addDataFirst(AddFormDataFirstDto dto);
/**
* 新增 代码优先 表单模板
* @param dto
* @return
*/
Boolean addCodeFirst(AddFormCodeFirstDto dto) throws Exception;
/**
* 更新 数据优先 表单模板
* @param dto
* @return
*/
Boolean updateDataFirst(UpdateFormDataFirstDto dto)throws JsonProcessingException;
/**
* 更新 代码优先 表单模板
* @param dto
* @return
*/
Boolean updateCodeFirst(UpdateFormCodeFirstDto dto) throws Exception;
}

View File

@ -0,0 +1,57 @@
package com.xjrsoft.form.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.core.enums.YesOrNoEnum;
import com.xjrsoft.form.dto.FormHistoryChangeDto;
import com.xjrsoft.form.entity.FormHistory;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.mapper.FormHistoryMapper;
import com.xjrsoft.form.mapper.FormTemplateMapper;
import com.xjrsoft.form.service.IFormHistoryService;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* <p>
* 自定义表单历史表 每次修改自定义表单会新增一条数据 服务实现类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@Service
@AllArgsConstructor
public class FormHistoryServiceImpl extends MPJBaseServiceImpl<FormHistoryMapper, FormHistory> implements IFormHistoryService {
private final FormHistoryMapper formHistoryMapper;
private final FormTemplateMapper formTemplateMapper;
@Override
@Transactional(rollbackFor = Exception.class)
@SneakyThrows
public Boolean change(FormHistoryChangeDto dto) {
//全部设置为非活动版本
LambdaQueryWrapper<FormHistory> wrapper = Wrappers.lambdaQuery(FormHistory.class).eq(FormHistory::getFormId, dto.getFormId());
FormHistory formHistory1 = new FormHistory();
formHistory1.setActivityFlag(YesOrNoEnum.NO.getCode());
formHistoryMapper.update(formHistory1, wrapper);
//把选择的版本设置为活动版本
FormHistory formHistory = formHistoryMapper.selectById(dto.getId());
formHistory.setActivityFlag(YesOrNoEnum.YES.getCode());
formHistoryMapper.updateById(formHistory);
//更新formTemplate表的数据
LambdaQueryWrapper<FormTemplate> formTemplateLambdaQuery = Wrappers.lambdaQuery(FormTemplate.class).eq(FormTemplate::getId, dto.getFormId());
FormTemplate formTemplate = new FormTemplate();
formTemplate.setFormJson(formHistory.getFormJson());
formTemplateMapper.update(formTemplate,formTemplateLambdaQuery);
return true;
}
}

View File

@ -0,0 +1,233 @@
package com.xjrsoft.form.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.core.domain.generator.ComponentConfig;
import com.xjrsoft.common.core.domain.generator.LayoutOptionModel;
import com.xjrsoft.common.core.enums.MenuType;
import com.xjrsoft.common.core.enums.YesOrNoEnum;
import com.xjrsoft.common.core.exception.MyException;
import com.xjrsoft.common.generate.model.ColumnConfig;
import com.xjrsoft.common.generate.model.ListConfig;
import com.xjrsoft.form.dto.AddFormReleaseDto;
import com.xjrsoft.form.dto.UpdateFormReleaseDto;
import com.xjrsoft.form.entity.FormDesignConfig;
import com.xjrsoft.form.entity.FormRelease;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.entity.MenuConfig;
import com.xjrsoft.form.mapper.FormReleaseMapper;
import com.xjrsoft.form.service.IFormReleaseService;
import com.xjrsoft.form.service.IFormTemplateService;
import com.xjrsoft.generate.constant.ComponentTypeConstant;
import com.xjrsoft.generate.utils.GeneratorUtil;
import com.xjrsoft.system.client.*;
import com.xjrsoft.system.entity.*;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 自定义表单 发布表 服务实现类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@Service
@AllArgsConstructor
public class FormReleaseServiceImpl extends MPJBaseServiceImpl<FormReleaseMapper, FormRelease> implements IFormReleaseService {
private final FormReleaseMapper formReleaseMapper;
private final IFormTemplateService formTemplateService;
private final IMenuClient menuClient;
private final IMenuButtonClient buttonClient;
private final IMenuColumnClient columnClient;
private final IMenuFormClient formClient;
private final IAuthorizeClient authorizeClient;
private final ObjectMapper objectMapper;
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean addFormRelease(AddFormReleaseDto dto) {
boolean exists = menuClient.existsMenuFeign( dto.getMenuConfig().getCode());
if (exists) {
throw new MyException("菜单编码已存在");
}
long releaseId = IdUtil.getSnowflakeNextId();
Long formId = dto.getFormId();
Long menuId = IdUtil.getSnowflakeNextId();
insertMenuConfig(dto.getMenuConfig(), dto.getListConfig(), releaseId, formId, menuId);
FormRelease formRelease = new FormRelease();
formRelease.setId(releaseId);
formRelease.setFormId(formId);
formRelease.setMenuId(menuId);
formRelease.setSortCode(dto.getMenuConfig().getSortCode());
formRelease.setRemark(dto.getMenuConfig().getRemark());
formRelease.setConfigJson(JSONUtil.toJsonStr(dto));
return formReleaseMapper.insert(formRelease) > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateFormRelease(UpdateFormReleaseDto dto) {
Long menuId = dto.getMenuId();
boolean exists = menuClient.existsMenuFeign(dto.getMenuConfig().getCode());
if (exists) {
throw new MyException("菜单编码已存在");
}
// 删除原有数据
buttonClient.deleteMenuButtonByMenuIdFeign(menuId);
columnClient.deleteMenuColumnByMenuIdFeign(menuId);
formClient.deleteMenuFormByMenuIdFeign(menuId);
// 清除功能权限
authorizeClient.removeAuthorieFeign(menuId);
insertMenuConfig(dto.getMenuConfig(), dto.getListConfig(), dto.getId(), dto.getFormId(), menuId);
FormRelease formRelease = new FormRelease();
formRelease.setId(dto.getId());
formRelease.setFormId(dto.getFormId());
formRelease.setMenuId(menuId);
formRelease.setSortCode(dto.getMenuConfig().getSortCode());
formRelease.setRemark(dto.getMenuConfig().getRemark());
formRelease.setConfigJson(JSONUtil.toJsonStr(dto));
return formReleaseMapper.updateById(formRelease) > 0;
}
/**
* 默认插入菜单
*/
@SneakyThrows
private Long insertMenuConfig(MenuConfig menuConfig, ListConfig listConfig, Long releaseId, Long formId, Long menuId) {
FormTemplate formTemplate = formTemplateService.getById(formId);
FormDesignConfig formConfig = objectMapper.readValue(formTemplate.getFormJson(), FormDesignConfig.class);
Menu menu = BeanUtil.toBean(menuConfig, Menu.class);
menu.setId(menuId);
menu.setName(menuConfig.getName() + RandomUtil.randomNumbers(4));
menu.setTitle(menuConfig.getName());
menu.setMenuType(MenuType.FUNCTION.getCode());
menu.setDisplay(YesOrNoEnum.YES.getCode());
menu.setAllowDelete(YesOrNoEnum.YES.getCode());
menu.setAllowModify(YesOrNoEnum.YES.getCode());
menu.setOutLink(YesOrNoEnum.NO.getCode());
menu.setKeepAlive(YesOrNoEnum.NO.getCode());
menu.setSortCode(menuConfig.getSortCode());
menu.setFormId(formId);
menu.setParentId(StrUtil.isBlank(menuConfig.getParentId()) ? 0L : Long.parseLong(menuConfig.getParentId()));
menu.setComponentType(YesOrNoEnum.YES.getCode());
//固定路径 与前端必须匹配
menu.setPath("/custom-form/" + Convert.toStr(releaseId));
menu.setComponent("/form/template/index");
//新增菜单
Menu menuR = menuClient.saveOrUpdateMenuFeign(menu);
List<MenuButton> btnList = new ArrayList<>();
listConfig.getButtonConfigs().forEach(buttonConfig -> {
if (BooleanUtils.isTrue(buttonConfig.getIsUse())) {
MenuButton menuButton = new MenuButton();
menuButton.setMenuId(menuR.getId());
menuButton.setName(buttonConfig.getName());
menuButton.setCode(menuR.getCode() + StringPool.COLON + buttonConfig.getCode());
menuButton.setIcon(buttonConfig.getIcon());
btnList.add(menuButton);
}
});
List<MenuColumn> colList = new ArrayList<>();
for (ColumnConfig columnConfig : listConfig.getColumnConfigs()) {
MenuColumn menuColumn = new MenuColumn();
menuColumn.setMenuId(menu.getId());
menuColumn.setName(columnConfig.getLabel());
menuColumn.setCode(columnConfig.getColumnName());
colList.add(menuColumn);
}
List<ComponentConfig> componentConfigList = GeneratorUtil.getFormComponentListWithoutLayout(formConfig.getFormJson().getList());
List<MenuForm> formList = new ArrayList<>();
for (ComponentConfig componentConfig : componentConfigList) {
String type = componentConfig.getType();
if (StringUtils.equalsIgnoreCase(type, ComponentTypeConstant.SUB_FORM) || StrUtil.equalsIgnoreCase(type, ComponentTypeConstant.ONE_FOR_ONE_FORM)) {
long id = IdUtil.getSnowflakeNextId();
MenuForm menuForm = new MenuForm();
menuForm.setId(id);
menuForm.setMenuId(menu.getId());
menuForm.setCode(componentConfig.getBindTable());
menuForm.setName(componentConfig.getLabel());
formList.add(menuForm);
for (ComponentConfig subConfig : componentConfig.getChildren()) {
buildMenuForm(id, menuId, subConfig, formList);
}
} else {
buildMenuForm(0L, menuId, componentConfig, formList);
}
}
buttonClient.saveMenuButtonBatchFeign(btnList);
columnClient.saveMenuColumnBatchFeign(colList);
formClient.saveMenuFormBatchFeign(formList);
return menu.getId();
}
private void buildMenuForm(Long parentId, Long menuId, ComponentConfig componentConfig, List<MenuForm> formList) {
String type = componentConfig.getType();
if (StringUtils.equalsIgnoreCase(type, ComponentTypeConstant.TAB)
|| StringUtils.equalsIgnoreCase(type, ComponentTypeConstant.CARD)
|| StringUtils.equalsIgnoreCase(type, ComponentTypeConstant.GRID)) {
List<LayoutOptionModel> tabList = componentConfig.getLayout();
for (LayoutOptionModel tab : tabList) {
List<ComponentConfig> tabComponentList = tab.getList();
for (ComponentConfig tabComponent : tabComponentList) {
buildMenuForm(parentId, menuId, tabComponent, formList);
}
}
} else {
String field = null;
if (StrUtil.equalsIgnoreCase(type, ComponentTypeConstant.DATE_RANGE)
|| StrUtil.equalsIgnoreCase(type, ComponentTypeConstant.TIME_RANGE)) {
field = componentConfig.getBindStartTime() + StringPool.COMMA + componentConfig.getBindEndTime();
} else {
field = StrUtil.isEmpty(componentConfig.getBindField()) ? componentConfig.getKey() : componentConfig.getBindField();
}
Boolean isRequired = MapUtils.getBoolean(componentConfig.getOptions(), "required", Boolean.FALSE);
MenuForm subMenuForm = new MenuForm();
subMenuForm.setParentId(parentId);
subMenuForm.setMenuId(menuId);
subMenuForm.setCode(field);
subMenuForm.setName(componentConfig.getLabel());
subMenuForm.setIsRequired(isRequired ? YesOrNoEnum.YES.getCode() : YesOrNoEnum.NO.getCode());
formList.add(subMenuForm);
}
}
}

View File

@ -0,0 +1,320 @@
package com.xjrsoft.form.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.db.Db;
import cn.hutool.db.DbUtil;
import cn.hutool.db.meta.MetaUtil;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.domain.generator.ComponentConfig;
import com.xjrsoft.common.core.enums.YesOrNoEnum;
import com.xjrsoft.common.core.exception.MyException;
import com.xjrsoft.common.generate.model.TableConfig;
import com.xjrsoft.common.generate.model.TableStructureConfig;
import com.xjrsoft.common.mybatis.utils.DatasourceUtil;
import com.xjrsoft.form.dto.AddFormCodeFirstDto;
import com.xjrsoft.form.dto.AddFormDataFirstDto;
import com.xjrsoft.form.dto.UpdateFormCodeFirstDto;
import com.xjrsoft.form.dto.UpdateFormDataFirstDto;
import com.xjrsoft.form.entity.FormDesignConfig;
import com.xjrsoft.form.entity.FormHistory;
import com.xjrsoft.form.entity.FormTemplate;
import com.xjrsoft.form.mapper.FormHistoryMapper;
import com.xjrsoft.form.mapper.FormTemplateMapper;
import com.xjrsoft.form.service.IFormTemplateService;
import com.xjrsoft.form.utils.FromTemplateUtil;
import com.xjrsoft.generate.utils.SqlUtil;
import com.xjrsoft.system.client.IDataAuthTableRelationClient;
import com.xjrsoft.system.client.IDatabaselinkClient;
import com.xjrsoft.tenant.config.TenantConfig;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* <p>
* 表单设计模板 服务实现类
* </p>
*
* @author tzx
* @since 2022-05-09
*/
@Service
@AllArgsConstructor
public class FormTemplateServiceImpl extends MPJBaseServiceImpl<FormTemplateMapper, FormTemplate> implements IFormTemplateService {
private final FormTemplateMapper formTemplateMapper;
private final FormHistoryMapper formHistoryMapper;
private final IDatabaselinkClient databaselinkClient;
private final ObjectMapper objectMapper;
private final TenantConfig tenantConfig;
private final IDataAuthTableRelationClient dataAuthTableRelationClient;
@Override
@SneakyThrows
public Boolean addDataFirst(AddFormDataFirstDto dto) {
FormTemplate template = BeanUtil.toBean(dto, FormTemplate.class);
List<ComponentConfig> list = dto.getFormJson().getFormJson().getList();
Optional<TableConfig> mainTableConfigOptional = dto.getFormJson().getTableConfigs().stream().filter(TableConfig::getIsMain).findFirst();
if (!mainTableConfigOptional.isPresent()) {
throw new MyException("主表不存在");
}
List<TableStructureConfig> tableStructureConfigs = FromTemplateUtil.wrapperTableStructureConfig(list, mainTableConfigOptional.get());
dto.getFormJson().setTableStructureConfigs(tableStructureConfigs);
template.setFormJson(objectMapper.writeValueAsString(dto.getFormJson()));
// 创建数据权限字段
createOtherFields(mainTableConfigOptional.get().getTableName(), dto.getFormJson());
// 保存数据权限关系
if (BooleanUtils.isTrue(dto.getFormJson().getIsDataAuth())) {
saveDataAuth(dto.getFormJson(), tableStructureConfigs);
}
Integer size = formTemplateMapper.insert(template);
//保存历史版本数据
FormHistory formHistory = new FormHistory();
formHistory.setFormId(template.getId());
formHistory.setFormJson(template.getFormJson());
formHistory.setVersion(YesOrNoEnum.YES.getCode());//第一个版本
formHistory.setActivityFlag(YesOrNoEnum.YES.getCode());//是活动版本
formHistoryMapper.insert(formHistory);
return size > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean addCodeFirst(AddFormCodeFirstDto dto) throws Exception {
FormTemplate template = BeanUtil.toBean(dto, FormTemplate.class);
List<TableStructureConfig> tableStructureConfigs = dto.getFormJson().getTableStructureConfigs();
//因为是codefirst 代码优先/界面优先
//因为要统一自定义表单存入到数据库的json格式 所以 在这里需要将codefirst的表结构配置json格式转换成datafirst的json格式
// TableStructureConfig -> TableConfig
String databaseId = dto.getFormJson().getDatabaseId();
dto.getFormJson().setTableConfigs(FromTemplateUtil.wrapperTableConfig(databaseId, tableStructureConfigs));
//因为实体类里面 formJson 是字符串类型 所以必须手动赋值一下 此时的formjson 是转换过tableconfig的
template.setFormJson(objectMapper.writeValueAsString(dto.getFormJson()));
createTable(tableStructureConfigs, databaseId);
// 保存数据权限关系
if (BooleanUtils.isTrue(dto.getFormJson().getIsDataAuth())) {
saveDataAuth(dto.getFormJson(), tableStructureConfigs);
}
Integer size = formTemplateMapper.insert(template);
//保存历史版本数据
FormHistory formHistory = new FormHistory();
formHistory.setFormId(template.getId());
formHistory.setFormJson(template.getFormJson());
formHistory.setVersion(YesOrNoEnum.YES.getCode());//第一个版本
formHistory.setActivityFlag(YesOrNoEnum.YES.getCode());//是活动版本
formHistoryMapper.insert(formHistory);
return size > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateDataFirst(UpdateFormDataFirstDto dto) throws JsonProcessingException {
FormTemplate template = BeanUtil.toBean(dto, FormTemplate.class);
List<ComponentConfig> list = dto.getFormJson().getFormJson().getList();
Optional<TableConfig> mainTableConfigOptional = dto.getFormJson().getTableConfigs().stream().filter(TableConfig::getIsMain).findFirst();
if (!mainTableConfigOptional.isPresent()) {
throw new MyException("主表不存在");
}
List<TableStructureConfig> tableStructureConfigs = FromTemplateUtil.wrapperTableStructureConfig(list, mainTableConfigOptional.get());
dto.getFormJson().setTableStructureConfigs(tableStructureConfigs);
template.setFormJson(objectMapper.writeValueAsString(dto.getFormJson()));
// 创建数据权限字段
createOtherFields(mainTableConfigOptional.get().getTableName(), dto.getFormJson());
//查询当前表单模板的version版本
LambdaQueryWrapper<FormHistory> queryWrapper = Wrappers.lambdaQuery(FormHistory.class)
.eq(FormHistory::getFormId, template.getId())
.select(FormHistory::getVersion, FormHistory::getId)
.orderByDesc(FormHistory::getVersion);
List<FormHistory> formHistoryList = formHistoryMapper.selectList(queryWrapper);
//全部设置为非活动版本
FormHistory formHistory1 = new FormHistory();
formHistory1.setActivityFlag(YesOrNoEnum.NO.getCode());
formHistoryMapper.update(formHistory1, Wrappers.lambdaQuery(FormHistory.class)
.eq(FormHistory::getFormId, template.getId())
.select(FormHistory::getVersion, FormHistory::getId));
//新增版本
FormHistory formHistory = new FormHistory();
formHistory.setFormId(template.getId());
formHistory.setFormJson(template.getFormJson());
if (formHistoryList.size() > 0 && ObjectUtil.isNotEmpty(formHistoryList.get(0).getVersion())){//兼容以前没有版本的情况,设置为1
formHistory.setVersion(formHistoryList.get(0).getVersion() + 1);
}else {
formHistory.setVersion(YesOrNoEnum.YES.getCode());
}
formHistory.setActivityFlag(YesOrNoEnum.YES.getCode());
formHistoryMapper.insert(formHistory);
// 保存数据权限关系
saveDataAuth(dto.getFormJson(), tableStructureConfigs);
return formTemplateMapper.updateById(template) > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateCodeFirst(UpdateFormCodeFirstDto dto) throws Exception {
FormTemplate template = BeanUtil.toBean(dto, FormTemplate.class);
List<TableStructureConfig> tableStructureConfigs = dto.getFormJson().getTableStructureConfigs();
// 获取表单旧配置
// FormTemplate oldTemplate = this.getById(dto.getId());
// FormDesignConfig oldFormDesignConfig = objectMapper.readValue(oldTemplate.getFormJson(), FormDesignConfig.class);
//因为是codefirst 代码优先/界面优先
//因为要统一自定义表单存入到数据库的json格式 所以 在这里需要将codefirst的表结构配置json格式转换成datafirst的json格式
// TableStructureConfig -> TableConfig
dto.getFormJson().setTableConfigs(new ArrayList<>());
String databaseId = dto.getFormJson().getDatabaseId();
DbType dbType = DatasourceUtil.getDbType(databaseId);
boolean isUpperCase = ArrayUtils.contains(new DbType[]{DbType.ORACLE, DbType.ORACLE_12C, DbType.DM, DbType.DB2}, dbType);
for (TableStructureConfig tableStructureConfig : tableStructureConfigs) {
//因为要统一自定义表单存入到数据库的json格式 所以 在这里需要将codefirst的表结构配置json格式转换成datafirst的json格式
// TableStructureConfig -> TableConfig
TableConfig tableConfig = new TableConfig();
tableConfig.setTableName(tableStructureConfig.getTableName());
tableConfig.setIsMain(tableStructureConfig.getIsMain());
tableConfig.setPkField(isUpperCase ? StringUtils.upperCase(GlobalConstant.DEFAULT_PK) : GlobalConstant.DEFAULT_PK);
tableConfig.setPkType(GlobalConstant.DEFAULT_PK_TYPE);
tableConfig.setRelationField(tableStructureConfig.getIsMain() ? null : isUpperCase ? StringUtils.upperCase(GlobalConstant.DEFAULT_FK) : GlobalConstant.DEFAULT_FK);
tableConfig.setRelationTableField(tableStructureConfig.getIsMain() ? null : isUpperCase ? StringUtils.upperCase(GlobalConstant.DEFAULT_PK) : GlobalConstant.DEFAULT_PK);
dto.getFormJson().getTableConfigs().add(tableConfig);
}
createTable(tableStructureConfigs, databaseId);
template.setFormJson(objectMapper.writeValueAsString(dto.getFormJson()));
//查询当前表单模板的version版本
LambdaQueryWrapper<FormHistory> queryWrapper = Wrappers.lambdaQuery(FormHistory.class)
.eq(FormHistory::getFormId, template.getId())
.select(FormHistory::getVersion, FormHistory::getId)
.orderByDesc(FormHistory::getVersion);
List<FormHistory> formHistoryList = formHistoryMapper.selectList(queryWrapper);
//全部设置为非活动版本
FormHistory formHistory1 = new FormHistory();
formHistory1.setActivityFlag(YesOrNoEnum.NO.getCode());
formHistoryMapper.update(formHistory1, Wrappers.lambdaQuery(FormHistory.class)
.eq(FormHistory::getFormId, template.getId())
.select(FormHistory::getVersion, FormHistory::getId));
//新增版本
FormHistory formHistory = new FormHistory();
formHistory.setFormId(template.getId());
formHistory.setFormJson(template.getFormJson());
if (formHistoryList.size() > 0 && ObjectUtil.isNotEmpty(formHistoryList.get(0).getVersion())){//兼容以前没有版本的情况,设置为1
formHistory.setVersion(formHistoryList.get(0).getVersion() + 1);
}else {
formHistory.setVersion(YesOrNoEnum.YES.getCode());
}
formHistory.setActivityFlag(YesOrNoEnum.YES.getCode());
formHistoryMapper.insert(formHistory);
// 保存数据权限关系
saveDataAuth(dto.getFormJson(), tableStructureConfigs);
return formTemplateMapper.updateById(template) > 0;
}
/**
* 创建表
* 修改此方法逻辑,一定要对比一下 GeneratorServiceImpl 中的 同名方法 是否 也需要修改!
*
* @param tableStructureConfigs 表结构配置
* @param databaseId 数据库id
*/
private void createTable(List<TableStructureConfig> tableStructureConfigs, String databaseId) throws SQLException {
//------------------------------------根据配置建表开始------------------------------------------
{
//判断是否为默认数据源
if (StrUtil.equalsIgnoreCase(databaseId, GlobalConstant.DEFAULT_DATASOURCE_KEY)) {
List<String> createTableSqls = DatasourceUtil.wrapperCreateTableSql(tableStructureConfigs, DatasourceUtil.getDataSourceMasterDbType());
for (String sql : createTableSqls) {
DbUtil.use(DatasourceUtil.getDatasourceMaster()).execute(sql);
}
} else {
DbType dbType = databaselinkClient.getDatabaselinkDbTypeFeign(databaseId);
List<String> createTableSqls = DatasourceUtil.wrapperCreateTableSql(tableStructureConfigs, dbType);
for (String sql : createTableSqls) {
DbUtil.use(DatasourceUtil.getDataSource(databaseId)).execute(sql);
}
}
}
//------------------------------------根据配置建表结束------------------------------------------
}
/**
* 保存表和数据权限关联关系
* @param formDesignConfig
* @param tableStructureConfigs
*/
private void saveDataAuth(FormDesignConfig formDesignConfig, List<TableStructureConfig> tableStructureConfigs) {
Optional<TableStructureConfig> maiTableOpt = tableStructureConfigs.stream().filter(TableStructureConfig::getIsMain).findFirst();
List<Long> dataAuthList = formDesignConfig.getDataAuthList().stream().map(Long::valueOf).collect(Collectors.toList());
dataAuthTableRelationClient.saveDataAuthTableRelationsFeign(maiTableOpt.get().getTableName(), dataAuthList);
}
@SneakyThrows
private void createOtherFields(String tableName, FormDesignConfig formDesignConfig) {
if (BooleanUtils.isTrue(formDesignConfig.getIsDataAuth())) {
// 添加权限字段 rule_user_id
String databaseId = formDesignConfig.getDatabaseId();
DataSource dataSource = DatasourceUtil.getDataSource(databaseId);
String[] columnNames = MetaUtil.getColumnNames(dataSource, tableName);
DbType dbType =DatasourceUtil.getDbType(databaseId);
if (!ArrayUtils.contains(columnNames, GlobalConstant.AUTH_USER_ID)) {
// 添加权限字段 rule_user_id
Db.use(dataSource).executeBatch(SqlUtil.buildAddDataAuthFieldSqls(dbType, tableName));
}
if (BooleanUtils.isTrue(tenantConfig.getEnabled()) && !ArrayUtils.contains(columnNames, tenantConfig.getTenantField())) {
Db.use(dataSource).executeBatch(SqlUtil.buildAddTenantFieldSqls(dbType, tableName));
}
}
}
}

View File

@ -0,0 +1,402 @@
package com.xjrsoft.form.utils;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.db.Entity;
import cn.hutool.extra.spring.SpringUtil;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.xjrsoft.common.core.constant.GlobalConstant;
import com.xjrsoft.common.core.constant.StringPool;
import com.xjrsoft.common.core.domain.generator.ComponentConfig;
import com.xjrsoft.common.mybatis.model.Department;
import com.xjrsoft.common.mybatis.model.User;
import com.xjrsoft.common.mybatis.utils.LocalDateTimeUtil;
import com.xjrsoft.common.redis.service.RedisUtil;
import com.xjrsoft.form.entity.FormDesignConfig;
import com.xjrsoft.generate.constant.ComponentTypeConstant;
import com.xjrsoft.generate.utils.GeneratorUtil;
import com.xjrsoft.magicapi.client.IMagicApiClient;
import com.xjrsoft.system.client.IAreaClient;
import com.xjrsoft.system.entity.Area;
import com.xjrsoft.system.entity.DictionaryDetail;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.ssssssss.magicapi.modules.db.model.PageResult;
import java.sql.Timestamp;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author Zexy
*/
@Slf4j
public final class FormDataTransUtil {
private FormDataTransUtil(){}
private static final RedisUtil redisUtil;
private static final IMagicApiClient magcApiClient;
private static final IAreaClient areaClient;
static {
redisUtil = SpringUtil.getBean(RedisUtil.class);
magcApiClient = SpringUtil.getBean(IMagicApiClient.class);
areaClient = SpringUtil.getBean(IAreaClient.class);
}
public static void transData(List<Entity> dataList, FormDesignConfig formDesignConfig) {
if (CollectionUtils.isEmpty(dataList)) {
return;
}
List<DictionaryDetail> detailList = null;
Map<String, Object> userMap = null;
Map<String, Object> deptMap = null;
// List<Map<String, Object>> postList = null;
Map<String, Object> areaMap = null;
Map<String, Map<String, Object>> apiDataMap = new HashMap<>();
List<ComponentConfig> componentConfigList = GeneratorUtil.getFormComponentListWithMain(formDesignConfig.getFormJson().getList());
Map<String, Map<String, Object>> fieldValuesMap = new HashMap<>(componentConfigList.size());
Map<String, Map<String, String>> multiFieldMap = new HashMap<>();
Map<String, String> dateFormatMap = new HashMap<>(4);
for (ComponentConfig componentConfig : componentConfigList) {
String type = componentConfig.getType();
String bindField = componentConfig.getBindField();
Map<String, Object> options = componentConfig.getOptions();
Integer infoType = MapUtils.getInteger(options, "infoType");
boolean isCascade = StrUtil.equalsIgnoreCase(ComponentTypeConstant.CASCADE, type);
if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.CHECKBOX, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.SELECT, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.ASSOCIATE_SELECT, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.ASSOCIATE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.MULTIPLE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.RADIO, type)
|| isCascade) {
String datasourceType = MapUtils.getString(options, "datasourceType");
if (StrUtil.equalsIgnoreCase(datasourceType, "dic")) {
if (detailList == null) {
detailList = redisUtil.get(GlobalConstant.DIC_DETAIL_CACHE_KEY, new TypeReference<List<DictionaryDetail>>() {});
}
Map<String, Object> detailMap = detailList.stream().filter(x -> StrUtil.equalsIgnoreCase(x.getItemId().toString(), MapUtils.getString(options, "itemId"))).collect(Collectors.toMap(DictionaryDetail::getValue, DictionaryDetail::getName, (e1, e2) -> e1));
fieldValuesMap.put(bindField, detailMap);
} else if (StrUtil.equalsIgnoreCase(datasourceType, "api") || isCascade) {
String apiId = MapUtils.getString(MapUtils.getMap(options, "apiConfig"), "apiId");
if (apiDataMap.get(apiId) == null) {
Object resultApiData = magcApiClient.executeApiFeign(apiId);
List<Map<String, Object>> apiDataList = null;
if (resultApiData.getClass().getName().contains("PageResult")) {
Map<String, Object> map = Convert.toMap(String.class, Object.class, resultApiData);
apiDataList = (List<Map<String, Object>>) map.get("list");
} else if (resultApiData instanceof List) {
apiDataList = (List<Map<String, Object>>) resultApiData;
}
if (isCascade) {
apiDataList = treeToList(apiDataList);
}
if (apiDataList != null ) {
apiDataMap.put(apiId, apiDataList.stream().filter(x -> ObjectUtil.isNotNull(x.get("value"))).collect(Collectors.toMap(data -> data.get("value").toString(), data -> data.get("label"), (e1, e2) -> e1)));
}
}
fieldValuesMap.put(bindField, apiDataMap.get(apiId));
}
if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.MULTIPLE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.CHECKBOX, type)
|| isCascade) {
Map<String, String> multiSettingMap = new HashMap<>(4);
multiSettingMap.put("separator", MapUtils.getString(options, "separator", StringPool.COMMA));
multiSettingMap.put("showFormat", MapUtils.getString(options, "showFormat"));
multiFieldMap.put(bindField, multiSettingMap);
}
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.AREA, type)) {
Set<Long> areaValueList = new LinkedHashSet<>();
for (Map<String, Object> data : dataList) {
String values = MapUtils.getString(data, bindField);
if (StrUtil.isEmpty(values)) {
continue;
}
String[] valueArray = values.split(StringPool.COMMA);
areaValueList.addAll(Arrays.stream(valueArray).map(NumberUtils::toLong).collect(Collectors.toSet()));
}
if (CollectionUtils.isNotEmpty(areaValueList)) {
List<Area> areaList = areaClient.getAreaListFeign(new ArrayList<>(areaValueList));
areaMap = areaList.stream().collect(Collectors.toMap(area -> area.getId().toString(), Area::getName, (e1, e2) -> e1));
} else {
areaMap = new HashMap<>(0);
}
fieldValuesMap.put(bindField, areaMap);
multiFieldMap.put(bindField, null);
}else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.ORGANIZATION, type)
|| (StrUtil.equalsIgnoreCase(ComponentTypeConstant.INFO, type) && infoType.equals(1))) {
if (deptMap == null) {
List<Department> departmentList = redisUtil.get(GlobalConstant.DEP_CACHE_KEY, new TypeReference<List<Department>>() {});
deptMap = departmentList.stream().collect(Collectors.toMap(department -> department.getId().toString(), Department::getName, (e1, e2) -> e1));
}
fieldValuesMap.put(bindField, deptMap);
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.USER, type)
|| (StrUtil.equalsIgnoreCase(ComponentTypeConstant.INFO, type) && infoType.equals(0))) {
if (userMap == null) {
List<User> userList = redisUtil.get(GlobalConstant.USER_CACHE_KEY, new TypeReference<List<User>>() {});
userMap = userList.stream().collect(Collectors.toMap(user -> user.getId().toString(), User::getName, (e1, e2) -> e1));
}
if (infoType == null) {
multiFieldMap.put(bindField, null);
}
fieldValuesMap.put(bindField, userMap);
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE, type)) {
dateFormatMap.put(bindField, LocalDateTimeUtil.convertFontFormat(MapUtils.getString(options, "format")));
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE_RANGE, type)) {
String format = LocalDateTimeUtil.convertFontFormat(MapUtils.getString(options, "format"));
dateFormatMap.put(componentConfig.getBindStartTime(), format);
dateFormatMap.put(componentConfig.getBindEndTime(), format);
}
}
for (Map<String, Object> data : dataList) {
for (Map.Entry<String, Map<String, Object>> entry : fieldValuesMap.entrySet()) {
String key = entry.getKey();
Object o = data.get(key);
if (StrUtil.isEmptyIfStr(o)) {
continue;
}
String value = String.valueOf(o);
Map<String, Object> entryValue = entry.getValue();
if (multiFieldMap.containsKey(key)) {
List<String> values = StrUtil.split(value, StringPool.COMMA);
Map<String, String> multiSettingsMap = multiFieldMap.get(key);
StringBuilder showValue = new StringBuilder();
for (int i = 0; i < values.size(); i++) {
String valueStr = values.get(i);
String separator = StringPool.COMMA;
Object showValueStr = entryValue.get(valueStr);
if (StrUtil.isEmptyIfStr(showValueStr)) {
continue;
}
if (CollectionUtils.isNotEmpty(multiSettingsMap)) {
separator = MapUtils.getString(multiSettingsMap, "separator", StringPool.COMMA);
String showFormat = MapUtils.getString(multiSettingsMap, "showFormat");
if (StrUtil.equalsIgnoreCase(showFormat, "showMostChildLevel")) {
if (i == values.size() - 1) {
showValue.append(showValueStr);
}
continue;
} else {
showValue.append(showValueStr);
}
} else {
showValue.append(showValueStr);
}
if (i < values.size() - 1) {
showValue.append(separator);
}
}
if (showValue.length() > 0) {
data.put(key, showValue.toString());
}
} else {
Object obj = entryValue.get(value);
if (StrUtil.isEmptyIfStr(obj)) {
continue;
}
data.put(key, obj);
}
}
// 时间格式化处理
for (Map.Entry<String, String> entry : dateFormatMap.entrySet()) {
String key = entry.getKey();
Object value = data.get(key);
if (value == null) {
continue;
}
if (value instanceof Timestamp) {
Timestamp timestamp = (Timestamp) value;
data.put(key, LocalDateTimeUtil.format(timestamp.toLocalDateTime(), entry.getValue()));
}
}
}
}
public static void transDataOver(List<Entity> dataList, FormDesignConfig formDesignConfig) {
if (CollectionUtils.isEmpty(dataList)) {
return;
}
List<DictionaryDetail> detailList = null;
Map<String, Object> userMap = null;
Map<String, Object> deptMap = null;
// List<Map<String, Object>> postList = null;
Map<String, Object> areaMap = null;
Map<String, Map<String, Object>> apiDataMap = new HashMap<>();
List<ComponentConfig> componentConfigList = GeneratorUtil.getFormComponentListWithMain(formDesignConfig.getFormJson().getList());
Map<String, Map<String, Object>> fieldValuesMap = new HashMap<>(componentConfigList.size());
Map<String, Map<String, String>> multiFieldMap = new HashMap<>();
Map<String, String> dateFormatMap = new HashMap<>(4);
List<String> keyList = new ArrayList<>(dataList.size());
for (ComponentConfig componentConfig : componentConfigList) {
String type = componentConfig.getType();
String bindField = componentConfig.getBindField();
keyList.add(bindField);
Map<String, Object> options = componentConfig.getOptions();
Integer infoType = MapUtils.getInteger(options, "infoType");
boolean isCascade = StrUtil.equalsIgnoreCase(ComponentTypeConstant.CASCADE, type);
if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.CHECKBOX, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.SELECT, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.ASSOCIATE_SELECT, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.ASSOCIATE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.MULTIPLE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.RADIO, type)
|| isCascade) {
String datasourceType = MapUtils.getString(options, "datasourceType");
if (StrUtil.equalsIgnoreCase(datasourceType, "dic")) {
if (detailList == null) {
detailList = redisUtil.get(GlobalConstant.DIC_DETAIL_CACHE_KEY, new TypeReference<List<DictionaryDetail>>() {});
}
Map<String, Object> detailMap = detailList.stream().filter(x -> StrUtil.equalsIgnoreCase(x.getItemId().toString(), MapUtils.getString(options, "itemId"))).collect(Collectors.toMap(DictionaryDetail::getValue, DictionaryDetail::getName, (e1, e2) -> e1));
fieldValuesMap.put(bindField, detailMap);
} else if (StrUtil.equalsIgnoreCase(datasourceType, "api") || isCascade) {
String apiId = MapUtils.getString(MapUtils.getMap(options, "apiConfig"), "apiId");
if (apiDataMap.get(apiId) == null) {
Object resultApiData = magcApiClient.executeApiFeign(apiId);
List<Map<String, Object>> apiDataList = null;
if (resultApiData instanceof PageResult) {
apiDataList = (List<Map<String, Object>>) ((PageResult) resultApiData).getList();
} else if (resultApiData instanceof List) {
apiDataList = (List<Map<String, Object>>) resultApiData;
}
if (isCascade) apiDataList = treeToList(apiDataList);
if (apiDataList != null ) apiDataMap.put(apiId, apiDataList.stream().filter(x -> ObjectUtil.isNotNull(x.get("value"))).collect(Collectors.toMap(data -> data.get("value").toString(), data -> data.get("label"), (e1, e2) -> e1)));
}
fieldValuesMap.put(bindField, apiDataMap.get(apiId));
}
if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.MULTIPLE_POPUP, type)
|| StrUtil.equalsIgnoreCase(ComponentTypeConstant.CHECKBOX, type)
|| isCascade) {
Map<String, String> multiSettingMap = new HashMap<>(4);
multiSettingMap.put("separator", MapUtils.getString(options, "separator", com.baomidou.mybatisplus.core.toolkit.StringPool.COMMA));
multiSettingMap.put("showFormat", MapUtils.getString(options, "showFormat"));
multiFieldMap.put(bindField, multiSettingMap);
}
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.AREA, type)) {
Set<Long> areaValueList = new LinkedHashSet<>();
for (Map<String, Object> data : dataList) {
String values = MapUtils.getString(data, bindField);
if (StrUtil.isEmpty(values)) continue;
String[] valueArray = values.split(com.baomidou.mybatisplus.core.toolkit.StringPool.COMMA);
areaValueList.addAll(Arrays.stream(valueArray).map(NumberUtils::toLong).collect(Collectors.toSet()));
}
if (CollectionUtils.isNotEmpty(areaValueList)) {
List<Area> areaList = areaClient.getAreaListFeign(new ArrayList<>(areaValueList));
areaMap = areaList.stream().collect(Collectors.toMap(area -> area.getId().toString(), Area::getName, (e1, e2) -> e1));
} else {
areaMap = new HashMap<>(0);
}
fieldValuesMap.put(bindField, areaMap);
multiFieldMap.put(bindField, null);
}else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.ORGANIZATION, type)
|| (StrUtil.equalsIgnoreCase(ComponentTypeConstant.INFO, type) && infoType.equals(1))) {
if (deptMap == null) {
List<Department> departmentList = redisUtil.get(GlobalConstant.DEP_CACHE_KEY, new TypeReference<List<Department>>() {});
deptMap = departmentList.stream().collect(Collectors.toMap(department -> department.getId().toString(), Department::getName, (e1, e2) -> e1));
}
fieldValuesMap.put(bindField, deptMap);
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.USER, type)
|| (StrUtil.equalsIgnoreCase(ComponentTypeConstant.INFO, type) && infoType.equals(0))) {
if (userMap == null) {
List<User> userList = redisUtil.get(GlobalConstant.USER_CACHE_KEY, new TypeReference<List<User>>() {});
userMap = userList.stream().collect(Collectors.toMap(user -> user.getId().toString(), User::getName, (e1, e2) -> e1));
}
if (infoType == null) {
multiFieldMap.put(bindField, null);
}
fieldValuesMap.put(bindField, userMap);
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE, type)) {
dateFormatMap.put(bindField, LocalDateTimeUtil.convertFontFormat(MapUtils.getString(options, "format")));
} else if (StrUtil.equalsIgnoreCase(ComponentTypeConstant.DATE_RANGE, type)) {
String format = LocalDateTimeUtil.convertFontFormat(MapUtils.getString(options, "format"));
dateFormatMap.put(componentConfig.getBindStartTime(), format);
dateFormatMap.put(componentConfig.getBindEndTime(), format);
}
}
for (Map<String, Object> data : dataList) {
for (String key : keyList) {
String addKey = key + com.baomidou.mybatisplus.core.toolkit.StringPool.UNDERSCORE + "api";
Object o = data.get(key);
String value = String.valueOf(o);
data.put(addKey,value);
}
for (Map.Entry<String, Map<String, Object>> entry : fieldValuesMap.entrySet()) {
String key = entry.getKey();
Object o = data.get(key);
if (StrUtil.isEmptyIfStr(o)) {
continue;
}
String value = String.valueOf(o);
Map<String, Object> entryValue = entry.getValue();
if (multiFieldMap.containsKey(key)) {
List<String> values = StrUtil.split(value, com.baomidou.mybatisplus.core.toolkit.StringPool.COMMA);
Map<String, String> multiSettingsMap = multiFieldMap.get(key);
StringBuilder showValue = new StringBuilder();
for (int i = 0; i < values.size(); i++) {
String valueStr = values.get(i);
String separator = com.baomidou.mybatisplus.core.toolkit.StringPool.COMMA;
Object showValueStr = entryValue.get(valueStr);
if (StrUtil.isEmptyIfStr(showValueStr)) continue;
if (CollectionUtils.isNotEmpty(multiSettingsMap)) {
separator = MapUtils.getString(multiSettingsMap, "separator", com.baomidou.mybatisplus.core.toolkit.StringPool.COMMA);
String showFormat = MapUtils.getString(multiSettingsMap, "showFormat");
if (StrUtil.equalsIgnoreCase(showFormat, "showMostChildLevel")) {
if (i == values.size() - 1) {
showValue.append(showValueStr);
}
continue;
} else {
showValue.append(showValueStr);
}
} else {
showValue.append(showValueStr);
}
if (i < values.size() - 1) {
showValue.append(separator);
}
}
if (showValue.length() > 0) data.put(key, showValue.toString());
} else {
Object obj = entryValue.get(value);
if (StrUtil.isEmptyIfStr(obj)) continue;
data.put(key, obj);
}
}
// 时间格式化处理
for (Map.Entry<String, String> entry : dateFormatMap.entrySet()) {
String key = entry.getKey();
Object value = data.get(key);
if (value == null) {
continue;
}
if (value instanceof Timestamp) {
Timestamp timestamp = (Timestamp) value;
data.put(key, LocalDateTimeUtil.format(timestamp.toLocalDateTime(), entry.getValue()));
}
}
}
}
private static List<Map<String, Object>> treeToList(List<Map<String, Object>> treeDataList) {
if (CollectionUtils.isEmpty(treeDataList)) {
return treeDataList;
}
List<Map<String, Object>> resultList = new ArrayList<>();
for (Map<String, Object> data : treeDataList) {
resultList.add(data);
Object obj = data.get("children");
if (obj instanceof List) {
resultList.addAll(treeToList((List<Map<String, Object>>)obj));
}
}
return resultList;
}
}

View File

@ -0,0 +1,4 @@
spring:
profiles:
active: public

View File

@ -0,0 +1,76 @@
server:
port: 3008
spring:
application:
name: form-service
main:
allow-bean-definition-overriding: true
autoconfigure:
#自动化配置 例外处理
exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure
datasource:
type: com.alibaba.druid.pool.DruidDataSource
dynamic:
primary: master
datasource:
master:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://new-energy-mysqlt.itc.gdyd.com:3307/fcd2-msat-init?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true
username: learun4dev
password: ABcd1234@
cloud:
nacos: #nacos监控
discovery:
server-addr: 10.0.252.1:8848
namespace: ITC
group: DNE
username: nacos
password: ABcd1234@
config:
server-addr: 10.0.252.1:8848 # nacos 配置中心地址
namespace: ITC
group: DNE
username: nacos
password: ABcd1234@
file-extension: yml # 指定格式 xjrsoft-demo-service-dev.yml
extension-configs:
- data-id: global-config.yml #导入全局配置
refresh: true
group: DNE
- data-id: mybatis-plus-config.yml #导入mybatisplus 配置
refresh: true
group: DNE
- data-id: sa-token-client-config.yml #导入sa-token配置
refresh: true
group: DNE
- data-id: redis-config.yml #导入redis配置
refresh: true
group: DNE
- data-id: seata-config.yml #导入seata配置
refresh: true
group: DNE
sentinel:
transport:
dashboard: localhost:8080 #sentinel dashboard 地址
port: 8719 #默认端口, 如果 被占用,会一直+1 直到未被占用为止
springdoc:
swagger-ui:
path: /swagger-ui.html
tags-sorter: alpha
operations-sorter: alpha
show-extensions: true
api-docs:
path: /form/v3/api-docs
group-configs:
- group: 'default'
paths-to-match: '/form/**'
packages-to-scan: com.xjrsoft.form
default-flat-param-object: false