com.fastchar.extjs.action.ExtEntityAction Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of fastchar-extjs Show documentation
FastChar-ExtJs is a Java Web framework that uses extjs libraries.Quickly build a background management system
There is a newer version: 2.2.2
package com.fastchar.extjs.action;

import com.fastchar.core.*;
import com.fastchar.database.FastPage;
import com.fastchar.database.FastType;
import com.fastchar.database.info.FastColumnInfo;
import com.fastchar.database.info.FastSqlInfo;
import com.fastchar.extjs.FastExtConfig;
import com.fastchar.extjs.annotation.AFastLog;
import com.fastchar.extjs.annotation.AFastSession;
import com.fastchar.extjs.core.FastExtEntity;
import com.fastchar.extjs.core.FastExtEnumHelper;
import com.fastchar.extjs.core.FastExtLayerHelper;
import com.fastchar.extjs.core.FastExtSameHelper;
import com.fastchar.extjs.core.database.FastExtColumnInfo;
import com.fastchar.extjs.core.database.FastExtData;
import com.fastchar.extjs.core.database.FastExtTableInfo;
import com.fastchar.extjs.core.database.FastSqlTool;
import com.fastchar.extjs.core.enums.FastEnumInfo;
import com.fastchar.extjs.core.heads.FastHeadExtInfo;
import com.fastchar.extjs.echarts.FastEChartsBean;
import com.fastchar.extjs.entity.ExtManagerEntity;
import com.fastchar.extjs.entity.ExtSystemConfigEntity;
import com.fastchar.extjs.info.ExtExcelModelInfo;
import com.fastchar.extjs.interfaces.IFastImportDataListener;
import com.fastchar.extjs.utils.POIHelper;
import com.fastchar.extjs.utils.POIUtils;
import com.fastchar.utils.*;
import com.google.gson.reflect.TypeToken;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Array;
import java.util.*;

@SuppressWarnings({"ResultOfMethodCallIgnored", "SuspiciousMethodCalls"})
@AFastSession
public class ExtEntityAction extends FastAction {

    @Override
    protected String getRoute() {
        return "/entity";
    }


    /**
     * 获取实体的列表数据
     * 参数：
     * page 页数 {int}
     * limit 每页大小 {int}
     * entityCode 实体编号 {String}
     * where 列表sql的where判断语句 ,例如：where['t.userId'] = 1
     * indexSort 指定排序列 json数组，例如：[{"property":"serviceNickName","direction":"DESC"}]
     * power 是否需要权限层级筛选，默认：true
     */
    public FastPage list() {
        String entityCode = getParam("entityCode", true);
        int page = getParamToInt("page", 1);
        int pageSize = getParamToInt("limit", 10);
        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return null;
        }
        FastExtEntity entity = FastChar.getOverrides().newInstance(extEntityClass);
        if (entity == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return null;
        }

        ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);

        Map where = getParamToMap("where");
        entity.putAll(where);

        Map indexSort = getParamToMap("indexSort");

        String sort = getParam("sort");
        if (FastStringUtils.isNotEmpty(sort)) {
            List> sortList = FastChar.getJson().fromJson(sort,
                    new TypeToken>>() {
                    }.getType());
            for (Map map : sortList) {
                if (map.get("property").startsWith("@")) {
                    continue;
                }
                entity.put(FastNumberUtils.formatToInt(indexSort.get(map.get("property"))) + map.get("property") + ":sort", map.get("direction"));
            }
        }

//         && !getParamToBoolean("fromTree", false) 未说明作用，暂时取消
        if (getParamToBoolean("power", Boolean.TRUE)) {
            entity.pullLayer(managerEntity);
        }
        FastPage fastPage = entity.showList(page, pageSize);
        if (fastPage.getSqlInfo() != null) {
            managerEntity.put("Sql" + entityCode + "_" + entity.getBoolean("^fromRecycle"), fastPage.getSqlInfo().getSql());
        }
        return fastPage;
    }


    /**
     * 添加实体数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * data 以data为前缀的参数，提交实体数据，例如：data.topicError=无,data.topicState=1,data.topicTitle=我的话题
     * method 执行实体的方法名，默认为：save方法
     */
    @AFastLog(value = "页面【${menu}】添加了一条数据！", type = "添加数据")
    public void save() {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");

        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);

        FastEntity entity = getParamToEntity("data", extEntityClass);
        if (FastStringUtils.isEmpty(menu)) {
            menu = entity.getTableDetails();
        }
        setRequestAttr("menu", menu);
        List> saveEntities = new ArrayList<>();
        pluckArrayValue(entity, saveEntities);

        List saveResult = new ArrayList<>();
        for (FastEntity saveEntity : saveEntities) {
            if (saveEntity.getTable() != null) {
                if (saveEntity.getTable() instanceof FastExtTableInfo) {
                    FastExtTableInfo extTableInfo = saveEntity.getTable();
                    if (extTableInfo.isBindSessionLayer()) {
                        saveEntity.put(FastExtEntity.EXTRA_PARENT_LAYER_CODE, managerEntity.getLayerValue());
                    }
                }
            }

            saveEntity.put("fromWeb", true);
            saveEntity.put("session", managerEntity);
            saveEntity.clearEmpty();

            String[] checks = getParamToArray("check");
            String method = getParam("method", "save");
            if (checks.length == 0) {
                if (saveEntity.save()) {
                    saveResult.add(new FastHandler().setCode(0).setError("添加成功！"));
                    continue;
                }
            } else {
                if (method.equalsIgnoreCase("save")) {
                    if (saveEntity.save(checks)) {
                        saveResult.add(new FastHandler().setCode(0).setError("添加成功！"));
                        continue;
                    } else if (FastStringUtils.isEmpty(saveEntity.getError())) {
                        saveResult.add(new FastHandler().setCode(-1).setError("添加失败！数据或已存在！"));
                        continue;
                    }
                } else if (method.equalsIgnoreCase("push")) {
                    FastHandler handler = new FastHandler();
                    if (saveEntity.push(handler, checks)) {
                        if (handler.getCode() == 0) {
                            saveResult.add(new FastHandler().setCode(0).setError("添加成功！"));
                            continue;
                        }
                        saveResult.add(new FastHandler().setCode(0).setError("更新成功！"));
                        continue;
                    }
                }
            }
            saveResult.add(new FastHandler().setCode(-1).setError("添加失败！" + saveEntity.getError()));
        }
        if (saveResult.size() == 1) {
            responseJson(saveResult.get(0).getCode(), saveResult.get(0).getError());
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            int errorCount = 0;
            for (int i = 0; i < saveResult.size(); i++) {
                FastHandler handler = saveResult.get(i);
                if (handler.getCode() != 0) {
                    errorCount++;
                }
                stringBuilder.append("数据").append(i + 1).append("：").append(handler.getError()).append("
");
            }
            if (errorCount == saveResult.size()) {
                responseJson(-1, stringBuilder.toString());
            } else {
                responseJson(0, stringBuilder.toString());
            }
        }

    }

    private void pluckArrayValue(FastEntity entity, List> entities) {
        Collection> columns = entity.getTable().getColumns();
        boolean hasArray = false;
        for (FastColumnInfo column : columns) {
            Object values = entity.get(column.getName());
            if (values == null || FastStringUtils.isEmpty(values.toString())) {
                continue;
            }

            if (entity.getBoolean(column.getName() + "@JsonArray")) {
                entity.remove(column.getName());
                entity.remove(column.getName() + "@JsonArray");
                values = FastChar.getJson().fromJson(values.toString(), List.class).toArray();
            }

            if (values.getClass().isArray()) {
                hasArray = true;
                for (int i = 0; i < Array.getLength(values); i++) {
                    Object singleValue = Array.get(values, i);
                    if (singleValue == null || FastStringUtils.isEmpty(singleValue.toString())) {
                        continue;
                    }
                    FastEntity newEntity = FastChar.getOverrides().newInstance(entity.getClass());
                    newEntity.setAll(entity);
                    newEntity.set(column.getName(), singleValue);
                    pluckArrayValue(newEntity, entities);
                }
            }
        }
        if (!hasArray) {
            entities.add(entity);
        }
    }


    /**
     * 删除实体数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * where 用作sql的where判断语句 ,例如：where['t.userId'] = 1
     * data 以data为前缀的参数，提交实体数据，例如：data.topicError=无,data.topicState=1,data.topicTitle=我的话题
     */
    @AFastLog(value = "页面【${menu}】进行删除数据！", type = "删除数据")
    public void delete() throws Exception {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");

        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        boolean all = getParamToBoolean("all", false);
        if (all) {
            FastExtEntity extEntity = FastClassUtils.newInstance(extEntityClass);
            if (extEntity != null) {
                if (FastStringUtils.isEmpty(menu)) {
                    menu = extEntity.getTableDetails();
                }
                setRequestAttr("menu", menu);
                ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);

                Map where = getParamToMap("where");
                extEntity.putAll(where);
                extEntity.pullLayer(managerEntity);


                boolean fromRecycle = extEntity.getBoolean("^fromRecycle");
                String showListSql = managerEntity.getString("Sql" + entityCode + "_" + fromRecycle);
                if (FastStringUtils.isEmpty(showListSql)) {
                    responseJson(-1, "清除失败！请稍后重试！");
                }

                Collection> primaries = extEntity.getPrimaries();
                String keyName = primaries.iterator().next().getName();
                for (FastColumnInfo primary : primaries) {
                    if (primary.isAutoincrement()) {
                        keyName = primary.getName();
                    }
                }
                int fromIndex = showListSql.indexOf("from");
                int whereIndex = showListSql.lastIndexOf("where");
                String tableName = extEntity.getTableName();
                if (fromRecycle) {
                    tableName = tableName + "_recycle";
                }

                String sqlStr = "select t." + keyName + " " + showListSql.substring(fromIndex, whereIndex);
                FastSqlInfo sqlInfo = FastSqlTool.appendWhere(extEntity.getFastData().getFastSql(), sqlStr, extEntity);
                String deleteSql = "delete from " + tableName + " where " +
                        keyName + " in ( select * from ( " + sqlInfo.getSql() + ") as tmp ) ";
                int update = FastChar.getDB().update(deleteSql, sqlInfo.toParams());
                if (update > 0) {
                    responseJson(0, "删除成功！共删除了" + update + "条数据！");
                }
            }
        } else {
            int count = 0;
            List> entity = getParamToEntityList("data", extEntityClass);
            for (FastEntity fastEntity : entity) {
                if (FastStringUtils.isEmpty(menu)) {
                    menu = fastEntity.getTableDetails();
                }
                setRequestAttr("menu", menu);

                fastEntity.put("fromWeb", true);
                if (!fastEntity.delete()) {
                    if (count > 0) {
                        responseJson(-1, "已成功删除" + count + "条数据后发生错误！" + fastEntity.getError());
                    }
                    responseJson(-1, fastEntity.getError());
                }
                count++;
            }
            responseJson(0, "删除成功！共删除了" + count + "条数据！", entity);
        }
        responseJson(-1, "删除失败！");
    }


    /**
     * 修改实体数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * data 以data为前缀的参数，提交实体数据，例如：data.topicError=无,data.topicState=1,data.topicTitle=我的话题
     */
    @AFastLog(value = "页面【${menu}】进行修改数据！", type = "修改数据")
    public void update() throws Exception {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");
        setRequestAttr("menu", menu);
        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        List> entity = getParamToEntityList("data", extEntityClass);
        for (FastEntity fastEntity : entity) {
            if (FastStringUtils.isEmpty(menu)) {
                menu = fastEntity.getTableDetails();
            }
            setRequestAttr("menu", menu);
            fastEntity.put("fromWeb", true);
            if (!fastEntity.update()) {
                if (fastEntity.getModified().size() > 0) {
                    responseJson(-1, fastEntity.getError());
                }
            }
        }
        responseJson(0, "修改成功！", entity);
    }


    /**
     * 批量更新数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * where 用作sql的where判断语句 ,例如：where['t.userId'] = 1
     */
    @AFastLog(value = "页面【${menu}】进行批量修改数据！", type = "批量修改数据")
    public void batchUpdate() throws Exception {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");
        setRequestAttr("menu", menu);

        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        FastExtEntity entity = FastClassUtils.newInstance(extEntityClass);
        if (entity == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        Map where = getParamToMap("where");
        entity.putAll(where);

        ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);
        entity.pullLayer(managerEntity);

        String field = getParam("field", true);
        String fieldValue = getParam("fieldValue", true);

        String showListSql = managerEntity.getString("Sql" + entityCode + "_" + entity.getBoolean("^fromRecycle"));
        if (FastStringUtils.isNotEmpty(showListSql)) {
            int fromIndex = showListSql.indexOf("from");
            int whereIndex = showListSql.lastIndexOf("where");

            Collection> primaries = entity.getPrimaries();
            if (primaries.size() > 0) {
                FastColumnInfo fastColumnInfo = primaries.iterator().next();
                String inSqlStr = " select " + fastColumnInfo.getName() + " " + showListSql.substring(fromIndex, whereIndex);

                FastSqlInfo sqlInfo = entity.toSelectSql(inSqlStr);

                String sqlStr = " update " + entity.getTableName() + "  set " + field + " = '" + fieldValue + "' " +
                        " where " + fastColumnInfo.getName() + " in ( select * from ( " + sqlInfo.getSql() + " ) as temp ) ";

                int updateCount = FastChar.getDB().update(sqlStr, sqlInfo.toParams());
                responseJson(0, "更新成功！共更新" + updateCount + "条数据！");
            }
        }


        responseJson(-1, "操作失败！");

    }


    /**
     * 复制实体数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * data 以data为前缀的参数，提交实体数据，例如：data.topicError=无,data.topicState=1,data.topicTitle=我的话题
     */
    @AFastLog(value = "页面【${menu}】进行复制数据！", type = "复制数据")
    public void copy() {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");
        setRequestAttr("menu", menu);
        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        List> entity = getParamToEntityList("data", extEntityClass);
        for (FastEntity fastEntity : entity) {
            if (FastStringUtils.isEmpty(menu)) {
                menu = fastEntity.getTableDetails();
            }
            setRequestAttr("menu", menu);
            fastEntity.put("fromWeb", true);
            FastEntity copySave = fastEntity.copySave();
            if (copySave == null) {
                responseJson(-1, "复制失败！" + fastEntity.getError());
            }
        }
        responseJson(0, "数据复制成功！");
    }


    /**
     * 清除某个属性为空的所有数据
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * where 用作sql的where判断语句 ,例如：where['t.userId'] = 1
     */
    @AFastLog(value = "页面【${menu}】进行清理数据！", type = "清理数据")
    public void clear() throws Exception {
        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");
        setRequestAttr("menu", menu);
        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        FastExtEntity entity = FastClassUtils.newInstance(extEntityClass);
        if (entity == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }

        if (FastStringUtils.isEmpty(menu)) {
            menu = entity.getTableDetails();
        }
        setRequestAttr("menu", menu);

        if (entity.getPrimaries().size() == 0) {
            responseJson(-1, "清除失败！此列表不允许此功能！");
        }

        Map where = getParamToMap("where");
        entity.putAll(where);

        ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);
        entity.pullLayer(managerEntity);

        String showListSql = managerEntity.getString("Sql" + entityCode + "_" + entity.getBoolean("^fromRecycle"));
        if (FastStringUtils.isEmpty(showListSql)) {
            responseJson(-1, "清除失败！请稍后重试！");
        }

        int fromIndex = showListSql.indexOf("from");
        int whereIndex = showListSql.lastIndexOf("where");

        Collection> primaries = entity.getPrimaries();
        String keyName = primaries.iterator().next().getName();

        String sqlStr = "select t." + keyName + " " + showListSql.substring(fromIndex, whereIndex);

        String field = getParam("field", true);
        field = FastSqlTool.formatAlias(field, "t");


        FastSqlInfo fastSqlInfo = entity.toSelectSql(sqlStr);
        sqlStr = fastSqlInfo.getSql() + " and  " + field + " is null ";


        String deleteSql = "delete from " + entity.getTableName() + " where " +
                keyName + " in ( select * from ( " + sqlStr + ") as tmp ) ";

        int update = FastChar.getDB().update(deleteSql, fastSqlInfo.toParams());

        responseJson(0, "清理成功！共清理" + update + "条数据！");
    }


    /**
     * 清除某个属性重复的数据，保留一条
     * 参数：
     * entityCode 实体编号 {String}
     * menu 操作的菜单名称，用作记录日志 {String}
     * where 用作sql的where判断语句 ,例如：where['t.userId'] = 1
     * type 0：只保留最早的一条 1：只保留最新的一条
     */
    @AFastLog(value = "页面【${menu}】进行清理重复数据！", type = "清理重复数据")
    public void repeat() throws Exception {

        String entityCode = getParam("entityCode", true);
        String menu = getParam("menu");
        setRequestAttr("menu", menu);
        Class> extEntityClass = FastExtConfig.getInstance().getExtEntities().getExtEntity(entityCode);
        if (extEntityClass == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }
        FastExtEntity entity = FastClassUtils.newInstance(extEntityClass);
        if (entity == null) {
            responseJson(-1, "EntityCode不存在！" + entityCode);
            return;
        }

        if (FastStringUtils.isEmpty(menu)) {
            menu = entity.getTableDetails();
        }
        setRequestAttr("menu", menu);

        if (entity.getPrimaries().size() == 0) {
            responseJson(-1, "清除失败！此列表不允许此功能！");
        }

        Map where = getParamToMap("where");
        entity.putAll(where);

        ExtManagerEntity managerEntity = ExtManagerEntity.getSession(this);
        entity.pullLayer(managerEntity);

        String showListSql = managerEntity.getString("Sql" + entityCode + "_" + entity.getBoolean("^fromRecycle"));
        if (FastStringUtils.isEmpty(showListSql)) {
            responseJson(-1, "清除失败！请稍后重试！");
        }

        int fromIndex = showListSql.indexOf("from");
        int whereIndex = showListSql.lastIndexOf("where");

        Collection> primaries = entity.getPrimaries();
        String keyName = primaries.iterator().next().getName();

        int type = getParamToInt("type");
        String selectItem = "min(" + keyName + ")";
        String sqlStr = "select {{selectItem}} " + showListSql.substring(fromIndex, whereIndex);
        if (type == 1) {
            selectItem = "max(" + keyName + ")";
            sqlStr = "select {{selectItem}}  " + showListSql.substring(fromIndex, whereIndex);
        }

        String field = getParam("field", true);
        field = FastSqlTool.formatAlias(field, "t");

        FastSqlInfo fastSqlInfo = entity.toSelectSql(sqlStr);
        sqlStr = fastSqlInfo.getSql();

        Object[] params = fastSqlInfo.toParams();

        List