Page History

package com.fr.report.fun;

import com.fr.plugin.injectable.SpecialLevel;
import com.fr.report.stable.fun.Actor;
import com.fr.stable.fun.Level;

/**
 * @author : richie
 * @since : 8.0
 */
public interface ActorProvider extends Level{

    String XML_TAG = SpecialLevel.ActorProvider.getTagName();
    int CURRENT_LEVEL = 1;

    Actor[] createActor();

}

package com.fr.report.stable.fun;

import com.fr.base.BaseFormula;
import com.fr.base.Style;
import com.fr.base.chart.BaseChartPainter;
import com.fr.base.present.Present;
import com.fr.calculate.cell.BoxCEProvider;
import com.fr.general.DeclareRecordType;
import com.fr.json.JSONArray;
import com.fr.json.JSONException;
import com.fr.json.JSONObject;
import com.fr.main.TemplateWorkBook;
import com.fr.main.workbook.ResultWorkBook;
import com.fr.page.PageSetChainProvider;
import com.fr.plugin.injectable.SpecialLevel;
import com.fr.regist.FunctionPoint;
import com.fr.report.cell.CellElement;
import com.fr.report.cell.cellattr.core.attribute.CellElementAttribute;
import com.fr.report.cell.cellattr.core.attribute.OptionalAttribute;
import com.fr.report.core.block.PolyWorkSheetExecutor;
import com.fr.report.core.cal.BoxFactory;
import com.fr.report.core.cal.SE;
import com.fr.report.core.sheet.SheetExecutor;
import com.fr.report.core.sheet.WorkBookExecutor;
import com.fr.report.poly.PolyWorkSheet;
import com.fr.report.poly.ResultChartBlock;
import com.fr.report.poly.ResultECBlock;
import com.fr.report.web.ToolBarManager;
import com.fr.report.worksheet.AbstractResECWorkSheet;
import com.fr.script.Calculator;
import com.fr.stable.fun.Level;
import com.fr.stable.script.ExTool;
import com.fr.stable.web.Repository;
import com.fr.web.cache.ReportCache;
import com.fr.web.cache.ReportEntry;
import com.fr.web.core.ReportSessionIDInfor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

/**
 * Created with IntelliJ IDEA.
 * User: richie
 * Date: 14-1-24
 * Time: 下午5:26
 * 用于执行不同报表预览方式的操作类
 */
public interface Actor extends Level, OperatorBuilder {

    String XML_TAG = SpecialLevel.Actor.getTagName();
    int CURRENT_LEVEL = 1;

    /**
     * 该操作对应的名称，如填报预览、分页预览、分析预览
     *
     * @return 操作名称
     */
    String description();

    /**
     * 判断该操作方式是否可以按需读取数据库数据，主要用于行式引擎判断
     *
     * @return 可以按需读取数据库则返回true，否则返回false
     */
    boolean canCalculateOnDemand();

    /**
     * 是否能够进行预计算，主要在分页预览的时候需要进行一些预处理
     *
     * @return 会进行预计算则返回true，否则返回false
     */
    boolean willPreCalculate();

    /**
     * 生成该种预览方式所用的盒子工厂
     *
     * @return 盒子工厂
     */
    BoxFactory createBoxFactory();

    /**
     * 生成该种预览方式所使用的结果报表块
     *
     * @return 结果报表块
     */
    ResultECBlock createResultECBlock();

    /**
     * 生成该种预览方式所使用的结果报表页
     *
     * @param se 报表计算引擎
     * @return 结果报表页
     */
    AbstractResECWorkSheet createResultECWorkSheet(SE se);

    /**
     * 将格子缓存到磁盘
     *
     * @param sheet           结果报表页
     * @param maxCount        所活跃的最大格子数
     * @param activePoolCount 缓存池最大容量
     * @param cacheFirst      是否优先缓存
     */
    void cacheCellElement(AbstractResECWorkSheet sheet, int maxCount, int activePoolCount, boolean cacheFirst);

    /**
     * 是否需要建立格子间关系
     *
     * @return 需要简历格间关系返回true，否则返回false
     */
    boolean considerBuildRelation();

    /**
     * 释放报表计算中所使用的资源
     *
     * @param se 报表计算引擎
     */
    void release(SheetExecutor se);

    /**
     * 克隆给定的单元格属性
     *
     * @param em 单元格属性
     * @return 克隆出来的单元格属性
     */
    OptionalAttribute cloneOptionalAttribute(OptionalAttribute em);

    /**
     * 生成超级链接属性
     *
     * @return 单元格的超级链接属性
     */
    CellElementAttribute createHyperCellAttr();

    /**
     * 生成单元格自动调整相关属性
     *
     * @return 单元格UI相关属性
     */
    CellElementAttribute createCellGUIAttr();

    /**
     * 生成单元格控件属性
     *
     * @return 单元格控件属性
     */
    CellElementAttribute createWidgetAttr();

    /**
     * 建立格子之间涉及公式时的联系
     *
     * @param exTool     处理格子间关系的工具
     * @param calculator 算子
     * @param curFa      当前的公式
     * @param oriFa      原始的公式
     * @param boxCe      二维格子对象
     */
    void buildRelation(ExTool exTool, Calculator calculator, BaseFormula curFa, BaseFormula oriFa, BoxCEProvider boxCe);

    /**
     * 是否动态改变脚本， 主要用于分页预览的情况
     *
     * @return 是否需要动态改变脚本
     */
    boolean isDynamicJavaScript();

    /**
     * 判断当前的预览方式是否可以用于定时任务
     *
     * @return 如果可以用于定时任务则返回true，否则返回false
     */
    boolean canBeUseForSchedule();

    /**
     * 设置当前预览方式下格子形态后的值
     * (分页直接去形态后的值, 填报数据分析保留原值)
     *
     * @param ce           当前格子
     * @param present      形态
     * @param presentValue 形态得到的值
     * @date 2014-9-24-上午8:49:38
     */
    void present(CellElement ce, Present present, Object presentValue);

    /**
     * 设置当前预览方式下格子形态后的样式
     *
     * @param ce           当前格子
     * @param present      形态
     * @param presentStyle 样式
     */
    void present(CellElement ce, Present present, Style presentStyle);

    /**
     * 该预览方式是否有可能将控件显示到单元格中
     *
     * @return 如果可能显示控件则返回true，否则返回false
     */
    boolean hasWidget();


    /**
     * 生成用于处理聚合报表聚合块的处理器
     *
     * @param tpl          聚合报表页
     * @param parameterMap 参数集
     * @param actor        预览方式处理器
     * @return 报表块处理器
     */
    PolyWorkSheetExecutor createPolySequenceExecutor(PolyWorkSheet tpl, Map parameterMap, Actor actor);

    /**
     * 注册功能
     *
     * @return 预览时对注册功能的限制
     */
    FunctionPoint getBookFUNC();

    /**
     * 生成一个全新的带有指定参数集的结果报表簿
     *
     * @param parameterMap 参数集
     * @return 结果报表薄
     */
    ResultWorkBook createResultBook(Map parameterMap);

    /**
     * 执行报表簿
     *
     * @param workBook     报表簿
     * @param parameterMap 参数集合
     * @return 结果报表簿
     */
    ResultWorkBook executeWorkBook(TemplateWorkBook workBook, Map parameterMap);

    /**
     * 执行报表簿
     *
     * @param workBook     报表簿
     * @param parameterMap 参数集合
     * @param sheetIndex   当前要计算的sheet索引
     * @return 结果报表簿
     */
    ResultWorkBook executeWorkBook(TemplateWorkBook workBook, Map parameterMap, int sheetIndex);


    /**
     * 生成报表薄跨sheet计算器
     *
     * @param workBook     报表薄
     * @param parameterMap 参数集
     * @return 跨sheet计算器
     */
    WorkBookExecutor createWorkBookExecutor(TemplateWorkBook workBook, Map parameterMap);

    /**
     * 获取该预览方式下的日志记录类型
     *
     * @return 日志记录类型
     */
    DeclareRecordType getRecordType();

    /**
     * 是否需要记录该预览方式下产生的日志
     *
     * @return 如果需要记录日志则返回true，否则返回false
     */
    boolean shouldRecord();

    /**
     * 更新缓存中的时间
     *
     * @param tpl 报表
     * @return 新的时间
     */
    long updateCacheTime(TemplateWorkBook tpl);

    /**
     * 生成模板的缓存对象
     *
     * @param tpl          报表薄
     * @param reportEntry  用于缓存报表的对象
     * @param parameterMap 参数集
     * @param useCache     是否启用了报表缓存
     * @return 模板缓存对象
     */
    ReportCache createReportCache(TemplateWorkBook tpl,
                                  ReportEntry reportEntry,
                                  Map parameterMap,
                                  boolean useCache);

    /**
     * 从缓存中读取结果报表（如果有缓存）
     *
     * @param tpl          报表薄
     * @param tplPath      报表路径
     * @param reportCache  用于缓存报表的对象
     * @param parameterMap 参数集
     * @param sheetIndex   sheet索引
     * @return 结果报表薄
     */
    ResultWorkBook getResultBookFromCacheIfNeed(TemplateWorkBook tpl,
                                                String tplPath,
                                                ReportCache reportCache,
                                                Map<String, Object> parameterMap,
                                                int sheetIndex);

    /**
     * 是否能够缩放页面，主要用于移动端，分页预览时可以缩放，填报时不能缩放
     *
     * @return 可以缩放则返回true，否则返回false
     */
    boolean shouldNotBeScale();

    /**
     * 是否逐页输出报表内容
     *
     * @param req HTTP请求
     * @return 逐页输出则返回true，否则返回false
     */
    boolean isPageByPage(HttpServletRequest req);

    /**
     * 根据结果报表返回分页对象集合
     *
     * @param wb 结果报表
     * @return 分页对象集合
     */
    PageSetChainProvider getPageSet(ResultWorkBook wb);

    /**
     * 获取当前预览方式需要显示的工具栏
     *
     * @param repo 上下文内容
     * @return 工具栏组成的集合
     */
    ToolBarManager[] toolbarManagers(Repository repo);

    /**
     * 生成报表参数界面以及报表主体组成所需要的配置文件
     *
     * @param repository 上下文内容
     * @return 配置文件
     * @throws JSONException 如果产生配置文件失败则抛出此异常
     */
    JSONObject panelConfig(Repository repository) throws JSONException;

    /**
     * 返回用于表示当前预览方式对应的JavaScript中的字符串
     *
     * @return 表示预览方式的字符串
     */
    String panelType();

    /**
     * 各种预览方式所对应的特殊js的路径
     *
     * @return js文件所在的路径
     */
    String mainJavaScriptPath();

    /**
     * 从Session中获取当前访问报表的报表页的数量，主要用于分页预览时的获取
     *
     * @param repository Session相关上下文
     * @return 报表页数量
     */
    int getReportCountInRepo(Repository repository);

    /**
     * 从Session中获取当前访问的报表页的序号
     *
     * @param repository Session相关上下文
     * @return 报表页序号
     */
    int calculateCurrentSheetIndex(Repository repository);

    /**
     * 生成不同预览方式下的图表block
     *
     * @param chartPainter 图表的painter
     */
    ResultChartBlock getChartBlock4Ploy(BaseChartPainter chartPainter);

    /**
     * 是否支持聚合报表
     *
     * @return 支持聚合报表则返回true，否则返回false
     */
    boolean supportPolyExecute();

    /**
     * 生成上下文信息集合
     *
     * @param req            HTTP请求
     * @param sessionIDInfor 报表会话
     * @return 上下文信息集合
     */
    Map<String, Object> createContext4Tpl(HttpServletRequest req, ReportSessionIDInfor sessionIDInfor);

    /**
     * 输出html
     *
     * @param req            HTTP请求
     * @param res            HTTP相应
     * @param map4Tpl        上下文信息集合
     * @param sessionIDInfor 报表会话
     */
    void flushHtml(HttpServletRequest req, HttpServletResponse res, Map<String, Object> map4Tpl, ReportSessionIDInfor sessionIDInfor) throws IOException;


    /**
     * 生成移动端的报表web属性
     *
     * @param req            HTTP请求
     * @param sessionIDInfor 报表会话
     * @return 返回报表web属性
     * @throws JSONException e
     */
    JSONObject createReportWebAttr4Mobile(HttpServletRequest req, ReportSessionIDInfor sessionIDInfor) throws JSONException;

    /**
     * 处理多sheet时生成的sheet配置数组
     *
     * @param repository 报表会话上下文
     * @return sheet配置数组
     */
    JSONArray processMultipleSheet(Repository repository);

    /**
     * 针对不同的预览方式不同的需求，修改session对象属性
     *
     * @param repo    报表会话上下文
     * @param req     请求
     * @param c       算子
     * @param map     已有的参数配置
     * @param isdebug __isdebug__参数
     */
    void dealWithSessionInfo(Repository repo, HttpServletRequest req, Calculator c, Map<String, Object> map, boolean isdebug);

    /**
     * 定时任务结果文件展示类型
     */
    int getScheduleShowType();
}

package com.fr.report.core.sheet;

import com.fr.main.workbook.ResultWorkBook;
import com.fr.report.elementcase.ResultElementCase;
import com.fr.report.report.ResultReport;
import com.fr.report.report.TemplateReport;
import com.fr.report.stable.fun.Actor;

import java.util.Map;

/**
 * Created by richie on 16/5/11.
 * 报表执行器
 */
public interface WorkBookExecutor {

	/**
	 * 生成结果报表
	 * @param currentIndex 序号
	 * @param report 模板
	 * @return 结果报表
	 */
	ResultReport execute(int currentIndex, TemplateReport report);

	/**
	 * 生成结果报表
	 * @return 结果报表
	 */
	ResultWorkBook execute();

	/**
	 * 生成总的结果报表
	 * @return 结果报表
	 */
	ResultWorkBook result();

	/**
	 * 执行类型
	 * @return 预览类型
	 */
	Actor getExeType();


	/**
	 * 添加sheet
	 * @param index 序号
	 * @param resEC 报表
	 */
	void addResult(int index, ResultReport resEC);

	/**
	 * 根据索引获取对应的报表块
	 * @param index 索引
	 * @return 报表块
	 */
	ResultElementCase getResultByIndex(int index);

	/**
	 * 初始化当前预览方式的结果报表
	 *
	 * @param parameterMap 参数map
	 *
	 * @return 当前预览方式的结果报表
	 *
	 */
	ResultWorkBook initResultBook(Map<String, Object> parameterMap);
}

<extra-report>
        <ActorProvider class="your class name"/>
</extra-report>

package com.fr.stable;

import com.fr.general.GeneralContext;
import com.fr.general.web.ParameterConstants;
import com.fr.plugin.context.PluginContext;
import com.fr.plugin.manage.PluginFilter;
import com.fr.plugin.observer.PluginEvent;
import com.fr.plugin.observer.PluginEventListener;
import com.fr.report.ExtraReportClassManager;
import com.fr.report.fun.ActorProvider;
import com.fr.report.stable.fun.Actor;
import com.fr.web.utils.WebUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created with IntelliJ IDEA.
 * User: richie
 * Date: 14-2-14
 * Time: 下午3:27
 */
public class ActorFactory {
    
    private static Map<String, Actor> actorMap = new HashMap<String, Actor>();
    
    private static Map<Actor, String> typeMap = new HashMap<Actor, String>();
    
    private static Map<String, Actor> reportMap = new HashMap<String, Actor>();
    
    private static Map<String, Actor> extraMap = new HashMap<String, Actor>();
    
    private static final ReadWriteLock LOCK = new ReentrantReadWriteLock();
    
    private static final Lock READ = LOCK.readLock();
    
    private static final Lock WRITE = LOCK.writeLock();
    
    static {
        GeneralContext.listenPluginRunningChanged(new PluginEventListener() {
            
            @Override
            public void on(PluginEvent event) {
    
                refresh();
            }
        }, new PluginFilter() {
            
            @Override
            public boolean accept(PluginContext context) {
                
                return context.contain(Actor.XML_TAG) || context.contain(ActorProvider.XML_TAG);
            }
        });
        refresh();
    }
    
    private static void refresh() {
        
        refreshExtra();
        merge();
    }
    
    private static synchronized void merge() {
        
        WRITE.lock();
        try {
            actorMap.clear();
            typeMap.clear();
            actorMap.putAll(reportMap);
            actorMap.putAll(extraMap);
            for (Map.Entry<String, Actor> entry : actorMap.entrySet()) {
                typeMap.put(entry.getValue(), entry.getKey());
            }
        } finally {
            WRITE.unlock();
        }
    }
    
    private synchronized static void refreshExtra() {
        
        extraMap.clear();
        Set<Actor> actors = ExtraReportClassManager.getInstance().getActors();
        for (Actor actor : actors) {
            extraMap.put(actor.panelType(), actor);
        }
        Set<ActorProvider> providers = ExtraReportClassManager.getInstance().getActorProviders();
        Actor[] providedActors;
        for (ActorProvider provider : providers) {
            providedActors = provider.createActor();
            if (providedActors != null) {
                for (Actor actor : providedActors) {
                    extraMap.put(actor.panelType(), actor);
                }
            }
        }
    }
    
    private ActorFactory() {

    }

    /**
     * 注册当前type的actor，插件中的actor不要调用这个方法，Factory会自动注册
     *
     * @param type 预览的类型
     * @param actor 预览的Actor
     */
    public synchronized static void registerActor(String type, Actor actor) {
    
        reportMap.put(type, actor);
        merge();
    }

    /**
     * 获取指定类型的Actor
     *
     * @param type 指定的类型
     */
    public static Actor getActor(String type) {
    
        Actor actor;
        READ.lock();
        try {
            actor = actorMap.get(type);
            if (actor == null) {
                actor = actorMap.get(ActorConstants.TYPE_PAGE);
            }
        } finally {
            READ.unlock();
        }
        return actor;
    }

    public static String getType(Actor actor) {
    
        READ.lock();
        try {
            String type = typeMap.get(actor);
            if (type != null) {
                return type;
            }
        } finally {
            READ.unlock();
        }
        return ActorConstants.TYPE_PAGE;

    }

    public static Actor getActor(String type, boolean isMobile, boolean isNoPage) {
    
        if (ActorConstants.TYPE_VIEW.equalsIgnoreCase(type) && isMobile) {
            type = ActorConstants.TYPE_PAGE;
        }
        if (ActorConstants.TYPE_PAGE.equalsIgnoreCase(type) && isNoPage) {
            type = ActorConstants.TYPE_NO_PAGE;
        }
        return getActor(type);
    }

    /**
     * 从request中获取Actor
     *
     * @param req http请求
     */
    public static Actor getActor(HttpServletRequest req) {
        return getActor(req, null);
    }

    /**
     * 从request中获取Actor
     *
     * @param req http请求
     */
    public static Actor getActor(HttpServletRequest req, Actor defaultActor) {
        String op = WebUtils.getHTTPRequestParameter(req, ParameterConstants.OP);
        //api打印的op也走这边的, op=getSessionID
        if (StringUtils.isEmpty(op) || actorMap.get(op) == null) {
            // 优先返回外部传入的 defaultActor，
            // 否则，若通过平台预览（op=fs_main），ActorFactory.getActor(req) 得到的结果始终是默认的 PageActor。
            if (defaultActor != null) {
                return defaultActor;
            }
            op = ActorConstants.TYPE_PAGE;
        }
        Actor actor;
        READ.lock();
        try {
            actor = actorMap.get(op);
            if (actor == null) {
                throw new RuntimeException("Not support op:" + op + "@" + ActorFactory.class.getName());
            }
        } finally {
            READ.unlock();
        }
        return actor;
    }
}