/**
* Creates a list of recipients containing all active subscribers.
*
* @throws RuntimeExcpetion
*
* @return NewsletterRecipientList
*/
public static function createInstanceActiveSubscribers()
{
$recipientList = new self();
$activeSubscribers = SubscriberPeer::retrieveSubscribed();
if (!empty($activeSubscribers)) {
/* @var $eachSubscriber Subscriber */
foreach ($activeSubscribers as $eachSubscriber) {
$recipientList->addBcc($eachSubscriber->getSwiftAddress());
}
return $recipientList;
} else {
throw new RuntimeException('There are no active subscribers.');
}
}
protected function execute($arguments = array(), $options = array())
{
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'] ? $options['connection'] : null)->getConnection();
$criteria = new Criteria(SubscriberPeer::DATABASE_NAME);
$criteria->add(SubscriberPeer::CREATED_AT, new DateTime(sprintf('-%d days', self::INACTIVE_DAYS)), Criteria::LESS_EQUAL);
$subscribers = SubscriberPeer::retrievePendingActivation($criteria);
if (!empty($subscribers)) {
$this->logSection($this->name, sprintf('Removing %d subscribers.', count($subscribers)));
/* @var $eachSubscriber Subscriber */
foreach ($subscribers as $eachSubscriber) {
if ($eachSubscriber->delete($connection)) {
$this->logSection($this->name, sprintf('Could not remove subscriber with id %d.', $eachSubscriber->getId()), 'ERROR');
}
}
} else {
$this->logSection($this->name, 'No subscribers found that require deletion.');
}
}
/**
* Retrieve multiple objects by pkey.
*
* @param array $pks List of primary keys
* @param PropelPDO $con the connection to use
* @return Subscriber[]
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function retrieveByPKs($pks, PropelPDO $con = null)
{
if ($con === null) {
$con = Propel::getConnection(SubscriberPeer::DATABASE_NAME, Propel::CONNECTION_READ);
}
$objs = null;
if (empty($pks)) {
$objs = array();
} else {
$criteria = new Criteria(SubscriberPeer::DATABASE_NAME);
$criteria->add(SubscriberPeer::ID, $pks, Criteria::IN);
$objs = SubscriberPeer::doSelect($criteria, $con);
}
return $objs;
}
/**
* Find object by primary key using raw SQL to go fast.
* Bypass doSelect() and the object formatter by using generated code.
*
* @param mixed $key Primary key to use for the query
* @param PropelPDO $con A connection object
*
* @return Subscriber A model object, or null if the key is not found
* @throws PropelException
*/
protected function findPkSimple($key, $con)
{
$sql = 'SELECT `id`, `name`, `preferred_language_id`, `email`, `created_at`, `updated_at`, `created_by`, `updated_by` FROM `subscribers` WHERE `id` = :p0';
try {
$stmt = $con->prepare($sql);
$stmt->bindValue(':p0', $key, PDO::PARAM_INT);
$stmt->execute();
} catch (Exception $e) {
Propel::log($e->getMessage(), Propel::LOG_ERR);
throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
}
$obj = null;
if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
$obj = new Subscriber();
$obj->hydrate($row);
SubscriberPeer::addInstanceToPool($obj, (string) $key);
}
$stmt->closeCursor();
return $obj;
}
public function mayOperate($sOperation, $oUser = false)
{
if ($oUser === false) {
$oUser = Session::getSession()->getUser();
}
$bIsAllowed = false;
if ($oUser && ($this->isNew() || $this->getCreatedBy() === $oUser->getId()) && SubscriberPeer::mayOperateOnOwn($oUser, $this, $sOperation)) {
$bIsAllowed = true;
} else {
if (SubscriberPeer::mayOperateOn($oUser, $this, $sOperation)) {
$bIsAllowed = true;
}
}
FilterModule::getFilters()->handleSubscriberOperationCheck($sOperation, $this, $oUser, array(&$bIsAllowed));
return $bIsAllowed;
}
/**
* newsletterUnsubscribe()
*
* Description
* • check if requested url is valid
* • display opt-out options if request method is get or post is invalid
* • process unsubscribe action if the request method is post
* • cleanup subscriber membership and subscriber as fallback
*
* @return Template
*/
private function newsletterUnsubscribe()
{
if (!isset($_REQUEST['unsubscribe'])) {
return $this->constructTemplate('unsubscribe_unknown_error');
}
// Process unsubscribe opt_out form if post
$oSubscriber = SubscriberQuery::create()->filterByEmail($_REQUEST['unsubscribe'])->findOne();
if (Manager::isPost()) {
$mOutput = $this->processOptOutSuscriptions($oSubscriber);
if ($mOutput) {
return $mOutput;
}
}
// If subscriber does not exist or the required checksum is not correct, return error message
if (!($oSubscriber && $oSubscriber->getUnsubscribeChecksum() === $_REQUEST['checksum'])) {
return $this->constructTemplate('unsubscribe_unknown_error');
}
SubscriberPeer::ignoreRights(true);
// Count valid subscriptions [with display_name, not temp or import groups]
$aSubscriberGroupMemberShips = $oSubscriber->getSubscriberGroupMemberships();
$aValidSubscriptions = array();
if (count($aSubscriberGroupMemberShips) > 1) {
foreach ($aSubscriberGroupMemberShips as $oSubscriberGroupMembership) {
if ($oSubscriberGroupMembership->getSubscriberGroup()->getDisplayName() == null) {
continue;
}
$aValidSubscriptions[] = $oSubscriberGroupMembership;
}
}
// Display view with opt_out options if there is more then one valid subscription
if (count($aValidSubscriptions) > 1) {
$oTemplate = $this->constructTemplate('unsubscribe_optout_form');
$oTemplate->replaceIdentifier('checksum', $_REQUEST['checksum']);
$oTemplate->replaceIdentifier('email', $oSubscriber->getEmail());
$bIsPostAndAllUnchecked = Manager::isPost() && !isset($_POST['subscriber_group_id']);
foreach ($aValidSubscriptions as $oSubscriberGroupMemberships) {
$oCheckboxTemplate = $this->constructTemplate('unsubscribe_optout_checkbox');
$oCheckboxTemplate->replaceIdentifier('subscriber_group_id', $oSubscriberGroupMemberships->getSubscriberGroupId());
$oCheckboxTemplate->replaceIdentifier('subscriber_group_name', $oSubscriberGroupMemberships->getSubscriberGroup()->getDisplayName());
$oCheckboxTemplate->replaceIdentifier('checked', !$bIsPostAndAllUnchecked ? ' checked="checked"' : '', null, Template::NO_HTML_ESCAPE);
$oTemplate->replaceIdentifierMultiple('subscriber_group_checkbox', $oCheckboxTemplate);
}
return $oTemplate;
}
// Delete subscriber because there is not a valid subscription (all temp subscriptions are removed too)
$oSubscriber->delete();
// Display unsubscribe confirmation international
return $this->constructTemplate('unsubscribe_confirm');
}
public function executeResult()
{
$this->setLayout(false);
if ($code = $this->getRequestParameter("codeid")) {
$c = new Criteria();
$c->add(SubscriberPeer::CODE, $code);
$user = SubscriberPeer::doSelectOne($c);
if ($user) {
$user->setPublicationStatus(UtilsHelper::STATUS_ACTIVE);
//$user->setCode(null);
$user->save();
$this->msg = "Subscribtion confirmed";
} else {
$this->err = "A problem occured";
}
return "Confirm";
}
$email = trim($this->getRequestParameter('newsletter_email'));
if (!empty($email)) {
$new = false;
$c = new Criteria();
$c->add(SubscriberPeer::EMAIL, $email);
$c->add(SubscriberPeer::PUBLICATION_STATUS, UtilsHelper::STATUS_WAITING);
$subscriber = SubscriberPeer::doSelectOne($c);
if (!$subscriber) {
$subscriber = new Subscriber();
$subscriber->setLabel($email);
$subscriber->setEmail($email);
$code = md5(time());
$subscriber->setCode($code);
$new = true;
} else {
$code = $subscriber->getCode();
}
$from_name = UtilsHelper::SYSTEM_SENDER;
$from_email = UtilsHelper::NO_REPLY_MAIL;
$mail = new sfMail();
$mail->initialize();
$mail->setMailer('sendmail');
$mail->setCharset('utf-8');
$mail->setSender($from_email, $from_name);
$mail->setFrom($from_email, $from_name);
$mail->addReplyTo($from_email);
$mail->addAddress($email);
$mail->addBcc(UtilsHelper::COPY_MAIL);
$mail->setContentType('text/html');
$mail->setSubject('Newsletter subscribtion');
$resultPage = Document::getDocumentByExclusiveTag('website_page_newsletter_result');
if ($resultPage) {
$resultPageHref = $resultPage->getHref();
}
$request = $this->getRequest();
$request->setParameter('activationUrl', $resultPageHref . "?codeid=" . $code);
$body = $this->getPresentationFor("newsletter", "confirmMail");
$mail->setBody($body);
try {
$mail->send();
$defMailinglist = Document::getDocumentByExclusiveTag('newsletter_mailinglist_default');
if ($defMailinglist && $new) {
$subscriber->save(null, $defMailinglist);
$subscriber->setPublicationStatus(UtilsHelper::STATUS_WAITING, true);
}
$this->msg = "Subscribtion successfull, check your email";
} catch (Exception $e) {
$this->getRequest()->setError('newsletter_email', "A problem occured");
}
} else {
$this->getRequest()->setError('newsletter_email', "Please enter your email");
$this->form = true;
}
}
$browser->responseContains('An email has been sent to you, in order to verify your address.');
$limeTest->plan += 3;
$subscriber = SubscriberPeer::retrieveByEmail($email);
$limeTest->isa_ok($subscriber, 'Subscriber', 'Subscriber found.');
$limeTest->is($subscriber->getName(), $name, 'Name matches.');
$limeTest->is($subscriber->getEmail(), $email, 'Email matches.');
$limeTest->plan += 3;
$activationHash = $subscriber->getActivateHash();
$unsubscribeHash = $subscriber->getUnsubscribeHash();
$limeTest->isnt(empty($activationHash), true, 'Activation Hash set.');
$limeTest->isnt(empty($unsubscribeHash), true, 'Unsubscribe Hash set.');
$limeTest->isnt($subscriber->isSubscribed(), true, 'Subscriber is not activated, yet.');
# test activation and unsubscribe with fixtures
$limeTest->plan += 1;
$subscriber = SubscriberPeer::retrieveByEmail('*****@*****.**');
$limeTest->ok(!$subscriber->isSubscribed(), 'Subscriber not activated, yet.');
$browser->getAndCheck('sfSubscription', 'activate', '/newsletter/subscription/activate/' . $subscriber->getId() * 42 . '?' . activateAction::PARAMETER_NAME . '=invalid', 404);
$browser->getAndCheck('sfSubscription', 'activate', '/newsletter/subscription/activate/' . $subscriber->getId() . '?' . activateAction::PARAMETER_NAME . '=5uhj32l4', 200);
$browser->isRequestParameter('id', $subscriber->getId());
$browser->isRequestParameter(activateAction::PARAMETER_NAME, '5uhj32l4');
$browser->responseContains('Your email address has been verified.');
$limeTest->plan += 1;
$subscriber = SubscriberPeer::retrieveByEmail('*****@*****.**');
$limeTest->ok($subscriber->isSubscribed(), 'Subscriber activated.');
$browser->getAndCheck('sfSubscription', 'unsubscribe', '/newsletter/subscription/unsubscribe/' . urlencode($subscriber->getEmail()) . '?' . unsubscribeAction::PARAMETER_NAME . '=asd87324', 200);
$browser->isRequestParameter('email', $subscriber->getEmail());
$browser->isRequestParameter(unsubscribeAction::PARAMETER_NAME, 'asd87324');
$browser->responseContains('Your email address has been unsubscribed from the newsletter.');
$limeTest->plan += 1;
$subscriber = SubscriberPeer::retrieveByEmail('*****@*****.**');
$limeTest->ok(!$subscriber->isSubscribed(), 'Subscriber unsubscribed again.');
<?php
require_once dirname(__FILE__) . '/../bootstrap/task.php';
# load fixtures of this plugin
$propelData->loadData(sfConfig::get('sf_plugins_dir') . '/sfNewsletterPlugin/data/fixtures');
$limeTest = new lime_test(2, new lime_output_color());
$task = new RemoveInactiveSubscribersTask($dispatcher, $formatter);
$task->run(array(), array());
$logs = $logger->getLogEntries();
$limeTest->like($logs[0], '/No subscribers found that require deletion./', 'No subscribers to delete.');
$subscribers = SubscriberPeer::retrievePendingActivation();
$datetime = new DateTime(sprintf('-%d days', RemoveInactiveSubscribersTask::INACTIVE_DAYS + 2));
/* @var $eachSubscriber Subscriber */
foreach ($subscribers as $eachSubscriber) {
$eachSubscriber->setCreatedAt($datetime)->save();
}
$task = new RemoveInactiveSubscribersTask($dispatcher, $formatter);
$task->run(array(), array());
$logs = $logger->getLogEntries();
$limeTest->like($logs[1], '/Removing 2 subscribers./', 'Deleted both subscribers.');
public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
{
$keys = SubscriberPeer::getFieldNames($keyType);
if (array_key_exists($keys[0], $arr)) {
$this->setId($arr[$keys[0]]);
}
if (array_key_exists($keys[1], $arr)) {
$this->setLabel($arr[$keys[1]]);
}
if (array_key_exists($keys[2], $arr)) {
$this->setEmail($arr[$keys[2]]);
}
if (array_key_exists($keys[3], $arr)) {
$this->setCode($arr[$keys[3]]);
}
if (array_key_exists($keys[4], $arr)) {
$this->setCreatedAt($arr[$keys[4]]);
}
if (array_key_exists($keys[5], $arr)) {
$this->setUpdatedAt($arr[$keys[5]]);
}
if (array_key_exists($keys[6], $arr)) {
$this->setPublicationStatus($arr[$keys[6]]);
}
}
$requestData = array('name' => 'Too short', 'email' => '*****@*****.**');
$form->bind($requestData);
$limeTest->ok($form->hasErrors(), 'The form contains errors.');
$limeTest->is(count($form->getErrorSchema()->getNamedErrors()), 1, 'Contains one error.');
/* @var $eachError sfValidatorError */
foreach ($form->getErrorSchema()->getNamedErrors() as $field => $eachError) {
switch ($field) {
case 'name':
$limeTest->like($eachError->getMessage(), '/too short/', 'Name is too short.');
break;
}
}
$form = new sfSubscribeForm();
$requestData = array('name' => 'One valid name', 'email' => '*****@*****.**');
$form->bind($requestData);
$limeTest->ok($form->isValid(), 'The form contains no errors.');
$limeTest->ok($form->save(), 'The form has been saved.');
$subscriber = SubscriberPeer::retrieveByEmail('*****@*****.**');
$limeTest->is($subscriber->getName(), 'One valid name', 'Subscriber found.');
$form = new sfSubscribeForm();
$requestData = array('name' => 'Another valid name', 'email' => '*****@*****.**');
$form->bind($requestData);
$limeTest->ok($form->hasErrors(), 'The form contains errors.');
try {
$form->save();
$limeTest->fail('The second form should not be saved.');
} catch (Exception $e) {
$limeTest->is($e->getCode(), 'email [invalid]', 'Error code matches.');
}
$subscriber = SubscriberPeer::retrieveByEmail('*****@*****.**');
$limeTest->is($subscriber->getName(), 'One valid name', 'Subscriber found.');
/**
* Selects a collection of SubscriberGroupMembership objects pre-filled with all related objects except UserRelatedByUpdatedBy.
*
* @param Criteria $criteria
* @param PropelPDO $con
* @param String $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
* @return array Array of SubscriberGroupMembership objects.
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function doSelectJoinAllExceptUserRelatedByUpdatedBy(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
{
$criteria = clone $criteria;
// Set the correct dbName if it has not been overridden
// $criteria->getDbName() will return the same object if not set to another value
// so == check is okay and faster
if ($criteria->getDbName() == Propel::getDefaultDB()) {
$criteria->setDbName(SubscriberGroupMembershipPeer::DATABASE_NAME);
}
SubscriberGroupMembershipPeer::addSelectColumns($criteria);
$startcol2 = SubscriberGroupMembershipPeer::NUM_HYDRATE_COLUMNS;
SubscriberPeer::addSelectColumns($criteria);
$startcol3 = $startcol2 + SubscriberPeer::NUM_HYDRATE_COLUMNS;
SubscriberGroupPeer::addSelectColumns($criteria);
$startcol4 = $startcol3 + SubscriberGroupPeer::NUM_HYDRATE_COLUMNS;
$criteria->addJoin(SubscriberGroupMembershipPeer::SUBSCRIBER_ID, SubscriberPeer::ID, $join_behavior);
$criteria->addJoin(SubscriberGroupMembershipPeer::SUBSCRIBER_GROUP_ID, SubscriberGroupPeer::ID, $join_behavior);
$stmt = BasePeer::doSelect($criteria, $con);
$results = array();
while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
$key1 = SubscriberGroupMembershipPeer::getPrimaryKeyHashFromRow($row, 0);
if (null !== ($obj1 = SubscriberGroupMembershipPeer::getInstanceFromPool($key1))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj1->hydrate($row, 0, true); // rehydrate
} else {
$cls = SubscriberGroupMembershipPeer::getOMClass();
$obj1 = new $cls();
$obj1->hydrate($row);
SubscriberGroupMembershipPeer::addInstanceToPool($obj1, $key1);
}
// if obj1 already loaded
// Add objects for joined Subscriber rows
$key2 = SubscriberPeer::getPrimaryKeyHashFromRow($row, $startcol2);
if ($key2 !== null) {
$obj2 = SubscriberPeer::getInstanceFromPool($key2);
if (!$obj2) {
$cls = SubscriberPeer::getOMClass();
$obj2 = new $cls();
$obj2->hydrate($row, $startcol2);
SubscriberPeer::addInstanceToPool($obj2, $key2);
}
// if $obj2 already loaded
// Add the $obj1 (SubscriberGroupMembership) to the collection in $obj2 (Subscriber)
$obj2->addSubscriberGroupMembership($obj1);
}
// if joined row is not null
// Add objects for joined SubscriberGroup rows
$key3 = SubscriberGroupPeer::getPrimaryKeyHashFromRow($row, $startcol3);
if ($key3 !== null) {
$obj3 = SubscriberGroupPeer::getInstanceFromPool($key3);
if (!$obj3) {
$cls = SubscriberGroupPeer::getOMClass();
$obj3 = new $cls();
$obj3->hydrate($row, $startcol3);
SubscriberGroupPeer::addInstanceToPool($obj3, $key3);
}
// if $obj3 already loaded
// Add the $obj1 (SubscriberGroupMembership) to the collection in $obj3 (SubscriberGroup)
$obj3->addSubscriberGroupMembership($obj1);
}
// if joined row is not null
$results[] = $obj1;
}
$stmt->closeCursor();
return $results;
}
public static function mayOperateOn($oUser, $mObject, $sOperation)
{
return SubscriberPeer::mayOperateOn($oUser, $mObject->getSubscriber(), $sOperation);
}
