/**
   * 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);
    }
  }
 /**
  * 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;
 }
 /**
  * Returns the instance of <tt>OfflineMessageStore</tt> being used by the XMPPServer.
  *
  * @return the instance of <tt>OfflineMessageStore</tt> being used by the XMPPServer.
  */
 public static OfflineMessageStore getInstance() {
   return XMPPServer.getInstance().getOfflineMessageStore();
 }
  /**
   * Returns a Collection of all messages in the store for a user. Messages may be deleted after
   * being selected from the database depending on the delete param.
   *
   * @param username the username of the user who's messages you'd like to receive.
   * @param delete true if the offline messages should be deleted.
   * @return An iterator of packets containing all offline messages.
   */
  public Collection<OfflineMessage> getMessages(String username, boolean delete) {
    List<OfflineMessage> messages = new ArrayList<>();
    SAXReader xmlReader = null;
    Connection con = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
      // Get a sax reader from the pool
      xmlReader = xmlReaders.take();
      con = DbConnectionManager.getConnection();
      pstmt = con.prepareStatement(LOAD_OFFLINE);
      pstmt.setString(1, username);
      rs = pstmt.executeQuery();
      while (rs.next()) {
        String msgXML = rs.getString(1);
        Date creationDate = new Date(Long.parseLong(rs.getString(2).trim()));
        OfflineMessage message;
        try {
          message =
              new OfflineMessage(
                  creationDate, xmlReader.read(new StringReader(msgXML)).getRootElement());
        } catch (DocumentException e) {
          // Try again after removing invalid XML chars (e.g. &#12;)
          Matcher matcher = pattern.matcher(msgXML);
          if (matcher.find()) {
            msgXML = matcher.replaceAll("");
          }
          try {
            message =
                new OfflineMessage(
                    creationDate, xmlReader.read(new StringReader(msgXML)).getRootElement());
          } catch (DocumentException de) {
            Log.error("Failed to route packet (offline message): " + msgXML, de);
            continue; // skip and process remaining offline messages
          }
        }

        // if there is already a delay stamp, we shouldn't add another.
        Element delaytest = message.getChildElement("delay", "urn:xmpp:delay");
        if (delaytest == null) {
          // 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));
        }
        messages.add(message);
      }
      // Check if the offline messages loaded should be deleted, and that there are
      // messages to delete.
      if (delete && !messages.isEmpty()) {
        PreparedStatement pstmt2 = null;
        try {
          pstmt2 = con.prepareStatement(DELETE_OFFLINE);
          pstmt2.setString(1, username);
          pstmt2.executeUpdate();
          removeUsernameFromSizeCache(username);
        } catch (Exception e) {
          Log.error("Error deleting offline messages of username: "******"Error retrieving offline messages of username: " + username, e);
    } finally {
      DbConnectionManager.closeConnection(rs, pstmt, con);
      // Return the sax reader to the pool
      if (xmlReader != null) {
        xmlReaders.add(xmlReader);
      }
    }
    return messages;
  }