1  /*
     2   * Copyright (c) 2003-2006, Simon Brown
     3   * All rights reserved.
     4   *
     5   * Redistribution and use in source and binary forms, with or without
     6   * modification, are permitted provided that the following conditions are met:
     7   *
     8   *   - Redistributions of source code must retain the above copyright
     9   *     notice, this list of conditions and the following disclaimer.
    10   *
    11   *   - Redistributions in binary form must reproduce the above copyright
    12   *     notice, this list of conditions and the following disclaimer in
    13   *     the documentation and/or other materials provided with the
    14   *     distribution.
    15   *
    16   *   - Neither the name of Pebble nor the names of its contributors may
    17   *     be used to endorse or promote products derived from this software
    18   *     without specific prior written permission.
    19   *
    20   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    21   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    22   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    23   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    24   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    25   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    26   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    27   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    28   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    29   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    30   * POSSIBILITY OF SUCH DAMAGE.
    31   */
    32  package net.sourceforge.pebble.index;
    33  
    34  import org.apache.commons.logging.Log;
    35  import org.apache.commons.logging.LogFactory;
    36  import net.sourceforge.pebble.domain.Blog;
    37  import net.sourceforge.pebble.domain.Tag;
    38  import net.sourceforge.pebble.domain.BlogEntry;
    39  
    40  import java.util.*;
    41  import java.io.*;
    42  
    43  /**
    44   * Represents the tag index for a blog.
    45   *
    46   * @author    Simon Brown
    47   */
    48  public class EmailSubscriptionList {
    49  
           /* 
    P/P     *  Method: net.sourceforge.pebble.index.EmailSubscriptionList__static_init
            * 
            *  Postconditions:
            *    init'ed(log)
            */
    50    private static final Log log = LogFactory.getLog(EmailSubscriptionList.class);
    51  
    52    private Blog blog;
    53  
    54    /** the list of e-mail addresses */
    55    private List<String> emailAddresses = new LinkedList<String>();
    56  
           /* 
    P/P     *  Method: void net.sourceforge.pebble.index.EmailSubscriptionList(Blog)
            * 
            *  Preconditions:
            *    blog != null
            * 
            *  Postconditions:
            *    this.blog == blog
            *    this.blog != null
            *    this.emailAddresses == &new LinkedList(EmailSubscriptionList#1)
            *    new LinkedList(EmailSubscriptionList#1) num objects == 1
            */
    57    public EmailSubscriptionList(Blog blog) {
    58      this.blog = blog;
    59  
    60      readIndex();
    61    }
    62  
    63    /**
    64     * Clears the index.
    65     */
    66    public void clear() {
             /* 
    P/P       *  Method: void clear()
              * 
              *  Preconditions:
              *    (soft) this.blog != null
              * 
              *  Postconditions:
              *    this.emailAddresses == &new LinkedList(clear#1)
              *    new LinkedList(clear#1) num objects == 1
              */
    67      emailAddresses = new LinkedList<String>();
    68      writeIndex();
    69    }
    70  
    71    /**
    72     * Adds an e-mail address.
    73     *
    74     * @param emailAddress    an e-mail address
    75     */
    76    public synchronized void addEmailAddress(String emailAddress) {
             /* 
    P/P       *  Method: void addEmailAddress(String)
              * 
              *  Preconditions:
              *    this.emailAddresses != null
              *    (soft) this.blog != null
              * 
              *  Test Vectors:
              *    java.util.List:contains(...)@77: {1}, {0}
              */
    77      if (!emailAddresses.contains(emailAddress)) {
    78        emailAddresses.add(emailAddress);
    79        writeIndex();
    80      }
    81    }
    82  
    83    /**
    84     * Removes an e-mail address.
    85     *
    86     * @param emailAddress    an e-mail address
    87     */
    88    public synchronized void removeEmailAddress(String emailAddress) {
             /* 
    P/P       *  Method: void removeEmailAddress(String)
              * 
              *  Preconditions:
              *    this.emailAddresses != null
              *    (soft) this.blog != null
              */
    89      emailAddresses.remove(emailAddress);
    90      writeIndex();
    91    }
    92  
    93    /**
    94     * Helper method to load the index.
    95     */
    96    private void readIndex() {
             /* 
    P/P       *  Method: void readIndex()
              * 
              *  Preconditions:
              *    this.blog != null
              *    (soft) this.emailAddresses != null
              * 
              *  Presumptions:
              *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
              * 
              *  Test Vectors:
              *    java.io.File:exists(...)@98: {0}, {1}
              */
    97      File indexFile = new File(blog.getIndexesDirectory(), "email-subscriptions.index");
    98      if (indexFile.exists()) {
    99        try {
   100          BufferedReader reader = new BufferedReader(new FileReader(indexFile));
   101          String emailAddress = reader.readLine();
   102          while (emailAddress != null) {
   103            emailAddresses.add(emailAddress);
   104            emailAddress = reader.readLine();
   105          }
   106  
   107          reader.close();
   108        } catch (Exception e) {
   109          log.error("Error while reading index", e);
   110        }
   111      }
   112    }
   113  
   114    /**
   115     * Helper method to write out the index to disk.
   116     */
   117    private void writeIndex() {
   118      try {
               /* 
    P/P         *  Method: void writeIndex()
                * 
                *  Preconditions:
                *    (soft) this.blog != null
                *    (soft) this.emailAddresses != null
                * 
                *  Presumptions:
                *    org.apache.commons.logging.LogFactory:getLog(...)@50 != null
                * 
                *  Test Vectors:
                *    java.util.Iterator:hasNext(...)@122: {1}, {0}
                */
   119        File indexFile = new File(blog.getIndexesDirectory(), "email-subscriptions.index");
   120        BufferedWriter writer = new BufferedWriter(new FileWriter(indexFile));
   121  
   122        for (String emailAddress : emailAddresses) {
   123          writer.write(emailAddress);
   124          writer.newLine();
   125        }
   126  
   127        writer.flush();
   128        writer.close();
   129      } catch (Exception e) {
   130        log.error("Error while writing index", e);
   131      }
   132    }
   133  
   134    /**
   135     * Gets the list of e-mail addresses.
   136     */
   137    public List<String> getEmailAddresses() {
             /* 
    P/P       *  Method: List getEmailAddresses()
              * 
              *  Preconditions:
              *    init'ed(this.emailAddresses)
              * 
              *  Postconditions:
              *    return_value == &new ArrayList(getEmailAddresses#1)
              *    new ArrayList(getEmailAddresses#1) num objects == 1
              */
   138      List list = new ArrayList<String>(emailAddresses);
   139      Collections.sort(list);
   140      return list;
   141    }
   142  
   143  }