示例#1
0
  /**
   * Returns the number of request made to a workgroup between specified dates.
   *
   * @param workgroupName the workgroup to search
   * @param startDate the time to begin the search from.
   * @param endDate the time to end the search.
   * @return the total number of requests
   */
  public static int getNumberOfRequestsForWorkgroup(
      String workgroupName, Date startDate, Date endDate) {
    Workgroup workgroup = getWorkgroup(workgroupName);
    if (workgroup == null) {
      return 0;
    }

    int count = 0;
    Connection con = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
      con = DbConnectionManager.getConnection();
      pstmt = con.prepareStatement(WORKGROUP_REQUEST_COUNT);
      pstmt.setLong(1, workgroup.getID());
      pstmt.setString(2, StringUtils.dateToMillis(startDate));
      pstmt.setString(3, StringUtils.dateToMillis(endDate));

      rs = pstmt.executeQuery();
      if (rs.next()) {
        count = rs.getInt(1);
      }
    } catch (Exception ex) {
      Log.error(ex.getMessage(), ex);
    } finally {
      DbConnectionManager.closeConnection(rs, pstmt, con);
    }

    return count;
  }
  /**
   * Deletes the specified offline message in the store for a user. The way to identify the message
   * to delete is based on the creationDate and username.
   *
   * @param username the username of the user who's message is going to be deleted.
   * @param creationDate the date when the offline message was stored in the database.
   */
  public void deleteMessage(String username, Date creationDate) {
    Connection con = null;
    PreparedStatement pstmt = null;
    try {
      con = DbConnectionManager.getConnection();
      pstmt = con.prepareStatement(DELETE_OFFLINE_MESSAGE);
      pstmt.setString(1, username);
      pstmt.setString(2, StringUtils.dateToMillis(creationDate));
      pstmt.executeUpdate();

      // Force a refresh for next call to getSize(username),
      // it's easier than loading the message to be deleted just
      // to update the cache.
      removeUsernameFromSizeCache(username);
    } catch (Exception e) {
      Log.error(
          "Error deleting offline messages of username: "******" creationDate: "
              + creationDate,
          e);
    } finally {
      DbConnectionManager.closeConnection(pstmt, con);
    }
  }
  /**
   * Adds a message to this message store. Messages will be stored and made available for later
   * delivery.
   *
   * @param message the message to store.
   */
  public void addMessage(Message message) {
    if (message == null) {
      return;
    }
    if (!shouldStoreMessage(message)) {
      return;
    }
    JID recipient = message.getTo();
    String username = recipient.getNode();
    // If the username is null (such as when an anonymous user), don't store.
    if (username == null || !UserManager.getInstance().isRegisteredUser(recipient)) {
      return;
    } else if (!XMPPServer.getInstance()
        .getServerInfo()
        .getXMPPDomain()
        .equals(recipient.getDomain())) {
      // Do not store messages sent to users of remote servers
      return;
    }

    long messageID = SequenceManager.nextID(JiveConstants.OFFLINE);

    // Get the message in XML format.
    String msgXML = message.getElement().asXML();

    Connection con = null;
    PreparedStatement pstmt = null;
    try {
      con = DbConnectionManager.getConnection();
      pstmt = con.prepareStatement(INSERT_OFFLINE);
      pstmt.setString(1, username);
      pstmt.setLong(2, messageID);
      pstmt.setString(3, StringUtils.dateToMillis(new java.util.Date()));
      pstmt.setInt(4, msgXML.length());
      pstmt.setString(5, msgXML);
      pstmt.executeUpdate();
    } catch (Exception e) {
      Log.error(LocaleUtils.getLocalizedString("admin.error"), e);
    } finally {
      DbConnectionManager.closeConnection(pstmt, con);
    }

    // Update the cached size if it exists.
    if (sizeCache.containsKey(username)) {
      int size = sizeCache.get(username);
      size += msgXML.length();
      sizeCache.put(username, size);
    }
  }
示例#4
0
 public void setCreationDate(String username, Date creationDate) throws UserNotFoundException {
   Connection con = null;
   PreparedStatement pstmt = null;
   try {
     con = DbConnectionManager.getConnection();
     pstmt = con.prepareStatement(UPDATE_CREATION_DATE);
     pstmt.setString(1, StringUtils.dateToMillis(creationDate));
     pstmt.setString(2, username);
     pstmt.executeUpdate();
   } catch (SQLException sqle) {
     throw new UserNotFoundException(sqle);
   } finally {
     DbConnectionManager.closeConnection(pstmt, con);
   }
 }
示例#5
0
  /**
   * Returns the number of canceled requests.
   *
   * @param workgroupName the workgroup to search
   * @param startDate the time to begin the search from.
   * @param endDate the time to end the search.
   * @return the total number of requests
   */
  public static long getTotalWaitTimeForWorkgroup(
      String workgroupName, Date startDate, Date endDate) {
    Workgroup workgroup = null;
    try {
      workgroup = WorkgroupManager.getInstance().getWorkgroup(new JID(workgroupName));
    } catch (Exception ex) {
      Log.error(ex.getMessage(), ex);
    }
    if (workgroup == null) {
      return 0;
    }

    int waitTime = 0;
    Connection con = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
      con = DbConnectionManager.getConnection();
      pstmt = con.prepareStatement(WORKGROUP_WAIT_TIME);
      pstmt.setLong(1, workgroup.getID());
      // Set the state the ignored requests.
      pstmt.setInt(2, 1);
      pstmt.setString(2, StringUtils.dateToMillis(startDate));
      pstmt.setString(3, StringUtils.dateToMillis(endDate));

      rs = pstmt.executeQuery();
      rs.next();
      waitTime = rs.getInt(1);
    } catch (Exception ex) {
      Log.error(ex.getMessage(), ex);
    } finally {
      DbConnectionManager.closeConnection(rs, pstmt, con);
    }

    return waitTime;
  }
示例#6
0
 public void setCreationDate(String username, Date creationDate) throws UserNotFoundException {
   if (isReadOnly()) {
     // Reject the operation since the provider is read-only
     throw new UnsupportedOperationException();
   }
   Connection con = null;
   PreparedStatement pstmt = null;
   try {
     con = DbConnectionManager.getConnection();
     pstmt = con.prepareStatement(UPDATE_CREATION_DATE);
     pstmt.setString(1, StringUtils.dateToMillis(creationDate));
     pstmt.setString(2, username);
     pstmt.executeUpdate();
   } catch (SQLException sqle) {
     throw new UserNotFoundException(sqle);
   } finally {
     DbConnectionManager.closeConnection(pstmt, con);
   }
 }
 /**
  * Returns the offline message of the specified user with the given creation date. The returned
  * message will NOT be deleted from the database.
  *
  * @param username the username of the user who's message you'd like to receive.
  * @param creationDate the date when the offline message was stored in the database.
  * @return the offline message of the specified user with the given creation stamp.
  */
 public OfflineMessage getMessage(String username, Date creationDate) {
   OfflineMessage message = null;
   Connection con = null;
   PreparedStatement pstmt = null;
   ResultSet rs = null;
   SAXReader xmlReader = null;
   try {
     // Get a sax reader from the pool
     xmlReader = xmlReaders.take();
     con = DbConnectionManager.getConnection();
     pstmt = con.prepareStatement(LOAD_OFFLINE_MESSAGE);
     pstmt.setString(1, username);
     pstmt.setString(2, StringUtils.dateToMillis(creationDate));
     rs = pstmt.executeQuery();
     while (rs.next()) {
       String msgXML = rs.getString(1);
       message =
           new OfflineMessage(
               creationDate, xmlReader.read(new StringReader(msgXML)).getRootElement());
       // Add a delayed delivery (XEP-0203) element to the message.
       Element delay = message.addChildElement("delay", "urn:xmpp:delay");
       delay.addAttribute("from", XMPPServer.getInstance().getServerInfo().getXMPPDomain());
       delay.addAttribute("stamp", XMPPDateTimeFormat.format(creationDate));
     }
   } catch (Exception e) {
     Log.error(
         "Error retrieving offline messages of username: "******" creationDate: "
             + creationDate,
         e);
   } finally {
     // Return the sax reader to the pool
     if (xmlReader != null) {
       xmlReaders.add(xmlReader);
     }
     DbConnectionManager.closeConnection(rs, pstmt, con);
   }
   return message;
 }
示例#8
0
  public User createUser(String username, String password, String name, String email)
      throws UserAlreadyExistsException {
    if (isReadOnly()) {
      // Reject the operation since the provider is read-only
      throw new UnsupportedOperationException();
    }
    try {
      loadUser(username);
      // The user already exists since no exception, so:
      throw new UserAlreadyExistsException("Username " + username + " already exists");
    } catch (UserNotFoundException unfe) {
      // The user doesn't already exist so we can create a new user

      // Determine if the password should be stored as plain text or encrypted.
      boolean usePlainPassword = JiveGlobals.getBooleanProperty("user.usePlainPassword");
      String encryptedPassword = null;
      if (!usePlainPassword) {
        try {
          encryptedPassword = AuthFactory.encryptPassword(password);
          // Set password to null so that it's inserted that way.
          password = null;
        } catch (UnsupportedOperationException uoe) {
          // Encrypting the password may have failed if in setup mode. Therefore,
          // use the plain password.
        }
      }

      Date now = new Date();
      Connection con = null;
      PreparedStatement pstmt = null;
      try {
        con = DbConnectionManager.getConnection();
        pstmt = con.prepareStatement(INSERT_USER);
        pstmt.setString(1, username);
        if (password == null) {
          pstmt.setNull(2, Types.VARCHAR);
        } else {
          pstmt.setString(2, password);
        }
        if (encryptedPassword == null) {
          pstmt.setNull(3, Types.VARCHAR);
        } else {
          pstmt.setString(3, encryptedPassword);
        }
        if (name == null) {
          pstmt.setNull(4, Types.VARCHAR);
        } else {
          pstmt.setString(4, name);
        }
        if (email == null) {
          pstmt.setNull(5, Types.VARCHAR);
        } else {
          pstmt.setString(5, email);
        }
        pstmt.setString(6, StringUtils.dateToMillis(now));
        pstmt.setString(7, StringUtils.dateToMillis(now));
        pstmt.execute();
      } catch (Exception e) {
        Log.error(LocaleUtils.getLocalizedString("admin.error"), e);
      } finally {
        DbConnectionManager.closeConnection(pstmt, con);
      }
      return new User(username, name, email, now, now);
    }
  }