PHP script to remove e-mail addresses from a comma-separated list [closed]

Answer 1

If I understand your question correctly, this is what you are attempting to achieve.

• Check to see if the user has posted from a form.
  • Get the email. (You should ensure that it is a sane value in this step)
  • Retrieve the member data.
  • Check to see if the user is on the list.
    • Remove the user and save the data if applicable.
  • Output the result of the function.
• Display a message with form to submit to self.

I know this can be done as a very simple task, but I don't trust that approach. Additionally, I think anything interacting with permanent storage of data should have some mild to moderate form of abstraction.

I would approach that task this way.

class MailingList {

    const EMAIL_OK = 1;
    const ERR_EMAIL_EXISTS = -1;
    const ERR_EMAIL_INVALID = -2;
    const ERR_EMAIL_NOTFOUND = -3;

    protected $_db_src;
    protected $_db_opt;
    protected $members = array(); // An array intended to hold members.

    public function email_exists($email) {
        return array_key_exists($this->members, $email);
    }

    public function remove_email($email) {
        $this->_sanitize_email($email);

        if ($email) {
            if (array_key_exists($this->members, $email)) {
                unset($this->members[$email]);
                $this->_update_members();
                return self::EMAIL_OK;
            } else {
                return self::ERR_EMAIL_NOTFOUND;
            }
        } else {
            return self::ERR_EMAIL_INVALID;
        }
    }

    public function add_email($email) {
        $this->_sanitize_email($email);

        if ($email) {
            if (array_key_exists($this->members) {
                return self::ERR_EMAIL_EXISTS;
            } else {
                $this->members[$email] = -1;
                $this->_save_members();
                $this->_load_members();
                return self::EMAIL_OK;
            }
        } else {
            return self::ERR_EMAIL_INVALID;
        }
    }

    // We expect a data source and options for the
    //     data source upon instantiation.
    // This is to prepare this class for abstraction and allow it to be
    //     extended to databases.

    public function __construct($data_source = "flatfile", $data_options = "email.txt") {
        $this->_db_src = $data_source;
        $this->_db_opt = $data_options;

        $this->_load_members();
    }

    protected function _load_members() {
        // Create the function name to ensure it exists.
        $data_function = "handle_" . $this->_db_src;
        if (!method_exists(&$this, $this->_db_src)) {
            throw new Exception('Invalid data source');
        }

        // Build our array of parameters to be sent to our handler function.
        $parameters = array_merge(array('load'), (array) $this->_db_opt);

        // This calls our data function with a load action parameter.
        // This is written to expect the data function to populate $this->members.
        return call_user_func_array(array(&$this, $data_function), $parameters);
    }

    // Most of this is similar to the constructor as far as data handling goes.
    protected function _save_members() {
        // Create the function name to ensure it exists.
        $data_function = "handle_" . $this->_db_src;
        if (!method_exists(&$this, $this->_db_src)) {
            throw new Exception('Invalid data source');
        }

        // Set up our data options with a save action.
        $parameters = array_merge(array('save'), (array) $this->_db_opt);

        return call_user_func_array(array(&$this, $data_function), $parameters);
    }

    // The heart of the storage engine, designed for CSV data.
    protected function handle_flatfile($action, $filename) {
        switch ($action) {
            case "load":
                // Make sure we can load members.
                if (!is_readable($filename)) {
                    throw new Exception("File: $filename, is not readable");
                }
                // Open our data file and load the information.
                // Populate $this->members as an array just the way we expect it.
                $this->members = array_flip(explode(',', file_get_contents($filename)));
                break;
            case "save":
                // Make sure we can write to the file before we move forward.
                if (!is_writeable($filename)) {
                    throw new Exception("File $filename, is now writable");
                }
                // Convert our array back to a CSV string and write it to the file.
                $status = file_put_contents($filename, implode(',', array_flip($this->members)));
                // If we failed to write to the file make sure something is done before we continue.
                if (!$status) {
                    throw new Exception("Writing to file failed!");
                }
                break;
            default:
                throw new Exception("Unknown action called on data handler.");
        }
    }

    // converts email addresses to lowercase to avoid duplication.
    // should add a regex filter here to ensure that we have a valid address
    protected function _sanitize_email(&$email) {
        $email = strtolower($email);
    }

}

function show_form() {
    echo '
' . PHP_EOL
       . 'Email Address:  
' . PHP_EOL
       . '' . PHP_EOL
       . '
';
}

if (isset($_POST) && isset($_POST['email'])) {
    $list = new MailingList();
    $status = $list->remove_email($_POST['email']);

    switch ($status) {
        case MalingList::EMAIL_OK:
            echo "
Your email was successfully removed.
";
            break;
        case MailingList::ERR_EMAIL_INVALID:
            echo "
The email address provided was invalid.
";
        case MailingList::ERR_EMAIL_NOTFOUND:
            echo "
The email address provided was not registered.
";
        default:
            show_form();
    }
} else {
    show_form();
}