/**
   * 데이터 수정.
   *
   * @param userDB
   * @param title
   * @param desc
   * @param cronExp
   * @param listSchedule
   * @return
   * @throws Exception
   */
  public static ScheduleMainDAO modifySchedule(
      final UserDBDAO userDB, ScheduleMainDAO scheduleDao, List<ScheduleDAO> listSchedule)
      throws Exception {

    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    sqlClient.update("scheduleMainUpdate", scheduleDao);

    // 기존 데이터를 삭제합니다.
    sqlClient.update("deleteSchedule", scheduleDao.getSeq());

    // save schedule
    for (ScheduleDAO scheduleDAO : listSchedule) {
      scheduleDAO.setSchedule_main_seq(scheduleDao.getSeq());
      ScheduleDAO retScheduleDAO = (ScheduleDAO) sqlClient.insert("scheduleInsert", scheduleDAO);

      // sql
      String[] sqls = SQLUtil.makeResourceDataArays(scheduleDAO.getSql());
      ScheduleDetailDAO detailDao = null;
      for (String sql : sqls) {
        detailDao = new ScheduleDetailDAO();
        detailDao.setSchedule_seq(retScheduleDAO.getSeq());
        detailDao.setDatas(sql);

        sqlClient.insert("scheduleDetailInsert", detailDao);
      }
    }

    return scheduleDao;
  }
  /**
   * mongodb update
   *
   * @param txtLimitCount
   * @param txtMacCount
   * @param txtFindPage
   * @param txtResultPage
   * @throws Exception
   */
  public static void updateMongoDBUserInfoData(
      String txtLimitCount, String txtMacCount, String txtFindPage, String txtResultPage)
      throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    // 	MONGO_DEFAULT_LIMIT
    userInfoData.setName(PreferenceDefine.MONGO_DEFAULT_LIMIT);
    userInfoData.setValue0(txtLimitCount);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    // MONGO_DEFAULT_MAX_COUNT
    userInfoData.setName(PreferenceDefine.MONGO_DEFAULT_MAX_COUNT);
    userInfoData.setValue0(txtMacCount);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    // MONGO_DEFAULT_FIND
    userInfoData.setName(PreferenceDefine.MONGO_DEFAULT_FIND);
    userInfoData.setValue0(txtFindPage);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    // MONGO_DEFAULT_RESULT
    userInfoData.setName(PreferenceDefine.MONGO_DEFAULT_RESULT);
    userInfoData.setValue0(txtResultPage);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
Exemple #3
0
  @Override
  public void updateThing(String type) throws SQLException {
    if (type.equals("BannerCount")) {
      SqlMapClient ibatis = Mapper.getSqlMapper();
      ibatis.update("updateBannerCount", bid);
    }
    if (type.equals("BannerImage")) {
      try {
        uploadFile();
      } catch (IOException e) {
        e.printStackTrace();
      }

      bb = new BannerBean();

      bb.setBanner_num(bid);
      bb.setAdmin_num(Integer.parseInt(session.get("admin_num")));
      bb.setBanner_image_url(uploadFileName);

      SqlMapClient ibatis = Mapper.getSqlMapper();
      ibatis.update("updateBannerImage", bb);
    }

    if (type.equals("BannerInfo")) {
      bb.setAdmin_num(Integer.parseInt(session.get("admin_num")));
      SqlMapClient ibatis = Mapper.getSqlMapper();
      ibatis.update("updateBannerInfo", bb);
    }
  }
Exemple #4
0
 public void updateMemo(Map map) {
   try {
     mybatis.update("sol_study.insertMemo", map);
   } catch (Exception e) {
     System.out.println("memo 저장 실패다: " + e);
   }
 }
  // 修改HAB值
  public void changeHAB(Context context) {
    List errList = context.errList;
    HashMap outputMap = new HashMap();
    if (errList.isEmpty()) {
      SqlMapClient sqlMapper = DataAccessor.getSession();

      try {
        sqlMapper.startTransaction();
        sqlMapper.update("activitiesLog.modifyHAB", context.getContextMap());
        sqlMapper.commitTransaction();
      } catch (SQLException e) {
        e.printStackTrace();
        LogPrint.getLogStackTrace(e, logger);
        errList.add(e);
      } finally {
        try {
          sqlMapper.endTransaction();
        } catch (SQLException e) {
          e.printStackTrace();
          LogPrint.getLogStackTrace(e, logger);
          errList.add(e);
        }
      }
    } else {
      outputMap.put("errList", errList);
      Output.jspOutput(outputMap, context, "/error.jsp");
    }

    if (errList.isEmpty()) {
      //
    } else {
      outputMap.put("errList", errList);
      Output.jspOutput(outputMap, context, "/error.jsp");
    }
  }
 /**
  * This method was generated by Apache iBATIS ibator. This method corresponds to the database
  * table playlist_songs
  *
  * @ibatorgenerated Thu Oct 22 12:34:10 CDT 2009
  */
 public int updateByExampleSelective(PlaylistSongs record, PlaylistSongsExample example)
     throws SQLException {
   UpdateByExampleParms parms = new UpdateByExampleParms(record, example);
   int rows =
       sqlMapClient.update("playlist_songs.ibatorgenerated_updateByExampleSelective", parms);
   return rows;
 }
Exemple #7
0
  public void insert(Map map) {
    try {
      mybatis.update("sol_study.insert", map);

    } catch (Exception e) {
      System.out.println("insert 실패: " + e);
    }
  }
 public boolean updateUser(User user) {
   try {
     sqlMapClient.update("updateUser", user);
   } catch (SQLException e) {
     e.printStackTrace();
   }
   return true;
 }
  // 연수행사(답글) 뷰페이지
  @RequestMapping("/trainingEventRepView.do")
  public String trainingEventRepView(HttpServletRequest request1, HttpSession session)
      throws SQLException {

    // -------------------------------------------------------------------------------------------------------------------//
    /*seq, currentPage, searchingNow (+ searchType, userinput) 의 변수값을 초기화 한다.*/

    int seq = Integer.parseInt(request1.getParameter("seq"));
    if (null == request1.getParameter("currentPage")) {
      currentPage = 1;
    } else {
      currentPage = Integer.parseInt(request1.getParameter("currentPage"));
    }
    searchingNow = Integer.parseInt(request1.getParameter("searchingNow"));

    // 검색일 경우 존재하는 변수 초기화
    if (searchingNow == 1) {
      searchType = request1.getParameter("searchType");
      userinput = request1.getParameter("userinput");

      // 뷰로 아래의 변수 3개를 보내는 이유는
      // 목록을 클릭했을 때 다시 검색중인 리스트로 돌아가기 위함이다. +위의 currentPage와 함께!
      request1.setAttribute("searchType", searchType);
      request1.setAttribute("userinput", userinput);
      request1.setAttribute("searchingNow", 1);
    } else {

      // 검색중이 아닌경우에는 아래의 변수값이 존재하지 않음을 의미하는 0을 초기화 시켜서 해당 jsp 로 보낸다.
      request1.setAttribute("searchType", 0);
      request1.setAttribute("userinput", 0);
      request1.setAttribute("searchingNow", 0);
    }
    // .-------------------------------------------------------------------------------------------------------------------//

    // -------------------------------------------------------------------------------------------------------------------//
    /*조회수 +1 하기*/

    // 조회수 +1 시킬 레코드를 불러온다.
    resultClass =
        (TrainingEventDTO) sqlMapper.queryForObject("TrainingEvent.selectTrainingEventOne", seq);

    // 뷰페이지의 조회수를 +1 업데이트
    paramClass.setSeq(seq);
    paramClass.setHits(resultClass.getHits() + 1);
    sqlMapper.update("TrainingEvent.updateHits", paramClass);
    // .-------------------------------------------------------------------------------------------------------------------//

    // 뷰페이지에 보여질 레코드 1개를 get
    resultClass =
        (TrainingEventDTO) sqlMapper.queryForObject("TrainingEvent.selectTrainingEventOne", seq);

    request1.setAttribute("seq", seq);
    request1.setAttribute("currentPage", currentPage);
    request1.setAttribute("searchingNow", searchingNow);
    request1.setAttribute("resultClass", resultClass); // 레코드1개

    return "/view/menu7/trainingEvent/trainingEventRepView.jsp";
  }
  /**
   * update SQLFormatter
   *
   * @param userdb
   * @param tabSize
   * @param resultSelect
   * @param sqlFormatIn
   */
  public static void updateSQLFormatterInfoData(
      String tabSize, String sqlFormatDecode, String sqlFormatIn) throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    userInfoData.setName(PreferenceDefine.DEFAULT_TAB_SIZE_PREFERENCE);
    userInfoData.setValue0(tabSize);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    userInfoData.setName(PreferenceDefine.SQL_FORMATTER_DECODE_PREFERENCE);
    userInfoData.setValue0(sqlFormatDecode);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    userInfoData.setName(PreferenceDefine.SQL_FORMATTER_IN_PREFERENCE);
    userInfoData.setValue0(sqlFormatIn);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
  /**
   * default home page
   *
   * @param use
   * @throws Exception
   */
  public static void updateDefaultHomePageUse(String use) throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    // 	select 제한  갯수
    userInfoData.setName(PreferenceDefine.DEFAULT_HOME_PAGE_USE);
    userInfoData.setValue0(use);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
  /**
   * general 정보의 session time을 저장합니다.
   *
   * @param sessionTimeOut
   * @throws Exception
   */
  public static void updateGeneralUserInfoData(String sessionTimeOut) throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    // 	select 제한  갯수
    userInfoData.setName(PreferenceDefine.SESSION_DFEAULT_PREFERENCE);
    userInfoData.setValue0(sessionTimeOut);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
  /**
   * general 정보의 export delimit을 저장합니다.
   *
   * @param sessionTimeOut
   * @throws Exception
   */
  public static void updateGeneralExportDelimitData(String delimit) throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    // 	select 제한  갯수
    userInfoData.setName(PreferenceDefine.EXPORT_DILIMITER);
    userInfoData.setValue0(delimit);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
  /**
   * sequenc
   *
   * @param dao
   * @return
   * @throws TadpoleSQLManagerException, SQLException
   */
  public static TadpoleSequenceDAO getSequence(TadpoleSequenceDAO dao)
      throws TadpoleSQLManagerException, SQLException {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    dao = (TadpoleSequenceDAO) sqlClient.queryForObject("lastSequene", dao);

    dao.setNo(dao.getNo() + 1);
    sqlClient.update("updateSequence", dao);

    return dao;
  }
  /**
   * 신규 사용자의 기본 유저 데이터 정보를 저장합니다.
   *
   * @param userdb
   * @param limitSelect
   * @param resultSelect
   * @param oraclePlan
   */
  public static void updateRDBUserInfoData(
      String limitSelect, String resultSelect, String oraclePlan) throws Exception {
    SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
    UserInfoDataDAO userInfoData = new UserInfoDataDAO();
    userInfoData.setUser_seq(SessionManager.getSeq());

    // 	select 제한  갯수
    userInfoData.setName(PreferenceDefine.SELECT_LIMIT_COUNT);
    userInfoData.setValue0(limitSelect);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    // 검색 결과 페이지 당 보여주는 갯수
    userInfoData.setName(PreferenceDefine.SELECT_RESULT_PAGE_PREFERENCE);
    userInfoData.setValue0(resultSelect);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$

    // ORACLE PLAN TABLE
    userInfoData.setName(PreferenceDefine.ORACLE_PLAN_TABLE);
    userInfoData.setValue0(oraclePlan);
    sqlClient.update("userInfoDataUpdate", userInfoData); // $NON-NLS-1$
  }
Exemple #16
0
  // 게시판 WRITE 액션
  public String execute() throws Exception {

    // 파라미터와 리절트 객체 생성.
    paramClass = new boardVO();
    resultClass = new boardVO();

    // 등록할 항목 설정.
    paramClass.setSubject(getSubject());
    paramClass.setName(getName());
    paramClass.setPassword(getPassword());
    paramClass.setContent(getContent());
    paramClass.setRegdate(today.getTime());

    // 등록 쿼리 수행.
    sqlMapper.insert("insertBoard", paramClass);

    // 첨부파일을 선택했다면 파일을 업로드한다.
    if (getUpload() != null) {

      // 등록한 글 번호 가져오기.
      resultClass = (boardVO) sqlMapper.queryForObject("selectLastNo");

      // 실제 서버에 저장될 파일 이름과 확장자 설정.
      String file_name = "file_" + resultClass.getNo();
      String file_ext =
          getUploadFileName()
              .substring(getUploadFileName().lastIndexOf('.') + 1, getUploadFileName().length());

      // 서버에 파일 저장.
      File destFile = new File(fileUploadPath + file_name + "." + file_ext);
      FileUtils.copyFile(getUpload(), destFile);

      // 파일 정보 파라미터 설정.
      paramClass.setNo(resultClass.getNo());
      paramClass.setFile_orgname(getUploadFileName()); // 원래 파일 이름
      paramClass.setFile_savname(file_name + "." + file_ext); // 서버에 저장한 파일 이름

      // 파일 정보 업데이트.
      sqlMapper.update("updateFile", paramClass);
    }

    return SUCCESS;
  }
Exemple #17
0
  @PUT
  @Consumes(MediaType.APPLICATION_JSON)
  @Produces(MediaType.TEXT_PLAIN)
  public String updateLedger(Ledger objLedger) {
    try {
      Reader reader = Resources.getResourceAsReader("./dao/SqlMapConfig.xml");
      SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);

      Ledger temp = (Ledger) sqlMap.queryForObject("Ledger.getLedgerById", objLedger);
      if (temp == null) {
        return "Ledger can not be identified. Try logging in again.!";
      }

      sqlMap.startTransaction();
      sqlMap.update("Ledger.updateByLedgerId", objLedger);
      sqlMap.commitTransaction();
      sqlMap.endTransaction();
    } catch (Exception e) {
      e.printStackTrace();
      return "Some problem occured while updating Ledger information. Kindly try again!";
    }
    return "Information updated successfully";
  }
Exemple #18
0
  public boolean updateUserInfo(UserDTO dto) throws Exception {
    boolean result = false;

    try {
      sqlClient.startTransaction();
      // sqlClient.startBatch();

      sqlClient.update("UserInfo.updateUserInfo", dto);
      sqlClient.insert("UserInfo.insertRankingHistory", dto);

      // sqlClient.executeBatch();
      sqlClient.commitTransaction();

      result = true;
    } catch (Exception e) {
      logger.error("dto is" + dto.toString());
      logger.error("sql Exception : " + e.getMessage());
      throw new Exception("TwitterRankDAO.updateUserInfo:" + e.getMessage());
    } finally {
      sqlClient.endTransaction();
    }

    return result;
  }
 /**
  * This method was generated by Apache iBATIS ibator. This method corresponds to the database
  * table playlist_songs
  *
  * @ibatorgenerated Thu Oct 22 12:34:10 CDT 2009
  */
 public int updateByPrimaryKey(PlaylistSongs record) throws SQLException {
   int rows = sqlMapClient.update("playlist_songs.ibatorgenerated_updateByPrimaryKey", record);
   return rows;
 }
Exemple #20
0
  public void getHate(int no) throws Exception {

    SqlMapClient sqlmap = IbatisUtil.getSqlmap();
    sqlmap.update("getHate", no);
  }
Exemple #21
0
 @Override
 public void updateDB(Server server) throws Exception {
   sqlMapClient.update("Server.updateDB", server);
 }
Exemple #22
0
  public void updateNotice(HashMap<String, Object> update) throws Exception {

    SqlMapClient sqlmap = IbatisUtil.getSqlmap();
    sqlmap.update("updateNotice", update);
  }
Exemple #23
0
 /**
  * This method was generated by MyBatis Generator. This method corresponds to the database table
  * SELL_MEDIA
  *
  * @mbggenerated Mon Oct 29 16:37:30 ART 2012
  */
 public int updateSellMediaByExample(SellMedia record, SellMediaExample example)
     throws SQLException {
   UpdateByExampleParms parms = new UpdateByExampleParms(record, example);
   int rows = sqlMapClient.update("SELL_MEDIA.updateByExample", parms);
   return rows;
 }
Exemple #24
0
 /**
  * This method was generated by MyBatis Generator. This method corresponds to the database table
  * SELL_MEDIA
  *
  * @mbggenerated Mon Oct 29 16:37:30 ART 2012
  */
 public int updateSellMediaByPrimaryKey(SellMedia record) throws SQLException {
   int rows = sqlMapClient.update("SELL_MEDIA.updateByPrimaryKey", record);
   return rows;
 }
  // 위생.안전 검사결과 수정
  @RequestMapping(value = "/improvementCaseEdit.do", method = RequestMethod.POST)
  public String improvementCaseEdit(
      MultipartHttpServletRequest request,
      HttpServletRequest request1,
      HttpServletResponse response1,
      HttpSession session)
      throws Exception {

    // 작성한 사용자(현재 로그인한 세션아이디)
    String session_id = (String) session.getAttribute("session_id");

    // 수정요청한 뷰 정보
    int seq = Integer.parseInt(request.getParameter("seq"));
    int currentPage = Integer.parseInt(request.getParameter("currentPage"));
    int searchingNow = Integer.parseInt(request.getParameter("searchingNow"));

    // 사용자가 입력한 값
    String description = request1.getParameter("description");
    Calendar today = Calendar.getInstance();

    // DTO Set()
    paramClass.setSeq(seq);
    paramClass.setDescription(description); // 수정내용
    paramClass.setUdt_name(session_id); // 수정인
    paramClass.setUdt_date(today.getTime()); // 수정일

    // DB에 update 하기 (글 수정)
    sqlMapper.update("ImprovementCase.updateImprovementCase", paramClass);
    // .기본적인 내용 업로드 종료

    // 1. 파일삭제를 위해 생성 - 파일삭제시 기존 업로드된파일의 경로를 얻기위함
    // 2. 이미지 파일 수정을 위해 생성 - 사용자가 수정시 이미지 업로더를 추가했는지 감소했는지 판단하고 업데이트를 하기 위함
    resultClass =
        (ImprovementCaseDTO)
            sqlMapper.queryForObject("ImprovementCase.selectImprovementCaseOne", seq);

    /*
    ##파일첨부 시작##
    업로드요청이 새로 들어올경우
    기존 파일을 삭제한 후에 새로 복사본을 서버에 저장함
    */

    MultipartFile file = request.getFile("filename"); // 업로드된 원본
    String orgName = file.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

    if (orgName != "") { // 파일을 첨부했을 경우

      // 기존파일 삭제시작
      if (resultClass.getAttach_path() != null) {
        File deleteFile = new File(resultClass.getAttach_path() + resultClass.getAttach_name());
        deleteFile.delete();
      }
      // .기존파일 삭제종료

      // 새로운파일 생성시작
      String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
      String fileName = "file_inspectionResult_" + randNum; // 서버저장 파일명(file_inspctionResult_랜덤번호)
      String fileExt = orgName.substring(orgName.lastIndexOf('.')); // 서버저장 확장자

      File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
      file.transferTo(save); // 복사본 생성

      // DB 파일 경로 저장용

      // 상대경로 path
      // String path = save.getPath().replace("\\", "/").substring(42); // 42전까지가 절대경로

      // 절대경로 path
      String path = file_path + fileName + fileExt;

      paramClass.setSeq(seq); // 시퀀스넘버
      paramClass.setAttach_name(fileName + fileExt); // 파일명
      paramClass.setAttach_path(path); // 파일경로(img src 경로를 의미함)

      // 파일 정보 업데이트.
      sqlMapper.update("ImprovementCase.updateFile", paramClass);
      /// 새로운파일 생성종료
    }
    // .파일첨부 종료

    /*
    ##이미지첨부 수정 시나리오##
    0. 기존값 == null 일때 -> 수정값 == null 이면, 아무것도안함 - 사용자가 어떠한 수정변화도 주지 않았음을 의미
    1. 기존값 == null 일때 -> 수정값 != null 이면, 수정레코드 업데이트 - 사용자가 이미지를 추가등록했음을 의미
    2. 기존값 != null 일때 -> 수정값 != null 이면, 기존레코드 삭제(이미지포함), 수정레코드 업데이트  - 사용자가 동일컬럼을 수정하였음을 의미
    3. 기존값 != null 일때 -> 수정값 == null 이면 -> 현재>수정개수, 기존컬럼 삭제(이미지포함) - 사용자가 이미지를 감소등록했음을 의미
    				                    		  -> 0==수정개수, 아무것도안함 - 사용자가 어떠한 수정변화도 주지 않았음을 의미
    				                    		  				 if(기존개수==1) 경우 논리적으로 삭제될 수 없음. -> 1개에선 감소할 수 없게 alert 방어경고
    */

    // 기존img개수 산출
    int orgCnt = Integer.parseInt(request.getParameter("cnt"));

    // 수정img개수 산출
    int uptCnt = 0;

    if (request.getFile("optupload1") != null) {
      uptCnt++;
    }
    if (request.getFile("optupload2") != null) {
      uptCnt++;
    }
    if (request.getFile("optupload3") != null) {
      uptCnt++;
    }
    if (request.getFile("optupload4") != null) {
      uptCnt++;
    }
    if (request.getFile("optupload5") != null) {
      uptCnt++;
    }
    if (request.getFile("optupload6") != null) {
      uptCnt++;
    }
    // 수정img개수 산출 종료

    // 1. 기존값 == null 일때 -> 수정값 != null 이면, 수정레코드 업데이트 - 사용자가 이미지를 추가등록했음을 의미

    // 1번 이미지
    if (resultClass.getImg1() == null) {
      // 1번 이미지
      if (request.getFile("optupload1") != null) { // 해당 변수가 존재하면

        MultipartFile file1 = request.getFile("optupload1"); // 업로드된 원본
        String orgName1 = file1.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName1 != "") { // 이미지 파일을 첨부했을 경우

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName1.substring(orgName1.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file1.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg1(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg1", paramClass);
        }
      }
    }
    // .1번 이미지 종료

    // 2번 이미지
    if (resultClass.getImg2() == null) {
      if (request.getFile("optupload2") != null) { // 해당 변수가 존재하면

        MultipartFile file2 = request.getFile("optupload2"); // 업로드된 원본
        String orgName2 = file2.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName2 != "") { // 이미지 파일을 첨부했을 경우
          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName2.substring(orgName2.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file2.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg2(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg2", paramClass);
        }
      }
    }
    // .2번 이미지 종료

    // 3번 이미지
    if (resultClass.getImg3() == null) {
      if (request.getFile("optupload3") != null) { // 해당 변수가 존재하면

        MultipartFile file3 = request.getFile("optupload3"); // 업로드된 원본
        String orgName3 = file3.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName3 != "") { // 이미지 파일을 첨부했을 경우

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName3.substring(orgName3.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file3.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg3(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg3", paramClass);
        }
      }
      // .3번 이미지 종료
    }

    // 4번 이미지
    if (resultClass.getImg4() == null) {
      if (request.getFile("optupload4") != null) { // 해당 변수가 존재하면

        MultipartFile file4 = request.getFile("optupload4"); // 업로드된 원본
        String orgName4 = file4.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName4 != "") { // 이미지 파일을 첨부했을 경우

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName4.substring(orgName4.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file4.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg4(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg4", paramClass);
        }
      }
    }
    // .4번 이미지 종료

    // 5번 이미지
    if (resultClass.getImg5() == null) {
      if (request.getFile("optupload5") != null) { // 해당 변수가 존재하면

        MultipartFile file5 = request.getFile("optupload5"); // 업로드된 원본
        String orgName5 = file5.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName5 != "") { // 이미지 파일을 첨부했을 경우

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName5.substring(orgName5.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file5.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg5(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg5", paramClass);
        }
      }
    }
    // .5번 이미지 종료

    // 6번 이미지
    if (resultClass.getImg6() == null) {
      if (request.getFile("optupload6") != null) { // 해당 변수가 존재하면

        MultipartFile file6 = request.getFile("optupload6"); // 업로드된 원본
        String orgName6 = file6.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName6 != "") { // 이미지 파일을 첨부했을 경우

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName6.substring(orgName6.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)

          file6.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg6(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg6", paramClass);
        }
      }
    }
    // .6번 이미지 종료

    // .1번 시나리오 종료

    // 2. 기존값 != null 일때 -> 수정값 != null 이면, 기존레코드 삭제(이미지포함), 수정레코드 업데이트  - 사용자가 동일컬럼을 수정하였음을 의미
    // 3. 기존값 != null 일때 -> 수정값 == null 이면 -> 현재변수>수정개수, 기존컬럼 삭제(이미지포함) - 사용자가 이미지를 감소등록했음을 의미
    //				                    		    -> 0 == 수정개수, 아무것도안함 - 사용자가 어떠한 수정변화도 주지 않았음을 의미

    // 1번 이미지
    if (resultClass.getImg1() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload1") != null) {

        // 새로운데이터 업데이트
        MultipartFile file1 = request.getFile("optupload1"); // 업로드된 원본
        String orgName1 = file1.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName1 != "") { // 이미지 파일을 첨부했을 경우

          // 기존이미지 삭제
          String imgName = resultClass.getImg1().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName1.substring(orgName1.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file1.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg1(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg1", paramClass);
        }
      }
      // .1종료

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload1") == null) {

        if (1 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg1().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg1(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg1", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료

    }
    // .1번 이미지 종료

    // 2번 이미지
    if (resultClass.getImg2() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload2") != null) {

        // 새로운데이터 업데이트
        MultipartFile file2 = request.getFile("optupload2"); // 업로드된 원본
        String orgName2 = file2.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName2 != "") { // 이미지 파일을 첨부했을 경우

          // 기존데이터 삭제
          String imgName = resultClass.getImg2().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존데이터 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName2.substring(orgName2.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file2.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg2(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg2", paramClass);
        }
      }

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload2") == null) {

        if (2 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg2().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg2(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg2", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료
    }
    // .2번 이미지 종료

    // 3번 이미지
    if (resultClass.getImg3() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload3") != null) {

        // 새로운데이터 업데이트
        MultipartFile file3 = request.getFile("optupload3"); // 업로드된 원본
        String orgName3 = file3.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName3 != "") { // 이미지 파일을 첨부했을 경우

          // 기존데이터 삭제
          String imgName = resultClass.getImg3().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존데이터 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName3.substring(orgName3.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file3.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg3(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg3", paramClass);
        }
      }

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload3") == null) {

        if (3 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg3().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg3(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg3", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료
    }
    // .3번 이미지 종료

    // 4번 이미지
    if (resultClass.getImg4() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload4") != null) {

        // 새로운데이터 업데이트
        MultipartFile file4 = request.getFile("optupload4"); // 업로드된 원본
        String orgName4 = file4.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName4 != "") { // 이미지 파일을 첨부했을 경우

          // 기존데이터 삭제
          String imgName = resultClass.getImg4().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존데이터 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName4.substring(orgName4.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file4.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg4(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg4", paramClass);
        }
      }

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload4") == null) {

        if (4 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg4().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg4(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg4", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료
    }
    // .4번 이미지 종료

    // 5번 이미지
    if (resultClass.getImg5() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload5") != null) {

        // 새로운데이터 업데이트
        MultipartFile file5 = request.getFile("optupload5"); // 업로드된 원본
        String orgName5 = file5.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName5 != "") { // 이미지 파일을 첨부했을 경우

          // 기존데이터 삭제
          String imgName = resultClass.getImg5().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존데이터 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName5.substring(orgName5.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)
          file5.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg5(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg5", paramClass);
        }
      }

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload5") == null) {

        if (5 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg5().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg5(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg5", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료
    }
    // .5번 이미지 종료

    // 6번 이미지
    if (resultClass.getImg6() != null) {

      // 1. 수정 변수가 존재하면
      if (request.getFile("optupload6") != null) {

        // 새로운데이터 업데이트
        MultipartFile file6 = request.getFile("optupload6"); // 업로드된 원본
        String orgName6 = file6.getOriginalFilename(); // 사용자가 업로드한 실제 파일 이름

        if (orgName6 != "") { // 이미지 파일을 첨부했을 경우

          // 기존데이터 삭제
          String imgName = resultClass.getImg6().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존데이터 삭제 종료

          String randNum = Integer.toString((int) (Math.random() * 99999)); // 랜덤번호
          String fileName = "img_improvementCase_" + randNum; // 서버저장 파일명(img_improvementCase_랜덤번호)
          String fileExt = orgName6.substring(orgName6.lastIndexOf('.')); // 서버저장 확장자

          File save = new File(file_path + fileName + fileExt); // 복사대상 생성 (경로+파일명+확장자)

          file6.transferTo(save); // 복사본 생성

          // 이미지파일 상대경로 제작
          String temp = image_path.replace("\\", "/");
          // 상대경로 path
          String path = temp + fileName + fileExt; // 상대경로+파일명+확장자

          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg6(path); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg6", paramClass);
        }
      }

      // 2. 수정 변수가 없으면 -> 이미지 수정을 원치않거나 or 이미지를 감소했거나
      if (request.getFile("optupload6") == null) {

        if (6 > uptCnt && 0 != uptCnt) { // 사용자가 이미지를 감소등록했음을 의미
          // 기존이미지 삭제
          String imgName = resultClass.getImg6().substring(38); // 38 이전은 상대경로
          File deleteFile = new File(imgPath + imgName); // 파일명 + 경로
          deleteFile.delete();
          // 기존이미지 삭제 종료

          // 해당 컬럼의 데이터만 제거
          paramClass.setSeq(seq); // 최대 시퀀스넘버
          paramClass.setImg6(null); // 이미지경로

          // 파일 정보 업데이트.
          sqlMapper.update("ImprovementCase.updateImg6", paramClass); // 해당 컬럼을 초기값인 null로 초기화

        } else if (0 == uptCnt) { // 수정을 원치 않은 경우
          // 아무작업안함
        }
      }
      // .2종료
    }
    // .6번 이미지 종료
    // .2~3번 시나리오 종료

    // .이미지첨부 수정 시나리오 종료

    return "redirect:/improvementCaseView.do?seq="
        + seq
        + "&currentPage="
        + currentPage
        + "&searchingNow="
        + searchingNow; // 호출한 뷰페이지로 리다이렉트
  }
 public static void modifyHouse(HouseBean bean) throws Exception {
   sqlMapper.update("howstay.adminHouse.modifyHouse", bean);
 }
 /**
  * delete schedule
  *
  * @param seq
  * @throws Exception
  */
 public static void deleteSchedule(int seq) throws Exception {
   SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleSystemInitializer.getUserDB());
   sqlClient.update("deleteScheduleMain", seq);
 }
Exemple #28
0
 @Override
 public void setWorkflowName(Map<String, String> map) throws Exception {
   sqlMapClient.update("Server.setWorkflowName", map);
 }
  // 修改主档明细
  public void updateLog(Context context) {
    Map outputMap = new HashMap();
    List errList = context.errList;

    String prvLogSun1 = "已访厂";
    String prvLogSun2 = "首次拜访";

    int casesun = Integer.parseInt(context.request.getParameter("casesun"));
    // 通过casesun(明细档Id),查询出name
    Map logName = null;
    try {
      context.contextMap.put("reportactlogid", context.contextMap.get("casesun"));
      logName =
          (Map)
              DataAccessor.query(
                  "activitiesLog.getActlogNameByActlogId",
                  context.contextMap,
                  DataAccessor.RS_TYPE.MAP);
    } catch (Exception e) {
      e.printStackTrace();
      LogPrint.getLogStackTrace(e, logger);
      // 添加详细错误信息
      errList.add("活动日志管理--修改主档明细错误!请联系管理员");
    }
    Object actLogName1 = logName.get("ACTLOG_NAME");
    String actLogName = null;
    if (actLogName1 != null && !"".equals(actLogName1)) {
      actLogName = actLogName1.toString();
    }
    int casesun1 = Integer.parseInt(context.request.getParameter("CASESUN1"));

    SqlMapClient sqlMapper = null;
    if (errList.isEmpty()) {
      try {
        sqlMapper = DataAccessor.getSession();
        sqlMapper.startTransaction();
        sqlMapper.update("activitiesLog.updateLog", context.contextMap);
        context.contextMap.put("logName", actLogName);
        if (actLogName.equals(prvLogSun1)) {
          sqlMapper.update("activitiesLog.updateCaseStateByVisitFactoryDate", context.contextMap);
        } else if (actLogName.equals(prvLogSun2)) {
          sqlMapper.update("activitiesLog.updateCaseStateByVisitFirst", context.contextMap);
        } else {
          sqlMapper.update("activitiesLog.updateCaseState", context.contextMap);
        }
        sqlMapper.commitTransaction();
      } catch (Exception e) {
        e.printStackTrace();
        LogPrint.getLogStackTrace(e, logger);
        errList.add("活动日志管理--修改主档明细错误!请联系管理员");
      } finally {
        try {
          sqlMapper.endTransaction();
        } catch (SQLException e) {
          e.printStackTrace();
          LogPrint.getLogStackTrace(e, logger);
        }
      }
    }
    if (errList.isEmpty()) {
      Output.jspSendRedirect(context, "defaultDispatcher?__action=activitiesLog.query");
    } else {
      outputMap.put("errList", errList);
      Output.jspOutput(outputMap, context, "/error.jsp");
    }
  }
  // 연수행사(원글) 뷰페이지
  @RequestMapping("/trainingEventView.do")
  public String trainingEventView(HttpServletRequest request1, HttpSession session)
      throws SQLException {

    int seq = Integer.parseInt(request1.getParameter("seq"));

    if (null == request1.getParameter("currentPage")) {
      currentPage = 1;
    } else {
      currentPage = Integer.parseInt(request1.getParameter("currentPage"));
    }

    /*
    searchingNow
    달력 리스트에서 view로 진입할 경우 0
    전체글 리스트에서 view로 진입할 경우 0
    검색중인 리스트에서 view로 진입 할 경우 1

    이 변수는 view 에서 목록을 클릭했을 때
    다시 이전 리스트를 기억하기 위해 정의된 변수이다.
    */

    // 이 값이 null로 들어오는 경우는 달력리스트에서 진입했을 때만 해당. (현재 달력리스트에서는 seq만 보냄)
    if (null == request1.getParameter("searchingNow")) {
      searchingNow = 0;
    } else {
      searchingNow = Integer.parseInt(request1.getParameter("searchingNow"));
    }

    // 검색일 경우 존재하는 변수 초기화
    if (searchingNow == 1) {
      searchType = request1.getParameter("searchType");
      userinput = request1.getParameter("userinput");

      // 뷰로 아래의 변수 3개를 보내는 이유는
      // 목록을 클릭했을 때 다시 검색중인 리스트로 돌아가기 위함이다. +위의 currentPage와 함께!
      request1.setAttribute("searchType", searchType);
      request1.setAttribute("userinput", userinput);
      request1.setAttribute("searchingNow", 1);
    } else {

      // 검색중이 아닌경우에는 아래의 변수값이 존재하지 않음을 의미하는 0을 초기화 시켜서 해당 jsp 로 보낸다.
      request1.setAttribute("searchType", 0);
      request1.setAttribute("userinput", 0);
      request1.setAttribute("searchingNow", 0);
    }

    // 조회수를 위한 get
    resultClass =
        (TrainingEventDTO) sqlMapper.queryForObject("TrainingEvent.selectTrainingEventOne", seq);

    // 뷰페이지의 조회수를 +1 업데이트
    paramClass.setSeq(seq);
    paramClass.setHits(resultClass.getHits() + 1);
    sqlMapper.update("TrainingEvent.updateHits", paramClass);

    // 뷰페이지에 보여질 레코드 1개를 get
    resultClass =
        (TrainingEventDTO) sqlMapper.queryForObject("TrainingEvent.selectTrainingEventOne", seq);

    /*
     * 행사도중에는 삭제불가능 하도록 하는 판단함수
     * 1. 결과등록(답글)은 행사종료일이거나 그 이상되어야만 가능함을 판단하는 변수
     * 2. 글의 삭제를 판단하는 변수
     * 3. 0은 등록불가 및 삭제불가, 1은 등록가능 및 삭제가능
     * str_date - 행사시작날짜
     * end_date - 행사종료날짜
     * current_date - 현재날짜
     */

    // 행사 시작 날짜(str_date)
    int str_date = Integer.parseInt(resultClass.getStr_date().replace("-", ""));
    // 행사 종료 날짜(end_date)
    int end_date = Integer.parseInt(resultClass.getEnd_date().replace("-", ""));
    // 현재 날짜(current_date)
    Calendar today = Calendar.getInstance();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    int current_date = Integer.parseInt(sdf.format(today.getTime()));

    // 행사가 시작했고,		종료되기 전이면
    if (current_date >= str_date && current_date <= end_date) {
      canWrite = 0; // 0은 등록불가 or 삭제불가
    } else {
      canWrite = 1; // 1은 등록가능 or 삭제가능
    }

    // 현재날짜를 String으로 받음
    // 행사가 종료될경우 글을 수정할 수 없게 하기 위하여, 현재시간을 String Type으로 jsp 로 보내어, end_date 값과 판단한다.
    Calendar today1 = Calendar.getInstance();
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
    String current_date1 = sdf1.format(today1.getTime());

    request1.setAttribute("current_date", current_date);
    request1.setAttribute("current_date1", current_date1); // 수정논리(기능추가)
    request1.setAttribute("seq", seq); // 뷰의 시퀀스넘버
    request1.setAttribute("currentPage", currentPage); // 현재페이지
    request1.setAttribute("searchingNow", searchingNow); // 전체글 or 검색글 논리변수
    request1.setAttribute("canWrite", canWrite); // 결과등록(답글) 입력 권한 논리변수
    request1.setAttribute("resultClass", resultClass); // 뷰에 출력될 레코드1개 참조변수
    return "/view/menu7/trainingEvent/trainingEventView.jsp";
  }