com.hangum.tadpole.commons.sql/src/com/hangum/tadpole/engine/query/sql/TadpoleSystem_UserQuery.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013 hangum.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the GNU Lesser Public License v2.1
   5  * which accompanies this distribution, and is available at
   6  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
   7  *
   8  * Contributors:
   9  *     hangum - initial API and implementation
  10  ******************************************************************************/
  11 package com.hangum.tadpole.engine.query.sql;
  12
  13 import java.sql.SQLException;
  14 import java.sql.Timestamp;
  15 import java.text.DateFormat;
  16 import java.text.SimpleDateFormat;
  17 import java.util.ArrayList;
  18 import java.util.Date;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import org.apache.commons.lang.math.NumberUtils;
  24 import org.apache.log4j.Logger;
  25
  26 import com.hangum.tadpole.commons.exception.TadpoleAuthorityException;
  27 import com.hangum.tadpole.commons.exception.TadpoleRuntimeException;
  28 import com.hangum.tadpole.commons.exception.TadpoleSQLManagerException;
  29 import com.hangum.tadpole.commons.libs.core.define.PublicTadpoleDefine;
  30 import com.hangum.tadpole.commons.libs.core.utils.LicenseValidator;
  31 import com.hangum.tadpole.commons.libs.core.utils.SHA256Utils;
  32 import com.hangum.tadpole.commons.util.ApplicationArgumentUtils;
  33 import com.hangum.tadpole.commons.util.DateUtil;
  34 import com.hangum.tadpole.commons.util.Utils;
  35 import com.hangum.tadpole.engine.Messages;
  36 import com.hangum.tadpole.engine.initialize.TadpoleEngineUserDB;
  37 import com.hangum.tadpole.engine.manager.TadpoleSQLManager;
  38 import com.hangum.tadpole.engine.query.dao.system.UserDAO;
  39 import com.hangum.tadpole.engine.query.dao.system.UserLoginHistoryDAO;
  40 import com.hangum.tadpole.preference.define.GetAdminPreference;
  41 import com.ibatis.sqlmap.client.SqlMapClient;
  42
  43
  44 /**
  45  * Define User query.
  46  *
  47  * @author hangum
  48  *
  49  */
  50 public class TadpoleSystem_UserQuery {
  51         private static final Logger logger = Logger.getLogger(TadpoleSystem_UserQuery.class);
  52
  53         /**
  54          *
  55          * @param userSeq
  56          * @return
  57          * @throws TadpoleSQLManagerException
  58          * @throws SQLException
  59          */
  60         public static UserDAO getUser(int userSeq)throws TadpoleSQLManagerException, SQLException {
  61                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
  62                 return (UserDAO)sqlClient.queryForObject("getUser", userSeq); //$NON-NLS-1$
  63         }
  64
  65         /**
  66          * 모든 유효한 유저 목록을 가져옵니다.
  67          *
  68          * @param strApproval
  69          * @param strUserConfirm
  70          * @param strDel
  71          * @return
  72          * @throws TadpoleSQLManagerException, SQLException
  73          */
  74         public static List<UserDAO> getAllUser(String strApproval, String strUserConfirm, String strDel) throws TadpoleSQLManagerException, SQLException {
  75                 Map<String, String> mapSearch = new HashMap<String, String>();
  76                 mapSearch.put("Approval", strApproval);
  77                 mapSearch.put("UserConfirm", strUserConfirm);
  78                 mapSearch.put("Del", strDel);
  79
  80                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
  81                 return sqlClient.queryForList("getAllUserSearch", mapSearch); //$NON-NLS-1$
  82         }
  83
  84         /**
  85          * 모든 유효한 유저 목록을 가져옵니다.
  86          *
  87          * @return
  88          * @throws TadpoleSQLManagerException, SQLException
  89          */
  90         public static List<UserDAO> getAllUser() throws TadpoleSQLManagerException, SQLException {
  91                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
  92                 return sqlClient.queryForList("getAllUser"); //$NON-NLS-1$
  93         }
  94
  95         /**
  96          * 모든 유효한 유저 수를 가져온다.
  97          *
  98          * @return
  99          * @throws TadpoleSQLManagerException, SQLException
 100          */
 101         public static int getAllUserCount() throws TadpoleSQLManagerException, SQLException {
 102                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 103                 Integer intUserCnt = (Integer)sqlClient.queryForObject("getAllUserCount"); //$NON-NLS-1$
 104
 105                 return intUserCnt;
 106         }
 107
 108         /**
 109          * 모든 유효한 유저 목록을 가져옵니다.
 110          *
 111          * @param delyn
 112          * @return
 113          * @throws TadpoleSQLManagerException, SQLException
 114          */
 115         public static List<UserDAO> getLiveAllUser() throws TadpoleSQLManagerException, SQLException {
 116                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 117                 return sqlClient.queryForList("getLiveAllUser"); //$NON-NLS-1$
 118         }
 119
 120         /**
 121          * add ldap user
 122          *
 123          * @param userName
 124          * @param email
 125          * @param external_id
 126          * @param useOTP
 127          *
 128          * @return
 129          * @throws TadpoleSQLManagerException
 130          * @throws SQLException
 131          */
 132         public static UserDAO newLDAPUser(String userName, String email, String external_id, String useOPT) throws TadpoleSQLManagerException, SQLException, Exception {
 133                 return newUser(PublicTadpoleDefine.INPUT_TYPE.LDAP.name(), email, "LDAP", "YES", Utils.getUniqueDigit(12), PublicTadpoleDefine.USER_ROLE_TYPE.USER.name(),
 134                                 userName, "KO", "Asia/Seoul", "YES", useOPT, "", "*", external_id, new Timestamp(System.currentTimeMillis()));
 135         }
 136
 137         /**
 138          * 신규 유저를 등록합니다.
 139          *
 140          * @param inputType
 141          * @param email
 142          * @param email_key
 143          * @param is_email_certification
 144          * @param passwd
 145          * @param roleType
 146          * @param name
 147          * @param language
 148          * @param timezone
 149          * @param approvalYn
 150          * @param use_otp
 151          * @param otp_secret
 152          * @param strAllowIP
 153          * @param strIsRegistDb
 154          * @param strIsSharedDb
 155          * @param intLimitAddDBCnt
 156          * @param serviceStart
 157          * @param serviceEnd
 158          * @param external_id
 159          * @param timeChangedPasswdTime
 160          * @return
 161          * @throws TadpoleSQLManagerException, SQLException
 162          */
 163         public static UserDAO newUser(String inputType, String email, String email_key, String is_email_certification, String passwd,
 164                                                                 String roleType, String name, String language, String timezone, String approvalYn, String use_otp, String otp_secret,
 165                                                                 String strAllowIP, String external_id, Timestamp timeChangedPasswdTime
 166         ) throws TadpoleSQLManagerException, SQLException, Exception {
 167                 UserDAO loginDAO = new UserDAO();
 168                 loginDAO.setInput_type(inputType);
 169                 loginDAO.setEmail(email);
 170                 loginDAO.setEmail_key(email_key);
 171                 loginDAO.setIs_email_certification(is_email_certification);
 172
 173                 loginDAO.setPasswd(SHA256Utils.getSHA256(passwd));
 174                 loginDAO.setChanged_passwd_time(timeChangedPasswdTime);//new Timestamp(System.currentTimeMillis()));
 175                 loginDAO.setRole_type(roleType);
 176
 177                 loginDAO.setName(name);
 178                 loginDAO.setLanguage(language);
 179                 loginDAO.setTimezone(timezone);
 180                 loginDAO.setApproval_yn(approvalYn);
 181
 182                 loginDAO.setUse_otp(use_otp);
 183                 loginDAO.setOtp_secret(otp_secret);
 184                 loginDAO.setAllow_ip(strAllowIP);
 185
 186                 loginDAO.setIs_regist_db(GetAdminPreference.getIsAddDB());
 187                 loginDAO.setIs_shared_db(GetAdminPreference.getIsSharedDB());
 188                 loginDAO.setLimit_add_db_cnt(NumberUtils.toInt(GetAdminPreference.getDefaultAddDBCnt()));
 189                 loginDAO.setIs_modify_perference(GetAdminPreference.getIsPreferenceModify());
 190                 loginDAO.setService_start(new Timestamp(System.currentTimeMillis()));
 191                 loginDAO.setService_end(new Timestamp(DateUtil.afterMonthToMillis(NumberUtils.toInt(GetAdminPreference.getServiceDurationDay()))));
 192                 loginDAO.setExternal_id(external_id);
 193
 194                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 195                 List isUser = sqlClient.queryForList("isUser", email); //$NON-NLS-1$
 196
 197                 if(isUser.isEmpty()) {
 198                         UserDAO userdb = (UserDAO)sqlClient.insert("newUser", loginDAO); //$NON-NLS-1$
 199                         TadpoleSystem_UserInfoData.initializeUserPreferenceData(userdb);
 200
 201                         return userdb;
 202                 } else {
 203                         throw new TadpoleRuntimeException(Messages.get().TadpoleSystem_UserQuery_3);
 204                 }
 205         }
 206
 207         /**
 208          * 이메일이 중복된 사용자가 있는지 검사합니다.
 209          *
 210          * @param email
 211          * @return
 212          * @throws TadpoleSQLManagerException, SQLException
 213          */
 214         public static boolean isDuplication(String email) throws TadpoleSQLManagerException, SQLException {
 215
 216                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 217                 List isUser = sqlClient.queryForList("isUser", email); //$NON-NLS-1$
 218
 219                 if(isUser.size() == 0) {
 220                         return true;
 221                 }
 222
 223                 return false;
 224         }
 225
 226         /**
 227          * search like email
 228          * @param email
 229          * @return
 230          * @throws TadpoleSQLManagerException, SQLException
 231          */
 232         public static List<UserDAO> findLikeUser(String email) throws TadpoleSQLManagerException, SQLException {
 233                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 234                 List<UserDAO> listUser = sqlClient.queryForList("findLikeUser", "%" + email + "%"); //$NON-NLS-1$
 235
 236                 return listUser;
 237         }
 238
 239         /**
 240          * 유저를 넘겨 받는다.
 241          * @param email
 242          * @return
 243          * @throws TadpoleSQLManagerException
 244          * @throws SQLException
 245          */
 246         public static List<UserDAO> findExistUser(String email) throws TadpoleSQLManagerException, SQLException {
 247                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 248                 List<UserDAO> listUser = sqlClient.queryForList("findEmailUser", email); //$NON-NLS-1$
 249                 return listUser;
 250         }
 251
 252         /**
 253          * 연속 몇번 로그인을 실패 했을 경우
 254          *
 255          * @param intLastLoginCnt
 256          * @param intUserSeq
 257          * @param email
 258          * @throws TadpoleSQLManagerException
 259          * @throws SQLException
 260          */
 261         public static void failLoginCheck(int intLastLoginCnt, int intUserSeq, String email) throws TadpoleSQLManagerException, SQLException {
 262                 Map<String, Object> queryMap = new HashMap<String, Object>();
 263                 queryMap.put("intUserSeq",                      intUserSeq);
 264                 queryMap.put("intLastLoginCnt", intLastLoginCnt);
 265
 266                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 267                 List<UserLoginHistoryDAO> listUser = sqlClient.queryForList("lastLoginCntHistory", queryMap); //$NON-NLS-1$
 268
 269                 int intFailCnt = 0;
 270                 for (UserLoginHistoryDAO userLoginHistoryDAO : listUser) {
 271                         if(PublicTadpoleDefine.YES_NO.NO.name().equals(userLoginHistoryDAO.getSucces_yn())) {
 272                                 intFailCnt++;
 273                         }
 274                 }
 275
 276                 // 연속 intLastLoingCnt 틀리면 계정을 잠근다.
 277                 if(intFailCnt == intLastLoginCnt) {
 278                         final UserDAO userDAO = new UserDAO();
 279                         userDAO.setSeq(intUserSeq);
 280
 281                         if(logger.isInfoEnabled()) logger.info(String.format("##### User account %s is lock", email));
 282                         updateUserApproval(userDAO, PublicTadpoleDefine.YES_NO.NO.name());
 283                 }
 284         }
 285
 286         /**
 287          * 유저를 넘겨 받는다.
 288          * @param email
 289          * @return
 290          * @throws TadpoleSQLManagerException
 291          * @throws SQLException
 292          */
 293         public static List<UserDAO> findExistExternalUser(String external_id) throws TadpoleSQLManagerException, SQLException {
 294                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 295                 List<UserDAO> listUser = sqlClient.queryForList("findExternalUser", external_id); //$NON-NLS-1$
 296                 return listUser;
 297         }
 298
 299         /**
 300          * 사용자 정보를 찾습니다.
 301          *
 302          * @param email
 303          * @return
 304          * @throws TadpoleSQLManagerException, SQLException
 305          */
 306         public static UserDAO findUser(String email) throws TadpoleSQLManagerException, SQLException {
 307                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 308                 List<UserDAO> listUser = new ArrayList<UserDAO>();
 309 //              if(ApplicationArgumentUtils.isOnlineServer()) {
 310 //                      listUser = sqlClient.queryForList("findEmailUser", email); //$NON-NLS-1$
 311 //              } else {
 312                         listUser = sqlClient.queryForList("findLikeUser", "%" + email + "%"); //$NON-NLS-1$
 313 //              }
 314
 315                 if(listUser.size() == 0) {
 316                         throw new TadpoleRuntimeException(Messages.get().TadpoleSystem_UserQuery_0);
 317                 }
 318
 319                 return listUser.get(0);
 320         }
 321
 322         public static List<UserDAO> findUserList(String email) throws TadpoleSQLManagerException, SQLException {
 323                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 324                 List<UserDAO> listUser = new ArrayList<UserDAO>();
 325
 326                 listUser = sqlClient.queryForList("findLikeUser", "%" + email + "%"); //$NON-NLS-1$
 327
 328                 if(listUser.size() == 0) {
 329                         throw new TadpoleRuntimeException(Messages.get().TadpoleSystem_UserQuery_0);
 330                 }
 331
 332                 return listUser;
 333         }
 334
 335         /**
 336          * 로그인시 email, passwd 확인
 337          *
 338          * @param email
 339          * @param passwd
 340          * @throws TadpoleSQLManagerException, SQLException
 341          */
 342         public static UserDAO login(String email, String passwd) throws TadpoleAuthorityException, TadpoleSQLManagerException, SQLException, Exception {
 343                 UserDAO login = new UserDAO();
 344                 login.setEmail(email);
 345                 login.setPasswd(SHA256Utils.getSHA256(passwd));
 346
 347                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 348                 UserDAO userInfo = (UserDAO)sqlClient.queryForObject("login", login); //$NON-NLS-1$
 349
 350                 if(null == userInfo) {
 351                         throw new TadpoleAuthorityException(Messages.get().TadpoleSystem_UserQuery_5);
 352 //              } else {
 353 //                      if(!passwd.equals(CipherManager.getInstance().decryption(userInfo.getPasswd()))) {
 354 //                              throw new TadpoleAuthorityException(Messages.get().TadpoleSystem_UserQuery_5);
 355 //                      }
 356                 }
 357
 358                 return userInfo;
 359         }
 360
 361         /**
 362          * update email confirm
 363          *
 364          * @param email
 365          * @throws TadpoleSQLManagerException, SQLException
 366          */
 367         public static void updateEmailConfirm(String email) throws TadpoleSQLManagerException, SQLException {
 368                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 369                 sqlClient.update("updateEmailConfirm", email);
 370         }
 371
 372         /**
 373          * save login history
 374          *
 375          * @param userSeq
 376          */
 377         public static void saveLoginHistory(int userSeq, String strIP) {
 378                 saveLoginHistory(userSeq, strIP, "YES", "");
 379         }
 380
 381         /**
 382          * save login history
 383          *
 384          * @param userSeq
 385          * @param strYesNo
 386          * @param strReason
 387          */
 388         public static void saveLoginHistory(int userSeq, String strIP, String strYesNo, String strReason) {
 389
 390                 if(LicenseValidator.getLicense().isValidate()) {
 391                         try {
 392                                 UserLoginHistoryDAO historyDao = new UserLoginHistoryDAO();
 393                                 historyDao.setLogin_ip(strIP);
 394                                 historyDao.setUser_seq(userSeq);
 395                                 historyDao.setSucces_yn(strYesNo);
 396                                 historyDao.setFail_reason(strReason);
 397
 398                                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 399                                 sqlClient.insert("saveLoginHistory", historyDao);
 400                         } catch(Exception e) {
 401                                 logger.error("save login history", e);
 402                         }
 403                 }
 404         }
 405
 406         /**
 407          * get login history
 408          *
 409          * @param strEmail
 410          * @param strYesNo
 411          * @param startTime
 412          * @param endTime
 413          */
 414         public static List<UserLoginHistoryDAO> getLoginHistory(String strEmail, String strYesNo, long startTime, long endTime) throws TadpoleSQLManagerException, SQLException {
 415                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 416
 417                 Map<String, Object> queryMap = new HashMap<String, Object>();
 418                 queryMap.put("email",           strEmail);
 419                 if(!"All".equals(strYesNo)) queryMap.put("succes_yn",   strYesNo);
 420
 421                 if(ApplicationArgumentUtils.isDBServer()) {
 422                         Date dateSt = new Date(startTime);
 423                         DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
 424                         queryMap.put("startTime",  formatter.format(dateSt));
 425
 426                         Date dateEd = new Date(endTime);
 427                         queryMap.put("endTime", formatter.format(dateEd));
 428                 } else {
 429                         Date dateSt = new Date(startTime);
 430                         DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
 431
 432                         queryMap.put("startTime",  formatter.format(dateSt));
 433
 434                         Date dateEd = new Date(endTime);
 435                         queryMap.put("endTime", formatter.format(dateEd));
 436                 }
 437
 438                 return (List<UserLoginHistoryDAO>)sqlClient.queryForList("getLoginHistory", queryMap);
 439         }
 440
 441         /**
 442          * get admin
 443          *
 444          * @return
 445          * @throws TadpoleSQLManagerException, SQLException
 446          */
 447         public static UserDAO getSystemAdmin() throws TadpoleSQLManagerException, SQLException {
 448                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 449                         return (UserDAO)sqlClient.queryForObject("getSystemAdmin"); //$NON-NLS-1$
 450         }
 451
 452         /**
 453          * group의 manager 정보를 리턴합니다.
 454          *
 455          * @param groupSeq
 456          * @return
 457          * @throws TadpoleSQLManagerException, SQLException
 458          */
 459         public static UserDAO getGroupManager(int groupSeq) throws TadpoleSQLManagerException, SQLException {
 460                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 461                 return (UserDAO)sqlClient.queryForObject("groupManager", groupSeq); //$NON-NLS-1$
 462         }
 463
 464         /**
 465          * admin user가 한명이라면 로그인 화면에서 기본 유저로 설정하기 위해...
 466          *
 467          * @return UserDAO
 468          * @throws TadpoleSQLManagerException, SQLException
 469          */
 470         public static UserDAO loginUserCount() throws TadpoleSQLManagerException, SQLException {
 471                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 472                 Integer isUser = (Integer)sqlClient.queryForObject("loginUserCount"); //$NON-NLS-1$
 473
 474                 if(isUser == 1) {
 475                         UserDAO userInfo = (UserDAO)sqlClient.queryForObject("onlyOnUser"); //$NON-NLS-1$
 476                         return userInfo;
 477                 }
 478
 479                 return null;
 480         }
 481
 482         /**
 483          * 개인 사용자가 그룹 사용자로 수정
 484          *
 485          * @param user
 486          * @throws TadpoleSQLManagerException, SQLException
 487          */
 488         public static void updateUserPersonToGroup(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 489                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 490                 user.setPasswd(SHA256Utils.getSHA256(user.getPasswd()));
 491                 user.setChanged_passwd_time(new Timestamp(System.currentTimeMillis()));
 492                 sqlClient.update("updateUserPersonToGroup", user); //$NON-NLS-1$
 493         }
 494
 495         /**
 496          * 유저 데이터를 수정
 497          * @param user
 498          * @throws TadpoleSQLManagerException, SQLException
 499          */
 500         public static void updateUserData(UserDAO user) throws TadpoleSQLManagerException, SQLException {
 501                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 502                 sqlClient.update("updateUserPermission", user); //$NON-NLS-1$
 503         }
 504
 505         /**
 506          * 유저의 name, password 를 수정한다.
 507          * @param user
 508          * @throws TadpoleSQLManagerException, SQLException
 509          */
 510         public static void updateUserNameEmail(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 511                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 512                 sqlClient.update("updateUserNameEmail", user); //$NON-NLS-1$
 513         }
 514
 515         /**
 516          * 유저의 기본정보를 수정
 517          * @param user
 518          * @throws TadpoleSQLManagerException, SQLException
 519          */
 520         public static void updateUserBasic(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 521                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 522                 sqlClient.update("updateUserBasic", user); //$NON-NLS-1$
 523         }
 524
 525         /**
 526          * 시스템 어드민이 유저의 패스워드 변경
 527          * @param user
 528          * @throws TadpoleSQLManagerException, SQLException
 529          */
 530         public static void updateSystemAdminUserPassword(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 531                 user.setPasswd(SHA256Utils.getSHA256(user.getPasswd()));
 532
 533                 // 10년전으로 패스워드 수정하였다고 기록한다.
 534                 // 그러면 강제로 패스워드 바꾸었다고 뜰거니까? ㅠㅠ --;;
 535                 user.setChanged_passwd_time(new Timestamp(DateUtil.beforeMonthToMillsMonth(12 * 10)));
 536
 537                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 538                 sqlClient.update("updateUserPassword", user); //$NON-NLS-1$
 539         }
 540
 541         /**
 542          * 유저의 패스워드 변경
 543          * @param user
 544          * @throws TadpoleSQLManagerException, SQLException
 545          */
 546         public static void updateUserPassword(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 547                 user.setPasswd(SHA256Utils.getSHA256(user.getPasswd()));
 548                 user.setChanged_passwd_time(new Timestamp(System.currentTimeMillis()));
 549
 550                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 551                 sqlClient.update("updateUserPassword", user); //$NON-NLS-1$
 552         }
 553
 554         /**
 555          * 유저의 패스워드 번경
 556          * @param user
 557          * @throws TadpoleSQLManagerException, SQLException
 558          */
 559         public static void updateUserPasswordWithID(UserDAO user) throws TadpoleSQLManagerException, SQLException, Exception {
 560                 user.setPasswd(SHA256Utils.getSHA256(user.getPasswd()));
 561                 user.setChanged_passwd_time(new Timestamp(System.currentTimeMillis()));
 562
 563                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 564                 sqlClient.update("updateUserPasswordWithID", user); //$NON-NLS-1$
 565         }
 566
 567         /**
 568          * 사용자 힌트 변경
 569          *
 570          * @param user
 571          * @throws TadpoleSQLManagerException, SQLException
 572          */
 573         public static void updateUserOTPCode(UserDAO user) throws TadpoleSQLManagerException, SQLException {
 574                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 575                 sqlClient.update("updateUserOTPCode", user); //$NON-NLS-1$
 576         }
 577
 578         /**
 579          * 사용자 정보.
 580          *
 581          * @param userSeq
 582          * @return
 583          * @throws TadpoleSQLManagerException, SQLException
 584          */
 585         public static UserDAO getUserInfo(int userSeq) throws TadpoleSQLManagerException, SQLException {
 586                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 587                 return (UserDAO)sqlClient.queryForObject("getUserInfo", userSeq); //$NON-NLS-1$
 588         }
 589
 590         /**
 591          * 사용자 정보 값을 수정합니다.
 592          * @param userDAO
 593          * @param name
 594          */
 595         public static void updateUserApproval(UserDAO userDAO, String yesNo) throws TadpoleSQLManagerException, SQLException {
 596                 UserDAO tmpUser = new UserDAO();
 597                 tmpUser.setSeq(userDAO.getSeq());
 598                 tmpUser.setApproval_yn(yesNo);
 599
 600                 SqlMapClient sqlClient = TadpoleSQLManager.getInstance(TadpoleEngineUserDB.getUserDB());
 601                 sqlClient.update("updateUserApproval", tmpUser); //$NON-NLS-1$
 602         }
 603
 604 }