src/Services/ABTestManager.php line 53

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: jibi
  5.  * Date: 19/04/2018
  6.  * Time: 15:46
  7.  */
  9. namespace App\Services;
  11. use App\Entity\Main\Cart;
  12. use App\Entity\Main\Site;
  13. use App\Entity\Main\SiteABTest;
  14. use App\Entity\Main\SitePackTemplate;
  15. use App\Entity\Main\Tracking;
  16. use App\Entity\Main\TrackingHasABTest;
  17. use App\Entity\Main\User;
  18. use App\EventListener\Main\DebugListener;
  19. use Doctrine\Common\Collections\ArrayCollection;
  20. use Doctrine\Common\Collections\Collection;
  21. use Doctrine\ORM\EntityManagerInterface;
  22. use Doctrine\ORM\EntityRepository;
  23. use Psr\Log\LoggerInterface;
  24. use Symfony\Component\HttpFoundation\Request;
  25. use Symfony\Component\HttpFoundation\RequestStack;
  26. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  28. class ABTestManager
  29. {
  30.     const
  31.         SESSION_IDENTIFIER = 'client_test'
  32.     ;
  35.     private $activeTests;
  37.     private mixed $clientTests = null;
  38.     private ?Request $request;
  39.     private EntityRepository $siteABTestsRepo;
  40.     /**
  41.      * @var array|mixed
  42.      */
  43.     private mixed $forcedABTests;
  45.     public function __construct(
  46.         private RequestStack $requestStack,
  47.         private EntityManagerInterface $entityManager,
  48.         private LoggerInterface $logger,
  49.         private $redisClient
  50.     ) {
  51.         $this->request = $this->requestStack->getCurrentRequest();
  52.         if ($this->request) {
  53.             $this->clientTests = $this->requestStack->getSession()->get(self::SESSION_IDENTIFIER);
  54.             $this->forcedABTests = $this->requestStack->getSession()->get(DebugListener::DEBUG_DATA_SESSION)[DebugListener::DEBUG_FORCED_ABTESTS] ?? [];
  55.         }
  57.         // If some AB tests are forced, we use them here.
  58.         $this->siteABTestsRepo = $entityManager->getRepository(SiteABTest::class);
  59.     }
  61.     /**
  62.      * @param Tracking $tracking
  63.      * @return array|mixed|null
  64.      */
  65.     public function getTestsForTracking(Tracking $tracking)
  66.     {
  67.         if (null == $this->clientTests) {
  68.             try {
  69.                 $this->clientTests = $tracking->getAbTests();
  70.             } catch (\Exception $e) {
  71.                 $this->logger->critical("Could not access tracking ABTESTS with the following exception : {$e->getMessage()}");
  72.                 $this->clientTests = [];
  73.             }
  74.         }
  76.         return $this->clientTests;
  77.     }
  79.     /**
  80.      * @return ArrayCollection|null
  81.      */
  82.     public function getActiveTests()
  83.     {
  84.         if (count($this->activeTests)) {
  85.             return $this->activeTests;
  86.         }
  87.     }
  89.     /**
  90.      * $registered will only create ab test for registered clients.
  91.      * it shouldn't be used for anonymous users.
  92.      *
  93.      * @param Tracking $tracking
  94.      * @param Site $site
  95.      * @param string $testType
  96.      * @param bool $save
  97.      * @throws \Exception
  98.      */
  99.     public function generateTestsForTracking(Tracking $tracking, Site $site, $testType = SiteABTest::TYPE_GENERAL, $save = true)
  100.     {
  101.         if (count($tracking->getAbTests()) && !in_array($testType, [SiteABTest::TYPE_REGISTERED, SiteABTest::TYPE_CART_SWITCH])) {
  102.             $this->logger->critical("Trying to add new ab test to an existing tracking.");
  103.             return;
  104.         }
  106.         $this->loadActiveTests($site);
  107.         $needSave = false;
  109.         // create new tests for this tracking
  110.         if (count($this->activeTests) && !in_array($testType, [SiteABTest::TYPE_REGISTERED, SiteABTest::TYPE_CART_SWITCH])) {
  111.             /** @var SiteABTest $activeTest */
  112.             foreach ($this->activeTests as $activeTest) {
  113.                 if ($activeTest->isActive() && $activeTest->isGeneral() && $this->isEligibleForTest($tracking, $activeTest)) {
  114.                     $version = $this->getVersionForTest($activeTest);
  116.                     // For the test for new design, Chris want us to keep the version of the test in the tracking o3 field.
  117.                     if ($activeTest->getAlias() == SiteABTest::BRU_DESIGN_V_ALIAS) {
  118.                         $tracking->setO3($version);
  119.                     }
  121.                     $newTest = new TrackingHasABTest();
  122.                     $newTest->setSiteAbTest($activeTest);
  123.                     $newTest->setTracking($tracking);
  124.                     $newTest->setVersion($version);
  125.                     $this->entityManager->persist($newTest);
  126.                     $tracking->addAbTest($newTest);
  127.                     $needSave = true;
  128.                 }
  129.             }
  131.             if ($needSave && $save) {
  132.                 $this->entityManager->flush();
  133.             }
  134.             return;
  135.         }
  137.         // if this is for registered user, we create only registered abTests
  138.         // We create those test ONLY if there is not already a registered user for this tracking.
  139.         if (count($this->activeTests) && $testType == SiteABTest::TYPE_REGISTERED && count($tracking->getUsers()) < 2) {
  140.             /** @var SiteABTest $activeTest */
  141.             foreach ($this->activeTests as $activeTest) {
  142.                 if ($activeTest->isActive() && $activeTest->isForRegisteredUsers() && $this->isEligibleForTest($tracking, $activeTest)) {
  143.                     $version = $this->getVersionForTest($activeTest);
  144.                     $newTest = new TrackingHasABTest();
  145.                     $newTest->setSiteAbTest($activeTest);
  146.                     $newTest->setTracking($tracking);
  147.                     $newTest->setVersion($version);
  148.                     $this->entityManager->persist($newTest);
  149.                     $tracking->addAbTest($newTest);
  150.                     $needSave = true;
  151.                 }
  152.             }
  154.             if ($needSave && $save) {
  155.                 $this->entityManager->flush();
  156.             }
  157.             return;
  158.         }
  160.         // if this is for cart switch, we create only cartSwitch abTests
  161.         // We create those test ONLY if there is not already a registered user for this tracking.
  162.         if (count($this->activeTests) && $testType == SiteABTest::TYPE_CART_SWITCH && count($tracking->getUsers()) < 2) {
  163.             /** @var SiteABTest $activeTest */
  164.             foreach ($this->activeTests as $activeTest) {
  165.                 if ($activeTest->isActive() && $activeTest->isForCartSwitch() && $this->isEligibleForTest($tracking, $activeTest)) {
  166.                     $version = $this->getVersionForTest($activeTest);
  167.                     $newTest = new TrackingHasABTest();
  168.                     $newTest->setSiteAbTest($activeTest);
  169.                     $newTest->setTracking($tracking);
  170.                     $newTest->setVersion($version);
  171.                     $this->entityManager->persist($newTest);
  172.                     $tracking->addAbTest($newTest);
  173.                     $needSave = true;
  174.                 }
  175.             }
  177.             if ($needSave && $save) {
  178.                 $this->entityManager->flush();
  179.             }
  181.             return;
  182.         }
  183.     }
  185.     /**
  186.      * Check if a cart can receive some switch abtest OR a specific one if a siteABtest is provided.
  187.      *
  188.      * @param Cart $cart
  189.      * @param Site $site
  190.      * @param SiteABTest|null $siteABTest
  191.      * @return bool
  192.      */
  193.     public function cartCanReceiveSwitchTest(Cart $cart, Site $site, SiteABTest $siteABTest = null)
  194.     {
  195.         // if this cart has no user, he can't receive an ABtest.
  196.         if (!$cart->getUser() instanceof User) {
  197.             return false;
  198.         }
  200.         // Carts with custom packs don't receive any switch AB test.
  201.         if ($cart->isWithCustomPack()) {
  202.             return false;
  203.         }
  205.         // a user that already purchased, can't get a switch test
  206.         if ($cart->getUser() instanceof User && $cart->getUser()->getLastOrder() instanceof Cart) {
  207.             return false;
  208.         }
  210.         if ($siteABTest instanceof SiteABTest) {
  211.             if (!$siteABTest->isForCartSwitch() || !$siteABTest->isActive()) {
  212.                 return false;
  213.             }
  215.             $abTests = [$siteABTest];
  216.         } else {
  217.             $this->loadActiveTests($site);
  219.             // If not active Test, then no :)
  220.             if (!count($this->activeTests)) {
  221.                 return false;
  222.             }
  224.             $abTests = $this->activeTests;
  225.         }
  227.         // ok so if there is an ABtest for cartSwitch that was created before the registration of this user, we can apply it.
  228.         /** @var SiteABTest $activeTest */
  229.         foreach ($abTests as $activeTest) {
  230.             if ($activeTest->isActive() && $activeTest->isForCartSwitch() && $cart->getUser()->getCreationStamp() >= $activeTest->getDateStarted()) {
  231.                 return true;
  232.             }
  233.         }
  235.         return false;
  236.     }
  238.     /**
  239.      * @param User $user
  240.      * @param Site $site
  241.      * @param SiteABTest|null $siteABTest
  242.      * @return bool
  243.      */
  244.     public function userCanReceiveRegisterTest(User $user, Site $site, SiteABTest $siteABTest = null)
  245.     {
  246.         if ($siteABTest instanceof SiteABTest) {
  247.             if (!$siteABTest->isForRegisteredUsers() || !$siteABTest->isActive()) {
  248.                 return false;
  249.             }
  251.             $abTests = [$siteABTest];
  252.         } else {
  253.             $this->loadActiveTests($site);
  255.             // If not active Test, then no :)
  256.             if (!count($this->activeTests)) {
  257.                 return false;
  258.             }
  260.             $abTests = $this->activeTests;
  261.         }
  263.         // When a user is logged in, his tracking is ALWAYS the same than the current tracking, so we can use his tracking.
  264.         $tracking = $user->getTracking();
  266.         // ok so if there is an ABtest for register that was created before the registration of this user, we can apply it.
  267.         /** @var SiteABTest $activeTest */
  268.         foreach ($abTests as $activeTest) {
  269.             if ($activeTest->isActive() && $activeTest->isForRegisteredUsers() && $user->getCreationStamp() >= $activeTest->getDateStarted() && $this->userIsEligibleForTest($user, $activeTest)) {
  270.                 return true;
  271.             }
  272.         }
  274.         return false;
  275.     }
  277.     /**
  278.      * @param Tracking $tracking
  279.      * @param $version
  280.      * @return bool
  281.      */
  282.     public function hasTest(Tracking $tracking, $version)
  283.     {
  284.         $hasVersion = false;
  285.         $clientTests = $this->getTestsForTracking($tracking);
  287.         // If some forced test are provided in the session, we use only those.
  288.         $debugData = $this->requestStack->getSession()->get(DebugListener::DEBUG_DATA_SESSION);
  290.         if (!empty($debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  291.             $hasTest = false;
  293.             if (is_array($version)) {
  294.                 foreach ($version as $loopVersion) {
  295.                     if (in_array($loopVersion, $debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  296.                         $hasTest = true;
  297.                         break;
  298.                     }
  299.                 }
  300.             } else {
  301.                 if (in_array($version, $debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  302.                     $hasTest = true;
  303.                 }
  304.             }
  306.             return $hasTest;
  307.         }
  309.         if (count($this->clientTests) && is_string($version)) {
  310.             /** @var TrackingHasABTest $clientTest */
  311.             foreach ($clientTests as $clientTest) {
  312.                 if ($clientTest->getVersion() == $version && $clientTest->getSiteABTest()->isActive()) {
  313.                     $hasVersion = true;
  314.                 }
  315.             }
  316.         } elseif (count($this->clientTests) && is_array($version) && count($version)) {
  317.             /** @var TrackingHasABTest $clientTest */
  318.             foreach ($clientTests as $clientTest) {
  319.                 foreach ($version as $string) {
  320.                     if ($clientTest->getVersion() == $string && $clientTest->getSiteABTest()->isActive()) {
  321.                         $hasVersion = true;
  322.                     }
  323.                 }
  324.                 if ($hasVersion) {
  325.                     break;
  326.                 }
  327.             }
  328.         }
  330.         return $hasVersion;
  331.     }
  333.     /**
  334.      * @param Cart $cart
  335.      * @param $version
  336.      * @return bool
  337.      */
  338.     public function cartHasTest(Cart $cart, $version)
  339.     {
  340.         $hasVersion = false;
  341.         $cartTests = $cart->getAbTests();
  343.         // If some forced test are provided in the session, we use only those.
  344.         $debugData = $this->requestStack->getSession()->get(DebugListener::DEBUG_DATA_SESSION);
  346.         if (!empty($debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  347.             $hasTest = false;
  349.             if (is_array($version)) {
  350.                 foreach ($version as $loopVersion) {
  351.                     if (in_array($loopVersion, $debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  352.                         $hasTest = true;
  353.                         break;
  354.                     }
  355.                 }
  356.             } else {
  357.                 if (in_array($version, $debugData[DebugListener::DEBUG_FORCED_ABTESTS])) {
  358.                     $hasTest = true;
  359.                 }
  360.             }
  362.             return $hasTest;
  363.         }
  365.         if (count($cartTests) && is_string($version)) {
  366.             /** @var TrackingHasABTest $cartTest */
  367.             foreach ($cartTests as $cartTest) {
  368.                 if ($cartTest->getVersion() == $version && $cartTest->getSiteABTest()->isActive()) {
  369.                     $hasVersion = true;
  370.                 }
  371.             }
  372.         } elseif (count($cartTests) && is_array($version) && count($version)) {
  373.             /** @var TrackingHasABTest $clientTest */
  374.             foreach ($cartTests as $cartTest) {
  375.                 foreach ($version as $string) {
  376.                     if ($cartTest->getVersion() == $string && $cartTest->getSiteABTest()->isActive()) {
  377.                         $hasVersion = true;
  378.                     }
  379.                 }
  380.                 if ($hasVersion) {
  381.                     break;
  382.                 }
  383.             }
  384.         }
  386.         return $hasVersion;
  387.     }
  389.     /**
  390.      * This is used for the free shipping AB test.
  391.      * @return mixed
  392.      */
  393.     public function getFreeShippingTestValues()
  394.     {
  395.         return json_decode('{"AT":{"0-+":0},"BE":{"0-+":0},"BL":{"0-+":0},"CA":{"0-+":0},"CH":{"0-+":0},"CZ":{"0-+":0},"DE":{"0-+":0},"DK":{"0-+":0},"ES":{"0-+":0},"FR":{"0-+":0},"GF":{"0-+":0},"GP":{"0-+":0},"GR":{"0-+":0},"HU":{"0-+":0},"IE":{"0-+":0},"IT":{"0-+":0},"LU":{"0-+":0},"MF":{"0-+":0},"MQ":{"0-+":0},"NC":{"0-+":0},"NL":{"0-+":0},"PF":{"0-+":0},"PL":{"0-+":0},"PM":{"0-+":0},"PT":{"0-+":0},"RE":{"0-+":0},"RO":{"0-+":0},"SE":{"0-+":0},"UK":{"0-+":0},"US":{"0-+":0},"WF":{"0-+":0},"YT":{"0-+":0}}', true);
  396.     }
  398.     /**
  399.      * @param Tracking $tracking
  400.      * @param array $packList
  401.      * @return array
  402.      */
  403.     public function getPacksForTracking(Tracking $tracking, $packList = [])
  404.     {
  405.         $abTestsList = $this->getTestsForTracking($tracking);
  406.         $abTestVersionArray = $this->getABTestsVersionsFromList($abTestsList);
  408.         return $this->filterPacksWithABTests($abTestVersionArray, $packList);
  409.     }
  411.     /**
  412.      * Get an array of the versions of ab tests of a tracking
  413.      * @param Tracking $tracking
  414.      * @param false $checkActiveTests
  415.      * @return array
  416.      */
  417.     public function getTrackingABTestsVersions(Tracking $tracking, $checkActiveTests = false)
  418.     {
  419.         $trackingABTestVersions = $tracking->getAbTests();
  421.         return $this->getABTestsVersionsFromList($trackingABTestVersions, $checkActiveTests);
  422.     }
  424.     /**
  425.      * @param $abTestAlias
  426.      * @return bool
  427.      */
  428.     public function siteABTestIsActive($abTestAlias): bool
  429.     {
  430.         $siteABTest =  $this->siteABTestsRepo->findOneBy(['alias' => $abTestAlias]);
  432.         if (!$siteABTest instanceof SiteABTest) {
  433.             return false;
  434.         }
  436.         if (!$siteABTest->isActive()) {
  437.             return false;
  438.         }
  440.         return true;
  441.     }
  443.     /**
  444.      * @param array $abTestsList
  445.      * @param array $packsList
  446.      * @return array
  447.      */
  448.     protected function filterPacksWithABTests(array $abTestsList, array $packsList)
  449.     {
  450.         $allPacks = [];
  451.         $exclusivePacks = [];
  453.         /** @var SitePackTemplate $pack */
  454.         foreach ($packsList as $pack) {
  455.             $packAbTests = $pack->getAbTestVersion();
  456.             $found = false;
  458.             foreach ($packAbTests as $abTestName => $abTestData) {
  459.                 if (in_array($abTestName, $abTestsList)) {
  460.                     $found = true;
  461.                     if (SitePackTemplate::AB_TEST_EXCLUSIVE === $abTestData['type']) {
  462.                         $exclusivePacks[] = $pack;
  463.                     } else {
  464.                         $allPacks[] = $pack;
  465.                     }
  466.                 }
  467.             }
  469.             if (!$found && empty($packAbTests)) {
  470.                 $allPacks[] = $pack;
  471.             }
  472.         }
  474.         // from here we choose what pack he will receive. If there is a single exclusive pack then we
  475.         // just take the exclusive ones.
  476.         if (count($exclusivePacks)) {
  477.             $packsToReturn = $exclusivePacks;
  478.         } else {
  479.             $packsToReturn = $allPacks;
  480.         }
  482.         return $packsToReturn;
  483.     }
  485.     /**
  486.      * @param Collection $abTestsList
  487.      * @param false $checkActiveTests
  488.      * @return array
  489.      */
  490.     protected function getABTestsVersionsFromList(Collection $abTestsList, $checkActiveTests = false)
  491.     {
  492.         $abTestVersionsArray = [];
  493.         if (count($abTestsList)) {
  494.             foreach ($abTestsList as $abTest) {
  495.                 if ($checkActiveTests) {
  496.                     if ($abTest->getSiteABTest()->isActive()) {
  497.                         $abTestVersionsArray[] = $abTest->getVersion();
  498.                     }
  499.                 } else {
  500.                     $abTestVersionsArray[] = $abTest->getVersion();
  501.                 }
  502.             }
  503.         }
  505.         return $abTestVersionsArray;
  506.     }
  508.     /**
  509.      * Choose and return the version for an AB test.
  510.      * this function update the test stats too.
  511.      *
  512.      * @param SiteABTest $siteABTest
  513.      * @return string
  514.      * @throws \Exception
  515.      */
  516.     private function getVersionForTest(SiteABTest $siteABTest)
  517.     {
  518.         $alias = $siteABTest->getAlias();
  519.         $version = $this->selectVersion($siteABTest);
  520.         $this->addSelectedClient($siteABTest, $version);
  522.         return "{$alias}_{$version}";
  523.     }
  525.     /**
  526.      * This function will attribute a version for the test.
  527.      * There is two way to assign a version :
  528.      * 1 - random, we take the chances and we assign randomly
  529.      * 2 - deterministic, if the config is in "closing_mode" (put true in json config) we fill the missing options
  530.      * depending on the target %
  531.      *
  532.      * @param SiteABTest $siteABTest
  533.      * @return int|string
  534.      */
  535.     private function selectVersion(SiteABTest $siteABTest)
  536.     {
  537.         $actualStats = $this->getStatsFromRedis($siteABTest);
  539.         $config = $siteABTest->getConfig();
  541.         if (!isset($config['closing_mode']) or !$config['closing_mode']) {
  542.             $selectedVersion = $this->getRandomVersion($actualStats, $siteABTest);
  543.         } else {
  544.             $selectedVersion = $this->getDeterministicVersion($actualStats, $siteABTest);
  546.             // if we couldn't determine a version, choose a random one.
  547.             if (null === $selectedVersion) {
  548.                 $selectedVersion = $this->getRandomVersion($actualStats, $siteABTest);
  549.             }
  550.         }
  552.         return $selectedVersion;
  553.     }
  555.     /**
  556.      * @param SiteABTest $siteABTest
  557.      * @param $selectedVersion
  558.      * @param bool $save
  559.      * @throws \Exception
  560.      */
  561.     private function addSelectedClient(SiteABTest $siteABTest, $selectedVersion, $save = true)
  562.     {
  563.         // get updated stats from redis.
  564.         $actualStats = $this->getStatsFromRedis($siteABTest);
  566.         $actualStats['total']++;
  567.         $actualStats['options'][$selectedVersion]['count']++;
  569.         foreach ($actualStats['options'] as $version => $data) {
  570.             if (0 == $data['count']) {
  571.                 $actualStats['options'][$version]['percent'] = 0;
  572.             } else {
  573.                 $percent = ($actualStats['options'][$version]['count'] / $actualStats['total']) * 100;
  574.                 $actualStats['options'][$version]['percent'] = round($percent);
  575.             }
  576.         }
  578.         // save them back to redis just after.
  579.         $this->setStatsToRedis($actualStats, $siteABTest);
  581.         // save every 20 counter in the db. (to prevent db overload we use redis as main counter.)
  582.         // or if test must be ended.
  583.         if (($save && 0 == ($actualStats['total'] % 20)) or $this->checkTestIsEnded($actualStats, $siteABTest)) {
  584.             $siteABTest->setStats($actualStats);
  585.             $this->entityManager->flush();
  586.         }
  587.     }
  589.     /**
  590.      * @param $actualStats
  591.      * @param SiteABTest $siteABTest
  592.      * @return bool
  593.      * @throws \Exception
  594.      */
  595.     private function checkTestIsEnded($actualStats, SiteABTest $siteABTest)
  596.     {
  597.         $now = new \DateTime();
  598.         $maxTest = $siteABTest->getConfig()['count_end'];
  599.         $endDate = $siteABTest->getConfig()['date_end'];
  600.         $ended = false;
  602.         if (null != $maxTest && $actualStats['total'] >= $maxTest) {
  603.             $ended = true;
  604.         } elseif (null != $endDate) {
  605.             $endDate = new \DateTime($endDate);
  606.             if ($now >= $endDate) {
  607.                 $ended = true;
  608.             }
  609.         }
  611.         if (true === $ended) {
  612.             $siteABTest->setActive(false);
  613.         }
  615.         return $ended;
  616.     }
  618.     /**
  619.      * @param $actualStats
  620.      * @return mixed
  621.      * @throws \LogicException
  622.      */
  623.     private function getRandomVersion($actualStats, SiteABTest $siteABTest)
  624.     {
  625.         $randomValue = mt_rand(1, 100);
  626.         $counter = 0;
  627.         $possibleVersions = $siteABTest->getPossibleVersions();
  629.         foreach ($actualStats['options'] as $option => $data) {
  630.             $counter += $data['target'];
  631.             if ($randomValue <= $counter) {
  632.                 if (in_array($option, $possibleVersions)) {
  633.                     $selectedVersion = $option;
  634.                 }
  635.                 break;
  636.             }
  637.         }
  639.         if (!isset($selectedVersion)) {
  640.             throw new \LogicException(
  641.                 "Unable to assign version, there must be a problem in your configuration, are you sure you have assigned 100% of votes ?"
  642.             );
  643.         }
  645.         return $selectedVersion;
  646.     }
  648.     /**
  649.      * @param $actualStats
  650.      * @return null|string
  651.      */
  652.     private function getDeterministicVersion($actualStats, SiteABTest $siteABTest)
  653.     {
  654.         $selectedVersion = null;
  656.         $possibleVersions = $siteABTest->getPossibleVersions();
  658.         foreach ($actualStats['options'] as $option => $data) {
  659.             if ($data['percent'] < $data['target']) {
  660.                 if (in_array($option, $possibleVersions)) {
  661.                     $selectedVersion = $option;
  662.                 }
  663.                 break;
  664.             }
  665.         }
  667.         if (!isset($selectedVersion)) {
  668.             throw new \LogicException(
  669.                 "Unable to assign version, there must be a problem in your configuration, are you sure you have assigned 100% of votes ?"
  670.             );
  671.         }
  673.         return $selectedVersion;
  674.     }
  676.     /**
  677.      * Get stats for a splitTest from redis
  678.      *
  679.      * @param SiteABTest $siteABTest
  680.      * @return mixed
  681.      */
  682.     private function getStatsFromRedis(SiteABTest $siteABTest)
  683.     {
  684.         $websiteIdentifier = $siteABTest->getSite()->getSiteId();
  685.         $splitTestIdentifier = $siteABTest->getRedisKey();
  686.         $key = $websiteIdentifier . "_" . $splitTestIdentifier;
  688.         $stats = $this->redisClient->get($key);
  689.         // no stats in redis, we need to initialise them
  690.         if (null == $stats) {
  691.             $stats = $siteABTest->getStats();
  692.             $this->setStatsToRedis($stats, $siteABTest);
  693.         } else {
  694.             $stats = json_decode($stats, true);
  695.         }
  697.         return $stats;
  698.     }
  700.     /**
  701.      * Set stats to redis.
  702.      *
  703.      * @param $stats
  704.      * @param SiteABTest $siteABTest
  705.      * @return mixed
  706.      */
  707.     private function setStatsToRedis($stats, SiteABTest $siteABTest)
  708.     {
  709.         $websiteIdentifier = $siteABTest->getSite()->getSiteId();
  710.         $splitTestIdentifier = $siteABTest->getRedisKey();
  711.         $key = $websiteIdentifier . "_" . $splitTestIdentifier;
  713.         $stats = json_encode($stats);
  715.         $result = $this->redisClient->setex($key, 604800, $stats);
  717.         return $result;
  718.     }
  720.     /**
  721.      * @param Site $site
  722.      */
  723.     private function loadActiveTests(Site $site)
  724.     {
  725.         $this->activeTests = $site->getAbTests();
  726.     }
  728.     /**
  729.      * Check if the tracking is eligible for this AB test.
  730.      *
  731.      * @param Tracking $tracking
  732.      * @param SiteABTest $siteABTest
  733.      * @return bool
  734.      */
  735.     private function isEligibleForTest(Tracking $tracking, SiteABTest $siteABTest)
  736.     {
  737.         // If this tracking already have this ABTest, don't add it again.
  738.         if ($tracking->alreadyHaveABTest($siteABTest)) {
  739.             return false;
  740.         }
  742.         // Check if this ABtest should not be applied to some specific affiliates.
  743.         if (array_key_exists(SiteABTest::TYPE_EXCLUDE_AFF, $siteABTest->getConfig())) {
  744.             $affiliatesToExclude = $siteABTest->getConfig()[SiteABTest::TYPE_EXCLUDE_AFF];
  746.             if (in_array($tracking->getAff()->getAffiliateId(), $affiliatesToExclude)) {
  747.                 return false;
  748.             }
  749.         }
  751.         // Check if this ABtest should be applied to some specific affiliates.
  752.         if (array_key_exists(SiteABTest::CONFIG_ALLOWED_AFF, $siteABTest->getConfig()) && count($siteABTest->getConfig()[SiteABTest::CONFIG_ALLOWED_AFF])) {
  753.             $allowedAffiliates = $siteABTest->getConfig()[SiteABTest::CONFIG_ALLOWED_AFF];
  754.             if (!in_array($tracking->getAff()->getAffiliateId(), $allowedAffiliates)) {
  755.                 return false;
  756.             }
  757.         }
  759.         return true;
  760.     }
  762.     /**
  763.      * Check if User is eligible for this AB test.
  764.      *
  765.      * @param User $user
  766.      * @param SiteABTest $siteABTest
  767.      * @return bool
  768.      */
  769.     private function userIsEligibleForTest(User $user, SiteABTest $siteABTest)
  770.     {
  771.         // If this User already have this ABTest, don't add it again.
  772.         if ($user->alreadyHaveABTest($siteABTest)) {
  773.             return false;
  774.         }
  776.         // Check if this ABtest should not be applied to some specific affiliates.
  777.         if (array_key_exists(SiteABTest::TYPE_EXCLUDE_AFF, $siteABTest->getConfig())) {
  778.             $affiliatesToExclude = $siteABTest->getConfig()[SiteABTest::TYPE_EXCLUDE_AFF];
  780.             if (in_array($user->getTracking()->getAff()->getAffiliateId(), $affiliatesToExclude)) {
  781.                 return false;
  782.             }
  783.         }
  785.         return true;
  786.     }
  787. }