/**
  * Helper Function - set mail from address
  * @param $request PKPRequest
  * @param MailTemplate $mail
  */
 function _setMailFrom($request, &$mail)
 {
     $site = $request->getSite();
     $press = $request->getPress();
     // Set the sender based on the current context
     if ($press && $press->getSetting('supportEmail')) {
         $mail->setReplyTo($press->getSetting('supportEmail'), $press->getSetting('supportName'));
     } else {
         $mail->setReplyTo($site->getLocalizedContactEmail(), $site->getLocalizedContactName());
     }
 }
Ejemplo n.º 2
0
 function sendReminder($subscription, $journal, $emailKey)
 {
     $userDao = DAORegistry::getDAO('UserDAO');
     $subscriptionTypeDao = DAORegistry::getDAO('SubscriptionTypeDAO');
     $journalName = $journal->getLocalizedName();
     $user = $userDao->getById($subscription->getUserId());
     if (!isset($user)) {
         return false;
     }
     $subscriptionType = $subscriptionTypeDao->getSubscriptionType($subscription->getTypeId());
     $subscriptionName = $journal->getSetting('subscriptionName');
     $subscriptionEmail = $journal->getSetting('subscriptionEmail');
     $subscriptionPhone = $journal->getSetting('subscriptionPhone');
     $subscriptionMailingAddress = $journal->getSetting('subscriptionMailingAddress');
     $subscriptionContactSignature = $subscriptionName;
     AppLocale::requireComponents(LOCALE_COMPONENT_PKP_USER, LOCALE_COMPONENT_APP_COMMON);
     if ($subscriptionMailingAddress != '') {
         $subscriptionContactSignature .= "\n" . $subscriptionMailingAddress;
     }
     if ($subscriptionPhone != '') {
         $subscriptionContactSignature .= "\n" . AppLocale::Translate('user.phone') . ': ' . $subscriptionPhone;
     }
     $subscriptionContactSignature .= "\n" . AppLocale::Translate('user.email') . ': ' . $subscriptionEmail;
     $paramArray = array('subscriberName' => $user->getFullName(), 'journalName' => $journalName, 'subscriptionType' => $subscriptionType->getSummaryString(), 'expiryDate' => $subscription->getDateEnd(), 'username' => $user->getUsername(), 'subscriptionContactSignature' => $subscriptionContactSignature);
     import('lib.pkp.classes.mail.MailTemplate');
     $mail = new MailTemplate($emailKey, $journal->getPrimaryLocale(), $journal, false);
     $mail->setReplyTo($subscriptionEmail, $subscriptionName);
     $mail->addRecipient($user->getEmail(), $user->getFullName());
     $mail->setSubject($mail->getSubject($journal->getPrimaryLocale()));
     $mail->setBody($mail->getBody($journal->getPrimaryLocale()));
     $mail->assignParams($paramArray);
     $mail->send();
 }
 function sendNotification($users, $journal, $issue)
 {
     if ($users->getCount() != 0) {
         import('lib.pkp.classes.mail.MailTemplate');
         $email = new MailTemplate('OPEN_ACCESS_NOTIFY', $journal->getPrimaryLocale());
         $email->setSubject($email->getSubject($journal->getPrimaryLocale()));
         $email->setReplyTo(null);
         $email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
         $paramArray = array('journalName' => $journal->getLocalizedName(), 'journalUrl' => Request::url($journal->getPath()), 'editorialContactSignature' => $journal->getSetting('contactName') . "\n" . $journal->getLocalizedName());
         $email->assignParams($paramArray);
         $publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
         $publishedArticles = $publishedArticleDao->getPublishedArticlesInSections($issue->getId());
         $mimeBoundary = '==boundary_' . md5(microtime());
         $templateMgr = TemplateManager::getManager();
         $templateMgr->assign('body', $email->getBody($journal->getPrimaryLocale()));
         $templateMgr->assign('templateSignature', $journal->getSetting('emailSignature'));
         $templateMgr->assign('mimeBoundary', $mimeBoundary);
         $templateMgr->assign('issue', $issue);
         $templateMgr->assign('publishedArticles', $publishedArticles);
         $email->addHeader('MIME-Version', '1.0');
         $email->setContentType('multipart/alternative; boundary="' . $mimeBoundary . '"');
         $email->setBody($templateMgr->fetch('subscription/openAccessNotifyEmail.tpl'));
         while ($user = $users->next()) {
             $email->addBcc($user->getEmail(), $user->getFullName());
         }
         $email->send();
     }
 }
 /**
  * Send email to a book for review author
  */
 function sendReminder($book, $journal, $emailKey)
 {
     $journalId = $journal->getId();
     $paramArray = array('authorName' => strip_tags($book->getUserFullName()), 'bookForReviewTitle' => '"' . strip_tags($book->getLocalizedTitle()) . '"', 'bookForReviewDueDate' => date('l, F j, Y', strtotime($book->getDateDue())), 'submissionUrl' => Request::url(null, 'author', 'submit'), 'editorialContactSignature' => strip_tags($book->getEditorContactSignature()));
     import('classes.mail.MailTemplate');
     $mail = new MailTemplate($emailKey);
     $mail->setReplyTo($book->getEditorEmail(), $book->getEditorFullName());
     $mail->addRecipient($book->getUserEmail(), $book->getUserFullName());
     $mail->setSubject($mail->getSubject($journal->getPrimaryLocale()));
     $mail->setBody($mail->getBody($journal->getPrimaryLocale()));
     $mail->assignParams($paramArray);
     $mail->send();
 }
Ejemplo n.º 5
0
 /**
  * Send the email
  * @param $args array
  * @param $request PKPRequest
  */
 function execute($args, $request)
 {
     $userDao = DAORegistry::getDAO('UserDAO');
     $toUser = $userDao->getById($this->userId);
     $fromUser = $request->getUser();
     import('lib.pkp.classes.mail.MailTemplate');
     $email = new MailTemplate();
     $email->addRecipient($toUser->getEmail(), $toUser->getFullName());
     $email->setReplyTo($fromUser->getEmail(), $fromUser->getFullName());
     $email->setSubject($this->getData('subject'));
     $email->setBody($this->getData('message'));
     $email->send();
 }
 /**
  * Send email to object for review author
  * @param $ofrAssignment ObjectForReviewAssignment
  * @param $journal Journal
  * @param $emailKey string
  */
 function sendReminder($ofrAssignment, $journal, $emailKey)
 {
     $journalId = $journal->getId();
     $author =& $ofrAssignment->getUser();
     $objectForReview =& $ofrAssignment->getObjectForReview();
     $editor =& $objectForReview->getEditor();
     $paramArray = array('authorName' => strip_tags($author->getFullName()), 'objectForReviewTitle' => '"' . strip_tags($objectForReview->getTitle()) . '"', 'objectForReviewDueDate' => date('l, F j, Y', strtotime($ofrAssignment->getDateDue())), 'submissionUrl' => Request::url($journal->getPath(), 'author', 'submit'), 'editorialContactSignature' => strip_tags($editor->getContactSignature()));
     import('classes.mail.MailTemplate');
     $mail = new MailTemplate($emailKey);
     $mail->setReplyTo($editor->getEmail(), $editor->getFullName());
     $mail->addRecipient($author->getEmail(), $author->getFullName());
     $mail->setSubject($mail->getSubject($journal->getPrimaryLocale()));
     $mail->setBody($mail->getBody($journal->getPrimaryLocale()));
     $mail->assignParams($paramArray);
     $mail->send();
     $ofrAssignment->setDateReminded(Core::getCurrentDate());
     $ofrAssignmentDao =& DAORegistry::getDAO('ObjectForReviewAssignmentDAO');
     $ofrAssignmentDao->updateObject($ofrAssignment);
 }
Ejemplo n.º 7
0
 /**
  * Handle incoming requests/notifications
  * @param $args array
  * @param $request PKPRequest
  */
 function handle($args, $request)
 {
     $templateMgr = TemplateManager::getManager($request);
     $journal = $request->getJournal();
     if (!$journal) {
         return parent::handle($args, $request);
     }
     // Just in case we need to contact someone
     import('lib.pkp.classes.mail.MailTemplate');
     // Prefer technical support contact
     $contactName = $journal->getSetting('supportName');
     $contactEmail = $journal->getSetting('supportEmail');
     if (!$contactEmail) {
         // Fall back on primary contact
         $contactName = $journal->getSetting('contactName');
         $contactEmail = $journal->getSetting('contactEmail');
     }
     $mail = new MailTemplate('PAYPAL_INVESTIGATE_PAYMENT');
     $mail->setReplyTo(null);
     $mail->addRecipient($contactEmail, $contactName);
     $paymentStatus = $request->getUserVar('payment_status');
     switch (array_shift($args)) {
         case 'ipn':
             // Build a confirmation transaction.
             $req = 'cmd=_notify-validate';
             if (get_magic_quotes_gpc()) {
                 foreach ($_POST as $key => $value) {
                     $req .= '&' . urlencode(stripslashes($key)) . '=' . urlencode(stripslashes($value));
                 }
             } else {
                 foreach ($_POST as $key => $value) {
                     $req .= '&' . urlencode($key) . '=' . urlencode($value);
                 }
             }
             // Create POST response
             $ch = curl_init();
             curl_setopt($ch, CURLOPT_URL, $this->getSetting($journal->getId(), 'paypalurl'));
             curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
             curl_setopt($ch, CURLOPT_POST, 1);
             curl_setopt($ch, CURLOPT_HTTPHEADER, array('User-Agent: PKP PayPal Service', 'Content-Type: application/x-www-form-urlencoded', 'Content-Length: ' . strlen($req)));
             curl_setopt($ch, CURLOPT_POSTFIELDS, $req);
             $ret = curl_exec($ch);
             $curlError = curl_error($ch);
             curl_close($ch);
             // Check the confirmation response and handle as necessary.
             if (strcmp($ret, 'VERIFIED') == 0) {
                 switch ($paymentStatus) {
                     case 'Completed':
                         $payPalDao = DAORegistry::getDAO('PayPalDAO');
                         $transactionId = $request->getUserVar('txn_id');
                         if ($payPalDao->transactionExists($transactionId)) {
                             // A duplicate transaction was received; notify someone.
                             $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Duplicate transaction ID: {$transactionId}", 'serverVars' => print_r($_SERVER, true)));
                             $mail->send();
                             exit;
                         } else {
                             // New transaction succeeded. Record it.
                             $payPalDao->insertTransaction($transactionId, $request->getUserVar('txn_type'), String::strtolower($request->getUserVar('payer_email')), String::strtolower($request->getUserVar('receiver_email')), $request->getUserVar('item_number'), $request->getUserVar('payment_date'), $request->getUserVar('payer_id'), $request->getUserVar('receiver_id'));
                             $queuedPaymentId = $request->getUserVar('custom');
                             import('classes.payment.ojs.OJSPaymentManager');
                             $ojsPaymentManager = new OJSPaymentManager($request);
                             // Verify the cost and user details as per PayPal spec.
                             $queuedPayment =& $ojsPaymentManager->getQueuedPayment($queuedPaymentId);
                             if (!$queuedPayment) {
                                 // The queued payment entry is missing. Complain.
                                 $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Missing queued payment ID: {$queuedPaymentId}", 'serverVars' => print_r($_SERVER, true)));
                                 $mail->send();
                                 exit;
                             }
                             //NB: if/when paypal subscriptions are enabled, these checks will have to be adjusted
                             // because subscription prices may change over time
                             $queuedAmount = $queuedPayment->getAmount();
                             $grantedAmount = $request->getUserVar('mc_gross');
                             $queuedCurrency = $queuedPayment->getCurrencyCode();
                             $grantedCurrency = $request->getUserVar('mc_currency');
                             $grantedEmail = String::strtolower($request->getUserVar('receiver_email'));
                             $queuedEmail = String::strtolower($this->getSetting($journal->getId(), 'selleraccount'));
                             if ($queuedAmount != $grantedAmount && $queuedAmount > 0 || $queuedCurrency != $grantedCurrency || $grantedEmail != $queuedEmail) {
                                 // The integrity checks for the transaction failed. Complain.
                                 $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Granted amount: {$grantedAmount}\n" . "Queued amount: {$queuedAmount}\n" . "Granted currency: {$grantedCurrency}\n" . "Queued currency: {$queuedCurrency}\n" . "Granted to PayPal account: {$grantedEmail}\n" . "Configured PayPal account: {$queuedEmail}", 'serverVars' => print_r($_SERVER, true)));
                                 $mail->send();
                                 exit;
                             }
                             // Update queued amount if amount set by user (e.g. donation)
                             if ($queuedAmount == 0 && $grantedAmount > 0) {
                                 $queuedPaymentDao = DAORegistry::getDAO('QueuedPaymentDAO');
                                 $queuedPayment->setAmount($grantedAmount);
                                 $queuedPayment->setCurrencyCode($grantedCurrency);
                                 $queuedPaymentDao->updateQueuedPayment($queuedPaymentId, $queuedPayment);
                             }
                             // Fulfill the queued payment.
                             if ($ojsPaymentManager->fulfillQueuedPayment($request, $queuedPayment, $this->getName())) {
                                 exit;
                             }
                             // If we're still here, it means the payment couldn't be fulfilled.
                             $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Queued payment ID {$queuedPaymentId} could not be fulfilled.", 'serverVars' => print_r($_SERVER, true)));
                             $mail->send();
                         }
                         exit;
                     case 'Pending':
                         // Ignore.
                         exit;
                     default:
                         // An unhandled payment status was received; notify someone.
                         $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Payment status: {$paymentStatus}", 'serverVars' => print_r($_SERVER, true)));
                         $mail->send();
                         exit;
                 }
             } else {
                 // An unknown confirmation response was received; notify someone.
                 $mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Confirmation return: {$ret}\nCURL error: {$curlError}", 'serverVars' => print_r($_SERVER, true)));
                 $mail->send();
                 exit;
             }
         case 'cancel':
             Handler::setupTemplate();
             $templateMgr->assign(array('currentUrl' => $request->url(null, 'index'), 'pageTitle' => 'plugins.paymethod.paypal.purchase.cancelled.title', 'message' => 'plugins.paymethod.paypal.purchase.cancelled', 'backLink' => $request->getUserVar('ojsReturnUrl'), 'backLinkLabel' => 'common.continue'));
             $templateMgr->display('frontend/pages/message.tpl');
             exit;
     }
     parent::handle($args, $request);
     // Don't know what to do with it
 }
Ejemplo n.º 8
0
 /**
  * Send notification email to Subscription Manager when online payment is completed.
  */
 function sendOnlinePaymentNotificationEmail($request, &$subscription, $mailTemplateKey)
 {
     $validKeys = array('SUBSCRIPTION_PURCHASE_INDL', 'SUBSCRIPTION_PURCHASE_INSTL', 'SUBSCRIPTION_RENEW_INDL', 'SUBSCRIPTION_RENEW_INSTL');
     if (!in_array($mailTemplateKey, $validKeys)) {
         return false;
     }
     $journal = $request->getJournal();
     $subscriptionContactName = $journal->getSetting('subscriptionName');
     $subscriptionContactEmail = $journal->getSetting('subscriptionEmail');
     if (empty($subscriptionContactEmail)) {
         $subscriptionContactEmail = $journal->getSetting('contactEmail');
         $subscriptionContactName = $journal->getSetting('contactName');
     }
     if (empty($subscriptionContactEmail)) {
         return false;
     }
     $userDao = DAORegistry::getDAO('UserDAO');
     $user = $userDao->getById($subscription->getUserId());
     $subscriptionTypeDao = DAORegistry::getDAO('SubscriptionTypeDAO');
     $subscriptionType =& $subscriptionTypeDao->getSubscriptionType($subscription->getTypeId());
     $roleDao = DAORegistry::getDAO('RoleDAO');
     $role = $roleDao->newDataObject();
     if ($roleDao->getJournalUsersRoleCount($journal->getId(), ROLE_ID_SUBSCRIPTION_MANAGER) > 0) {
         $role->setId(ROLE_ID_SUBSCRIPTION_MANAGER);
         $rolePath = $role->getPath();
     } else {
         $role->setId(ROLE_ID_MANAGER);
         $rolePath = $role->getPath();
     }
     $paramArray = array('subscriptionType' => $subscriptionType->getSummaryString(), 'userDetails' => $user->getContactSignature(), 'membership' => $subscription->getMembership());
     switch ($mailTemplateKey) {
         case 'SUBSCRIPTION_PURCHASE_INDL':
         case 'SUBSCRIPTION_RENEW_INDL':
             $paramArray['subscriptionUrl'] = $request->url($journal->getPath(), $rolePath, 'editSubscription', 'individual', array($subscription->getId()));
             break;
         case 'SUBSCRIPTION_PURCHASE_INSTL':
         case 'SUBSCRIPTION_RENEW_INSTL':
             $paramArray['subscriptionUrl'] = $request->rl($journal->getPath(), $rolePath, 'editSubscription', 'institutional', array($subscription->getId()));
             $paramArray['institutionName'] = $subscription->getInstitutionName();
             $paramArray['institutionMailingAddress'] = $subscription->getInstitutionMailingAddress();
             $paramArray['domain'] = $subscription->getDomain();
             $paramArray['ipRanges'] = $subscription->getIPRangesString();
             break;
     }
     import('lib.pkp.classes.mail.MailTemplate');
     $mail = new MailTemplate($mailTemplateKey);
     $mail->setReplyTo($subscriptionContactEmail, $subscriptionContactName);
     $mail->addRecipient($subscriptionContactEmail, $subscriptionContactName);
     $mail->setSubject($mail->getSubject($journal->getPrimaryLocale()));
     $mail->setBody($mail->getBody($journal->getPrimaryLocale()));
     $mail->assignParams($paramArray);
     $mail->send();
 }
Ejemplo n.º 9
0
 /**
  * Register a new user.
  */
 function execute()
 {
     $userDao =& DAORegistry::getDAO('UserDAO');
     $journal =& Request::getJournal();
     if (isset($this->userId)) {
         $user =& $userDao->getById($this->userId);
     }
     if (!isset($user)) {
         $user = new User();
     }
     $user->setSalutation($this->getData('salutation'));
     $user->setFirstName($this->getData('firstName'));
     $user->setMiddleName($this->getData('middleName'));
     $user->setLastName($this->getData('lastName'));
     $user->setInitials($this->getData('initials'));
     $user->setGender($this->getData('gender'));
     $user->setAffiliation($this->getData('affiliation'), null);
     // Localized
     $user->setSignature($this->getData('signature'), null);
     // Localized
     $user->setEmail($this->getData('email'));
     $user->setData('orcid', $this->getData('orcid'));
     $user->setUrl($this->getData('userUrl'));
     $user->setPhone($this->getData('phone'));
     $user->setFax($this->getData('fax'));
     $user->setMailingAddress($this->getData('mailingAddress'));
     $user->setCountry($this->getData('country'));
     $user->setBiography($this->getData('biography'), null);
     // Localized
     $user->setGossip($this->getData('gossip'), null);
     // Localized
     $user->setMustChangePassword($this->getData('mustChangePassword') ? 1 : 0);
     $user->setAuthId((int) $this->getData('authId'));
     $site =& Request::getSite();
     $availableLocales = $site->getSupportedLocales();
     $locales = array();
     foreach ($this->getData('userLocales') as $locale) {
         if (AppLocale::isLocaleValid($locale) && in_array($locale, $availableLocales)) {
             array_push($locales, $locale);
         }
     }
     $user->setLocales($locales);
     if ($user->getAuthId()) {
         $authDao =& DAORegistry::getDAO('AuthSourceDAO');
         $auth =& $authDao->getPlugin($user->getAuthId());
     }
     if ($user->getId() != null) {
         $userId = $user->getId();
         if ($this->getData('password') !== '') {
             if (isset($auth)) {
                 $auth->doSetUserPassword($user->getUsername(), $this->getData('password'));
                 $user->setPassword(Validation::encryptCredentials($userId, Validation::generatePassword()));
                 // Used for PW reset hash only
             } else {
                 $user->setPassword(Validation::encryptCredentials($user->getUsername(), $this->getData('password')));
             }
         }
         if (isset($auth)) {
             // FIXME Should try to create user here too?
             $auth->doSetUserInfo($user);
         }
         $userDao->updateObject($user);
     } else {
         $user->setUsername($this->getData('username'));
         if ($this->getData('generatePassword')) {
             $password = Validation::generatePassword();
             $sendNotify = true;
         } else {
             $password = $this->getData('password');
             $sendNotify = $this->getData('sendNotify');
         }
         if (isset($auth)) {
             $user->setPassword($password);
             // FIXME Check result and handle failures
             $auth->doCreateUser($user);
             $user->setAuthId($auth->authId);
             $user->setPassword(Validation::encryptCredentials($user->getId(), Validation::generatePassword()));
             // Used for PW reset hash only
         } else {
             $user->setPassword(Validation::encryptCredentials($this->getData('username'), $password));
         }
         $user->setDateRegistered(Core::getCurrentDate());
         $userId = $userDao->insertUser($user);
         $isManager = Validation::isJournalManager();
         if (!empty($this->_data['enrollAs'])) {
             foreach ($this->getData('enrollAs') as $roleName) {
                 // Enroll new user into an initial role
                 $roleDao =& DAORegistry::getDAO('RoleDAO');
                 $roleId = $roleDao->getRoleIdFromPath($roleName);
                 if (!$isManager && $roleId != ROLE_ID_READER) {
                     continue;
                 }
                 if ($roleId != null) {
                     $role = new Role();
                     $role->setJournalId($journal->getId());
                     $role->setUserId($userId);
                     $role->setRoleId($roleId);
                     $roleDao->insertRole($role);
                 }
             }
         }
         if ($sendNotify) {
             // Send welcome email to user
             import('classes.mail.MailTemplate');
             $mail = new MailTemplate('USER_REGISTER');
             $mail->setReplyTo(null);
             $mail->assignParams(array('username' => $this->getData('username'), 'password' => $password, 'userFullName' => $user->getFullName()));
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->send();
         }
     }
     // Insert the user interests
     $interests = $this->getData('interestsKeywords') ? $this->getData('interestsKeywords') : $this->getData('interestsTextOnly');
     import('lib.pkp.classes.user.InterestManager');
     $interestManager = new InterestManager();
     $interestManager->setInterestsForUser($user, $interests);
 }
Ejemplo n.º 10
0
 /**
  * Create or update a user.
  * @param $args array
  * @param $request PKPRequest
  */
 function &execute($args, $request)
 {
     parent::execute($request);
     $userDao = DAORegistry::getDAO('UserDAO');
     $context = $request->getContext();
     if (isset($this->userId)) {
         $userId = $this->userId;
         $user = $userDao->getById($userId);
     }
     if (!isset($user)) {
         $user = $userDao->newDataObject();
         $user->setInlineHelp(1);
         // default new users to having inline help visible
     }
     $user->setSalutation($this->getData('salutation'));
     $user->setFirstName($this->getData('firstName'));
     $user->setMiddleName($this->getData('middleName'));
     $user->setLastName($this->getData('lastName'));
     $user->setSuffix($this->getData('suffix'));
     $user->setInitials($this->getData('initials'));
     $user->setGender($this->getData('gender'));
     $user->setAffiliation($this->getData('affiliation'), null);
     // Localized
     $user->setSignature($this->getData('signature'), null);
     // Localized
     $user->setEmail($this->getData('email'));
     $user->setUrl($this->getData('userUrl'));
     $user->setPhone($this->getData('phone'));
     $user->setOrcid($this->getData('orcid'));
     $user->setMailingAddress($this->getData('mailingAddress'));
     $user->setCountry($this->getData('country'));
     $user->setBiography($this->getData('biography'), null);
     // Localized
     $user->setMustChangePassword($this->getData('mustChangePassword') ? 1 : 0);
     $user->setAuthId((int) $this->getData('authId'));
     $site = $request->getSite();
     $availableLocales = $site->getSupportedLocales();
     $locales = array();
     foreach ($this->getData('userLocales') as $locale) {
         if (AppLocale::isLocaleValid($locale) && in_array($locale, $availableLocales)) {
             array_push($locales, $locale);
         }
     }
     $user->setLocales($locales);
     if ($user->getAuthId()) {
         $authDao = DAORegistry::getDAO('AuthSourceDAO');
         $auth =& $authDao->getPlugin($user->getAuthId());
     }
     if ($user->getId() != null) {
         if ($this->getData('password') !== '') {
             if (isset($auth)) {
                 $auth->doSetUserPassword($user->getUsername(), $this->getData('password'));
                 $user->setPassword(Validation::encryptCredentials($user->getId(), Validation::generatePassword()));
                 // Used for PW reset hash only
             } else {
                 $user->setPassword(Validation::encryptCredentials($user->getUsername(), $this->getData('password')));
             }
         }
         if (isset($auth)) {
             // FIXME Should try to create user here too?
             $auth->doSetUserInfo($user);
         }
         $userDao->updateObject($user);
     } else {
         $user->setUsername($this->getData('username'));
         if ($this->getData('generatePassword')) {
             $password = Validation::generatePassword();
             $sendNotify = true;
         } else {
             $password = $this->getData('password');
             $sendNotify = $this->getData('sendNotify');
         }
         if (isset($auth)) {
             $user->setPassword($password);
             // FIXME Check result and handle failures
             $auth->doCreateUser($user);
             $user->setAuthId($auth->authId);
             $user->setPassword(Validation::encryptCredentials($user->getId(), Validation::generatePassword()));
             // Used for PW reset hash only
         } else {
             $user->setPassword(Validation::encryptCredentials($this->getData('username'), $password));
         }
         $user->setDateRegistered(Core::getCurrentDate());
         $userId = $userDao->insertObject($user);
         if ($sendNotify) {
             // Send welcome email to user
             import('lib.pkp.classes.mail.MailTemplate');
             $mail = new MailTemplate('USER_REGISTER');
             $mail->setReplyTo($context->getSetting('contactEmail'), $context->getSetting('contactName'));
             $mail->assignParams(array('username' => $this->getData('username'), 'password' => $password, 'userFullName' => $user->getFullName()));
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->send();
         }
     }
     import('lib.pkp.classes.user.InterestManager');
     $interestManager = new InterestManager();
     $interestManager->setInterestsForUser($user, $this->getData('interests'));
     return $user;
 }
Ejemplo n.º 11
0
 /**
  * Internal function to prepare notification email
  * @param $emailTemplateKey string
  */
 function _prepareNotificationEmail($mailTemplateKey)
 {
     $userDao = DAORegistry::getDAO('UserDAO');
     $subscriptionTypeDao = DAORegistry::getDAO('SubscriptionTypeDAO');
     $journalSettingsDao = DAORegistry::getDAO('JournalSettingsDAO');
     $journal = Request::getJournal();
     $journalName = $journal->getLocalizedTitle();
     $journalId = $journal->getId();
     $user = $userDao->getById($this->subscription->getUserId());
     $subscriptionType =& $subscriptionTypeDao->getSubscriptionType($this->subscription->getTypeId());
     $subscriptionName = $journalSettingsDao->getSetting($journalId, 'subscriptionName');
     $subscriptionEmail = $journalSettingsDao->getSetting($journalId, 'subscriptionEmail');
     $subscriptionPhone = $journalSettingsDao->getSetting($journalId, 'subscriptionPhone');
     $subscriptionMailingAddress = $journalSettingsDao->getSetting($journalId, 'subscriptionMailingAddress');
     $subscriptionContactSignature = $subscriptionName;
     if ($subscriptionMailingAddress != '') {
         $subscriptionContactSignature .= "\n" . $subscriptionMailingAddress;
     }
     if ($subscriptionPhone != '') {
         $subscriptionContactSignature .= "\n" . __('user.phone') . ': ' . $subscriptionPhone;
     }
     $subscriptionContactSignature .= "\n" . __('user.email') . ': ' . $subscriptionEmail;
     $paramArray = array('subscriberName' => $user->getFullName(), 'journalName' => $journalName, 'subscriptionType' => $subscriptionType->getSummaryString(), 'username' => $user->getUsername(), 'subscriptionContactSignature' => $subscriptionContactSignature);
     import('lib.pkp.classes.mail.MailTemplate');
     $mail = new MailTemplate($mailTemplateKey);
     $mail->setReplyTo($subscriptionEmail, $subscriptionName);
     $mail->addRecipient($user->getEmail(), $user->getFullName());
     $mail->setSubject($mail->getSubject($journal->getPrimaryLocale()));
     $mail->setBody($mail->getBody($journal->getPrimaryLocale()));
     $mail->assignParams($paramArray);
     return $mail;
 }
Ejemplo n.º 12
0
 /**
  * Fulfill a queued payment.
  * @param $request PKPRequest
  * @param $queuedPayment QueuedPayment
  * @param $payMethodPluginName string Name of payment plugin.
  * @return mixed Dependent on payment type.
  */
 function fulfillQueuedPayment($request, &$queuedPayment, $payMethodPluginName = null)
 {
     $returner = false;
     if ($queuedPayment) {
         switch ($queuedPayment->getType()) {
             case PAYMENT_TYPE_MEMBERSHIP:
                 $userDao = DAORegistry::getDAO('UserDAO');
                 $user =& $userDao->getById($queuedPayment->getuserId());
                 $userDao->renewMembership($user);
                 $returner = true;
                 break;
             case PAYMENT_TYPE_PURCHASE_SUBSCRIPTION:
                 $subscriptionId = $queuedPayment->getAssocId();
                 $institutionalSubscriptionDao = DAORegistry::getDAO('InstitutionalSubscriptionDAO');
                 $individualSubscriptionDao = DAORegistry::getDAO('IndividualSubscriptionDAO');
                 if ($institutionalSubscriptionDao->subscriptionExists($subscriptionId)) {
                     $subscription =& $institutionalSubscriptionDao->getSubscription($subscriptionId);
                     $institutional = true;
                 } else {
                     $subscription =& $individualSubscriptionDao->getSubscription($subscriptionId);
                     $institutional = false;
                 }
                 if (!$subscription || $subscription->getUserId() != $queuedPayment->getUserId() || $subscription->getJournalId() != $queuedPayment->getJournalId()) {
                     // FIXME: Is this supposed to be here?
                     error_log(print_r($subscription, true));
                     return false;
                 }
                 // Update subscription end date now that payment is completed
                 if ($institutional) {
                     // Still requires approval from JM/SM since includes domain and IP ranges
                     import('classes.subscription.InstitutionalSubscription');
                     $subscription->setStatus(SUBSCRIPTION_STATUS_NEEDS_APPROVAL);
                     if ($subscription->isNonExpiring()) {
                         $institutionalSubscriptionDao->updateSubscription($subscription);
                     } else {
                         $institutionalSubscriptionDao->renewSubscription($subscription);
                     }
                     // Notify JM/SM of completed online purchase
                     $journalSettingsDao = DAORegistry::getDAO('JournalSettingsDAO');
                     if ($journalSettingsDao->getSetting($subscription->getJournalId(), 'enableSubscriptionOnlinePaymentNotificationPurchaseInstitutional')) {
                         import('classes.subscription.SubscriptionAction');
                         SubscriptionAction::sendOnlinePaymentNotificationEmail($request, $subscription, 'SUBSCRIPTION_PURCHASE_INSTL');
                     }
                 } else {
                     import('classes.subscription.IndividualSubscription');
                     $subscription->setStatus(SUBSCRIPTION_STATUS_ACTIVE);
                     if ($subscription->isNonExpiring()) {
                         $individualSubscriptionDao->updateSubscription($subscription);
                     } else {
                         $individualSubscriptionDao->renewSubscription($subscription);
                     }
                     // Notify JM/SM of completed online purchase
                     $journalSettingsDao = DAORegistry::getDAO('JournalSettingsDAO');
                     if ($journalSettingsDao->getSetting($subscription->getJournalId(), 'enableSubscriptionOnlinePaymentNotificationPurchaseIndividual')) {
                         import('classes.subscription.SubscriptionAction');
                         SubscriptionAction::sendOnlinePaymentNotificationEmail($request, $subscription, 'SUBSCRIPTION_PURCHASE_INDL');
                     }
                 }
                 $returner = true;
                 break;
             case PAYMENT_TYPE_RENEW_SUBSCRIPTION:
                 $subscriptionId = $queuedPayment->getAssocId();
                 $institutionalSubscriptionDao = DAORegistry::getDAO('InstitutionalSubscriptionDAO');
                 $individualSubscriptionDao = DAORegistry::getDAO('IndividualSubscriptionDAO');
                 if ($institutionalSubscriptionDao->subscriptionExists($subscriptionId)) {
                     $subscription =& $institutionalSubscriptionDao->getSubscription($subscriptionId);
                     $institutional = true;
                 } else {
                     $subscription =& $individualSubscriptionDao->getSubscription($subscriptionId);
                     $institutional = false;
                 }
                 if (!$subscription || $subscription->getUserId() != $queuedPayment->getUserId() || $subscription->getJournalId() != $queuedPayment->getJournalId()) {
                     // FIXME: Is this supposed to be here?
                     error_log(print_r($subscription, true));
                     return false;
                 }
                 if ($institutional) {
                     $institutionalSubscriptionDao->renewSubscription($subscription);
                     // Notify JM/SM of completed online purchase
                     $journalSettingsDao = DAORegistry::getDAO('JournalSettingsDAO');
                     if ($journalSettingsDao->getSetting($subscription->getJournalId(), 'enableSubscriptionOnlinePaymentNotificationRenewInstitutional')) {
                         import('classes.subscription.SubscriptionAction');
                         SubscriptionAction::sendOnlinePaymentNotificationEmail($request, $subscription, 'SUBSCRIPTION_RENEW_INSTL');
                     }
                 } else {
                     $individualSubscriptionDao->renewSubscription($subscription);
                     // Notify JM/SM of completed online purchase
                     $journalSettingsDao = DAORegistry::getDAO('JournalSettingsDAO');
                     if ($journalSettingsDao->getSetting($subscription->getJournalId(), 'enableSubscriptionOnlinePaymentNotificationRenewIndividual')) {
                         import('classes.subscription.SubscriptionAction');
                         SubscriptionAction::sendOnlinePaymentNotificationEmail($request, $subscription, 'SUBSCRIPTION_RENEW_INDL');
                     }
                 }
                 $returner = true;
                 break;
             case PAYMENT_TYPE_FASTTRACK:
                 $articleDao = DAORegistry::getDAO('ArticleDAO');
                 $article = $articleDao->getById($queuedPayment->getAssocId(), $queuedPayment->getJournalId());
                 $article->setFastTracked(true);
                 $articleDao->updateObject($article);
                 $returner = true;
                 break;
             case PAYMENT_TYPE_GIFT:
                 $giftId = $queuedPayment->getAssocId();
                 $giftDao = DAORegistry::getDAO('GiftDAO');
                 $gift =& $giftDao->getGift($giftId);
                 if (!$gift) {
                     return false;
                 }
                 $password = null;
                 // Suppress scrutinizer warn
                 $journalDao = DAORegistry::getDAO('JournalDAO');
                 $journalId = $gift->getAssocId();
                 $journal = $journalDao->getById($journalId);
                 if (!$journal) {
                     return false;
                 }
                 // Check if user account corresponding to recipient email exists in the system
                 $userDao = DAORegistry::getDAO('UserDAO');
                 $roleDao = DAORegistry::getDAO('RoleDAO');
                 $recipientFirstName = $gift->getRecipientFirstName();
                 $recipientEmail = $gift->getRecipientEmail();
                 $newUserAccount = false;
                 if ($userDao->userExistsByEmail($recipientEmail)) {
                     // User already has account, check if enrolled as reader in journal
                     $user = $userDao->getUserByEmail($recipientEmail);
                     $userId = $user->getId();
                     if (!$roleDao->userHasRole($journalId, $userId, ROLE_ID_READER)) {
                         // User not enrolled as reader, enroll as reader
                         $role = new Role();
                         $role->setJournalId($journalId);
                         $role->setUserId($userId);
                         $role->setRoleId(ROLE_ID_READER);
                         $roleDao->insertRole($role);
                     }
                 } else {
                     // User does not have an account. Create one and enroll as reader.
                     $recipientLastName = $gift->getRecipientLastName();
                     $username = Validation::suggestUsername($recipientFirstName, $recipientLastName);
                     $password = Validation::generatePassword();
                     $user = $userDao->newDataObject();
                     $user->setUsername($username);
                     $user->setPassword(Validation::encryptCredentials($username, $password));
                     $user->setFirstName($recipientFirstName);
                     $user->setMiddleName($gift->getRecipientMiddleName());
                     $user->setLastName($recipientLastName);
                     $user->setEmail($recipientEmail);
                     $user->setDateRegistered(Core::getCurrentDate());
                     $userDao->insertObject($user);
                     $userId = $user->getId();
                     $role = new Role();
                     $role->setJournalId($journalId);
                     $role->setUserId($userId);
                     $role->setRoleId(ROLE_ID_READER);
                     $roleDao->insertRole($role);
                     $newUserAccount = true;
                 }
                 // Update gift status (make it redeemable) and add recipient user account reference
                 import('classes.gift.Gift');
                 $gift->setStatus(GIFT_STATUS_NOT_REDEEMED);
                 $gift->setRecipientUserId($userId);
                 $giftDao->updateObject($gift);
                 // Send gift available email to recipient, cc buyer
                 $giftNoteTitle = $gift->getGiftNoteTitle();
                 $buyerFullName = $gift->getBuyerFullName();
                 $giftNote = $gift->getGiftNote();
                 $giftLocale = $gift->getLocale();
                 AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON, $giftLocale);
                 $giftDetails = $gift->getGiftName($giftLocale);
                 $giftJournalName = $journal->getName($giftLocale);
                 $giftContactSignature = $journal->getSetting('contactName');
                 import('lib.pkp.classes.mail.MailTemplate');
                 $mail = new MailTemplate('GIFT_AVAILABLE', $giftLocale);
                 $mail->setReplyTo(null);
                 $mail->assignParams(array('giftJournalName' => $giftJournalName, 'giftNoteTitle' => $giftNoteTitle, 'recipientFirstName' => $recipientFirstName, 'buyerFullName' => $buyerFullName, 'giftDetails' => $giftDetails, 'giftNote' => $giftNote, 'giftContactSignature' => $giftContactSignature));
                 $mail->addRecipient($recipientEmail, $user->getFullName());
                 $mail->addCc($gift->getBuyerEmail(), $gift->getBuyerFullName());
                 $mail->send();
                 unset($mail);
                 // Send gift login details to recipient
                 $params = array('giftJournalName' => $giftJournalName, 'recipientFirstName' => $recipientFirstName, 'buyerFullName' => $buyerFullName, 'giftDetails' => $giftDetails, 'giftUrl' => $request->url($journal->getPath(), 'user', 'gifts'), 'username' => $user->getUsername(), 'giftContactSignature' => $giftContactSignature);
                 if ($newUserAccount) {
                     $mail = new MailTemplate('GIFT_USER_REGISTER', $giftLocale);
                     $params['password'] = $password;
                 } else {
                     $mail = new MailTemplate('GIFT_USER_LOGIN', $giftLocale);
                 }
                 $mail->setReplyTo(null);
                 $mail->assignParams($params);
                 $mail->addRecipient($recipientEmail, $user->getFullName());
                 $mail->send();
                 unset($mail);
                 $returner = true;
                 break;
             case PAYMENT_TYPE_PURCHASE_ARTICLE:
             case PAYMENT_TYPE_PURCHASE_ISSUE:
             case PAYMENT_TYPE_DONATION:
             case PAYMENT_TYPE_SUBMISSION:
             case PAYMENT_TYPE_PUBLICATION:
                 $returner = true;
                 break;
             default:
                 // Invalid payment type
                 assert(false);
         }
     }
     $completedPaymentDao = DAORegistry::getDAO('OJSCompletedPaymentDAO');
     $completedPayment =& $this->createCompletedPayment($queuedPayment, $payMethodPluginName);
     $completedPaymentDao->insertCompletedPayment($completedPayment);
     $queuedPaymentDao = DAORegistry::getDAO('QueuedPaymentDAO');
     $queuedPaymentDao->deleteQueuedPayment($queuedPayment->getId());
     return $returner;
 }
 /**
  * Static function to send an email to a mailing list user e.g. regarding signup
  * @param $request PKPRequest
  * @param $email string
  * @param $token string the user's token (for confirming and unsubscribing)
  * @param $template string The mail template to use
  */
 function sendMailingListEmail(&$request, $email, $token, $template)
 {
     import('classes.mail.MailTemplate');
     $site = $request->getSite();
     $router =& $request->getRouter();
     $dispatcher =& $router->getDispatcher();
     $params = array('siteTitle' => $site->getLocalizedTitle(), 'unsubscribeLink' => $dispatcher->url($request, ROUTE_PAGE, null, 'notification', 'unsubscribeMailList', array($token)));
     if ($template == 'NOTIFICATION_MAILLIST_WELCOME') {
         $router =& $request->getRouter();
         $dispatcher =& $router->getDispatcher();
         $confirmLink = $dispatcher->url($request, ROUTE_PAGE, null, 'notification', 'confirmMailListSubscription', array($token));
         $params["confirmLink"] = $confirmLink;
     }
     $mail = new MailTemplate($template);
     $mail->setReplyTo($site->getLocalizedContactEmail(), $site->getLocalizedContactName());
     $mail->assignParams($params);
     $mail->addRecipient($email);
     $mail->send();
 }
Ejemplo n.º 14
0
 /**
  * Handle incoming requests/notifications
  * @param $args array
  * @param $request PKPRequest
  */
 function handle($args, &$request)
 {
     $user =& $request->getUser();
     $templateMgr =& TemplateManager::getManager();
     $journal =& $request->getJournal();
     if (!$journal) {
         return parent::handle($args, $request);
     }
     // Just in case we need to contact someone
     import('classes.mail.MailTemplate');
     // Prefer technical support contact
     $contactName = $journal->getSetting('supportName');
     $contactEmail = $journal->getSetting('supportEmail');
     if (!$contactEmail) {
         // Fall back on primary contact
         $contactName = $journal->getSetting('contactName');
         $contactEmail = $journal->getSetting('contactEmail');
     }
     $mail = new MailTemplate('DPS_INVESTIGATE_PAYMENT');
     $mail->setReplyTo(null);
     $mail->addRecipient($contactEmail, $contactName);
     $paymentStatus = $request->getUserVar('payment_status');
     @session_start();
     switch (array_shift($args)) {
         case 'purchase':
             error_log("Forming XML for transaction API call");
             try {
                 # get access to queuedPayment
                 $orderId = $_SESSION['dps_plugin_payment_id'];
                 import('classes.payment.ojs.OJSPaymentManager');
                 $ojsPaymentManager = new OJSPaymentManager($request);
                 $queuedPayment =& $ojsPaymentManager->getQueuedPayment($orderId);
                 if (!$queuedPayment) {
                     throw new Exception("OJS: DPS: No order for this transaction or transaction ID lost from session. See DPS statement for OJS order number: TxnData1.");
                 }
                 $amount = sprintf("%01.2f", $queuedPayment->amount);
                 $domDoc = new DOMDocument('1.0', 'UTF-8');
                 $rootElt = $domDoc->createElement('GenerateRequest');
                 $rootNode = $domDoc->appendChild($rootElt);
                 $rootNode->appendChild($domDoc->createElement('PxPayUserId', $this->getSetting($journal->getId(), 'dpsuser')));
                 $rootNode->appendChild($domDoc->createElement('PxPayKey', $this->getSetting($journal->getId(), 'dpskey')));
                 $rootNode->appendChild($domDoc->createElement('MerchantReference', $this->getSetting($journal->getId(), 'dpsmerchant')));
                 $rootNode->appendChild($domDoc->createElement('AmountInput', $amount));
                 $rootNode->appendChild($domDoc->createElement('CurrencyInput', 'NZD'));
                 $rootNode->appendChild($domDoc->createElement('TxnType', 'Purchase'));
                 $rootNode->appendChild($domDoc->createElement('TxnData1', $orderId));
                 $rootNode->appendChild($domDoc->createElement('TxnData2', $user->getUserName()));
                 $rootNode->appendChild($domDoc->createElement('EmailAddress', $user->getEmail()));
                 $rootNode->appendChild($domDoc->createElement('UrlSuccess', $request->url(null, 'payment', 'plugin', array($this->getName(), 'success'))));
                 $rootNode->appendChild($domDoc->createElement('UrlFail', $request->url(null, 'payment', 'plugin', array($this->getName(), 'failure'))));
                 $xmlRequest = $domDoc->saveXML();
                 if (!$xmlRequest) {
                     throw new Exception("DPS: Generating XML API call failed ", "119");
                 }
                 error_log("xmlrequest: " . print_r($xmlRequest, true));
                 $ch = curl_init();
                 curl_setopt($ch, CURLOPT_URL, $this->getSetting($journal->getId(), 'dpsurl'));
                 curl_setopt($ch, CURLOPT_POST, 1);
                 curl_setopt($ch, CURLOPT_POSTFIELDS, $domDoc->saveXML());
                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                 curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 1);
                 curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
                 curl_setopt($ch, CURLOPT_CAINFO, $this->getSetting($journal->getId(), 'dpscertpath'));
                 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
                 curl_setopt($ch, CURLOPT_TIMEOUT, 10);
                 $result = curl_exec($ch);
                 $curlError = curl_error($ch);
                 $curlErrorNo = curl_errno($ch);
                 curl_close($ch);
                 # check that we got a response
                 if ($result == false) {
                     error_log("DPS error: {$curlError} ({$curlErrorNo})");
                     throw new Exception("DPS error: {$curlError}", $curlErrorNo);
                 }
                 # make sure response is valid.
                 error_log("Parsing response XML");
                 libxml_use_internal_errors(true);
                 $rexml = simplexml_load_string($result);
                 error_log("XML response: " . print_r($rexml, true));
                 if (!$rexml) {
                     error_log("Invalid XML response from DPS");
                     throw new Exception("Invalid XML response from DPS");
                 }
                 # check URL exists in response
                 if (!isset($rexml->URI[0])) {
                     throw new Exception("URI not returned: " . $rexml->ResponseText[0]);
                 }
                 $payment_url = (string) $rexml->URI[0];
                 # redirect to that URL
                 header("Location: {$payment_url}");
                 exit;
             } catch (exception $e) {
                 @curl_close($ch);
                 error_log("Fatal error with credit card entry stage: " . $e->getCode() . ": " . $e->getMessage());
                 # create a notification about this error
                 $params = array('contents' => "Fatal error with DPS response stage: " . $e->getMessage() . ". User:"******". Email:" . $user->getEmail() . ".");
                 if (!$this->sendNotifications($params, $request)) {
                     error_log("Failed to send notifications to journal managers");
                 }
                 AppLocale::requireComponents(LOCALE_COMPONENT_APPLICATION_COMMON);
                 $templateMgr =& TemplateManager::getManager();
                 $templateMgr->assign(array('pageTitle' => 'plugins.paymethod.dps.purchase.failure.title', 'detail' => $e->getMessage(), 'backLink' => $request->url(null, 'user', 'subscriptions')));
                 $templateMgr->display($this->getTemplatePath() . 'failure.tpl');
                 exit;
             }
             break;
         case 'success':
             try {
                 error_log("Forming XML ProcessResponse");
                 $domDoc = new DOMDocument('1.0', 'UTF-8');
                 $rootElt = $domDoc->createElement('ProcessResponse');
                 $rootNode = $domDoc->appendChild($rootElt);
                 $rootNode->appendChild($domDoc->createElement('PxPayUserId', $this->getSetting($journal->getId(), 'dpsuser')));
                 $rootNode->appendChild($domDoc->createElement('PxPayKey', $this->getSetting($journal->getId(), 'dpskey')));
                 $rootNode->appendChild($domDoc->createElement('Response', $request->getUserVar('result')));
                 $xmlRequest = $domDoc->saveXML();
                 if (!$xmlRequest) {
                     throw new Exception("Failed to generate XML transaction response");
                 }
                 # send confirmation to DPS
                 error_log("Forming curl API request");
                 $ch = curl_init();
                 curl_setopt($ch, CURLOPT_URL, $this->getSetting($journal->getId(), 'dpsurl'));
                 curl_setopt($ch, CURLOPT_POST, 1);
                 curl_setopt($ch, CURLOPT_POSTFIELDS, $domDoc->saveXML());
                 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                 curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 1);
                 curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
                 curl_setopt($ch, CURLOPT_CAINFO, $this->getSetting($journal->getId(), 'dpscertpath'));
                 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
                 curl_setopt($ch, CURLOPT_TIMEOUT, 10);
                 # check response is OK
                 $result = curl_exec($ch);
                 $curlError = curl_error($ch);
                 $curlErrorNo = curl_errno($ch);
                 curl_close($ch);
                 if ($result == false) {
                     error_log("Transaction response call failed: {$curlError} ({$curlErrorNo})");
                     throw new Exception("Transaction response call failed: {$curlError}", $curlErrorNo);
                 }
                 error_log("Processing response");
                 libxml_use_internal_errors(true);
                 $rexml = simplexml_load_string($result);
                 # check xml is valid
                 if (!$rexml) {
                     throw new Exception('Response from DPS not valid XML ', '130');
                 }
                 # check for success value
                 if ($rexml->Success[0] == null) {
                     throw new Exception('Response code not returned by DPS', '130');
                 }
                 # check for failed transaction
                 $code = (int) $rexml->Success[0];
                 if ($code != 1) {
                     throw new Exception('Transaction failed: ' . $rexml->ResponseText[0]);
                 }
                 if ($rexml->ResponseText[0] == null) {
                     throw new Exception('OJS: DPS: Response text not returned from transaction confirmation');
                 }
                 if ($rexml->TxnId[0] == null) {
                     throw new Exception('OJS: DPS: Reference number (txnId) not returned from transaction confirmation');
                 }
                 if ($rexml->MerchantReference[0] == null) {
                     throw new Exception('OJS: DPS: Merchant reference not returned from transaction confirmation');
                 }
                 # sanity / double checks
                 # get access to queuedPayment to check that details match
                 $queuedPaymentId = $_SESSION['dps_plugin_payment_id'];
                 import('classes.payment.ojs.OJSPaymentManager');
                 $ojsPaymentManager = new OJSPaymentManager($request);
                 $queuedPayment =& $ojsPaymentManager->getQueuedPayment($queuedPaymentId);
                 if (!$queuedPayment) {
                     throw new Exception("OJS: DPS: No order for this transaction or transaction ID lost from session. See DPS statement for OJS order number: TxnData1.");
                 }
                 $amount = $queuedPayment->amount;
                 $paidAmount = (string) $rexml->AmountSettlement[0];
                 $pattern = "/[0-9]+(\\.[0-9]{2})?/";
                 if ($paidAmount == null) {
                     throw new Exception('Paid amount not returned by DPS', '160');
                 }
                 if (!preg_match($pattern, $paidAmount)) {
                     # check format whether correct for paid amount, etc: no negative
                     throw new Exception('Paid amount format error: negative? badly formed decimal: ' . $paidAmount, '170');
                 }
                 # check userid returned by DPS
                 if ($rexml->TxnData2[0] == null) {
                     throw new Exception('Validation failure due to user id is not returned by DPS', '180');
                 }
                 # check user id and amount match
                 if (number_format($paidAmount, 2, '.', '') != $amount) {
                     throw new Exception('Payment amount mismatch on transaction. Expected: ' . $amount . ' got: ' . $paidAmount);
                 }
                 $userId = (string) $rexml->TxnData2[0];
                 if ($user->getUserName() != $userId) {
                     throw new Exception('User identity mismatch on transaction. Expected: ' . $user->getUserName() . ' got: ' . $userId);
                 }
                 # clear session vars - avoid replay
                 unset($_SESSION['dps_plugin_payment_id']);
                 # tick off queued payment as paid
                 if (!$ojsPaymentManager->fulfillQueuedPayment($queuedPayment, $this->getName())) {
                     throw new Exception('Could not fulill the queued payment in OJS');
                 }
                 error_log("All validation tests pass. Transaction is OK.");
                 # show success page with details
                 AppLocale::requireComponents(LOCALE_COMPONENT_PKP_COMMON, LOCALE_COMPONENT_PKP_USER, LOCALE_COMPONENT_APPLICATION_COMMON);
                 $templateMgr->assign(array('pageTitle' => 'plugins.paymethod.dps.purchase.success.title', 'message' => 'plugins.paymethod.dps.purchase.success', 'backLink' => $request->url(null, 'index'), 'backLinkLabel' => 'common.continue'));
                 $templateMgr->display($this->getTemplatePath() . 'success.tpl');
                 exit;
                 break;
             } catch (exception $e) {
                 @curl_close($ch);
                 error_log("Fatal error with payment processing stage: " . $e->getCode() . ": " . $e->getMessage());
                 # make notification
                 $params = array('contents' => "Fatal error with DPS response stage: " . $e->getMessage() . ". User:"******". Email:" . $user->getEmail() . ".");
                 if (!$this->sendNotifications($params, $request)) {
                     error_log("Failed to send notifications to journal managers");
                 }
                 # render failure page to user
                 AppLocale::requireComponents(LOCALE_COMPONENT_APPLICATION_COMMON);
                 $templateMgr =& TemplateManager::getManager();
                 $templateMgr->assign(array('pageTitle' => 'plugins.paymethod.dps.purchase.failure.title', 'detail' => $e->getMessage(), 'backLink' => $request->url(null, 'user', 'subscriptions')));
                 $templateMgr->display($this->getTemplatePath() . 'failure.tpl');
                 exit;
             }
             break;
             # DPS requested our failure URL - eg user canceled form
         # DPS requested our failure URL - eg user canceled form
         case 'failure':
             AppLocale::requireComponents(LOCALE_COMPONENT_APPLICATION_COMMON);
             $templateMgr =& TemplateManager::getManager();
             $templateMgr->assign(array('pageTitle' => 'plugins.paymethod.dps.purchase.failure.title', 'backLink' => $request->url(null, 'user', 'subscriptions')));
             $templateMgr->display($this->getTemplatePath() . 'cancel.tpl');
             break;
     }
     parent::handle($args, $request);
     // Don't know what to do with it
 }
 /**
  * Save review assignment
  * @param $args array
  * @param $request PKPRequest
  */
 function execute($args, $request)
 {
     $userDao = DAORegistry::getDAO('UserDAO');
     $user = $userDao->newDataObject();
     $user->setFirstName($this->getData('firstName'));
     $user->setMiddleName($this->getData('middleName'));
     $user->setLastName($this->getData('lastName'));
     $user->setEmail($this->getData('email'));
     $authDao = DAORegistry::getDAO('AuthSourceDAO');
     $auth = $authDao->getDefaultPlugin();
     $user->setAuthId($auth ? $auth->getAuthId() : 0);
     $user->setInlineHelp(1);
     // default new reviewers to having inline help visible
     $user->setUsername($this->getData('username'));
     $password = Validation::generatePassword();
     if (isset($auth)) {
         $user->setPassword($password);
         // FIXME Check result and handle failures
         $auth->doCreateUser($user);
         $user->setAuthId($auth->authId);
         $user->setPassword(Validation::encryptCredentials($user->getId(), Validation::generatePassword()));
         // Used for PW reset hash only
     } else {
         $user->setPassword(Validation::encryptCredentials($this->getData('username'), $password));
     }
     $user->setDateRegistered(Core::getCurrentDate());
     $reviewerId = $userDao->insertObject($user);
     // Set the reviewerId in the Form for the parent class to use
     $this->setData('reviewerId', $reviewerId);
     // Insert the user interests
     import('lib.pkp.classes.user.InterestManager');
     $interestManager = new InterestManager();
     $interestManager->setInterestsForUser($user, $this->getData('interests'));
     // Assign the selected user group ID to the user
     $userGroupDao = DAORegistry::getDAO('UserGroupDAO');
     /* @var $userGroupDao UserGroupDAO */
     $userGroupId = (int) $this->getData('userGroupId');
     $userGroupDao->assignUserToGroup($reviewerId, $userGroupId);
     if (!$this->getData('skipEmail')) {
         // Send welcome email to user
         import('lib.pkp.classes.mail.MailTemplate');
         $mail = new MailTemplate('REVIEWER_REGISTER');
         if ($mail->isEnabled()) {
             $context = $request->getContext();
             $mail->setReplyTo($context->getSetting('contactEmail'), $context->getSetting('contactName'));
             $mail->assignParams(array('username' => $this->getData('username'), 'password' => $password, 'userFullName' => $user->getFullName()));
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->send($request);
         }
     }
     return parent::execute($args, $request);
 }
 /**
  * Register a new user.
  * @return userId int
  */
 function execute()
 {
     $userDao =& DAORegistry::getDAO('UserDAO');
     $user = new User();
     $user->setSalutation($this->getData('salutation'));
     $user->setFirstName($this->getData('firstName'));
     $user->setMiddleName($this->getData('middleName'));
     $user->setLastName($this->getData('lastName'));
     $user->setGender($this->getData('gender'));
     $user->setInitials($this->getData('initials'));
     $user->setAffiliation($this->getData('affiliation'), null);
     // Localized
     $user->setEmail($this->getData('email'));
     $user->setData('orcid', $this->getData('orcid'));
     $user->setUrl($this->getData('userUrl'));
     $user->setPhone($this->getData('phone'));
     $user->setFax($this->getData('fax'));
     $user->setMailingAddress($this->getData('mailingAddress'));
     $user->setCountry($this->getData('country'));
     $user->setBiography($this->getData('biography'), null);
     // Localized
     $user->setGossip($this->getData('gossip'), null);
     // Localized
     $authDao =& DAORegistry::getDAO('AuthSourceDAO');
     $auth =& $authDao->getDefaultPlugin();
     $user->setAuthId($auth ? $auth->getAuthId() : 0);
     $site =& Request::getSite();
     $availableLocales = $site->getSupportedLocales();
     $locales = array();
     foreach ($this->getData('userLocales') as $locale) {
         if (AppLocale::isLocaleValid($locale) && in_array($locale, $availableLocales)) {
             array_push($locales, $locale);
         }
     }
     $user->setLocales($locales);
     $user->setUsername($this->getData('username'));
     $password = Validation::generatePassword();
     $sendNotify = $this->getData('sendNotify');
     if (isset($auth)) {
         $user->setPassword($password);
         // FIXME Check result and handle failures
         $auth->doCreateUser($user);
         $user->setAuthId($auth->authId);
         $user->setPassword(Validation::encryptCredentials($user->getId(), Validation::generatePassword()));
         // Used for PW reset hash only
     } else {
         $user->setPassword(Validation::encryptCredentials($this->getData('username'), $password));
     }
     $user->setMustChangePassword(isset($auth) ? 0 : 1);
     $user->setDateRegistered(Core::getCurrentDate());
     parent::execute($user);
     $userId = $userDao->insertUser($user);
     // Insert the user interests
     $interests = $this->getData('interestsKeywords') ? $this->getData('interestsKeywords') : $this->getData('interestsTextOnly');
     import('lib.pkp.classes.user.InterestManager');
     $interestManager = new InterestManager();
     $interestManager->setInterestsForUser($user, $interests);
     $roleDao =& DAORegistry::getDAO('RoleDAO');
     $journal =& Request::getJournal();
     $role = new Role();
     $role->setJournalId($journal->getId());
     $role->setUserId($userId);
     $role->setRoleId(ROLE_ID_REVIEWER);
     $roleDao->insertRole($role);
     if ($sendNotify) {
         // Send welcome email to user
         import('classes.mail.MailTemplate');
         $mail = new MailTemplate('REVIEWER_REGISTER');
         $mail->setReplyTo(null);
         $mail->assignParams(array('username' => $this->getData('username'), 'password' => $password, 'userFullName' => $user->getFullName()));
         $mail->addRecipient($user->getEmail(), $user->getFullName());
         $mail->send();
     }
     return $userId;
 }
Ejemplo n.º 17
0
 /**
  * Save thesis. 
  */
 function execute()
 {
     $thesisPlugin =& PluginRegistry::getPlugin('generic', $this->parentPluginName);
     $thesisPlugin->import('Thesis');
     $thesisDao =& DAORegistry::getDAO('ThesisDAO');
     $journal =& Request::getJournal();
     $journalId = $journal->getId();
     $thesis = new Thesis();
     $thesis->setJournalId($journalId);
     $thesis->setStatus(THESIS_STATUS_INACTIVE);
     $thesis->setDegree($this->getData('degree'));
     $thesis->setDegreeName($this->getData('degreeName'));
     $thesis->setDepartment($this->getData('department'));
     $thesis->setUniversity($this->getData('university'));
     $thesis->setTitle($this->getData('title'));
     $thesis->setDateApproved($this->getData('dateApprovedYear') . '-' . $this->getData('dateApprovedMonth') . '-' . $this->getData('dateApprovedDay'));
     $thesis->setUrl($this->getData('url'));
     $thesis->setAbstract($this->getData('abstract'));
     $thesis->setComment($this->getData('comment'));
     $thesis->setStudentFirstName($this->getData('studentFirstName'));
     $thesis->setStudentMiddleName($this->getData('studentMiddleName'));
     $thesis->setStudentLastName($this->getData('studentLastName'));
     $thesis->setStudentEmail($this->getData('studentEmail'));
     $thesis->setStudentEmailPublish($this->getData('studentEmailPublish') == null ? 0 : 1);
     $thesis->setStudentBio($this->getData('studentBio'));
     $thesis->setSupervisorFirstName($this->getData('supervisorFirstName'));
     $thesis->setSupervisorMiddleName($this->getData('supervisorMiddleName'));
     $thesis->setSupervisorLastName($this->getData('supervisorLastName'));
     $thesis->setSupervisorEmail($this->getData('supervisorEmail'));
     $thesis->setDiscipline($this->getData('discipline'));
     $thesis->setSubjectClass($this->getData('subjectClass'));
     $thesis->setSubject($this->getData('keyword'));
     $thesis->setCoverageGeo($this->getData('coverageGeo'));
     $thesis->setCoverageChron($this->getData('coverageChron'));
     $thesis->setCoverageSample($this->getData('coverageSample'));
     $thesis->setMethod($this->getData('method'));
     $thesis->setLanguage($this->getData('language'));
     $thesis->setDateSubmitted(Core::getCurrentDate());
     $thesisDao->insertThesis($thesis);
     // Send supervisor confirmation email
     if (!empty($this->uploadCodeEnabled)) {
         $uploadCode = $thesisPlugin->getSetting($journalId, 'uploadCode');
         $submittedUploadCode = $this->getData('uploadCode');
     }
     if (empty($uploadCode) || $uploadCode != $submittedUploadCode) {
         $journalName = $journal->getLocalizedTitle();
         $thesisName = $thesisPlugin->getSetting($journalId, 'thesisName');
         $thesisEmail = $thesisPlugin->getSetting($journalId, 'thesisEmail');
         $thesisPhone = $thesisPlugin->getSetting($journalId, 'thesisPhone');
         $thesisFax = $thesisPlugin->getSetting($journalId, 'thesisFax');
         $thesisMailingAddress = $thesisPlugin->getSetting($journalId, 'thesisMailingAddress');
         $thesisContactSignature = $thesisName;
         if (!empty($thesisMailingAddress)) {
             $thesisContactSignature .= "\n" . $thesisMailingAddress;
         }
         if (!empty($thesisPhone)) {
             $thesisContactSignature .= "\n" . AppLocale::Translate('user.phone') . ': ' . $thesisPhone;
         }
         if (!empty($thesisFax)) {
             $thesisContactSignature .= "\n" . AppLocale::Translate('user.fax') . ': ' . $thesisFax;
         }
         $thesisContactSignature .= "\n" . AppLocale::Translate('user.email') . ': ' . $thesisEmail;
         $studentName = $thesis->getStudentFirstName() . ' ' . $thesis->getStudentLastName();
         $supervisorName = $thesis->getSupervisorFirstName() . ' ' . $thesis->getSupervisorLastName();
         $paramArray = array('journalName' => $journalName, 'thesisName' => $thesisName, 'thesisEmail' => $thesisEmail, 'title' => $thesis->getTitle(), 'studentName' => $studentName, 'degree' => AppLocale::Translate($thesis->getDegreeString()), 'degreeName' => $thesis->getDegreeName(), 'department' => $thesis->getDepartment(), 'university' => $thesis->getUniversity(), 'dateApproved' => $thesis->getDateApproved(), 'supervisorName' => $supervisorName, 'abstract' => $thesis->getAbstract(), 'thesisContactSignature' => $thesisContactSignature);
         import('classes.mail.MailTemplate');
         $mail = new MailTemplate('THESIS_ABSTRACT_CONFIRM');
         $mail->setReplyTo($thesisEmail, $thesisName);
         $mail->assignParams($paramArray);
         $mail->addRecipient($thesis->getSupervisorEmail(), $supervisorName);
         $mail->addCc($thesis->getStudentEmail(), $studentName);
         $mail->send();
     }
 }
 /**
  * Handle incoming requests/notifications
  * @param $args array
  * @param $request PKPRequest
  */
 function handle($args, $request)
 {
     $press = $request->getPress();
     $templateMgr = TemplateManager::getManager($request);
     $user = $request->getUser();
     $op = isset($args[0]) ? $args[0] : null;
     $queuedPaymentId = isset($args[1]) ? (int) $args[1] : 0;
     import('classes.payment.omp.OMPPaymentManager');
     $ompPaymentManager = new OMPPaymentManager($request);
     $queuedPayment =& $ompPaymentManager->getQueuedPayment($queuedPaymentId);
     // if the queued payment doesn't exist, redirect away from payments
     if (!$queuedPayment) {
         return $request->redirect(null, 'index');
     }
     switch ($op) {
         case 'notify':
             import('lib.pkp.classes.mail.MailTemplate');
             AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON);
             $contactName = $press->getSetting('contactName');
             $contactEmail = $press->getSetting('contactEmail');
             $mail = new MailTemplate('MANUAL_PAYMENT_NOTIFICATION');
             $mail->setReplyTo($contactEmail, $contactName);
             $mail->addRecipient($contactEmail, $contactName);
             $mail->assignParams(array('pressName' => $press->getLocalizedName(), 'userFullName' => $user ? $user->getFullName() : '(' . __('common.none') . ')', 'userName' => $user ? $user->getUsername() : '(' . __('common.none') . ')', 'itemName' => $queuedPayment->getName(), 'itemCost' => $queuedPayment->getAmount(), 'itemCurrencyCode' => $queuedPayment->getCurrencyCode()));
             $mail->send();
             $templateMgr->assign(array('currentUrl' => $request->url(null, null, 'payment', 'plugin', array('notify', $queuedPaymentId)), 'pageTitle' => 'plugins.paymethod.manual.paymentNotification', 'message' => 'plugins.paymethod.manual.notificationSent', 'backLink' => $queuedPayment->getRequestUrl(), 'backLinkLabel' => 'common.continue'));
             return $templateMgr->display('frontend/pages/message.tpl');
     }
     return parent::handle($args, $request);
     // Don't know what to do with it
 }
Ejemplo n.º 19
0
 /**
  * Register a new user.
  */
 function execute()
 {
     $requireValidation = Config::getVar('email', 'require_validation');
     if ($this->existingUser) {
         // If using implicit auth - we hardwire that we are working on an existing user
         // Existing user in the system
         $userDao =& DAORegistry::getDAO('UserDAO');
         if ($this->implicitAuth) {
             // If we are using implicit auth - then use the session username variable - rather than data from the form
             $sessionManager =& SessionManager::getManager();
             $session =& $sessionManager->getUserSession();
             $user =& $userDao->getByUsername($session->getSessionVar('username'));
         } else {
             $user =& $userDao->getByUsername($this->getData('username'));
         }
         if ($user == null) {
             return false;
         }
         $userId = $user->getId();
     } else {
         // New user
         $user = new User();
         $user->setUsername($this->getData('username'));
         $user->setSalutation($this->getData('salutation'));
         $user->setFirstName($this->getData('firstName'));
         $user->setMiddleName($this->getData('middleName'));
         $user->setInitials($this->getData('initials'));
         $user->setLastName($this->getData('lastName'));
         $user->setGender($this->getData('gender'));
         $user->setAffiliation($this->getData('affiliation'), null);
         // Localized
         $user->setSignature($this->getData('signature'), null);
         // Localized
         $user->setEmail($this->getData('email'));
         $user->setData('orcid', $this->getData('orcid'));
         $user->setUrl($this->getData('userUrl'));
         $user->setPhone($this->getData('phone'));
         $user->setFax($this->getData('fax'));
         $user->setMailingAddress($this->getData('mailingAddress'));
         $user->setBiography($this->getData('biography'), null);
         // Localized
         $user->setDateRegistered(Core::getCurrentDate());
         $user->setCountry($this->getData('country'));
         $site =& Request::getSite();
         $availableLocales = $site->getSupportedLocales();
         $locales = array();
         foreach ($this->getData('userLocales') as $locale) {
             if (AppLocale::isLocaleValid($locale) && in_array($locale, $availableLocales)) {
                 array_push($locales, $locale);
             }
         }
         $user->setLocales($locales);
         if (isset($this->defaultAuth)) {
             $user->setPassword($this->getData('password'));
             // FIXME Check result and handle failures
             $this->defaultAuth->doCreateUser($user);
             $user->setAuthId($this->defaultAuth->authId);
         }
         $user->setPassword(Validation::encryptCredentials($this->getData('username'), $this->getData('password')));
         if ($requireValidation) {
             // The account should be created in a disabled
             // state.
             $user->setDisabled(true);
             $user->setDisabledReason(__('user.login.accountNotValidated'));
         }
         $userDao =& DAORegistry::getDAO('UserDAO');
         $userDao->insertUser($user);
         $userId = $user->getId();
         if (!$userId) {
             return false;
         }
         // Insert the user interests
         $interests = $this->getData('interestsKeywords') ? $this->getData('interestsKeywords') : $this->getData('interestsTextOnly');
         import('lib.pkp.classes.user.InterestManager');
         $interestManager = new InterestManager();
         $interestManager->setInterestsForUser($user, $interests);
         $sessionManager =& SessionManager::getManager();
         $session =& $sessionManager->getUserSession();
         $session->setSessionVar('username', $user->getUsername());
     }
     $journal =& Request::getJournal();
     $roleDao =& DAORegistry::getDAO('RoleDAO');
     // Roles users are allowed to register themselves in
     $allowedRoles = array('reader' => 'registerAsReader', 'author' => 'registerAsAuthor', 'reviewer' => 'registerAsReviewer');
     $journalSettingsDao =& DAORegistry::getDAO('JournalSettingsDAO');
     if (!$journalSettingsDao->getSetting($journal->getId(), 'allowRegReader')) {
         unset($allowedRoles['reader']);
     }
     if (!$journalSettingsDao->getSetting($journal->getId(), 'allowRegAuthor')) {
         unset($allowedRoles['author']);
     }
     if (!$journalSettingsDao->getSetting($journal->getId(), 'allowRegReviewer')) {
         unset($allowedRoles['reviewer']);
     }
     foreach ($allowedRoles as $k => $v) {
         $roleId = $roleDao->getRoleIdFromPath($k);
         if ($this->getData($v) && !$roleDao->userHasRole($journal->getId(), $userId, $roleId)) {
             $role = new Role();
             $role->setJournalId($journal->getId());
             $role->setUserId($userId);
             $role->setRoleId($roleId);
             $roleDao->insertRole($role);
         }
     }
     if (!$this->existingUser) {
         import('classes.mail.MailTemplate');
         if ($requireValidation) {
             // Create an access key
             import('lib.pkp.classes.security.AccessKeyManager');
             $accessKeyManager = new AccessKeyManager();
             $accessKey = $accessKeyManager->createKey('RegisterContext', $user->getId(), null, Config::getVar('email', 'validation_timeout'));
             // Send email validation request to user
             $mail = new MailTemplate('USER_VALIDATE');
             $mail->setReplyTo(null);
             $mail->assignParams(array('userFullName' => $user->getFullName(), 'activateUrl' => Request::url($journal->getPath(), 'user', 'activateUser', array($this->getData('username'), $accessKey))));
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->send();
             unset($mail);
         }
         if ($this->getData('sendPassword')) {
             // Send welcome email to user
             $mail = new MailTemplate('USER_REGISTER');
             $mail->setReplyTo(null);
             $mail->assignParams(array('username' => $this->getData('username'), 'password' => String::substr($this->getData('password'), 0, 30), 'userFullName' => $user->getFullName()));
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->send();
             unset($mail);
         }
     }
     if (isset($allowedRoles['reader']) && $this->getData('openAccessNotification')) {
         $userSettingsDao =& DAORegistry::getDAO('UserSettingsDAO');
         $userSettingsDao->updateSetting($userId, 'openAccessNotification', true, 'bool', $journal->getId());
     }
 }
 /**
  * Remove book reviewer and reset book for review.
  */
 function removeBookForReviewAuthor($args = array(), &$request)
 {
     $this->setupTemplate();
     if (empty($args)) {
         $request->redirect(null, 'editor');
     }
     $bfrPlugin =& PluginRegistry::getPlugin('generic', BOOKS_FOR_REVIEW_PLUGIN_NAME);
     $returnPage = $request->getUserVar('returnPage');
     if ($returnPage != null) {
         $validPages =& $this->getValidReturnPages();
         if (!in_array($returnPage, $validPages)) {
             $returnPage = null;
         }
     }
     $journal =& $request->getJournal();
     $journalId = $journal->getId();
     $bookId = (int) $args[0];
     $bfrDao =& DAORegistry::getDAO('BookForReviewDAO');
     // Ensure book for review is for this journal
     if ($bfrDao->getBookForReviewJournalId($bookId) == $journalId) {
         import('classes.mail.MailTemplate');
         $email = new MailTemplate('BFR_REVIEWER_REMOVED');
         $send = $request->getUserVar('send');
         // Editor has filled out mail form or skipped mail
         if ($send && !$email->hasErrors()) {
             // Update book for review
             $book =& $bfrDao->getBookForReview($bookId);
             $book->setStatus(BFR_STATUS_AVAILABLE);
             $book->setUserId(null);
             $book->setDateRequested(null);
             $book->setDateAssigned(null);
             $book->setDateDue(null);
             $book->setDateMailed(null);
             $book->setDateSubmitted(null);
             $book->setArticleId(null);
             $bfrDao->updateObject($book);
             $email->send();
             $user =& $request->getUser();
             import('classes.notification.NotificationManager');
             $notificationManager = new NotificationManager();
             $notificationManager->createTrivialNotification($user->getId(), NOTIFICATION_TYPE_BOOK_AUTHOR_REMOVED);
             $request->redirect(null, 'editor', 'booksForReview', $returnPage);
             // Display mail form for editor
         } else {
             if (!$request->getUserVar('continued')) {
                 $book =& $bfrDao->getBookForReview($bookId);
                 $userFullName = $book->getUserFullName();
                 $userEmail = $book->getUserEmail();
                 $paramArray = array('authorName' => strip_tags($userFullName), 'bookForReviewTitle' => '"' . strip_tags($book->getLocalizedTitle()) . '"', 'editorialContactSignature' => String::html2text($book->getEditorContactSignature()));
                 $email->addRecipient($userEmail, $userFullName);
                 $email->setReplyTo($book->getEditorEmail(), $book->getEditorFullName());
                 $email->assignParams($paramArray);
             }
             $returnUrl = $request->url(null, 'editor', 'removeBookForReviewAuthor', $bookId, array('returnPage' => $returnPage));
             $email->displayEditForm($returnUrl);
         }
     }
     $request->redirect(null, 'editor', 'booksForReview', $returnPage);
 }
Ejemplo n.º 21
0
 /**
  * Helper function - set mail From
  * can be overriden by child classes
  * @param $request PKPRequest
  * @param MailTemplate $mail
  * @param $site Site
  */
 function _setMailFrom($request, &$mail, &$site)
 {
     $mail->setReplyTo($site->getLocalizedContactEmail(), $site->getLocalizedContactName());
     return true;
 }
Ejemplo n.º 22
0
 /**
  * Import the parsed users into the system.
  * @param $sendNotify boolean send an email notification to each imported user containing their username and password
  * @param $continueOnError boolean continue to import remaining users if a failure occurs
  * @return boolean success
  */
 function importUsers($sendNotify = false, $continueOnError = false)
 {
     $success = true;
     $this->importedUsers = array();
     $this->errors = array();
     $userDao = DAORegistry::getDAO('UserDAO');
     $roleDao = DAORegistry::getDAO('RoleDAO');
     if ($sendNotify) {
         // Set up mail template to send to added users
         import('lib.pkp.classes.mail.MailTemplate');
         $mail = new MailTemplate('USER_REGISTER');
         $journalDao = DAORegistry::getDAO('JournalDAO');
         $journal = $journalDao->getById($this->journalId);
         $mail->setReplyTo(null);
     }
     for ($i = 0, $count = count($this->usersToImport); $i < $count; $i++) {
         $user =& $this->usersToImport[$i];
         // If the email address already exists in the system,
         // then assign the user the username associated with that email address.
         if ($user->getEmail() != null) {
             $emailExists = $userDao->getUserByEmail($user->getEmail(), true);
             if ($emailExists != null) {
                 $user->setUsername($emailExists->getUsername());
             }
         }
         if ($user->getUsername() == null) {
             $newUsername = true;
             $this->generateUsername($user);
         } else {
             $newUsername = false;
         }
         if ($user->getUnencryptedPassword() != null) {
             $user->setPassword(Validation::encryptCredentials($user->getUsername(), $user->getUnencryptedPassword()));
         } else {
             if ($user->getPassword() == null) {
                 $this->generatePassword($user);
             }
         }
         if (!$newUsername) {
             // Check if user already exists
             $userExists = $userDao->getByUsername($user->getUsername(), true);
             if ($userExists != null) {
                 $user->setId($userExists->getId());
             }
         } else {
             $userExists = false;
         }
         if ($newUsername || !$userExists) {
             // Create new user account
             // If the user's username was specified in the data file and
             // the username already exists, only the new roles are added for that user
             if (!$userDao->insertObject($user)) {
                 // Failed to add user!
                 $this->errors[] = sprintf('%s: %s (%s)', __('manager.people.importUsers.failedToImportUser'), $user->getFullName(), $user->getUsername());
                 if ($continueOnError) {
                     // Skip to next user
                     $success = false;
                     continue;
                 } else {
                     return false;
                 }
             }
         }
         // Add reviewing interests to interests table
         $interestDao = DAORegistry::getDAO('InterestDAO');
         $interests = $user->getTemporaryInterests();
         $interests = explode(',', $interests);
         $interests = array_map('trim', $interests);
         // Trim leading whitespace
         if (is_array($interests) && !empty($interests)) {
             $interestDao->setUserInterests($interests, $user->getId());
         }
         // Enroll user in specified roles
         // If the user is already enrolled in a role, that role is skipped
         foreach ($user->getRoles() as $role) {
             $role->setUserId($user->getId());
             $role->setJournalId($this->journalId);
             if (!$roleDao->userHasRole($role->getJournalId(), $role->getUserId(), $role->getRoleId())) {
                 if (!$roleDao->insertRole($role)) {
                     // Failed to add role!
                     $this->errors[] = sprintf('%s: %s - %s (%s)', __('manager.people.importUsers.failedToImportRole'), $role->getRoleName(), $user->getFullName(), $user->getUsername());
                     if ($continueOnError) {
                         // Continue to insert other roles for this user
                         $success = false;
                         continue;
                     } else {
                         return false;
                     }
                 }
             }
         }
         if ($sendNotify && !$userExists) {
             // Send email notification to user as if user just registered themselves
             $mail->addRecipient($user->getEmail(), $user->getFullName());
             $mail->sendWithParams(array('journalName' => $journal->getName($journal->getPrimaryLocale()), 'username' => $user->getUsername(), 'password' => $user->getUnencryptedPassword() == null ? '-' : $user->getUnencryptedPassword(), 'userFullName' => $user->getFullName()));
             $mail->clearRecipients();
         }
         array_push($this->importedUsers, $user);
     }
     return $success;
 }
Ejemplo n.º 23
0
 /**
  * Handle incoming requests/notifications
  * @param $args array
  * @param $request PKPRequest
  */
 function handle($args, &$request)
 {
     file_put_contents("outputfile2.txt", file_get_contents("php://input"));
     $liqPayDao = DAORegistry::getDAO('LiqPayDAO');
     //
     $templateMgr =& TemplateManager::getManager();
     $journal =& $request->getJournal();
     //        $liqPayDao->transactionExists('3333333');
     //       var_dump( $this->getSetting($journal->getId(), 'liqpaydebug'));
     //
     //        if ($this->getSetting($journal->getId(), 'liqpaydebug')){
     //            die('wwww');
     //        }
     //        die('222ee');
     if (!$journal) {
         return parent::handle($args, $request);
     }
     // Just in case we need to contact someone
     import('classes.mail.MailTemplate');
     // Prefer technical support contact
     $contactName = $journal->getSetting('supportName');
     $contactEmail = $journal->getSetting('supportEmail');
     if (!$contactEmail) {
         // Fall back on primary contact
         $contactName = $journal->getSetting('contactName');
         $contactEmail = $journal->getSetting('contactEmail');
     }
     $mail = new MailTemplate('LIQPAY_INVESTIGATE_PAYMENT');
     $mail->setReplyTo(null);
     $mail->addRecipient($contactEmail, $contactName);
     $liqpay = new LiqPay($this->getSetting($journal->getId(), 'liqpaypubkey'), $this->getSetting($journal->getId(), 'liqpayprivatkey'));
     switch (array_shift($args)) {
         case 'notification':
             //                data - результат функции base64_encode( $json_string )
             //signature - результат функции base64_encode( sha1( $private_key . $data . $private_key ) )
             $sign = base64_encode(sha1($this->getSetting($journal->getId(), 'liqpayprivatkey') . $request->getUserVar('data') . $this->getSetting($journal->getId(), 'liqpayprivatkey'), 1));
             $this->log->info('Start transaction ' . $sign);
             //var_dump($sign, $request->getUserVar('signature'), $_REQUEST);
             //                $params = json_decode (base64_decode($request->getUserVar('data')), true);
             //                var_dump($params);
             //
             //                die;
             // Check signature
             if ((string) $sign == (string) $request->getUserVar('signature')) {
                 $params = json_decode(base64_decode($request->getUserVar('data')), true);
                 $this->log->info('Input parameters ' . var_export($params, true));
                 // Check transactions exist
                 $transactionId = $params['transaction_id'];
                 $this->log->info('Transaction ID ' . var_export($transactionId, true));
                 if ($liqPayDao->transactionExists($transactionId . rand(0, 100))) {
                     $this->log->info('Transaction is exists ' . var_export($transactionId, true));
                     // A duplicate transaction was received; notify someone.
                     $mail->assignParams(array('journalName' => $journal->getLocalizedTitle(), 'data' => print_r($params, true), 'additionalInfo' => "Duplicate transaction ID: {$transactionId}", 'serverVars' => print_r($_SERVER, true)));
                     $mail->send();
                     exit;
                 } else {
                     $this->log->info('Payment status  ' . var_export($params['status'], true));
                     // New transaction succeeded. Record it.
                     //                        $liqPayDao->insertTransaction(
                     //                            $transactionId,
                     //                            $params['type'],
                     //                            String::strtolower($params['sender_phone']),
                     //                            $params['status'],
                     //                            $params['liqpay_order_id'],
                     //                            date('Y-m-d H:i:s')
                     //                        );
                     //if debug mode turn on the all payments is success
                     if ($this->getSetting($journal->getId(), 'liqpaydebug')) {
                         $params['status'] = 'success';
                     }
                     switch ($params['status']) {
                         case 'success':
                             $params['description'];
                             preg_match('/\\/(\\d+$)/', $params['description'], $matches);
                             $this->log->info('Input queuedPaymentId ' . var_export($matches[1], true));
                             $queuedPaymentId = $matches[1];
                             import('classes.payment.ojs.OJSPaymentManager');
                             $ojsPaymentManager = new OJSPaymentManager($request);
                             // Verify the cost and user details as per PayPal spec.
                             $queuedPayment = $ojsPaymentManager->getQueuedPayment($queuedPaymentId);
                             if (!$queuedPayment) {
                                 $this->log->info('Not found queued payment for ' . var_export($queuedPaymentId, true));
                                 // The queued payment entry is missing. Complain.
                                 $mail->assignParams(array('journalName' => $journal->getLocalizedTitle(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Missing queued payment ID: {$queuedPaymentId}", 'serverVars' => print_r($_SERVER, true)));
                                 $mail->send();
                                 exit;
                             }
                             //NB: if/when paypal subscriptions are enabled, these checks will have to be adjusted
                             // because subscription prices may change over time
                             $queuedAmount = $queuedPayment->getAmount();
                             var_dump($queuedPayment->getCurrencyCode());
                             die;
                             if ($queuedAmount || ($queuedCurrency = $queuedPayment->getCurrencyCode()) != ($grantedCurrency = $request->getUserVar('mc_currency')) || ($grantedEmail = String::strtolower($request->getUserVar('receiver_email'))) != ($queuedEmail = String::strtolower($this->getSetting($journal->getId(), 'selleraccount')))) {
                                 // The integrity checks for the transaction failed. Complain.
                                 $mail->assignParams(array('journalName' => $journal->getLocalizedTitle(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Granted amount: {$grantedAmount}\n" . "Queued amount: {$queuedAmount}\n" . "Granted currency: {$grantedCurrency}\n" . "Queued currency: {$queuedCurrency}\n" . "Granted to PayPal account: {$grantedEmail}\n" . "Configured PayPal account: {$queuedEmail}", 'serverVars' => print_r($_SERVER, true)));
                                 $mail->send();
                                 exit;
                             }
                             // Update queued amount if amount set by user (e.g. donation)
                             if ($queuedAmount == 0 && $grantedAmount > 0) {
                                 $queuedPaymentDao =& DAORegistry::getDAO('QueuedPaymentDAO');
                                 $queuedPayment->setAmount($grantedAmount);
                                 $queuedPayment->setCurrencyCode($grantedCurrency);
                                 $queuedPaymentDao->updateQueuedPayment($queuedPaymentId, $queuedPayment);
                             }
                             // Fulfill the queued payment.
                             if ($ojsPaymentManager->fulfillQueuedPayment($queuedPayment, $this->getName())) {
                                 exit;
                             }
                             // If we're still here, it means the payment couldn't be fulfilled.
                             $mail->assignParams(array('journalName' => $journal->getLocalizedTitle(), 'postInfo' => print_r($_POST, true), 'additionalInfo' => "Queued payment ID {$queuedPaymentId} could not be fulfilled.", 'serverVars' => print_r($_SERVER, true)));
                             $mail->send();
                             exit;
                         case 'cancel':
                             AppLocale::requireComponents(LOCALE_COMPONENT_PKP_COMMON, LOCALE_COMPONENT_PKP_USER, LOCALE_COMPONENT_APPLICATION_COMMON);
                             $templateMgr->assign(array('currentUrl' => $request->url(null, 'index'), 'pageTitle' => 'plugins.paymethod.paypal.purchase.cancelled.title', 'message' => 'plugins.paymethod.paypal.purchase.cancelled', 'backLink' => $request->getUserVar('ojsReturnUrl'), 'backLinkLabel' => 'common.continue'));
                             $templateMgr->display('common/message.tpl');
                             exit;
                             break;
                     }
                 }
             }
     }
     parent::handle($args, $request);
     // Don't know what to do with it
 }