epaperaction.java

来自「培训考试系统代码」· Java 代码 · 共 1,100 行 · 第 1/3 页

package com.huawei.icd30.agt.exam;

import java.util.Random;
import java.util.ArrayList;
import javax.servlet.http.*;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import com.huawei.icd30.agt.util.*;
import com.huawei.icd30.common.db.*;
import java.util.*;

/**
 * <p> 从EPaperForm类中提取从页面提交的信息，
 * 实现试卷的生成、修改、删除、查询、发布与取消操作，
 * 操作失败定向到出错页面。</p>
 * <p> </p>
 * <p> </p>
 * @author 龙燕茜
 * @version 1.0
 */

public class EPaperAction extends Action
{
    public ActionForward perform(ActionMapping mapping,
           ActionForm form, HttpServletRequest req,
           HttpServletResponse res)
    {
        //判断session是否超时
/*        ActionForward checkForword = Tools.checkSession(req,res);
        if(checkForword != null)
        {
             return checkForword;
        }
*/

        //获取操作类型
        String opeType =((EPaperForm)form).getOpeType();//从form中获取
        if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_MAKEINPUT))
        {
             return forInputPaper(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_MAKE))
        {//调用生成试卷函数
             return makePaper(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_MODIFY)
                 || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_MODIFY_RELEASE))
        {//调用修改试卷函数
             return modifyPaper(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_DELETE)
                 || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_DELETE_SINGLE))
        {//调用删除试卷函数
             return deletePaper(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_QUERY)
                 || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_QUERY_FORSELECT)
                 || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_QUERY_FORSELECT1))
        {//调用查询试卷函数
             return queryPaper(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_QUERY_DETAILEDIT)
             || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_QUERY_DETAILSHOW))
        {//查询试卷详细信息
             return queryPaperDetail(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_STATUS_CHANGE)
             || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_RELEASE_SINGLE))
        {//更改试卷状态
             return changeStatus(mapping,form,req,res);
        }
        else if(opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_SELECTED)
             || opeType.equalsIgnoreCase(OperatorFlagCode.EPAPER_SELECTED_SUBMIT))
        {//选择不同页面的自测题
             return paperSelected(mapping,form,req,res,opeType);
        }
        else
        {//操作类型错误,定向到错误页面,错误编码:UNKNOW_ERROR
             req.setAttribute("errorId",ErrorCode.UNKNOW_ERROR);
             return (mapping.findForward("error"));
        }
    }

    /**
     * 查询策略，并定向到生成试卷的输入页面
     */
    private ActionForward forInputPaper(ActionMapping mapping,
           ActionForm form, HttpServletRequest req,
           HttpServletResponse res)
    {
       //定义连接的实例
       SysDbConn aplcoms = null;
       try
       {
           //得到一个连接的实例
           aplcoms = SysConnPool.getInstance().getAplComs();

           //根据策略ID号，从数据库中获取策略内容的详细信息
           aplcoms.preparedQuery("");

           SysResultSet rs = aplcoms.csCommonQuery("SQL_Agt_GetPolicy" ,"1" ,"-1").getResultSet();

           //把策略传送到页面
           req.setAttribute("EPAPER-GET-POLICY",rs);

           //定向输入页面
            return (mapping.findForward("epaperinput"));

       }
       catch (SysDbException aple)
       {//捕获CommonService系统异常,定向到出错页面
           //输出异常信息
           aple.printStackTrace();
           req.setAttribute("errorId",ErrorCode.COMMONSERVICE_ERROR);
           return (mapping.findForward("error"));
       }
       catch(java.sql.SQLException sqle)
       {//捕获调用aplcoms异常,定向到出错页面
           // 输出异常信息
           sqle.printStackTrace();
           req.setAttribute("errorId",ErrorCode.DATABASE_ERROR);
           return (mapping.findForward("error"));
       }
       catch(Exception e)
       {//捕获未知异常,定向到出错页面
           //输出异常信息
           e.printStackTrace();
           req.setAttribute("errorId",ErrorCode.UNKNOW_ERROR);
           return (mapping.findForward("error"));
       }
       finally
       {//关闭连接实例
           if(aplcoms != null)
           {
              aplcoms.close();
           }
       }
    }


    /**
     * 生成试卷操作
     */
    private ActionForward makePaper(ActionMapping mapping,
           ActionForm form, HttpServletRequest req,
           HttpServletResponse res)
    {

        //定义试题列表(分别为存放id号与分数)
        ArrayList testIdArrList = new ArrayList();
        ArrayList testScoreArrList = new ArrayList();

        //调用getPaperTestByPolicy函数得到属于试卷的试题，并存放到
        //testIdArrList与testScoreArrList列表中，如果调用
        //getPaperTestByPolicy函数不为空则直接返回
        ActionForward af = getPaperTestByPolicy(mapping,form,req,testIdArrList,testScoreArrList);
        if(af != null)
        {
            return af;
        }


        //调用insertPaperToDB函数把试卷信息与试卷的，试题列表中的内容插入数据库，如果调用
        //insertPaperToDB函数不为空则直接返回
        af = insertPaperToDB(mapping,form,req,testIdArrList,testScoreArrList);
        if(af != null)
        {
            return af;
        }

        //调用queryPaperDetail函数定向到预览页面
        ((EPaperForm)form).setOpeType(OperatorFlagCode.EPAPER_QUERY_DETAILBROWSE);
        return queryPaperDetail(mapping,form,req,res);
    }

   /**
    * 根据策略从题库中获取试题,放到数组列表中(试题ID与对应分数),
    * 根据数组下标进行对应。
    * @param form  struts封装页面请求的数据
    * @param res 响应
    * @param testIdArrList 试卷的试题ID列表
    * @param testScoreArrList 试卷的试题分数列表
    * @return 成功返回null,失败返回一ActionForward对象
    */
   private ActionForward getPaperTestByPolicy(ActionMapping mapping,ActionForm form,
           HttpServletRequest req,
           ArrayList testIdArrList,ArrayList testScoreArrList)
    {

       //从EPaperFrom对象中获取生成试卷的条件数据；
       String policyId = ((EPaperForm)form).getPolicyId();

       //定义连接的实例
       SysDbConn aplcoms = null;
       try
       {
           //得到一个连接的实例
           aplcoms = SysConnPool.getInstance().getAplComs();

           /*//查询数据库得到总题数
           int testCount = 0;
           aplcoms.preparedQuery("");
           aplcoms.setString(1 ,policyId);
           SysResultSet rs1 = aplcoms.csCommonQuery("SQL_Agt_GetPolicyTestCount" ,"1" ,"-1").getResultSet();
           if(rs1!= null)
           {
              rs1.next();
              testCount = rs1.getInt(0);
           }
           if(testCount == 0)
           {
              req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_POLICYERROR);
              return (mapping.findForward("error"));
           }
           //根据策略的总题数对testIdArrList与testScoreArrList进行初始化;
           testIdArrList = new ArrayList(testCount);
           testScoreArrList = new ArrayList(testCount);*/

            //根据策略ID，从数据库中获取策略内容记录
            aplcoms.preparedQuery("");
            aplcoms.setString(1 ,policyId);

            SysResultSet rs2 = aplcoms.csCommonQuery("SQL_Agt_PolicyQueryDetail" ,"1" ,"-1").getResultSet();

            if(rs2 != null)
            {//策略内容不为空

                //结果集按序号进行排序
                rs2.sort(1,true);

                while(rs2.next())
                {
                    //定义试题临时列表(分别为存放id号与分数)
                    ArrayList tmpTestIdArrList = null;
                    ArrayList tmpTestScoreArrList = null;

                    //从rs2中获取一条具体策略内容记录;
                    //策略内容作为搜索试题条件,对题库进行搜索
                    int testType = rs2.getInt(2);
                    int degree = rs2.getInt(6);
                    int testMeans = rs2.getInt(8);
                    int useLevel = rs2.getInt(10);
                    String classId = rs2.getString(11);
                    int policyNumber = rs2.getInt(4);
                    int perScore = rs2.getInt(5);

                    aplcoms.preparedQuery("");
                    aplcoms.setInt(1 ,testType);
                    aplcoms.setInt(2 ,degree);
                    aplcoms.setInt(3 ,testMeans);
                    aplcoms.setInt(4 ,useLevel);
                    aplcoms.setString(5 ,classId);

                    SysResultSet rs3 = aplcoms.csCommonQuery("SQL_Agt_TestItemQuery" ,"1" ,"-1").getResultSet();
                    if(rs3 != null)
                    {//有符合条件的试题,则取出并进行随机抽取

                        //记录数
                        int rCount = rs3.getMetaData().getRecordCount();

                        if(rCount < policyNumber)
                        {
                              //huangyuyuan add 2004-05-28
                              if(1==testType)
                              {
                                //定向到出错页面
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR_PD);
                                return (mapping.findForward("error"));
                              }
                              else if(2==testType)
                              {
                                //定向到出错页面
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR_DAX);
                                return (mapping.findForward("error"));
                              }
                              else if(3==testType)
                              {
                                //定向到出错页面
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR_DUX);
                                return (mapping.findForward("error"));
                              }
                              else if(4==testType)
                              {
                                //定向到出错页面
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR_TK);
                                return (mapping.findForward("error"));
                              }
                              else if(5==testType)
                              {
                                //定向到出错页面
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR_WD);
                                return (mapping.findForward("error"));
                              }
                              else
                              {
                                //定向到出错页面,错误编号:EPAPER_MAKE_TESTERROR
                                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR);
                                return (mapping.findForward("error"));
                              }

                          /*
                              //定向到出错页面,错误编号:EPAPER_MAKE_TESTERROR
                              req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR);
                              return (mapping.findForward("error"));
                         */
                          //--
                        }

                        tmpTestIdArrList = new ArrayList(rCount);
                        tmpTestScoreArrList = new ArrayList(rCount);

                        while(rs3.next())
                        {
                             //获取试题ID号
                             tmpTestIdArrList.add(rs3.getString(0));
                             tmpTestScoreArrList.add(String.valueOf(perScore));
                        }
                        //调用drawOutTest函数从数组中进行随机并插入试卷的
                              //试题列表testIdArrList与testScoreArrList中
                        drawOutTest(tmpTestIdArrList,tmpTestScoreArrList,policyNumber,
                                        testIdArrList,testScoreArrList);
                    }
                    else
                    {//没有符合条件的试题,定向到出错页面,错误编号:EPAPER_MAKE_ERROR
                        req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_TESTERROR);
                        return (mapping.findForward("error"));
                    }
                }
             }
            else
            {//策略内容为空，定向到出错页面,错误编号:EPAPER_MAKE_ERROR
                req.setAttribute("errorId",ErrorCode.EPAPER_MAKE_POLICYERROR);
                return (mapping.findForward("error"));
            }
            return null;
       }
       catch (SysDbException aple)
       {//捕获CommonService系统异常,定向到出错页面
           //输出异常信息
           aple.printStackTrace();
           req.setAttribute("errorId",ErrorCode.COMMONSERVICE_ERROR);
           return (mapping.findForward("error"));
       }
       catch(java.sql.SQLException sqle)
       {//捕获调用aplcoms异常,定向到出错页面
           // 输出异常信息
           sqle.printStackTrace();
           req.setAttribute("errorId",ErrorCode.DATABASE_ERROR);
           return (mapping.findForward("error"));
       }
       catch(Exception e)
       {//捕获未知异常,定向到出错页面
           //输出异常信息
           e.printStackTrace();
           req.setAttribute("errorId",ErrorCode.UNKNOW_ERROR);
           return (mapping.findForward("error"));
       }
       finally
       {//关闭连接实例
           if(aplcoms != null)
           {
              aplcoms.close();
           }
       }
    }