/** * 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); }