package com.product.module.data.service;
|
|
import com.google.common.collect.Sets;
|
import com.google.common.collect.Lists;
|
import com.google.common.collect.Maps;
|
import com.product.admin.service.UpdateLoginUserInfoService;
|
import com.product.common.lang.StringUtils;
|
import com.product.common.utils.IdcardUtils;
|
import com.product.core.config.Global;
|
import com.product.core.dao.BaseDao;
|
import com.product.core.entity.DataTableEntity;
|
import com.product.core.entity.FieldSetEntity;
|
import com.product.core.exception.BaseException;
|
import com.product.core.service.support.AbstractBaseService;
|
import com.product.core.spring.context.SpringBeanUtil;
|
import com.product.core.spring.context.SpringMVCContextHolder;
|
import com.product.module.data.config.CmnCode;
|
import com.product.module.data.config.CmnConst;
|
import com.product.module.data.service.idel.IOrganizationImportService;
|
import com.product.module.sys.entity.SystemUser;
|
import com.product.org.admin.service.StaffManagerService;
|
import com.product.util.BaseUtil;
|
import com.product.util.CallBack;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
|
/**
|
* @ClassName OrganizationImportService
|
* @Description 组织机构导入数据处理
|
* @Author cheng
|
* @Date 2021/12/2 16:14
|
*/
|
@Service
|
public class OrganizationImportService extends AbstractBaseService implements IOrganizationImportService {
|
|
|
@Autowired
|
StaffManagerService staffManagerService;
|
|
private final String companyLevelSeparator = ">";
|
|
/**
|
* 导入公司 之前 数据处理
|
*
|
* @param dt
|
* @throws BaseException
|
*/
|
@Override
|
public DataTableEntity importCompanyBefore(DataTableEntity dt) throws BaseException {
|
ImportErrorEntity errorEntity = new ImportErrorEntity();
|
try {
|
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
//管理员权限验证
|
managerPermissionValidation(errorEntity, currentUser);
|
FieldSetEntity managerFieldSet = currentUser.getCurrentManager();
|
String managerCompany = managerFieldSet.getString(CmnConst.ORG_LEVEL_UUID);
|
// 当前管理员管理的公司
|
String managerCompanyUuids = currentUser.getCurrentCompany().getString(CmnConst.ORG_LEVEL_UUID);
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
//数据验证结果
|
Map<String, String> fieldType = Maps.newHashMap();
|
fieldType.put(CmnConst.SEQUENCE, "int");
|
errorEntity = fieldRequiredValidation(dt, new String[]{CmnConst.FIELD_ORG_LEVEL_NAME, CmnConst.FIELD_ORG_LEVEL_ALL, CmnConst.SEQUENCE}, null, f -> {
|
if (f != null && f[0] != null) {
|
FieldSetEntity fse = f[0];
|
//公司名称
|
String companyName = fse.getString(CmnConst.FIELD_ORG_LEVEL_NAME);
|
//公司全称
|
String companyAllName = fse.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
//上级公司全称
|
String parentAllName = companyAllName.replace(companyLevelSeparator + companyName, "");
|
fse.setValue("parentAllName", parentAllName);
|
}
|
});
|
DataTableEntity systemData = getBaseDao().listTable(CmnConst.TABLE_PRODUCT_SYS_ORG_LEVELS, " org_level_type=0 AND "
|
+ BaseUtil.buildQuestionMarkFilter(CmnConst.ORG_LEVEL_UUID, managerCompanyUuids.split(","), true), new Object[]{}, "org_level_code");
|
// 验证重复 & 合并错误信息
|
errorEntity.mergeError(fieldRepeatValidation(dt, systemData, CmnConst.FIELD_ORG_LEVEL_ALL));
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
List<FieldSetEntity> data = dt.getData();
|
data.sort((a, b) -> {
|
String Aorg_level_all = a.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
String Borg_level_all = b.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
int lengthA = Aorg_level_all != null ? Aorg_level_all.length() : -1;
|
int lengthB = Borg_level_all != null ? Borg_level_all.length() : -1;
|
return lengthA - lengthB;
|
});
|
// 获取当前管理管理公司以及子公司
|
DataTableEntity allCompany = getBaseDao().listTable(CmnConst.TABLE_PRODUCT_SYS_ORG_LEVELS, " org_level_type=0 AND "
|
+ BaseUtil.buildQuestionMarkFilter(CmnConst.ORG_LEVEL_UUID, managerCompanyUuids.split(","), true), new Object[]{}, "org_level_code");
|
Map<String, String> levelCode = Maps.newHashMap();
|
if (!BaseUtil.dataTableIsEmpty(allCompany)) {
|
for (int i = 0; i < allCompany.getRows(); i++) {
|
String org_level_all = allCompany.getString(i, CmnConst.FIELD_ORG_LEVEL_ALL);
|
String org_level_code = allCompany.getString(i, CmnConst.FIELD_ORG_LEVEL_CODE);
|
// 将公司编码用全称存储
|
levelCode.put(org_level_all, org_level_code);
|
}
|
}
|
for (FieldSetEntity fse : data) {
|
//当前行
|
Integer rowIndex = fse.getInteger("~row~");
|
//公司全称
|
String companyAllName = fse.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
//上级组织机构全称
|
String parentAllName = fse.getString("parentAllName");
|
//上级机构编码
|
String code = levelCode.get(parentAllName);
|
if (StringUtils.isEmpty(code)) {
|
errorEntity.addError(rowIndex, " 获取上级机构编码错误，请检查公司名称、全称是否正确，错误行号：").append(rowIndex + 1);
|
continue;
|
}
|
//初始化公司数据
|
initOrganizationFieldSet(fse, currentUser.getClient_uuid(), code, 0);
|
// 将当前公司生成的org_level_code 放入map中
|
levelCode.put(companyAllName, fse.getString(CmnConst.FIELD_ORG_LEVEL_CODE));
|
String uuid = null;
|
try {
|
// 保存出错直接跳过该条数据
|
getBaseDao().add(fse);
|
} catch (Exception e) {
|
continue;
|
}
|
if (null != uuid) {
|
// 导入时创建该公司的数据权限
|
FieldSetEntity fs = new FieldSetEntity();
|
fs.setTableName(CmnConst.TABLE_PRODUCT_SYS_DATA_STRATEGY_MASTER);
|
// fs.setValue(CmnConst.ORG_LEVEL_UUID, uuid);
|
fs.setValue("property_uuid", "001");
|
fs.setValue("is_used", "1");
|
fs.setValue("effective_start_date", new Date());
|
fs.setValue(CmnConst.CREATED_BY, currentUser.getUser_id());
|
fs.setValue(CmnConst.CREATED_UTC_DATETIME, new Date());
|
getBaseDao().add(fs);
|
}
|
}
|
// 回写到隐藏管理员所管理的公司 todo group_concat 太多会报错
|
getBaseDao().executeUpdate("UPDATE product_sys_org_manager SET org_level_uuid =(SELECT group_concat(UUID) FROM product_sys_org_levels WHERE CLIENT_UUID =? AND ORG_LEVEL_TYPE =0) WHERE CLIENTS_UUID=? AND MANAGER_TYPE=? "
|
, new Object[]{currentUser.getClient_uuid(), currentUser.getClient_uuid(), 3});
|
// 回写当前管理员管理的公司
|
if (currentUser.getUserType() == 2 && dt.getUuids() != null) {
|
if (!StringUtils.isEmpty(managerCompany)) {
|
managerCompany += ",";
|
} else {
|
managerCompany = "";
|
}
|
managerCompany += dt.getUuidsToString();
|
String manager_uuid = managerFieldSet.getUUID();
|
String sql = "update product_sys_org_manager set org_level_uuid=? where uuid=?";
|
getBaseDao().executeUpdate(sql, new Object[]{managerCompany, manager_uuid});
|
}
|
//抛出错误
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
UpdateLoginUserInfoService loginUserInfoService = SpringBeanUtil.getBean("updateLoginUserInfoService", UpdateLoginUserInfoService.class);
|
loginUserInfoService.updateUserInfoByUserId(new Object[]{currentUser.getUser_id()}, false);
|
return dt;
|
} else {
|
errorEntity.newThrowBaseException("导入公司失败，未提取到数据");
|
}
|
} catch (BaseException e) {
|
throw e;
|
} catch (Exception e) {
|
e.printStackTrace();
|
errorEntity.addError(0, "导入公司失败，未知错误 ，" + e.getMessage());
|
errorEntity.newThrowBaseException();
|
}
|
return null;
|
}
|
|
/**
|
* 字段重复验证
|
*
|
* @param errorEntity
|
* @param importData 导入数据
|
* @param systemData 系统数据 （可选）
|
* @param fieldNames 字段名称
|
* @return
|
* @throws BaseException
|
*/
|
protected ImportErrorEntity fieldRepeatValidation(ImportErrorEntity errorEntity, DataTableEntity importData, DataTableEntity systemData, String[] fieldNames) throws BaseException {
|
if (fieldNames == null || fieldNames.length <= 0) {
|
return errorEntity;
|
}
|
List<FieldSetEntity> dataList = importData.clones().getData();
|
Map<String, Object> valueMap = Maps.newHashMap();
|
if (!BaseUtil.dataTableIsEmpty(systemData)) {
|
for (int i = 0; i < systemData.getRows(); i++) {
|
for (String field : fieldNames) {
|
String value = systemData.getString(i, field);
|
if (!StringUtils.isEmpty(value)) {
|
valueMap.put(field + this.companyLevelSeparator + value, Boolean.FALSE);
|
}
|
}
|
}
|
}
|
fieldRepeatValidation(errorEntity, dataList, valueMap, fieldNames);
|
return errorEntity;
|
}
|
|
/**
|
* 字段重复验证
|
*
|
* @param dataList 导入数据
|
* @param valueMap
|
* @param fieldNames 字段名称
|
* @throws BaseException
|
*/
|
protected void fieldRepeatValidation(ImportErrorEntity errorEntity, List<FieldSetEntity> dataList, Map<String, Object> valueMap, String[] fieldNames) throws BaseException {
|
|
for (FieldSetEntity fse : dataList) {
|
DataLocation dataLocation = getDataLocation(fse);
|
for (String fieldName : fieldNames) {
|
String value = fse.getString(fieldName);
|
if (!StringUtils.isEmpty(value)) {
|
if (valueMap.get(fieldName + this.companyLevelSeparator + value) != null) {
|
Object val = valueMap.get(fieldName + this.companyLevelSeparator + value);
|
if (val != null) {
|
String error;
|
if (val instanceof Boolean) {
|
// 系统中存在
|
// 第 N 行，第 N 列，'表头名称' ('数据值') 数据重复，在系统中已存在
|
error = "第 %s 行，第 %s 列 '%s', 数据重复，在系统中已存在";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(fieldName), dataLocation.getColName(fieldName), value);
|
} else {
|
FieldSetEntity fs = (FieldSetEntity) val;
|
DataLocation historyLocation = getDataLocation(fs);
|
// 第N行，第 N列，'表头名称' ('数据值') 数据和第 %s 行，第N行，第 N列，'表头名称' ('数据值') 数据重复
|
error = "第 %s 行，第 %s 列 '%s', 数据和第 %s 行，第 %s 列 '%s' ,数据重复";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(fieldName), dataLocation.getColName(fieldName), value,
|
historyLocation.getRowIndex(), historyLocation.getColIndex(fieldName), historyLocation.getColName(fieldName), value);
|
}
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
}
|
} else {
|
valueMap.put(fieldName + this.companyLevelSeparator + value, fse);
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 字段重复验证
|
*
|
* @param importData 导入数据
|
* @param systemData 系统数据 （可选）
|
* @param fieldName 字段名称
|
* @return
|
* @throws BaseException
|
*/
|
protected ImportErrorEntity fieldRepeatValidation(DataTableEntity importData, DataTableEntity
|
systemData, String fieldName) throws BaseException {
|
return fieldRepeatValidation(new ImportErrorEntity(), importData, systemData, new String[]{fieldName});
|
}
|
|
/**
|
* 字段必填验证
|
*
|
* @param dt
|
* @return
|
* @throws BaseException
|
*/
|
protected ImportErrorEntity fieldRequiredValidation(DataTableEntity dt, String[]
|
fieldNames, Map<String, String> fieldType, CallBack<FieldSetEntity> callBack) throws BaseException {
|
ImportErrorEntity errorEntity = new ImportErrorEntity();
|
for (int i = 0; i < dt.getRows(); i++) {
|
FieldSetEntity fieldSetEntity = dt.getFieldSetEntity(i);
|
if (callBack != null) {
|
callBack.method(fieldSetEntity);
|
}
|
fieldRequiredValidation(errorEntity, fieldSetEntity, fieldNames, fieldType);
|
}
|
|
return errorEntity;
|
}
|
|
/**
|
* 字段类型验证
|
* 目前支持 int double dateTime
|
*
|
* @param errorEntity
|
* @param fse
|
* @param fieldTypeMap
|
* @return
|
* @throws BaseException
|
*/
|
protected boolean fieldTypeValidation(ImportErrorEntity errorEntity, FieldSetEntity
|
fse, Map<String, String> fieldTypeMap) throws BaseException {
|
boolean flag = true;
|
if (fieldTypeMap != null && fieldTypeMap.size() > 0 && fse != null) {
|
for (Map.Entry<String, String> v : fieldTypeMap.entrySet()) {
|
String fieldType = v.getValue();
|
String key = v.getKey();
|
Object value = fse.getObject(key);
|
if (value == null) {
|
continue;
|
}
|
String type = null;
|
String msg = "";
|
try {
|
switch (fieldType) {
|
case "int":
|
type = "整数";
|
fse.getInteger(key);
|
continue;
|
case "dateTime":
|
type = "日期";
|
Date date = fse.getDate(key);
|
fse.setValue(key, date);
|
continue;
|
case "double":
|
type = "小数";
|
fse.getDouble(key);
|
continue;
|
case "mobile_phone":
|
type = "移动电话";
|
String phone = fse.getString(key);
|
// 验证是否为中国大陆 手机号
|
if (!BaseUtil.isChinaPhoneLegal(phone)) {
|
throw new BaseException("", "");
|
}
|
continue;
|
case "id_card":
|
type = "身份证号码";
|
String idCard = fse.getString(key);
|
// 验证身份证号码是否合法
|
if (IdcardUtils.validateCard(idCard)) {
|
msg = BaseUtil.idCardVerification(idCard);
|
throw new BaseException("", "");
|
}
|
continue;
|
case "email":
|
type = "邮箱";
|
String email = fse.getString(key);
|
// 邮箱验证
|
if (!BaseUtil.isEmail(email)) {
|
throw new BaseException("", "");
|
}
|
continue;
|
case "sex":
|
type = "性别";
|
String sex = fse.getString(key);
|
// 邮箱验证
|
if (!"男".equals(sex) && !"女".equals(sex)) {
|
throw new BaseException("", "");
|
}
|
continue;
|
default:
|
}
|
} catch (BaseException e) {
|
DataLocation dataLocation = getDataLocation(fse);
|
String error = "第 %s 行，第 %s 列，数据类型错误" + (type != null ? "，请输入正确的 '%s'值" : "");
|
if (type != null) {
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(key), type);
|
} else {
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(key));
|
}
|
if (!StringUtils.isEmpty(msg)) {
|
error += "," + msg;
|
}
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
flag = false;
|
}
|
}
|
}
|
|
return flag;
|
}
|
|
|
/**
|
* 字段必填验证
|
*
|
* @param fse
|
* @return
|
* @throws BaseException
|
*/
|
private boolean fieldRequiredValidation(ImportErrorEntity errorEntity, FieldSetEntity fse, String[]
|
fieldNames, Map<String, String> fieldType) throws BaseException {
|
if (fse == null || fieldNames == null || fieldNames.length <= 0) {
|
return true;
|
}
|
DataLocation dataLocation = getDataLocation(fse);
|
boolean flag = true;
|
for (String fieldName : fieldNames) {
|
if (!StringUtils.isEmpty(fieldName)) {
|
String value = fse.getString(fieldName);
|
if (StringUtils.isEmpty(value)) {
|
String error = "第 %s 行，第 %s 列 '%s', 不能为空";
|
Integer rowIndex = dataLocation.getRowIndex();
|
String colIndex = dataLocation.getColIndex(fieldName);
|
String colName = dataLocation.getColName(fieldName);
|
error = String.format(error, rowIndex, colIndex, colName);
|
errorEntity.addError(rowIndex, error);
|
flag = false;
|
}
|
}
|
}
|
if (flag) {
|
return fieldTypeValidation(errorEntity, fse, fieldType);
|
} else {
|
fieldTypeValidation(errorEntity, fse, fieldType);
|
return false;
|
}
|
}
|
|
/**
|
* 导入部门 之前 数据处理
|
*
|
* @param dt
|
* @throws BaseException
|
*/
|
@Override
|
public DataTableEntity importDeptBefore(DataTableEntity dt) throws BaseException {
|
ImportErrorEntity errorEntity = new ImportErrorEntity();
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
try {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
//管理员权限验证
|
managerPermissionValidation(errorEntity, currentUser);
|
|
Map<String, String> fieldType = Maps.newHashMap();
|
fieldType.put(CmnConst.SEQUENCE, "int");
|
//数据必填验证结果
|
errorEntity = fieldRequiredValidation(dt, new String[]{CmnConst.FIELD_ORG_LEVEL_NAME, CmnConst.FIELD_ORG_LEVEL_ALL, CmnConst.SEQUENCE, CmnConst.ORG_LEVEL_UUID}, fieldType, null);
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
FieldSetEntity currentManager = currentUser.getCurrentManager();
|
String managerCompanyUuids = currentManager.getString(CmnConst.ORG_LEVEL_UUID);
|
String uuidFilter = BaseUtil.buildQuestionMarkFilter("uuid", managerCompanyUuids.split(","), true);
|
StringBuilder sql = new StringBuilder(8);
|
sql.append(" select uuid,org_level_name,org_level_code, ");
|
sql.append(" org_level_code_parent,org_level_all,org_level_type ");
|
sql.append(" FROM product_sys_org_levels where client_uuid=? and ( ");
|
sql.append(" ( ");
|
sql.append(" ").append(uuidFilter);
|
sql.append(" AND org_level_type=0 ) ");
|
sql.append(" or ( ");
|
sql.append(" ").append(uuidFilter.replace("uuid", "org_level_uuid"));
|
sql.append(" AND org_level_type=1 ) ");
|
sql.append(" ) order by org_level_code,org_level_type");
|
// 系统数据
|
DataTableEntity systemData = getBaseDao().listTable(sql.toString(), new Object[]{currentUser.getClient_uuid()});
|
importDeptBefore(dt, systemData, currentUser, errorEntity);
|
return dt;
|
} catch (BaseException e) {
|
e.printStackTrace();
|
throw e;
|
} catch (Exception e) {
|
e.printStackTrace();
|
errorEntity.addError(0, "导入部门失败，未知错误 ，" + e.getMessage());
|
errorEntity.newThrowBaseException();
|
}
|
}
|
errorEntity.newThrowBaseException("导入公司失败，未提取到数据");
|
return null;
|
}
|
|
private void importDeptBefore(DataTableEntity dt, DataTableEntity systemData, SystemUser
|
user, ImportErrorEntity errorEntity) throws BaseException {
|
List<FieldSetEntity> data = dt.getData();
|
// 机构全称排序
|
data.sort(Comparator.comparing(a -> a.getString(CmnConst.FIELD_ORG_LEVEL_ALL)));
|
if (BaseUtil.dataTableIsEmpty(systemData)) {
|
errorEntity.newThrowBaseException("获取系统机构信息失败，请联系管理员 ");
|
}
|
List<FieldSetEntity> systemDataList = systemData.getData();
|
// 公司
|
Map<String, FieldSetEntity> companyMap = Maps.newHashMap();
|
// 部门
|
Map<String, FieldSetEntity> deptMap = Maps.newHashMap();
|
for (FieldSetEntity fse : systemDataList) {
|
// 机构类型
|
String orgLevelType = fse.getString(CmnConst.FIELD_ORG_LEVEL_TYPE);
|
// 机构全称
|
String org_level_all = fse.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
Map<String, FieldSetEntity> map;
|
if ("0".equals(orgLevelType)) {
|
map = companyMap;
|
} else if ("1".equals(org_level_all)) {
|
map = deptMap;
|
} else {
|
continue;
|
}
|
map.put(org_level_all, fse);
|
}
|
for (int i = 0; i < dt.getRows(); i++) {
|
FieldSetEntity fse = dt.getFieldSetEntity(i);
|
// 公司全称
|
String companyAllName = fse.getString(CmnConst.ORG_LEVEL_UUID);
|
// 部门全称
|
String deptAllName = fse.getString(CmnConst.FIELD_ORG_LEVEL_ALL);
|
// 部门名称
|
String deptName = fse.getString(CmnConst.FIELD_ORG_LEVEL_NAME);
|
|
DataLocation dataLocation = getDataLocation(fse);
|
FieldSetEntity companyFse = companyMap.get(companyAllName);
|
if (companyFse == null || StringUtils.isEmpty(companyFse.getUUID())) {
|
String error = "第 %s 行，上级机构获取失败，所属公司不存在，请检查' %s '是否正确：' %s '";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColName(CmnConst.ORG_LEVEL_UUID), companyAllName);
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
continue;
|
}
|
String error = "第 %s 行，上级机构获取失败，上级部门不存在，请检查' %s '是否正确：' %s '";
|
// 部门上级全称
|
String parentDeptAllName = getParentAllName(deptAllName, deptName);
|
if (StringUtils.isEmpty(parentDeptAllName)) {
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColName(CmnConst.FIELD_ORG_LEVEL_ALL), deptAllName);
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
continue;
|
}
|
// 上级编码
|
String code;
|
// 上级机构的uuid
|
String parentUuid;
|
if (!parentDeptAllName.equals(companyAllName)) {
|
FieldSetEntity deptFse = deptMap.get(parentDeptAllName);
|
if (deptFse == null || StringUtils.isEmpty(deptFse.getUUID())) {
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColName(CmnConst.FIELD_ORG_LEVEL_ALL), deptAllName);
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
continue;
|
}
|
// 取出上级部门的code作为上级编码
|
code = deptFse.getString(CmnConst.FIELD_ORG_LEVEL_CODE);
|
|
parentUuid = deptFse.getString(CmnConst.ORG_LEVEL_UUID);
|
} else {
|
// 取出上级公司的code作为上级编码
|
code = companyFse.getString(CmnConst.FIELD_ORG_LEVEL_CODE);
|
parentUuid = companyFse.getUUID();
|
}
|
initOrganizationFieldSet(fse, user.getClient_uuid(), code, 1);
|
fse.setValue(CmnConst.ORG_LEVEL_UUID, parentUuid);
|
getBaseDao().saveFieldSetEntity(fse);
|
deptMap.put(deptAllName, fse);
|
}
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
}
|
|
private String getParentAllName(String allName, String name) {
|
if (!StringUtils.isEmpty(allName) && !StringUtils.isEmpty(name)) {
|
int index = allName.indexOf(this.companyLevelSeparator + name);
|
if (index > -1) {
|
return allName.substring(0, index);
|
}
|
}
|
return "";
|
}
|
|
/**
|
* 导入岗位等级 之前 数据处理
|
*
|
* @param dt
|
* @throws BaseException
|
*/
|
@Override
|
public DataTableEntity importPostLevelBefore(DataTableEntity dt) throws BaseException {
|
ImportErrorEntity errorEntity = new ImportErrorEntity();
|
try {
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
//管理员权限验证
|
managerPermissionValidation(errorEntity, currentUser);
|
// 当前管理员管理的公司
|
String managerCompanyUuids = currentUser.getCurrentManager().getString(CmnConst.ORG_LEVEL_UUID);
|
Map<String, List<FieldSetEntity>> groupCompany = Maps.newHashMap();
|
Map<String, String> fieldType = Maps.newHashMap();
|
fieldType.put(CmnConst.SEQUENCE, "int");
|
fieldType.put(CmnConst.FIELD_JOB_GRADE_CLASS, "int");
|
StringBuilder sql = new StringBuilder();
|
sql.append(" select concat( ");
|
sql.append(" org_level_uuid,'>',job_grade_name) uuid ");
|
sql.append(" FROM product_sys_job_post_grades where ");
|
sql.append(BaseUtil.buildQuestionMarkFilter("org_level_uuid", managerCompanyUuids.split(","), true));
|
DataTableEntity systemData = getBaseDao().listTable(sql.toString(), new Object[]{});
|
Set<Object> systemDataSet = Sets.newHashSet();
|
if (!BaseUtil.dataTableIsEmpty(systemData)) {
|
systemDataSet.addAll(Arrays.asList(systemData.getUuidsToString().split(",")));
|
}
|
for (int i = 0; i < dt.getRows(); i++) {
|
FieldSetEntity fse = dt.getFieldSetEntity(i);
|
// 字段必填验证
|
boolean validation = fieldRequiredValidation(errorEntity, fse, new String[]{CmnConst.ORG_LEVEL_UUID, CmnConst.FIELD_JOB_GRADE_NAME, CmnConst.SEQUENCE, CmnConst.FIELD_JOB_GRADE_CLASS}, fieldType);
|
if (!validation) {
|
// 验证未通过 跳过该条数据
|
continue;
|
}
|
// 公司全称
|
String companyAllName = fse.getString(CmnConst.ORG_LEVEL_UUID);
|
|
List<FieldSetEntity> groupPostGradeList = groupCompany.get(companyAllName);
|
if (groupPostGradeList == null) {
|
groupPostGradeList = Lists.newArrayList();
|
groupCompany.put(companyAllName, groupPostGradeList);
|
}
|
groupPostGradeList.add(fse);
|
}
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
Set<String> companyAllNames = groupCompany.keySet();
|
sql = new StringBuilder();
|
sql.append(" select uuid,org_level_all ");
|
sql.append(" FROM product_sys_org_levels ");
|
sql.append(" where ");
|
sql.append(BaseUtil.buildQuestionMarkFilter("uuid", managerCompanyUuids.split(","), true));
|
sql.append(" AND ");
|
sql.append(BaseUtil.buildQuestionMarkFilter("org_level_all", companyAllNames.toArray(), true));
|
// 根据用户上传的公司全称 & 该管理员管理的所有公司 进行查询公司的uuid
|
DataTableEntity companyInfo = getBaseDao().listTable(sql.toString(), new Object[]{});
|
// 定义没有找到公司的数据 写入错误方法
|
CallBack<FieldSetEntity> callBack = (value) -> {
|
for (FieldSetEntity fs : value) {
|
DataLocation dataLocation = getDataLocation(fs);
|
String error = "第 %s 行，第 %s 数据错误,所属公司不存在，请检查列 '%s'";
|
errorEntity.addError(dataLocation.getRowIndex(), String.format(error,
|
dataLocation.getRowIndex(),
|
dataLocation.getColIndex(CmnConst.ORG_LEVEL_UUID),
|
dataLocation.getColName(CmnConst.ORG_LEVEL_UUID)));
|
}
|
};
|
// 没有查询到所有公司信息
|
if (BaseUtil.dataTableIsEmpty(companyInfo)) {
|
for (List<FieldSetEntity> value : groupCompany.values()) {
|
// 循环写入错误
|
callBack.method(value.toArray(new FieldSetEntity[]{}));
|
}
|
errorEntity.newThrowBaseException();
|
} else {
|
// copy 公司全称
|
Set<String> companyNames = Sets.newHashSet();
|
companyNames.addAll(companyAllNames);
|
// 循环查询的公司结果
|
for (int i = 0; i < companyInfo.getRows(); i++) {
|
String uuid = companyInfo.getString(i, CmnConst.UUID);
|
String org_level_all = companyInfo.getString(i, CmnConst.FIELD_ORG_LEVEL_ALL);
|
if (companyNames.contains(org_level_all)) {
|
companyNames.remove(org_level_all);
|
}
|
List<FieldSetEntity> postGradeList = groupCompany.get(org_level_all);
|
if (postGradeList != null) {
|
for (FieldSetEntity fs : postGradeList) {
|
// 将公司uuid写入每条数据
|
BaseUtil.createCreatorAndCreationTime(currentUser, fs);
|
fs.setValue(CmnConst.ORG_LEVEL_UUID, uuid);
|
fs.setValue(CmnConst.IS_USED, 1);
|
String job_grade_name = fs.getString(CmnConst.FIELD_JOB_GRADE_NAME);
|
// String group_name = fs.getString(CmnConst.FIELD_GROUP_NAME);
|
String managerValue = uuid + this.companyLevelSeparator + job_grade_name;
|
|
if (systemDataSet.contains(managerValue)) {
|
|
DataLocation dataLocation = getDataLocation(fs);
|
String error = "第 %s 行，第 %s 列，数据重复";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_JOB_GRADE_NAME));
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
continue;
|
}
|
systemDataSet.add(managerValue);
|
}
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
}
|
}
|
// 判断有是否有公司没查询到
|
if (companyNames != null && companyNames.size() > 0) {
|
List<FieldSetEntity> postGradeList = Lists.newArrayList();
|
for (String companyName : companyNames) {
|
//将没查询到的公司所属岗位等级合并
|
postGradeList.addAll(groupCompany.get(companyName));
|
}
|
if (postGradeList.size() > 0) {
|
//调用错误组装回调
|
callBack.method(postGradeList.toArray(new FieldSetEntity[]{}));
|
// 抛出错误
|
errorEntity.newThrowBaseException();
|
}
|
}
|
// 保存所有数据
|
getBaseDao().add(dt);
|
return dt;
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
|
errorEntity.newThrowBaseException("导入岗位等级失败", e);
|
}
|
errorEntity.newThrowBaseException("导入岗位等级失败，未提取到数据");
|
return null;
|
}
|
|
/**
|
* 导入岗位 之前 数据处理
|
*
|
* @param dt
|
* @throws BaseException
|
*/
|
@Override
|
public DataTableEntity importPostBefore(DataTableEntity dt) throws BaseException {
|
ImportErrorEntity errorEntity = new ImportErrorEntity();
|
if (!BaseUtil.dataTableIsEmpty(dt)) {
|
SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
|
//管理员权限验证
|
managerPermissionValidation(errorEntity, currentUser);
|
Map<String, String> fieldType = Maps.newHashMap();
|
// 当前管理员管理的公司
|
String managerCompanyUuids = currentUser.getCurrentManager().getString(CmnConst.ORG_LEVEL_UUID);
|
fieldType.put(CmnConst.SEQUENCE, "int");
|
String companyFilter = BaseUtil.buildQuestionMarkFilter(CmnConst.ORG_LEVEL_UUID, managerCompanyUuids.split(","), true);
|
StringBuilder sql = new StringBuilder(8);
|
sql.append(" SELECT org_level_all uuid, uuid dept_uuid,org_level_uuid FROM product_sys_org_levels where org_level_type=1 and length(org_level_uuid)>0 ");
|
sql.append(" and ");
|
sql.append(companyFilter);
|
DataTableEntity deptData = getBaseDao().listTable(sql.toString(), new Object[]{});
|
if (BaseUtil.dataTableIsEmpty(deptData)) {
|
errorEntity.newThrowBaseException("您所管理的公司没有可供选择的部门，请核对部门数据");
|
}
|
sql = new StringBuilder(8);
|
sql.append(" SELECT job_grade_name uuid,org_level_uuid,uuid grade_uuid ");
|
sql.append(" FROM product_sys_job_post_grades WHERE ");
|
sql.append(companyFilter);
|
// 查询当前管理管理公司所有的岗位等级
|
DataTableEntity postGradeData = getBaseDao().listTable(sql.toString(), new Object[]{});
|
if (BaseUtil.dataTableIsEmpty(postGradeData)) {
|
// errorEntity.newThrowBaseException("您所管理的公司没有可供选择的岗位等级，请核对岗位等级数据");
|
}
|
for (int i = 0; i < dt.getRows(); i++) {
|
FieldSetEntity fse = dt.getFieldSetEntity(i);
|
// 字段必填 & 类型验证
|
boolean validationResult = fieldRequiredValidation(errorEntity, fse, new String[]{CmnConst.FIELD_DEPT_UUID, CmnConst.FIELD_JOB_POST_NAME, CmnConst.SEQUENCE}, fieldType);
|
if (!validationResult) {
|
// 验证未通过跳过
|
continue;
|
}
|
// 部门全称
|
String deptAllName = fse.getString(CmnConst.FIELD_DEPT_UUID);
|
// 岗位等级名称
|
String[] gradeNames = BaseUtil.ifNull(fse.getString(CmnConst.FIELD_JOB_POST_GRADE), "").split(",");
|
List<FieldSetEntity> fieldSetEntity = deptData.getFieldSetEntity(deptAllName);
|
// 部门所在的公司
|
String companyUuid = null;
|
// 错误标识
|
boolean errorFlag = false;
|
DataLocation dataLocation = null;
|
if (fieldSetEntity == null || fieldSetEntity.size() < 1) {
|
dataLocation = getDataLocation(fse);
|
String error = "第 %s 行，第 %s 列，部门不存在，请核对 '%s' 数据在系统中是否存在";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_DEPT_UUID), dataLocation.getColName(CmnConst.FIELD_DEPT_UUID));
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
errorFlag = true;
|
} else {
|
FieldSetEntity fs = fieldSetEntity.get(0);
|
companyUuid = fs.getString(CmnConst.ORG_LEVEL_UUID);
|
fse.setValue(CmnConst.FIELD_DEPT_UUID, fs.getString(CmnConst.FIELD_DEPT_UUID));
|
}
|
// 根据岗位等级名称取出相关数据
|
List<FieldSetEntity> postGradeList = new ArrayList<>();
|
for (String gradeName : gradeNames) {
|
if (!BaseUtil.dataTableIsEmpty(postGradeData) && postGradeData.getFieldSetEntity(gradeName) != null) {
|
postGradeList.addAll(postGradeData.getFieldSetEntity(gradeName));
|
}
|
}
|
String error = "第 %s 行，第 %s 列，岗位等级不存在，请核对 '%s' 数据在系统中是否存在";
|
// 判断岗位等级是否存在 默认不抛出错误
|
if (postGradeList.size() < 1 && false) {
|
if (dataLocation == null) {
|
dataLocation = getDataLocation(fse);
|
}
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_JOB_POST_GRADE), dataLocation.getColName(CmnConst.FIELD_JOB_POST_GRADE));
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
errorFlag = true;
|
} else if (postGradeList.size() > 0) {
|
String gradeUuid = "";
|
// 循环岗位等级
|
for (FieldSetEntity fs : postGradeList) {
|
// 查找岗位等级与公司是否匹配
|
if (companyUuid != null && companyUuid.equals(fs.getString(CmnConst.ORG_LEVEL_UUID))) {
|
if (!StringUtils.isEmpty(gradeUuid)) {
|
gradeUuid += ",";
|
}
|
gradeUuid += fs.getString("grade_uuid");
|
}
|
}
|
// 没有匹配到该公司下有相应的岗位等级
|
if (StringUtils.isEmpty(gradeUuid)) {
|
if (dataLocation == null) {
|
dataLocation = getDataLocation(fse);
|
}
|
error = "第 %s 行，第 %s 列，岗位等级在不存在，请核对 '%s' 数据在所属部门的公司中是否存在";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_JOB_POST_GRADE), dataLocation.getColName(CmnConst.FIELD_JOB_POST_GRADE));
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
errorFlag = true;
|
} else {
|
String[] gradeUuids = gradeUuid.split(",");
|
// 创建岗位与岗位等级的映射表
|
DataTableEntity subGradeMapping = new DataTableEntity();
|
for (String uuid : gradeUuids) {
|
FieldSetEntity gradeMappingFieldSet = new FieldSetEntity();
|
gradeMappingFieldSet.setTableName(CmnConst.TABLE_PRODUCT_SYS_JOB_POSTS_GRADES_MAPPING);
|
gradeMappingFieldSet.setValue("job_grade_uuid", uuid);
|
BaseUtil.createCreatorAndCreationTime(gradeMappingFieldSet);
|
subGradeMapping.addFieldSetEntity(gradeMappingFieldSet);
|
}
|
fse.addSubDataTable(subGradeMapping);
|
fse.setValue(CmnConst.FIELD_JOB_POST_GRADE, null);
|
}
|
}
|
if (errorFlag) {
|
continue;
|
}
|
// 导入数据默认启用
|
fse.setValue(CmnConst.IS_USED, 1);
|
}
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
} else {
|
return dt;
|
}
|
}
|
errorEntity.newThrowBaseException("导入岗位等级失败，未提取到数据");
|
return null;
|
}
|
|
/**
|
* 导入员工 之前 数据处理
|
*
|
* @param fse
|
* @throws BaseException
|
*/
|
@Override
|
public DataTableEntity importStaffBefore(DataTableEntity fse) throws BaseException {
|
ImportStaffDataVo staffDataVo = new ImportStaffDataVo(fse);
|
staffDataVo.startImporting();
|
return fse;
|
}
|
|
|
/**
|
* 员工导入操作类
|
*/
|
private class ImportStaffDataVo {
|
//导入的所有数据
|
private DataTableEntity dt;
|
/**
|
* 错误处理类
|
*/
|
private ImportErrorEntity errorEntity;
|
/**
|
* 系统中上级领导数据
|
*/
|
DataTableEntity directLeaderData;
|
/**
|
* 部门数据
|
*/
|
DataTableEntity deptData;
|
/**
|
* 角色数据
|
*/
|
DataTableEntity roleData;
|
/**
|
* 岗位 & 岗位等级数据
|
*/
|
DataTableEntity postData;
|
/**
|
* 员工表历史数据
|
*/
|
DataTableEntity systemData;
|
/**
|
* 导入数据的所有领导(员工编码）
|
*/
|
Set<String> direct_leader_codes;
|
/**
|
* 导入的数据按部门分组
|
*/
|
Map<String, List<FieldSetEntity>> deptGroupMap;
|
/**
|
* 当前用户
|
*/
|
SystemUser currentUser;
|
/**
|
* 当前客户
|
*/
|
String client_uuid;
|
/**
|
* 导入的数据以员工编码存放（员工编码是唯一的）
|
*/
|
Map<String, FieldSetEntity> staffCodeMap;
|
/**
|
* 导入数据类型验证
|
*/
|
Map<String, String> fieldType;
|
/**
|
* 公司过滤条件
|
*/
|
String companyFilter;
|
/**
|
* 分隔符
|
*/
|
String separator = ">";
|
|
StringBuilder sql;
|
/**
|
* 初始密码
|
* 来源于 properties 中的初始密码 如不存在默认为 '123'
|
*/
|
String init_pwd;
|
/**
|
* 部门全称存放的部门详情数据
|
*/
|
private Map<String, FieldSetEntity> deptMap;
|
/**
|
* 员工管理service
|
* 定义该操作类中避免没必要的注入 进入构造时会初始化对应bean
|
*/
|
private StaffManagerService staffManagerService;
|
|
/**
|
* 构造方法 用于clone 非必要不要自行调用此方法
|
*
|
* @param currentData
|
* @param currentDeptData
|
*/
|
ImportStaffDataVo(FieldSetEntity currentData, FieldSetEntity currentDeptData) throws BaseException {
|
// 该构造用于 clone 方法
|
// 非clone 方式调用会出现未知错误
|
this.currentData = currentData;
|
this.currentDeptData = currentDeptData;
|
if (currentData == null || currentDeptData == null) {
|
try {
|
throw new RuntimeException("Constructor arguments cannot be null");
|
} catch (RuntimeException e) {
|
throw new BaseException(e);
|
}
|
}
|
}
|
|
/**
|
* 无参构造 初始必要数据
|
*
|
* @param dt
|
*/
|
public ImportStaffDataVo(DataTableEntity dt) throws BaseException {
|
errorEntity = new ImportErrorEntity();
|
if (BaseUtil.dataTableIsEmpty(dt)) {
|
errorEntity.newThrowBaseException("导入员工失败，未提取到数据");
|
}
|
this.staffManagerService = SpringBeanUtil.getBean("staffManagerService", StaffManagerService.class);
|
direct_leader_codes = Sets.newHashSet();
|
fieldType = Maps.newHashMap();
|
currentUser = SpringMVCContextHolder.getCurrentUser();
|
client_uuid = currentUser.getClient_uuid();
|
staffCodeMap = Maps.newHashMap();
|
deptGroupMap = Maps.newHashMap();
|
init_pwd = Global.getSystemConfig("initial.pwd", "123");
|
this.dt = dt;
|
//管理员权限验证
|
managerPermissionValidation(errorEntity, currentUser);
|
// 公司过滤条件
|
companyFilter = BaseUtil.buildQuestionMarkFilter(CmnConst.ORG_LEVEL_UUID, currentUser.getCurrentManager().getString(CmnConst.ORG_LEVEL_UUID).split(","), true);
|
fieldType.put("id_number", "id_card");
|
fieldType.put("birth_date", "dateTime");
|
fieldType.put("entry_datetime", "dateTime");
|
fieldType.put("mobile_phone", "mobile_phone");
|
fieldType.put("staff_email", "email");
|
fieldType.put("age", "int");
|
}
|
|
/**
|
* 导入数据入口
|
* 开始导入
|
*/
|
public void startImporting() throws BaseException {
|
// 数据有效性验证 数据必填验证 & 数据有效性验证 & 数据分组
|
this.requiredValidation();
|
// 查询系统中已存在的员工
|
findExistStaff();
|
// 数据重复验证
|
this.repeatValidation();
|
this.throwError();
|
// 初始化所需数据
|
this.initializeSystemData();
|
// 开始处理导入数据
|
this.handleDataTable();
|
}
|
|
/**
|
* handleDataTable 遍历时的数据
|
* 可能是通过 clone 对象赋值的 没有通过 handleDataTable 方法
|
*/
|
private FieldSetEntity currentData;
|
/**
|
* handleDataTable 遍历数据对应的部门
|
* 可能是通过 clone 对象赋值的 没有通过 handleDataTable 方法
|
*/
|
private FieldSetEntity currentDeptData;
|
|
/**
|
* 上级领导未找到
|
*/
|
private void superStaffNotExist() throws BaseException {
|
DataLocation dataLocation = getDataLocation(this.currentData);
|
String error = "第 %s 行，第 %s 列，上级领导获取失败，请检查 %s 填写值是否正确，该列值应填写 %s 列对应的值";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_DIRECT_LEADER_CODE), dataLocation.getColName(CmnConst.FIELD_DIRECT_LEADER_CODE), dataLocation.getColName(CmnConst.FIELD_STAFF_CODE));
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
}
|
|
/**
|
* 处理所有记录
|
*/
|
private void handleDataTable() throws BaseException {
|
for (Map.Entry<String, List<FieldSetEntity>> fieldSets : this.deptGroupMap.entrySet()) {
|
String deptAllName = fieldSets.getKey();
|
currentDeptData = this.getStaffDept(deptAllName);
|
List<FieldSetEntity> values = fieldSets.getValue();
|
if (currentDeptData == null) {
|
for (int i = 0; i < values.size(); i++) {
|
this.currentData = values.get(i);
|
DataLocation dataLocation = getDataLocation(this.currentData);
|
String error = "第 %s 行，第 %s 列，部门在系统或管理的公司中不存在，请检查列 '%s' 的值 '%s' 是否正确";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex(CmnConst.FIELD_DEPT_UUID),
|
dataLocation.getColName(CmnConst.FIELD_DEPT_UUID), deptAllName);
|
this.errorEntity.addError(dataLocation.getRowIndex(), error);
|
}
|
continue;
|
}
|
for (FieldSetEntity value : values) {
|
if (value.getBoolean("~processed~")) {
|
continue;
|
}
|
this.currentData = value;
|
this.handleFieldSet();
|
}
|
}
|
throwError();
|
}
|
|
/**
|
* 处理单条记录
|
*/
|
private void handleFieldSet() throws BaseException {
|
if (this.currentData.getBoolean("~processed~")) {
|
return;
|
}
|
String dept_uuid = this.currentDeptData.getString(CmnConst.UUID);
|
String org_level_uuid = this.currentDeptData.getString(CmnConst.ORG_LEVEL_UUID);
|
this.currentData.setValue("~processed~", 1);
|
this.currentData.setValue("~dept_uuid~", dept_uuid);
|
this.currentData.setValue(CmnConst.FIELD_STAFF_CODE, this.currentData.getString("~temp_staff_code~"));
|
this.currentData.setValue(CmnConst.FIELD_DEPT_UUID, currentDeptData.getString(CmnConst.FIELD_DEPT_UUID));
|
this.currentData.setValue(CmnConst.ORG_LEVEL_UUID, org_level_uuid);
|
this.currentData.setValue("status", 1);
|
|
//取出配置中账户初始密码
|
this.currentData.setValue(CmnConst.USER_PWD, this.init_pwd);
|
String sex = this.currentData.getString("sex");
|
if (!StringUtils.isEmpty(sex)) {
|
// 性别不为空时 转换参照数据 性别验证已在上个方法中验证过
|
this.currentData.setValue("sex", sex.equals("男") ? 0 : 1);
|
}
|
// 导入数据配置中 使用 staff_avatar 字段作为用户登录账户的载体 在此处转换回来
|
this.currentData.setValue(CmnConst.USER_ACCOUNT, this.currentData.getString("staff_avatar"));
|
// 删除载体数据
|
this.currentData.remove("staff_avatar");
|
// 将show_name 字段（员工名称） 复制到 user表字段上
|
this.currentData.setValue(CmnConst.USER_NAME, this.currentData.getString("show_name"));
|
String job_post_grade_uuid = this.currentData.getString(CmnConst.FIELD_JOB_POST_GRADE_UUID);
|
String job_post_name = this.currentData.getString("job_post_uuid");
|
|
// 岗位 & 岗位等级
|
List<FieldSetEntity> postDataList = postData.getFieldSetEntity(this.currentData.getString("job_post_uuid"));
|
if (postDataList == null || postDataList.size() <= 0) {
|
// 没有岗位
|
postNotExist.method(this.currentData, "job_post_uuid");
|
} else {
|
// 记录找到的岗位等级uuid ，多个用逗号分隔
|
String grade_uuid = "";
|
// 岗位uuid
|
String post_uuid = null;
|
// 循环系统中岗位数据
|
for (FieldSetEntity postFs : postDataList) {
|
// 判断岗位是否在部门下 & 岗位名称和导入数据的岗位名称是否相同
|
if (currentDeptData.getString(CmnConst.FIELD_DEPT_UUID).equals(postFs.getString(CmnConst.FIELD_DEPT_UUID)) && job_post_name.equals(postFs.getUUID())) {
|
// 系统中岗位的uuid
|
String job_post_uuid = postFs.getString("job_post_uuid");
|
// 岗位uuid不为空时 判断当前postFs 中的岗位uuid是否跟已找到的岗位相同
|
if (post_uuid != null && !post_uuid.equals(job_post_uuid)) {
|
continue;
|
}
|
if (post_uuid == null) {
|
// 记录岗位uuid
|
post_uuid = job_post_uuid;
|
}
|
// 获取岗位中的岗位等级名称
|
String job_grade_name = postFs.getString(CmnConst.FIELD_JOB_GRADE_NAME);
|
// 拆分循环导入岗位等级名称
|
if (!BaseUtil.strIsNull(job_post_grade_uuid)) {
|
for (String grade_name : job_post_grade_uuid.split(",")) {
|
// 判断岗位等级名称和系统中相同
|
if (job_grade_name.equals(grade_name)) {
|
if (!StringUtils.isEmpty(grade_uuid)) {
|
grade_uuid += ",";
|
}
|
grade_uuid += postFs.getString(CmnConst.FIELD_JOB_POST_GRADE);
|
}
|
}
|
}
|
}
|
|
}
|
// 没有找到岗位
|
if (StringUtils.isEmpty(post_uuid)) {
|
// 抛出岗位未找到错误
|
postNotExist.method(this.currentData, "job_post_uuid");
|
} else {
|
// 找到岗位
|
this.currentData.setValue("job_post_uuid", post_uuid);
|
}
|
// 没有找到岗位等级
|
if (!StringUtils.isEmpty(grade_uuid)) {
|
// postNotExist.method(this.currentData, CmnConst.FIELD_JOB_POST_GRADE_UUID);
|
// } else {
|
this.currentData.setValue(CmnConst.FIELD_JOB_POST_GRADE_UUID, grade_uuid);
|
}
|
}
|
// 导入数据中岗位名称
|
String[] role_uuids = this.currentData.getString("role_uuids").split(",");
|
String roleUuid = "";
|
// 角色处理
|
roleFor:
|
// 循环角色名称
|
for (String roleName : role_uuids) {
|
// 使用角色名称获取系统数据
|
List<FieldSetEntity> roleList = roleData.getFieldSetEntity(roleName);
|
if (roleList != null && roleList.size() > 0) {
|
// 循环系统中的角色
|
for (FieldSetEntity roleFs : roleList) {
|
// 因系统中角色所属公司可多选，在此处前后拼接逗号
|
String roleCompany = "," + roleFs.getString(CmnConst.ORG_LEVEL_UUID) + ",";
|
// 判断角色是否有导入数据的公司
|
if (roleCompany.contains("," + org_level_uuid + ",")) {
|
String role_uuid = roleFs.getString("role_uuid");
|
if (!StringUtils.isEmpty(roleUuid)) {
|
roleUuid += ",";
|
}
|
roleUuid += role_uuid;
|
continue roleFor;
|
}
|
}
|
}
|
|
// 没有找到角色数据 抛出错误
|
roleNotExist.method(this.currentData, roleName);
|
|
}
|
this.currentData.setValue("role_uuids", roleUuid);
|
//装载上级领导code
|
this.loadingSuperCode();
|
if (staffManagerService == null) {
|
staffManagerService = SpringBeanUtil.getBean("staffManagerService", StaffManagerService.class);
|
}
|
staffManagerService.saveStaffInfo(this.currentData);
|
}
|
|
/**
|
* 抛出错误
|
*
|
* @throws BaseException
|
*/
|
void throwError() throws BaseException {
|
if (errorEntity.isError) {
|
errorEntity.newThrowBaseException();
|
}
|
}
|
|
/**
|
* 装载上级领导编码
|
*
|
* @return
|
*/
|
private boolean loadingSuperCode() throws BaseException {
|
// 上级领导（员工编码）
|
String direct_leader_code = this.currentData.getString(CmnConst.FIELD_DIRECT_LEADER_CODE);
|
String superCode = "";
|
if (!StringUtils.isEmpty(direct_leader_code)) {
|
List<FieldSetEntity> fieldSetEntity = directLeaderData.getFieldSetEntity(direct_leader_code);
|
if (staffCodeMap.get(direct_leader_code) == null && (fieldSetEntity == null || fieldSetEntity.size() <= 0)) {
|
// 未找到上级领导
|
this.superStaffNotExist();
|
return false;
|
} else {
|
//上级领导在导入数据 或系统中已存在
|
// 根据编码获取上级（导入数据）
|
FieldSetEntity superFs = staffCodeMap.get(direct_leader_code);
|
if (superFs == null && (fieldSetEntity == null || fieldSetEntity.size() <= 0)) {
|
// 未找到上级领导
|
this.superStaffNotExist();
|
return false;
|
} else if (superFs == null) {
|
// 在系统中拿出上级领导
|
superFs = fieldSetEntity.get(0);
|
}
|
String user_id = superFs.getString(CmnConst.USER_ID);
|
if (StringUtils.isEmpty(user_id)) {
|
// user_id 不存在，该上级在导入数据中未保存过
|
String deptAllName = superFs.getString(CmnConst.FIELD_DEPT_UUID);
|
if (superFs.getBoolean("~processed~")) {
|
deptAllName = superFs.getString("~" + CmnConst.FIELD_DEPT_UUID + "~");
|
}
|
FieldSetEntity deptFs = getStaffDept(deptAllName);
|
if (deptFs == null) {
|
return false;
|
}
|
// 克隆当前对象 将父级的部门 & 员工表数据放入克隆对象中
|
ImportStaffDataVo clone = this.clone(deptFs, superFs);
|
// 先让父级数据进行保存操作
|
// 这里会出现递归操作 因为 handleFieldSet 方法调用了当前方法 父级的父级进入一致的判断会一直递归 clone并保存
|
// 如果递归层数过多可能会出现 full gc
|
clone.handleFieldSet();
|
} else {
|
//已保存过的数据 取出已生成的tricode
|
superCode = superFs.getString(CmnConst.TRICODE);
|
}
|
}
|
}
|
this.currentData.setValue(CmnConst.FIELD_DIRECT_LEADER_CODE, superCode);
|
return true;
|
}
|
|
/**
|
* 克隆对象
|
* 克隆后 sql 成员变量未初始化
|
*
|
* @param currentDeptData
|
* @param currentData
|
* @return
|
*/
|
private ImportStaffDataVo clone(FieldSetEntity currentDeptData, FieldSetEntity currentData) throws BaseException {
|
ImportStaffDataVo clone = new ImportStaffDataVo(currentData, currentDeptData);
|
clone.deptData = this.deptData;
|
clone.postData = this.postData;
|
clone.roleData = this.roleData;
|
clone.deptGroupMap = this.deptGroupMap;
|
clone.errorEntity = this.errorEntity;
|
clone.direct_leader_codes = this.direct_leader_codes;
|
clone.deptMap = this.deptMap;
|
clone.dt = this.dt;
|
clone.systemData = this.systemData;
|
clone.directLeaderData = this.directLeaderData;
|
clone.staffCodeMap = this.staffCodeMap;
|
clone.companyFilter = this.companyFilter;
|
clone.currentUser = this.currentUser;
|
clone.fieldType = this.fieldType;
|
clone.init_pwd = this.init_pwd;
|
clone.client_uuid = this.client_uuid;
|
return clone;
|
}
|
|
/**
|
* 根据部门全称获取部门详情
|
*
|
* @param deptAllName
|
* @return
|
* @throws BaseException
|
*/
|
private FieldSetEntity getStaffDept(String deptAllName) throws BaseException {
|
if (deptMap == null) {
|
deptMap = Maps.newHashMap();
|
}
|
if (deptMap.get(deptAllName) != null) {
|
return deptMap.get(deptAllName);
|
}
|
List<FieldSetEntity> deptDatList = deptData.getFieldSetEntity(deptAllName);
|
if (deptDatList == null || deptDatList.size() < 0) {
|
return null;
|
}
|
return deptDatList.get(0);
|
}
|
|
/**
|
* 角色未找到错误回调
|
*/
|
private CallBack<Object> roleNotExist = f -> {
|
FieldSetEntity fs = (FieldSetEntity) f[0];
|
Object role_name = f[1];
|
DataLocation dataLocation = getDataLocation(fs);
|
String error = "第 %s 行，第 %s 列，%s 在系统中不存在，请检查列值%s 是否正确";
|
error = String.format(error, dataLocation.getRowIndex(), dataLocation.getColIndex("role_uuids"),
|
dataLocation.getColName("role_uuids"), role_name);
|
errorEntity.addError(dataLocation.getRowIndex(), error);
|
};
|
/**
|
* 岗位 & 岗位等级未找到错误回调
|
*/
|
private CallBack<Object> postNotExist = f -> {
|
FieldSetEntity fs = (FieldSetEntity) f[0];
|
String fieldName = (String) f[1];
|
DataLocation datLocation = getDataLocation(fs);
|
String error = "第 %s 行，第 %s 列，'%s' 数据在系统中不存在，请检查 '%s' 是否正确";
|
error = String.format(error, datLocation.getRowIndex(), datLocation.getColIndex(fieldName),
|
datLocation.getColName(fieldName), fs.getString(fieldName));
|
errorEntity.addError(datLocation.getRowIndex(), error);
|
};
|
|
/**
|
* 初始化系统数据
|
*/
|
private void initializeSystemData() throws BaseException {
|
//查询上级领导
|
findDirectLeaderData();
|
// 查询管理员管理的(公司下的)部门
|
findDeptData();
|
// 管理员管理的角色
|
findRoleData();
|
// 管理员管理的岗位 & 岗位等级
|
findPostData();
|
this.throwError();
|
}
|
|
/**
|
* 查询所有岗位 & 岗位等级
|
*/
|
private void findPostData() throws BaseException {
|
sql = new StringBuilder();
|
sql.append(" select a.job_post_name uuid,a.uuid job_post_uuid,c.job_grade_name,c.uuid job_post_grades_uuid,a.dept_uuid FROM product_sys_job_posts a ");
|
sql.append(" LEFT join product_sys_job_posts_grades_mapping b on ");
|
sql.append(" a.dept_uuid in (select uuid FROM product_sys_org_levels where org_level_type=1 and ");
|
sql.append(companyFilter);
|
sql.append(" ) and a.uuid=b.job_post_uuid ");
|
sql.append(" LEFT join product_sys_job_post_grades c on b.job_grade_uuid=c.uuid ");
|
sql.append(" group by a.job_post_name,a.uuid ,c.job_grade_name,c.uuid,a.dept_uuid ");
|
// 查询岗位 & 岗位等级
|
postData = getBaseDao().listTable(sql.toString(), new Object[]{});
|
if (BaseUtil.dataTableIsEmpty(roleData)) {
|
errorEntity.addError(0, "系统中没有可供选择的岗位或岗位等级");
|
}
|
}
|
|
/**
|
* 查询所有角色
|
*/
|
private void findRoleData() throws BaseException {
|
sql = new StringBuilder();
|
sql.append(" select role_name as uuid,uuid as role_uuid,org_level_uuid FROM product_sys_role ");
|
sql.append(" where is_used = 1 and ");
|
sql.append(companyFilter);
|
// 查询角色
|
roleData = getBaseDao().listTable(sql.toString(), new Object[]{});
|
if (BaseUtil.dataTableIsEmpty(roleData)) {
|
errorEntity.addError(0, "系统中没有可供选择的角色");
|
}
|
}
|
|
/**
|
* 查询所有部门
|
*/
|
private void findDeptData() throws BaseException {
|
// 查询部门
|
sql = new StringBuilder();
|
sql.append(" select org_level_all uuid,uuid as dept_uuid,org_level_uuid,org_level_code,org_level_code_parent FROM product_sys_org_levels ");
|
sql.append(" where org_level_type = 1 and ");
|
sql.append(BaseUtil.buildQuestionMarkFilter(CmnConst.FIELD_ORG_LEVEL_ALL, deptGroupMap.size(), true));
|
sql.append(" and ");
|
sql.append(companyFilter);
|
// 查询部门
|
deptData = getBaseDao().listTable(sql.toString(), deptGroupMap.keySet().toArray());
|
if (BaseUtil.dataTableIsEmpty(deptData)) {
|
errorEntity.addError(0, "系统中没有可供选择的部门");
|
}
|
}
|
|
/**
|
* 查询导入数据所有的上级领导
|
*/
|
private void findDirectLeaderData() throws BaseException {
|
sql = new StringBuilder();
|
sql.append(" SELECT staff_code uuid,tricode,user_id FROM product_sys_staffs ");
|
sql.append(" where ");
|
sql.append(BaseUtil.buildQuestionMarkFilter(CmnConst.FIELD_STAFF_CODE, direct_leader_codes.size(), true));
|
if (direct_leader_codes.size() > 0) {
|
sql.append(" and ");
|
}
|
sql.append(" org_level_uuid in (select uuid FROM product_sys_org_levels where org_level_type=0 and client_uuid=?) ");
|
// 暂时注释不用公司做限制
|
// sql.append(" and ");
|
// sql.append(companyFilter);
|
// 查询上级领导
|
List<String> params = Lists.newArrayList(direct_leader_codes.iterator());
|
params.add(currentUser.getClient_uuid());
|
directLeaderData = getBaseDao().listTable(sql.toString(), params.toArray());
|
}
|
|
/**
|
* 查询所有员工编码以及user表中的账号
|
*/
|
private void findExistStaff() throws BaseException {
|
sql = new StringBuilder(126);
|
sql.append(" select concat(b.client_uuid,'>',staff_code) staff_code,a.user_account as staff_avatar ");
|
sql.append(" FROM product_sys_users a left join product_sys_staffs b on (b.client_uuid=? or b.uuid is null) and a.user_id=b.user_id ");
|
systemData = getBaseDao().listTable(sql.toString(), new Object[]{client_uuid});
|
}
|
|
/**
|
* 数据格式效验
|
*/
|
private void repeatValidation() throws BaseException {
|
// 注 ：staff_avatar 字段为 user表中 user_account 的载体
|
fieldRepeatValidation(errorEntity, dt, systemData, new String[]{CmnConst.FIELD_STAFF_CODE, "staff_avatar"});
|
}
|
|
/**
|
* 必填效验 数据处理
|
*/
|
private void requiredValidation() throws BaseException {
|
errorEntity.mergeError(fieldRequiredValidation(dt, new String[]{"show_name", "staff_avatar", CmnConst.FIELD_STAFF_CODE,
|
CmnConst.FIELD_DEPT_UUID, "job_post_uuid", "role_uuids"}, fieldType, (FieldSetEntity[] f) -> {
|
FieldSetEntity fs = f[0];
|
//上级领导编码
|
String direct_leader_code = fs.getString(CmnConst.FIELD_DIRECT_LEADER_CODE);
|
//工作部门全称
|
String deptAllName = fs.getString(CmnConst.FIELD_DEPT_UUID);
|
String id_number = fs.getString("id_number");
|
String age = fs.getString("age");
|
Date birth_date = fs.getDate("birth_date");
|
String sex = fs.getString("sex");
|
String staff_code = fs.getString(CmnConst.FIELD_STAFF_CODE);
|
|
if (!StringUtils.isEmpty(staff_code)) {
|
fs.setValue("~temp_staff_code~", staff_code);
|
fs.setValue(CmnConst.FIELD_STAFF_CODE, client_uuid + this.separator + staff_code);
|
staffCodeMap.put(staff_code, fs);
|
}
|
fs.setValue(CmnConst.CLIENT_UUID, client_uuid);
|
if (!StringUtils.isEmpty(direct_leader_code)) {
|
//将上级领导编码统一放入集合中
|
// 上级领导编码 = 员工编码
|
direct_leader_codes.add(direct_leader_code);
|
}
|
//按部门分组数据
|
if (!StringUtils.isEmpty(deptAllName)) {
|
List<FieldSetEntity> fieldSets = deptGroupMap.get(deptAllName);
|
if (fieldSets == null) {
|
fieldSets = Lists.newArrayList();
|
deptGroupMap.put(deptAllName, fieldSets);
|
}
|
fieldSets.add(fs);
|
}
|
if (!StringUtils.isEmpty(id_number)) {
|
try {
|
if (birth_date == null) {
|
// 根据身份证取出生日期
|
fs.setValue("birth_date", BaseUtil.getBirthday(id_number));
|
}
|
if (StringUtils.isEmpty(age)) {
|
// 根据身份证取出年龄
|
fs.setValue("age", BaseUtil.getAge(id_number));
|
}
|
if (StringUtils.isEmpty(sex)) {
|
// 根据身份证取出性别
|
fs.setValue("sex", BaseUtil.getSex(id_number));
|
}
|
} catch (Exception e) {
|
|
}
|
}
|
|
|
}));
|
|
}
|
}
|
|
|
/**
|
* 重载导入员工方法
|
* 处理公司、部门、岗位、岗位等级、账号 相关数据
|
*
|
* @param postData 系统岗位&岗位等级数据
|
* @param roleData 系统角色数据
|
* @param roleNotExist 角色不存在错误回调
|
* @param postNotExist 岗位&岗位等级不存在错误回调
|
* @param fs 导入数据
|
* @param deptFieldSet 部门数据
|
* @param deptAllName 部门全称
|
* @throws BaseException
|
*/
|
private void importStaffBefore(DataTableEntity postData, DataTableEntity
|
roleData, CallBack<Object> roleNotExist, CallBack<Object> postNotExist, FieldSetEntity fs, FieldSetEntity deptFieldSet, String deptAllName) throws BaseException {
|
|
String dept_uuid = fs.getString(CmnConst.UUID);
|
String org_level_uuid = fs.getString(CmnConst.ORG_LEVEL_UUID);
|
fs.setValue(CmnConst.FIELD_STAFF_CODE, fs.getString("~temp_staff_code~"));
|
fs.setValue(CmnConst.FIELD_DEPT_UUID, dept_uuid);
|
fs.setValue(CmnConst.ORG_LEVEL_UUID, org_level_uuid);
|
|
String job_post_grade_uuid = fs.getString(CmnConst.FIELD_JOB_POST_GRADE);
|
String job_post_name = fs.getString("job_post_uuid");
|
|
// 岗位 & 岗位等级
|
List<FieldSetEntity> postDataList = postData.getFieldSetEntity(deptAllName);
|
if (postDataList == null || postDataList.size() <= 0) {
|
// 没有岗位
|
postNotExist.method(fs, "job_post_uuid");
|
} else {
|
// 记录找到的岗位等级uuid ，多个用逗号分隔
|
String grade_uuid = "";
|
// 岗位uuid
|
String post_uuid = null;
|
// 循环系统中岗位数据
|
for (FieldSetEntity postFs : postDataList) {
|
// 判断岗位是否在部门下 & 岗位名称和导入数据的岗位名称是否相同
|
if (dept_uuid.equals(postFs.getString(CmnConst.FIELD_DEPT_UUID)) && job_post_name.equals(postFs.getString(CmnConst.FIELD_JOB_POST_NAME))) {
|
// 系统中岗位的uuid
|
String job_post_uuid = postFs.getString("job_post_uuid");
|
// 岗位uuid不为空时 判断当前postFs 中的岗位uuid是否跟已找到的岗位相同
|
if (post_uuid != null && !post_uuid.equals(job_post_uuid)) {
|
continue;
|
}
|
if (post_uuid == null) {
|
// 记录岗位uuid
|
post_uuid = job_post_uuid;
|
}
|
// 获取岗位中的岗位等级名称
|
String job_grade_name = postFs.getString(CmnConst.FIELD_JOB_GRADE_NAME);
|
// 拆分循环导入岗位等级名称
|
for (String grade_name : job_post_grade_uuid.split(",")) {
|
// 判断岗位等级名称和系统中相同
|
if (job_grade_name.equals(grade_name)) {
|
if (!StringUtils.isEmpty(grade_uuid)) {
|
grade_uuid += ",";
|
}
|
grade_uuid += postFs.getString(CmnConst.FIELD_JOB_POST_GRADE);
|
}
|
}
|
}
|
// 没有找到岗位
|
if (StringUtils.isEmpty(post_uuid)) {
|
// 抛出岗位未找到错误
|
postNotExist.method(fs, "job_post_uuid");
|
} else {
|
// 找到岗位
|
fs.setValue("job_post_uuid", post_uuid);
|
}
|
// 没有找到岗位等级
|
if (StringUtils.isEmpty(grade_uuid)) {
|
postNotExist.method(fs, CmnConst.FIELD_JOB_POST_GRADE);
|
} else {
|
fs.setValue(CmnConst.FIELD_JOB_POST_GRADE, grade_uuid);
|
}
|
}
|
}
|
// 导入数据中岗位名称
|
String[] role_uuids = (String[]) fs.getObject("role_uuids");
|
String roleUuid = "";
|
// 角色处理
|
roleFor:
|
// 循环角色名称
|
for (String roleName : role_uuids) {
|
// 使用角色名称获取系统数据
|
List<FieldSetEntity> roleList = roleData.getFieldSetEntity(roleName);
|
// 在系统中没有找到角色名称一致的数据
|
if (roleList == null || roleList.size() <= 0) {
|
roleNotExist.method(fs, roleName);
|
} else {
|
// 循环系统中的角色
|
for (FieldSetEntity roleFs : roleList) {
|
// 因系统中角色所属公司可多选，在此处前后拼接逗号
|
String roleCompany = "," + roleFs.getString(CmnConst.ORG_LEVEL_UUID) + ",";
|
// 判断角色是否有导入数据的公司
|
if (roleCompany.contains("," + org_level_uuid + ",")) {
|
String role_uuid = roleFs.getString("role_uuid");
|
if (!StringUtils.isEmpty(roleUuid)) {
|
roleUuid += ",";
|
}
|
roleUuid += role_uuid;
|
continue roleFor;
|
}
|
}
|
// 没有找到角色数据 抛出错误
|
roleNotExist.method(fs, roleName);
|
}
|
|
}
|
}
|
|
/**
|
* 获取数据位置对象
|
*
|
* @param fse
|
* @return
|
*/
|
private DataLocation getDataLocation(FieldSetEntity fse) {
|
if (fse.getString("~dataLocation~") != null) {
|
return (DataLocation) fse.getObject("~dataLocation~");
|
} else {
|
DataLocation dataLocation = new DataLocation(fse);
|
fse.setValue("~dataLocation~", dataLocation);
|
return dataLocation;
|
}
|
}
|
|
/**
|
* 初始化机构数据
|
*
|
* @param fse
|
* @param level_type
|
*/
|
public void initOrganizationFieldSet(FieldSetEntity fse, String client_uuid, String parentCode,
|
int level_type) {
|
fse.setValue(CmnConst.FIELD_ORG_LEVEL_CODE_PARENT, parentCode);
|
fse.setValue(CmnConst.FIELD_ORG_LEVEL_CODE, BaseUtil.createCode(fse, CmnConst.TABLE_PRODUCT_SYS_ORG_LEVELS, CmnConst.FIELD_ORG_LEVEL_CODE, parentCode));
|
BaseUtil.createCreatorAndCreationTime(fse);
|
fse.remove(CmnConst.ORG_LEVEL_UUID);
|
fse.setValue(CmnConst.CLIENT_UUID, client_uuid);
|
fse.setValue(CmnConst.FIELD_ORG_LEVEL_STATUS, 0);
|
fse.setValue(CmnConst.FIELD_ORG_LEVEL_TYPE, level_type);
|
fse.setCodeFieldUpdateFlat(CmnConst.FIELD_ORG_LEVEL_CODE, false);
|
}
|
|
public void managerPermissionValidation(ImportErrorEntity errorEntity, SystemUser user) throws
|
BaseException {
|
FieldSetEntity managerFieldSet = user.getCurrentManager();
|
if (managerFieldSet == null || user.getUserType() != 2) {
|
errorEntity.newThrowBaseException("没有导入此数据的权限，请联系统管理员");
|
} else if (StringUtils.isEmpty(managerFieldSet.getString(CmnConst.ORG_LEVEL_UUID))) {
|
errorEntity.newThrowBaseException("公司权限不存在，请联系统管理员");
|
}
|
}
|
|
|
/**
|
* 错误位置
|
*/
|
class DataLocation {
|
|
//当前行
|
private Integer rowIndex;
|
//列名
|
private List<String> colNameList;
|
//字段列索引
|
private Map<String, String> fieldIndex;
|
|
DataLocation(FieldSetEntity fse) {
|
//当前行
|
this.rowIndex = fse.getInteger("~row~");
|
//列名
|
this.colNameList = (List<String>) fse.getObject("~colName~");
|
//字段列索引
|
this.fieldIndex = (Map<String, String>) fse.getObject("~fieldIndex~");
|
}
|
|
/**
|
* 获取当前行索引
|
*
|
* @return
|
*/
|
public Integer getRowIndex() {
|
return rowIndex + 1;
|
}
|
|
/**
|
* 获取当前列索引
|
*
|
* @param fieldName
|
* @return
|
*/
|
public String getColIndex(String fieldName) {
|
if (fieldIndex == null || StringUtils.isEmpty(fieldName)) {
|
return null;
|
}
|
String colIndex = fieldIndex.get(fieldName);
|
return !StringUtils.isEmpty(colIndex) ? String.valueOf(Integer.valueOf(colIndex) + 1) : "未知";
|
}
|
|
/**
|
* 获取当前列名称
|
*
|
* @param fieldName
|
* @return
|
*/
|
public String getColName(String fieldName) {
|
String colIndex = getColIndex(fieldName);
|
if (this.colNameList == null || colIndex == null || "未知".equals(colIndex)) {
|
return "未知列名";
|
}
|
return colNameList.get(Integer.valueOf(colIndex) - 1);
|
}
|
|
|
}
|
|
|
static class ImportErrorEntity {
|
|
interface errorMsg {
|
errorMsg append(Object errorMsg);
|
}
|
|
private Map<Integer, String> errorMap;
|
|
private boolean isError = false;
|
|
/**
|
* 新增错误 自动换行
|
*
|
* @param row
|
* @param errorMsg
|
* @return
|
*/
|
public errorMsg addError(int row, String errorMsg) {
|
if (errorMap == null) {
|
errorMap = Maps.newHashMap();
|
}
|
isError = true;
|
String error = errorMap.get(row);
|
if (!StringUtils.isEmpty(error)) {
|
error += "\n";
|
} else {
|
error = "";
|
}
|
error += errorMsg;
|
errorMap.put(row, error);
|
return (emg) -> this.append(row, String.valueOf(emg));
|
}
|
|
/**
|
* 合并错误
|
*
|
* @param errorEntity
|
* @return
|
*/
|
public ImportErrorEntity mergeError(ImportErrorEntity errorEntity) {
|
Map<Integer, String> errorMap = errorEntity.errorMap;
|
if (errorEntity.isError) {
|
if (this.errorMap == null) {
|
this.errorMap = errorMap;
|
this.isError = true;
|
return this;
|
} else {
|
errorMap.forEach((k, v) -> {
|
String error = this.errorMap.get(k);
|
if (!StringUtils.isEmpty(error)) {
|
error += "\n";
|
} else {
|
error = "";
|
}
|
error += v;
|
this.isError = true;
|
this.errorMap.put(k, error);
|
});
|
}
|
}
|
return this;
|
}
|
|
/**
|
* 拼接错误
|
*
|
* @param row
|
* @param errorMsg
|
* @return
|
*/
|
public errorMsg append(int row, String errorMsg) {
|
if (errorMap == null) {
|
errorMap = Maps.newHashMap();
|
}
|
isError = true;
|
String error = errorMap.get(row);
|
if (StringUtils.isEmpty(error)) {
|
error = "";
|
}
|
error += errorMsg;
|
errorMap.put(row, error);
|
return (emg) -> this.append(row, String.valueOf(emg));
|
}
|
|
public void newThrowBaseException() {
|
newThrowBaseException(null, null);
|
}
|
|
public void newThrowBaseException(String msg, Exception exception) {
|
if (!StringUtils.isEmpty(msg)) {
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), msg);
|
} else if (errorMap != null) {
|
List<Integer> es = Lists.newArrayList(errorMap.keySet().iterator());
|
StringBuilder errorMsg = new StringBuilder();
|
for (Integer e : es) {
|
String error = errorMap.get(e);
|
if (!StringUtils.isEmpty(error)) {
|
errorMsg.append(error).append("\n");
|
}
|
}
|
if (errorMsg.length() > 0) {
|
if (exception != null) {
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), errorMsg.toString(), exception);
|
} else {
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), errorMsg.toString());
|
}
|
}
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), " 未知错误，请联系管理员，error message is empty for 'throwExportDataError' Method ");
|
}
|
if (exception != null) {
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), " 未知错误，请联系管理员，error message is empty for 'throwExportDataError' Method ", exception);
|
}
|
throw new BaseException(CmnCode.UPLOAD_TEMPLATE_IMPORT_DATA_FAIL.getValue(), " 未知错误，请联系管理员，error message is empty for 'throwExportDataError' Method ");
|
}
|
|
public void newThrowBaseException(String msg) {
|
newThrowBaseException(msg, null);
|
}
|
|
}
|
}
|
