Ejemplo n.º 1
0
 /**
  * Get a suggested username, making sure it's not
  * already used by the system. (Poor-man's AJAX.)
  */
 function suggestUsername()
 {
     $this->validate();
     $suggestion = Validation::suggestUsername(Request::getUserVar('firstName'), Request::getUserVar('lastName'));
     echo $suggestion;
 }
Ejemplo n.º 2
0
 /**
  * Get a suggested username, making sure it's not
  * already used by the system. (Poor-man's AJAX.)
  */
 function suggestUsername($args, $request)
 {
     $this->validate($request);
     $suggestion = Validation::suggestUsername($request->getUserVar('firstName'), $request->getUserVar('lastName'));
     echo $suggestion;
 }
Ejemplo n.º 3
0
 /**
  * Fulfill a queued payment.
  * @param $queuedPayment QueuedPayment
  * @param $payMethodPluginName string Name of payment plugin.
  * @return mixed Dependent on payment type.
  */
 function fulfillQueuedPayment(&$queuedPayment, $payMethodPluginName = null)
 {
     $returner = false;
     if ($queuedPayment) {
         switch ($queuedPayment->getType()) {
             case PAYMENT_TYPE_MEMBERSHIP:
                 $userDao =& DAORegistry::getDAO('UserDAO');
                 $user =& $userDao->getUser($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($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($subscription, 'SUBSCRIPTION_PURCHASE_INDL');
                     }
                 }
                 $returner = true;
                 break;
             case PAYMENT_TYPE_RENEW_SUBSCRIPTION:
                 $subscriptionId = $queuedPayment->getAssocId();
                 $institutionalSubscriptionDao =& DAORegistry::getDAO('InstitutionalSubscriptionDAO');
                 if ($institutionalSubscriptionDao->subscriptionExists($subscriptionId)) {
                     $subscription =& $institutionalSubscriptionDao->getSubscription($subscriptionId);
                     $institutional = true;
                 } else {
                     $individualSubscriptionDao =& DAORegistry::getDAO('IndividualSubscriptionDAO');
                     $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($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($subscription, 'SUBSCRIPTION_RENEW_INDL');
                     }
                 }
                 $returner = true;
                 break;
             case PAYMENT_TYPE_FASTTRACK:
                 $articleDao =& DAORegistry::getDAO('ArticleDAO');
                 $article =& $articleDao->getArticle($queuedPayment->getAssocId(), $queuedPayment->getJournalId());
                 $article->setFastTracked(true);
                 $articleDao->updateArticle($article);
                 $returner = true;
                 break;
             case PAYMENT_TYPE_GIFT:
                 $giftId = $queuedPayment->getAssocId();
                 $giftDao =& DAORegistry::getDAO('GiftDAO');
                 $gift =& $giftDao->getGift($giftId);
                 if (!$gift) {
                     return false;
                 }
                 $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 = new User();
                     $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->insertUser($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_APPLICATION_COMMON, $giftLocale);
                 $giftDetails = $gift->getGiftName($giftLocale);
                 $giftJournalName = $journal->getTitle($giftLocale);
                 $giftContactSignature = $journal->getSetting('contactName');
                 import('classes.mail.MailTemplate');
                 $mail = new MailTemplate('GIFT_AVAILABLE', $giftLocale);
                 $mail->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
                 $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->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
                 $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->getQueuedPaymentId());
     return $returner;
 }
 /**
  * Get a suggested username, making sure it's not already used.
  * @param $args array
  * @param $request PKPRequest
  * @return JSONMessage JSON object
  */
 function suggestUsername($args, $request)
 {
     $suggestion = Validation::suggestUsername($request->getUserVar('firstName'), $request->getUserVar('lastName'));
     return new JSONMessage(true, $suggestion);
 }
 /**
  * Get a suggested username, making sure it's not
  * already used by the system. (Poor-man's AJAX.)
  * @param $args array
  * @param $request PKPRequest
  */
 function suggestUsername($args, &$request)
 {
     parent::validate();
     $suggestion = Validation::suggestUsername($request->getUserVar('firstName'), $request->getUserVar('lastName'));
     echo $suggestion;
 }
    /**
     * Do the actual web SOAP service request.
     * @param $token string
     * @param $authToken string The token returned from _doAuthenticate
     * @return boolean|string True for success, an error message otherwise.
     */
    function _doUserRequest($token, $authToken)
    {
        // Build the multipart SOAP message from scratch.
        $soapMessage = '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns="http://www.avectra.com/2005/">
			<soapenv:Header>
				<ns:AuthorizationToken>
					<ns:Token>' . $authToken . '</ns:Token>
				</ns:AuthorizationToken>
		</soapenv:Header>
		<soapenv:Body>
			<ns:BNEGetIndividualInformation>
				<ns:SSOToken>' . $token . '</ns:SSOToken>
			</ns:BNEGetIndividualInformation>
		</soapenv:Body>
	</soapenv:Envelope>';
        // Prepare HTTP session.
        $curlCh = curl_init();
        curl_setopt($curlCh, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curlCh, CURLOPT_POST, true);
        // Set up SSL.
        curl_setopt($curlCh, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($curlCh, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
        // Make SOAP request.
        $ofrPlugin =& $this->_getObjectsForReviewPlugin();
        $journal =& Request::getJournal();
        curl_setopt($curlCh, CURLOPT_URL, $ofrPlugin->getSetting($journal->getId(), 'anthroNetSoapURL'));
        $extraHeaders = array('Host: avectra.aaanet.org', 'SOAPAction: "http://www.avectra.com/2005/BNEGetIndividualInformation"', 'Content-Type: text/xml;charset=UTF-8');
        curl_setopt($curlCh, CURLOPT_HTTPHEADER, $extraHeaders);
        curl_setopt($curlCh, CURLOPT_POSTFIELDS, $soapMessage);
        $result = true;
        $response = curl_exec($curlCh);
        // We do not localize our error messages as they are all
        // fatal errors anyway and must be analyzed by technical staff.
        if ($response === false) {
            $result = 'OJS-OFR: Expected string response.';
        }
        if ($result === true && ($status = curl_getinfo($curlCh, CURLINFO_HTTP_CODE)) != OFR_WS_RESPONSE_OK) {
            $result = 'OJS-OFR: Expected ' . OFR_WS_RESPONSE_OK . ' response code, got ' . $status . ' instead.';
        }
        curl_close($curlCh);
        // Check SOAP response by simple string manipulation rather
        // than instantiating a DOM.
        if (is_string($response)) {
            $request = Application::getRequest();
            /**
             * The XML returned looks something like this:
             *
             * <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
             * 		<soap:Header><AuthorizationToken xmlns="http://www.avectra.com/2005/"><Token>2a51ca85-d490-4444-802c-d247259d674a</Token></AuthorizationToken></soap:Header>
             * 		<soap:Body>
             * 			<BNEGetIndividualInformationResponse xmlns="http://www.avectra.com/2005/">
             * 				<BNEGetIndividualInformationResult>
             * 					<Individual xmlns="">
             * 						<ind_cst_key>2a51ca85-d490-9999-802c-d24XX59d674a</ind_cst_key>
             * 						<cst_recno>000001</cst_recno>
             * 						<ind_first_name>John</ind_first_name>
             * 						<ind_last_name>Public</ind_last_name>
             * 						<cst_eml_address_dn>user@email.com</cst_eml_address_dn>
             * 						<InterestCodes>&lt;InterestCode&gt;Art and Material Culture&lt;/InterestCode&gt;</InterestCodes>
             * 					</Individual>
             * 				</BNEGetIndividualInformationResult>
             * 			</BNEGetIndividualInformationResponse>
             * 		</soap:Body>
             * </soap:Envelope>
             */
            $matches = array();
            if (!preg_match('#<faultstring>([^<]*)</faultstring>#', $response)) {
                // Ensure that the user is logged into the AnthroNet portal.
                if (preg_match('#<ind_cst_key>00000000\\-0000\\-0000\\-0000\\-000000000000</ind_cst_key>#', $response)) {
                    $request->redirect(null, 'user');
                } else {
                    $email = $firstName = $lastName = $interestCodes = null;
                    $interestCodesArray = array();
                    if (preg_match('#<cst_eml_address_dn>(.*?)</cst_eml_address_dn>#', $response, $matches)) {
                        $email = $matches[1];
                    }
                    if (preg_match('#<ind_first_name>(.*?)</ind_first_name>#', $response, $matches)) {
                        $firstName = $matches[1];
                    }
                    if (preg_match('#<ind_last_name>(.*?)</ind_last_name>#', $response, $matches)) {
                        $lastName = $matches[1];
                    }
                    if (preg_match('#<InterestCodes>(.*?)</InterestCodes>#', $response, $matches)) {
                        $interestCodes = $matches[1];
                        preg_match_all('#&lt;InterestCode&gt;(.*?)&lt;/InterestCode&gt;#', $interestCodes, $matches, PREG_PATTERN_ORDER);
                        if (is_array($matches[1])) {
                            $interestCodesArray = $matches[1];
                        }
                    }
                    $userDao =& DAORegistry::getDAO('UserDAO');
                    // see if this user exists already.
                    $user = $userDao->getUserByEmail($email);
                    if (!$user) {
                        $user = new User();
                        $userName = Validation::suggestUsername($firstName, $lastName);
                        $user->setUsername($userName);
                        $user->setFirstName($firstName);
                        $user->setLastName($lastName);
                        $user->setEmail($email);
                        $user->setDateRegistered(Core::getCurrentDate());
                        $locales = array('en_US');
                        $user->setLocales($locales);
                        $user->setPassword(Validation::encryptCredentials($userName, Validation::generatePassword()));
                        $userDao->insertUser($user);
                    }
                    import('lib.pkp.classes.user.InterestManager');
                    $interestManager = new InterestManager();
                    $interestManager->setInterestsForUser($user, $interestCodesArray);
                    // enroll as Author, if not already.
                    $roleDao =& DAORegistry::getDAO('RoleDAO');
                    if (!$roleDao->userHasRole($journal->getId(), $user->getId(), ROLE_ID_AUTHOR)) {
                        $role = new Role();
                        $role->setJournalId($journal->getId());
                        $role->setUserId($user->getId());
                        $role->setRoleId(ROLE_ID_AUTHOR);
                        $roleDao->insertRole($role);
                    }
                    return $user;
                }
            } else {
                $result = 'OFR: ' . $status . ' - ' . $matches[1];
            }
        } else {
            $result = 'OJS-OFR: Expected string response.';
        }
        return false;
    }