PHP Member::Groups方法代码示例

 /**
  * If the REMOTE_USER is set and is in the Member table, log that member in. If
  * not, and Config::inst()->get('AuthRemoteUserExtension', 'auto_create_user') is set, add that
  * Member to the configured group, and log the new user in. Otherwise, do nothing.
  */
 public function onAfterInit()
 {
     if (isset($_SERVER['REMOTE_USER'])) {
         $unique_identifier = $_SERVER['REMOTE_USER'];
     } elseif (isset($_SERVER['REDIRECT_REMOTE_USER'])) {
         $unique_identifier = $_SERVER['REDIRECT_REMOTE_USER'];
     }
     if (isset($unique_identifier)) {
         $unique_identifier_field = Member::config()->unique_identifier_field;
         $member = Member::get()->filter($unique_identifier_field, $unique_identifier)->first();
         if ($member) {
             $member->logIn();
             $this->owner->redirectBack();
         } elseif (Config::inst()->get('AuthRemoteUserExtension', 'auto_create_user') && strlen(Config::inst()->get('AuthRemoteUserExtension', 'auto_user_group'))) {
             $group = Group::get()->filter('Title', Config::inst()->get('AuthRemoteUserExtension', 'auto_user_group'))->first();
             if ($group) {
                 $member = new Member();
                 $member->{$unique_identifier_field} = $unique_identifier;
                 $member->write();
                 $member->Groups()->add($group);
                 $member->logIn();
             }
         }
     }
 }

 /**
  * creates and logs in a temporary user.
  *
  */
 private function createAndLoginUser()
 {
     $this->username = "TEMPLATEOVERVIEW_URLCHECKER___";
     $this->password = rand(1000000000, 9999999999);
     //Make temporary admin member
     $adminMember = Member::get()->filter(array("Email" => $this->username))->first();
     if ($adminMember != NULL) {
         $adminMember->delete();
     }
     $this->member = new Member();
     $this->member->Email = $this->username;
     $this->member->Password = $this->password;
     $this->member->write();
     $adminGroup = Group::get()->filter(array("code" => "administrators"))->first();
     if (!$adminGroup) {
         user_error("No admin group exists");
     }
     $this->member->Groups()->add($adminGroup);
     curl_setopt($this->ch, CURLOPT_USERPWD, $this->username . ":" . $this->password);
     $loginUrl = Director::absoluteURL('/Security/LoginForm');
     curl_setopt($this->ch, CURLOPT_CUSTOMREQUEST, "POST");
     curl_setopt($this->ch, CURLOPT_URL, $loginUrl);
     curl_setopt($this->ch, CURLOPT_POST, 1);
     curl_setopt($this->ch, CURLOPT_POSTFIELDS, 'Email=' . $this->username . '&Password=' . $this->password);
     //execute the request (the login)
     $loginContent = curl_exec($this->ch);
     $httpCode = curl_getinfo($this->ch, CURLINFO_HTTP_CODE);
     $err = curl_errno($this->ch);
     $errmsg = curl_error($this->ch);
     $header = curl_getinfo($this->ch);
     if ($httpCode != 200) {
         echo "<span style='color:red'>There was an error logging in!</span><br />";
     }
 }

 function activate($data, $form, $request)
 {
     //Check if there's a temp member with a Verification Code equal to this
     //if there is, register the new member and log him in
     //if not, tell him the code is wrong
     //Check if this member already exists
     $tempMember = TempMember::codeExists($data);
     if (!$tempMember) {
         $form->sessionMessage(_t("Register.REGISTRATION ERROR", "There's no account waiting for activation with this code.\n\t\t\t\t\t\t\t\t\t If you already have an account log in here <a href=\"my-events/\">here</a>"), 'bad');
         Director::redirectBack();
         return;
     }
     // Create a new Member object
     $member = new Member();
     $member->FirstName = $tempMember->FirstName;
     $member->Surname = $tempMember->Surname;
     $member->Phone = $tempMember->Phone;
     $member->Email = $tempMember->Email;
     $member->Password = $tempMember->Password;
     $member->ReceiveMail = $tempMember->ReceiveMail;
     $member->ReceiveMail = $tempMember->ReceiveMail;
     $member->RequestListedAsPresenter = $tempMember->RequestListedAsPresenter;
     $member->LocationAddress = $tempMember->LocationAddress;
     $member->LocationLatitude = $tempMember->LocationLatitude;
     $member->LocationLongitude = $tempMember->LocationLongitude;
     $member->Description = $tempMember->Description;
     // Write to db.
     // This needs to happen before we add it to a group
     $member->write();
     if ($tempMember->RequestListedAsPresenter) {
         $presentorApproval = new PresentorApproval();
         $presentorApproval->MemberID = $member->ID;
         $presentorApproval->MemberName = $tempMember->FirstName . ' ' . $tempMember->Surname;
         $presentorApproval->Message = $tempMember->Description;
         $presentorApproval->Email = $tempMember->Email;
         $presentorApproval->Confirmation = 'Pending';
         $presentorApproval->IsDone = false;
         $presentorApproval->write();
     }
     $tempMember->delete();
     $member->logIn();
     // Add the member to User Group
     // Check if it exists first
     if ($group = DataObject::get_one('Group', 'ID = 3')) {
         $member->Groups()->add($group);
         // Redirect based on URL
         // TO EDIT
         Director::redirect('SuccessVerification');
     } else {
         $form->sessionMessage(_t("Register.REGISTRATION ERROR", "Your registration wasn't successful please try again"), 'bad');
         Director::redirectBack();
     }
 }

 /**
  * Test that orphaned pages are handled correctly
  */
 public function testOrphanedPages()
 {
     $origStage = Versioned::get_reading_mode();
     // Setup user who can view draft content, but lacks cms permission.
     // To users such as this, orphaned pages should be inaccessible. canView for these pages is only
     // necessary for admin / cms users, who require this permission to edit / rearrange these pages.
     $permission = new Permission();
     $permission->Code = 'VIEW_DRAFT_CONTENT';
     $group = new Group(array('Title' => 'Staging Users'));
     $group->write();
     $group->Permissions()->add($permission);
     $member = new Member();
     $member->Email = 'someguy@example.com';
     $member->write();
     $member->Groups()->add($group);
     // both pages are viewable in stage
     Versioned::reading_stage('Stage');
     $about = $this->objFromFixture('Page', 'about');
     $staff = $this->objFromFixture('Page', 'staff');
     $this->assertFalse($about->isOrphaned());
     $this->assertFalse($staff->isOrphaned());
     $this->assertTrue($about->canView($member));
     $this->assertTrue($staff->canView($member));
     // Publishing only the child page to live should orphan the live record, but not the staging one
     $staff->publish('Stage', 'Live');
     $this->assertFalse($staff->isOrphaned());
     $this->assertTrue($staff->canView($member));
     Versioned::reading_stage('Live');
     $staff = $this->objFromFixture('Page', 'staff');
     // Live copy of page
     $this->assertTrue($staff->isOrphaned());
     // because parent isn't published
     $this->assertFalse($staff->canView($member));
     // Publishing the parent page should restore visibility
     Versioned::reading_stage('Stage');
     $about = $this->objFromFixture('Page', 'about');
     $about->publish('Stage', 'Live');
     Versioned::reading_stage('Live');
     $staff = $this->objFromFixture('Page', 'staff');
     $this->assertFalse($staff->isOrphaned());
     $this->assertTrue($staff->canView($member));
     // Removing staging page should not prevent live page being visible
     $about->deleteFromStage('Stage');
     $staff->deleteFromStage('Stage');
     $staff = $this->objFromFixture('Page', 'staff');
     $this->assertFalse($staff->isOrphaned());
     $this->assertTrue($staff->canView($member));
     // Cleanup
     Versioned::set_reading_mode($origStage);
 }

 /**
  * Gets the list of groups that can be set after the submission of a particular form
  *
  * This works around the problem with the checkboxsetfield which doesn't validate that the
  * groups that the user has selected are not validated against the list of groups the user is
  * allowed to choose from.
  *
  * @param Form   $form
  * @param Member $member
  */
 protected function getSettableGroupIdsFrom(Form $form, Member $member = null)
 {
     // first off check to see if groups were selected by the user. If so, we want
     // to remove that control from the form list (just in case someone's sent through an
     // ID for a group like, say, the admin's group...). It means we have to handle the setting
     // ourselves, but that's okay
     $groupField = $form->Fields()->dataFieldByName('Groups');
     // The list of selectable groups
     $groupIds = $allowedIds = $this->SelectableGroups()->map('ID', 'ID')->toArray();
     // we need to track the selected groups against the existing user's groups - this is
     // so that we don't accidentally remove them from the list of groups
     // a user might have been placed in via other means
     $existingIds = array();
     if ($member) {
         $existing = $member->Groups();
         if ($existing && $existing->Count() > 0) {
             $existingIds = $existing->map('ID', 'ID')->toArray();
             // remove any that are in the selectable groups map - we only want to
             // worry about those that aren't managed by this form
             foreach ($groupIds as $gid) {
                 unset($existingIds[$gid]);
             }
         }
     }
     if ($groupField) {
         $givenIds = $groupField->Value();
         $groupIds = array();
         if ($givenIds) {
             foreach ($givenIds as $givenId) {
                 if (isset($allowedIds[$givenId])) {
                     $groupIds[] = $givenId;
                 }
             }
         }
         $form->Fields()->removeByName('Groups');
     }
     foreach ($this->Groups()->column('ID') as $mustId) {
         $groupIds[] = $mustId;
     }
     foreach ($existingIds as $existingId) {
         if (!in_array($existingId, $groupIds)) {
             $groupIds[] = $existingId;
         }
     }
     return $groupIds;
 }

 /**
  * No validation errors occured, so we register the customer and send
  * mails with further instructions for the double opt-in procedure.
  *
  * @param SS_HTTPRequest $data       SS session data
  * @param Form           $form       the form object
  * @param array          $formData   CustomHTMLForms session data
  * @param bool           $doRedirect Set to true to redirect after submitSuccess
  *
  * @return void
  * 
  * @author Sebastian Diel <sdiel@pixeltricks.de>,
  *         Roland Lehmann <rlehmann@pixeltricks.de>,
  *         Sascha Koehler <skoehler@pixeltricks.de>
  * @since 28.01.2015
  */
 protected function submitSuccess($data, $form, $formData, $doRedirect = true)
 {
     $anonymousCustomer = false;
     /*
      * Logout anonymous users and save their shoppingcart temporarily.
      */
     if (SilvercartCustomer::currentUser()) {
         $anonymousCustomer = SilvercartCustomer::currentUser();
         SilvercartCustomer::currentUser()->logOut();
     }
     // Aggregate Data and set defaults
     $formData['MemberID'] = Member::currentUserID();
     $formData['Locale'] = Translatable::get_current_locale();
     if ($this->demandBirthdayDate()) {
         $formData['Birthday'] = $formData['BirthdayYear'] . '-' . $formData['BirthdayMonth'] . '-' . $formData['BirthdayDay'];
         if ($this->UseMinimumAgeToOrder()) {
             if (!SilvercartConfig::CheckMinimumAgeToOrder($formData['Birthday'])) {
                 $this->errorMessages['BirthdayDay'] = array('message' => SilvercartConfig::MinimumAgeToOrderError(), 'fieldname' => _t('SilvercartPage.BIRTHDAY'), 'BirthdayDay' => array('message' => SilvercartConfig::MinimumAgeToOrderError()));
                 $this->errorMessages['BirthdayMonth'] = array('message' => SilvercartConfig::MinimumAgeToOrderError(), 'fieldname' => _t('SilvercartPage.BIRTHDAY'), 'BirthdayMonth' => array('message' => SilvercartConfig::MinimumAgeToOrderError()));
                 $this->errorMessages['BirthdayYear'] = array('message' => SilvercartConfig::MinimumAgeToOrderError(), 'fieldname' => _t('SilvercartPage.BIRTHDAY'), 'BirthdayYear' => array('message' => SilvercartConfig::MinimumAgeToOrderError()));
                 $this->setSubmitSuccess(false);
                 return $this->submitFailure($data, $form);
             }
         }
     }
     // Create new regular customer and perform a log in
     $customer = new Member();
     // Pass shoppingcart to registered customer and delete the anonymous
     // customer.
     if ($anonymousCustomer) {
         $newShoppingCart = $anonymousCustomer->getCart()->duplicate(true);
         foreach ($anonymousCustomer->getCart()->SilvercartShoppingCartPositions() as $shoppingCartPosition) {
             $newShoppingCartPosition = $shoppingCartPosition->duplicate(false);
             $newShoppingCartPosition->SilvercartShoppingCartID = $newShoppingCart->ID;
             $newShoppingCartPosition->write();
             $shoppingCartPosition->transferToNewPosition($newShoppingCartPosition);
         }
         $customer->SilvercartShoppingCartID = $newShoppingCart->ID;
         $anonymousCustomer->delete();
     }
     $customer->castedUpdate($formData);
     $customer->write();
     $customer->logIn();
     $customer->changePassword($formData['Password']);
     $customerGroup = $this->getTargetCustomerGroup($formData);
     if ($customerGroup) {
         $customer->Groups()->add($customerGroup);
     }
     // Create ShippingAddress for customer and populate it with registration data
     $address = new SilvercartAddress();
     $address->castedUpdate($formData);
     $country = DataObject::get_by_id('SilvercartCountry', (int) $formData['Country']);
     if ($country) {
         $address->SilvercartCountryID = $country->ID;
     }
     $address->write();
     $this->extend('updateRegisteredAddress', $address, $data, $form, $formData);
     //connect the ShippingAddress and the InvoiceAddress to the customer
     $customer->SilvercartShippingAddressID = $address->ID;
     $customer->SilvercartInvoiceAddressID = $address->ID;
     $customer->SilvercartAddresses()->add($address);
     $customer->write();
     // Remove from the anonymous newsletter recipients list
     if (SilvercartAnonymousNewsletterRecipient::doesExist($customer->Email)) {
         $recipient = SilvercartAnonymousNewsletterRecipient::getByEmailAddress($customer->Email);
         if ($recipient->NewsletterOptInStatus) {
             $customer->NewsletterOptInStatus = 1;
             $customer->NewsletterConfirmationHash = $recipient->NewsletterOptInConfirmationHash;
             $customer->write();
         }
         SilvercartAnonymousNewsletterRecipient::removeByEmailAddress($customer->Email);
     }
     if ($customer->SubscribedToNewsletter && !$customer->NewsletterOptInStatus) {
         SilvercartNewsletter::subscribeRegisteredCustomer($customer);
     }
     $this->extend('updateRegisteredCustomer', $customer, $data, $form, $formData);
     if ($doRedirect) {
         // Redirect to welcome page
         if (array_key_exists('backlink', $formData) && !empty($formData['backlink'])) {
             $this->controller->redirect($formData['backlink']);
         } else {
             $this->controller->redirect($this->controller->PageByIdentifierCode('SilvercartRegisterConfirmationPage')->Link());
         }
     }
//.........这里部分代码省略.........

 /**
  * Create permissions, groups and member records if they don't exist.
  */
 public function requireDefaultRecords()
 {
     parent::requireDefaultRecords();
     $groups = array();
     // create or update groups, cache id by title
     foreach (self::$groups as $title => $description) {
         if (!($group = DataObject::get_one('Group', " Title = '{$title}'"))) {
             $group = new Group(array('Title' => $title));
         }
         // update description if exists, otherwise set
         $group->Description = $description;
         $group->write();
         $groups[$title] = $group->ID;
     }
     // create or update permissions and assign to associated group
     foreach (self::$permissions as $code => $groupTitle) {
         if (!($perm = DataObject::get_one('Permission', " Code = '{$code}' "))) {
             $perm = new Permission(array('Code' => $code));
         }
         $perm->GroupID = $groups[$groupTitle];
         $perm->write();
     }
     // if config option is true create or update members, then add Member to group
     if ($this->config()->get('create_members_and_assign_to_groups') === true) {
         foreach (self::$members as $memberInfo) {
             $email = $memberInfo['Email'];
             if (!($member = DataObject::get_one('Member', " Email = '{$email}' "))) {
                 $member = new Member();
             }
             // set or update data
             $member->update($memberInfo);
             $member->write();
             foreach (self::$member_groups[$email] as $groupTitle) {
                 // if not in the group already add it
                 $groupID = $groups[$groupTitle];
                 if (!$member->Groups()->filter('ID', $groupID)->first()) {
                     $member->Groups()->add($groupID);
                 }
                 $member->write();
             }
         }
     }
 }

 /**
  * Get all the workflows that this user is responsible for
  *
  * @param Member $user
  *				The user to get workflows for
  *
  * @return ArrayList
  *				The list of workflow instances this user owns
  */
 public function usersWorkflows(Member $user)
 {
     $groupIds = $user->Groups()->column('ID');
     $groupInstances = null;
     $filter = array('');
     if (is_array($groupIds)) {
         $groupInstances = DataList::create('WorkflowInstance')->filter(array('Group.ID:ExactMatchMulti' => $groupIds))->where('"WorkflowStatus" != \'Complete\'');
     }
     $userInstances = DataList::create('WorkflowInstance')->filter(array('Users.ID:ExactMatch' => $user->ID))->where('"WorkflowStatus" != \'Complete\'');
     if ($userInstances) {
         $userInstances = $userInstances->toArray();
     } else {
         $userInstances = array();
     }
     if ($groupInstances) {
         $groupInstances = $groupInstances->toArray();
     } else {
         $groupInstances = array();
     }
     $all = array_merge($groupInstances, $userInstances);
     return ArrayList::create($all);
 }

 private function createshopadmin()
 {
     $member = new Member();
     $member->FirstName = 'Shop';
     $member->Surname = 'Admin';
     $member->Email = 'shop@silverstripe-ecommerce.com';
     $member->SetPassword = 'test123';
     $member->Password = 'test123';
     $member->write();
     $group = EcommerceRole::get_admin_group();
     $member->Groups()->add($group);
 }

 /**
  * Returns allowed payment methods.
  * 
  * @param string                 $shippingCountry                  The SilvercartCountry to check the payment methods for.
  * @param SilvercartShoppingCart $shoppingCart                     The shopping cart object
  * @param Boolean                $forceAnonymousCustomerIfNotExist When true, an anonymous customer will be created when no customer exists
  * 
  * @return ArrayList
  * 
  * @author Sebastian Diel <sdiel@pixeltricks.de>,
  *         Sascha Koehler <skoehler@pixeltricks.de>
  * @since 15.11.2014
  */
 public static function getAllowedPaymentMethodsFor($shippingCountry, $shoppingCart, $forceAnonymousCustomerIfNotExist = false)
 {
     $allowedPaymentMethods = array();
     if (!$shippingCountry) {
         return $allowedPaymentMethods;
     }
     $paymentMethods = $shippingCountry->SilvercartPaymentMethods('isActive = 1');
     $member = SilvercartCustomer::currentUser();
     if (!$member && $forceAnonymousCustomerIfNotExist) {
         $member = new Member();
         $anonymousGroup = Group::get()->filter('Code', 'anonymous')->first();
         $memberGroups = new ArrayList();
         $memberGroups->push($anonymousGroup);
     } else {
         $memberGroups = $member->Groups();
     }
     $shippingMethodID = null;
     if (Controller::curr() instanceof SilvercartCheckoutStep_Controller) {
         $checkoutData = Controller::curr()->getCombinedStepData();
         if (array_key_exists('ShippingMethod', $checkoutData)) {
             $shippingMethodID = $checkoutData['ShippingMethod'];
         }
     }
     if ($paymentMethods) {
         foreach ($paymentMethods as $paymentMethod) {
             $assumePaymentMethod = true;
             $containedInGroup = false;
             $containedInUsers = false;
             $doAccessChecks = true;
             // ------------------------------------------------------------
             // Basic checks
             // ------------------------------------------------------------
             if ($paymentMethod->enableActivationByOrderRestrictions) {
                 $assumePaymentMethod = $paymentMethod->isActivationByOrderRestrictionsPossible($member);
                 $doAccessChecks = false;
             }
             $checkAmount = $shoppingCart->getAmountTotalWithoutFees()->getAmount();
             if (!$paymentMethod->isAvailableForAmount($checkAmount)) {
                 $assumePaymentMethod = false;
                 $doAccessChecks = false;
             }
             // ------------------------------------------------------------
             // Shipping method check
             // ------------------------------------------------------------
             if (!is_null($shippingMethodID) && $paymentMethod->SilvercartShippingMethods()->exists() && !$paymentMethod->SilvercartShippingMethods()->find('ID', $shippingMethodID)) {
                 $assumePaymentMethod = false;
                 $doAccessChecks = false;
             }
             // ------------------------------------------------------------
             // Access checks
             // ------------------------------------------------------------
             if ($doAccessChecks) {
                 // Check if access for groups or is set positively
                 if ($paymentMethod->ShowOnlyForGroups()->exists()) {
                     foreach ($paymentMethod->ShowOnlyForGroups() as $paymentGroup) {
                         if ($memberGroups->find('ID', $paymentGroup->ID)) {
                             $containedInGroup = true;
                             break;
                         }
                     }
                     if ($containedInGroup) {
                         $assumePaymentMethod = true;
                     } else {
                         $assumePaymentMethod = false;
                     }
                 }
                 // Check if access for users or is set positively
                 if ($paymentMethod->ShowOnlyForUsers()->exists()) {
                     if ($paymentMethod->ShowOnlyForUsers()->find('ID', $member->ID)) {
                         $containedInUsers = true;
                     }
                     if ($containedInUsers) {
                         $assumePaymentMethod = true;
                     } else {
                         if (!$containedInGroup) {
                             $assumePaymentMethod = false;
                         }
                     }
                 }
                 // Check if access for groups is set negatively
                 if ($paymentMethod->ShowNotForGroups()->exists()) {
                     foreach ($paymentMethod->ShowNotForGroups() as $paymentGroup) {
                         if ($memberGroups->find('ID', $paymentGroup->ID)) {
                             if (!$containedInUsers) {
                                 $assumePaymentMethod = false;
                             }
                         }
//.........这里部分代码省略.........

 /**
  * Get all the workflows that this user is responsible for
  * 
  * @param Member $user 
  *				The user to get workflows for
  * 
  * @return DataObjectSet
  *				The list of workflow instances this user owns
  */
 public function usersWorkflows(Member $user)
 {
     $all = new DataObjectSet();
     $groupIds = $user->Groups()->column('ID');
     $groupJoin = ' INNER JOIN "WorkflowInstance_Groups" "wig" ON "wig"."WorkflowInstanceID" = "WorkflowInstance"."ID"';
     if (is_array($groupIds)) {
         $filter = '("WorkflowStatus" = \'Active\' OR "WorkflowStatus"=\'Paused\') AND "wig"."GroupID" IN (' . implode(',', $groupIds) . ')';
         $groupAssigned = DataObject::get('WorkflowInstance', $filter, '"Created" DESC', $groupJoin);
         if ($groupAssigned) {
             $all->merge($groupAssigned);
         }
     }
     $userJoin = ' INNER JOIN "WorkflowInstance_Users" "wiu" ON "wiu"."WorkflowInstanceID" = "WorkflowInstance"."ID"';
     $filter = '("WorkflowStatus" = \'Active\' OR "WorkflowStatus"=\'Paused\') AND "wiu"."MemberID" = ' . $user->ID;
     $userAssigned = DataObject::get('WorkflowInstance', $filter, '"Created" DESC', $userJoin);
     if ($userAssigned) {
         $all->merge($userAssigned);
     }
     return $all;
 }

 /**
  * Creates an anonymous customer if there's no currentMember object.
  *
  * @return Member
  *
  * @author Sebastian Diel <sdiel@pixeltricks.de>,
  *         Sascha Koehler <skoehler@pixeltricks.de>
  * @since 15.11.2014
  */
 public static function createAnonymousCustomer()
 {
     $member = self::currentUser();
     if (!$member) {
         $member = new Member();
         $member->write();
         // Add customer to intermediate group
         $customerGroup = Group::get()->filter('Code', 'anonymous')->first();
         if ($customerGroup) {
             $member->Groups()->add($customerGroup);
         }
         $member->logIn(true);
     }
     return $member;
 }

 /**
  * Adds new member
  * 
  * @param	array	member data. 
  * @return	boolean	true/false
  */
 public function addMember($data)
 {
     if (is_array($data)) {
         $member = new Member();
         $member->Email = $data['ccustemail'];
         $member->FirstName = ucwords(strtolower($data['ccustfirstname']));
         $member->Surname = ucwords(strtolower($data['ccustlastname']));
         $member->ClickBankAccountType = 'Paid';
         $password = Member::create_new_password();
         $member->Password = "{$password}";
         /* link to memberprofilepage module */
         $profilePage = DataObject::get_one('MemberProfilePage');
         $member->ProfilePageID = $profilePage->ID;
         if ($profilePage->EmailType == 'Validation') {
             $email = new MemberConfirmationEmail($member->ProfilePage(), $member);
             $email->send();
             $member->NeedsValidation = true;
         } elseif ($profilePage->EmailType == 'Confirmation') {
             $email = new MemberConfirmationEmail($member->ProfilePage(), $member);
             $email->send();
         }
         /* populate new member profile */
         $clickBankProfile = new ClickBankMemberProfile();
         if ($clickBankProfile) {
             self::populateFields($clickBankProfile, $data);
         }
         $clickBankProfile->write();
         $member->ClickBankProfileID = $clickBankProfile->ID;
         // save new member
         $member->write();
         // assign & update new member to a ClickBank user group
         $clickBankGroupIds = $profilePage->getClickBankMemberGroups();
         if ($clickBankGroupIds) {
             $member->Groups()->setByIDList($clickBankGroupIds);
             $member->write();
         }
         // assign & update new member to a regular memberprofile user group
         $memberGroupIds = $profilePage->getMemberProfileGroups();
         if ($memberGroupIds) {
             $member->Groups()->setByIDList($memberGroupIds);
             $member->write();
         }
         /* Populate log */
         $clickBankIpnLog = new ClickBankIpnLog();
         $clickBankIpnLog->MemberID = $member->ID;
         foreach ($data as $key => $val) {
             if (isset($clickBankIpnLog->{$key})) {
                 $clickBankIpnLog->{$key} = $val;
             }
         }
         $clickBankIpnLog->write();
         return true;
     }
     return false;
 }