public function getFunctionByScenarioTestSetAndPosition($position, EiScenario $ei_scenario = null, EiTestSet $ei_test_set = null) { if ($position == null || $ei_scenario == null || $ei_test_set == null) { return null; } $q = Doctrine_Core::getTable('EiFonction')->createQuery('f')->where('EiTestSetFunction.ei_fonction_id=f.id And EiTestSetFunction.ei_test_set_id=? And EiTestSetFunction.position=?', array($ei_test_set->getId(), $position))->andWhere('EiTestSet.id=EiTestSetFunction.ei_test_set_id And EiTestSet.ei_scenario_id=?', array($ei_scenario->getId()))->execute(); if (count($q) > 0) { return $q->getFirst(); } return null; }
/** * @param EiTestSet $testSet * @param int $position * * @updated 18/08/2015 */ private function generateTestSetFunctionFromPosition(EiTestSet $testSet, $position = 1, EiIteration $iteration = null) { // Si la fonction n'a pas encore été chargée dans le jeu de test, on le fait. if ($testSet->getFunctionAt($position) === null) { // Récupération de la version de la structure. /** @var EiProfilScenario $profilScenario */ $profilScenario = Doctrine_Core::getTable("EiProfilScenario")->findOneByEiScenarioIdAndProfileIdAndProfileRef($testSet->getEiScenarioId(), $testSet->getProfileId(), $testSet->getProfileRef()); /** @var EiVersion $version */ $version = $profilScenario->getEiVersion(); /** @var EiVersionStructure $rootStructure */ $rootStructure = Doctrine_Core::getTable("EiVersionStructure")->getEiVersionStructureRootId($version->getId()); $chrono = new Chronometre(); $globalCh = $chrono->lancerChrono("Génération de la fonction à la position " . $position, true); if ($rootStructure !== null) { $conn = Doctrine_Manager::connection(); //************************************************************// //***** CREATION DES PARAMETRES DU BLOCK SUIVANT *****// //************************************************************// $start = $chrono->lancerChrono("RECHERCHE PROCHAIN BLOCK", true); // Récupération de l'instance de la table EiTestSetBlockParam /** @var EiTestSetBlockParamTable $tableJDTBP */ $tableJDTBP = Doctrine_Core::getTable("EiTestSetBlockParam"); // Récupération de la table de gestion de la pile. /** @var EiTestSetBlockStackTable $tableJDTS */ $tableJDTS = Doctrine_Core::getTable("EiTestSetBlockStack"); try { $conn->beginTransaction(); // Récupération de la dernière fonction exécutée. /** @var EiTestSetFunction $lastFunc */ $lastFunc = Doctrine_Core::getTable("EiTestSetFunction")->findOneByPositionAndEiTestSetId($position - 1, $testSet->getId()); // Récupération du block dans la stack. $path = $lastFunc == null ? EiTestSetFunction::getDefaultPath() : $lastFunc->getPath(); $blockStack = $tableJDTS->getLastElementFromPath($testSet->getId(), $path); do { // var_dump("------------- BEGIN -------------"); // if( $blockStack != null ) // var_dump($blockStack->toArray(false)); // Récupération du block suivant à la position -1. $nextBlock = $testSet->getNextBlock(is_bool($lastFunc) ? null : $lastFunc, is_bool($blockStack) ? null : $blockStack, $conn); // if ($nextBlock != null){ // var_dump($nextBlock->toArray(false)); // var_dump("First fragment is a function ? " . ($nextBlock->firstFragmentElementIsFunction() ? 1:0)); // } if ($nextBlock != null) { $start2 = $chrono->lancerChrono("GENERATION DES PARAMETRES DE BLOCKS", true); // Génération de ses paramètres dans le JDT. /** @var EiTestSetBlockParam $blockParam */ $tableJDTBP->generate($testSet, $nextBlock, $conn); $chrono->arreterEtAfficherChrono("GENERATION DES PARAMETRES DE BLOCKS", $start2); } // var_dump("------------- END -------------"); } while ($nextBlock != null && !$nextBlock->firstFragmentElementIsFunction() && ($blockStack = $nextBlock)); // var_dump($nextBlock->toArray(false)); // var_dump($nextBlock->getEiTestSetBlockStackParent()->toArray(false)); // exit; $chrono->arreterEtAfficherChrono("RECHERCHE PROCHAIN BLOCK", $start); //*****************************************************// //***** GENERATION DES FICHIERS XML & XSL *****// //*****************************************************// $start = $chrono->lancerChrono("Génération XML Mapping Data Set METHODE 1", true); // On génére les paramètres de blocks à partir de la branche du block. if ($nextBlock != null) { $xml = $nextBlock->generateBlockParametersXML(); } else { $xml = $testSet->generateBlockParametersXML(); } $chrono->arreterEtAfficherChrono("Génération XML Mapping Data Set METHODE 1", $start); // echo $xml; $start = $chrono->lancerChrono("Génération XSL Test Set", true); // Récupération de la liste des fonctions du fragment. $functionsList = $nextBlock != null ? $nextBlock->getFragmentsFunctions() : array(); // var_dump($functionsList); // Si block if ($nextBlock != null && $nextBlock->getPartIndex() != $nextBlock->getPartsCount()) { $xsl = $nextBlock->generateXSLForTestSet($functionsList); } elseif ($nextBlock != null) { $xsl = $nextBlock->generateXSLForTestSet($functionsList); } else { $xsl = $testSet->getEiVersion()->generateXSLForTestSet(); } $chrono->arreterEtAfficherChrono("Génération XSL Test Set", $start); // echo $xsl; //exit; $start = $chrono->lancerChrono("Génération XML Test Set", true); if ($nextBlock != null) { $testSet->generateFromXML($xsl, $xml, $position, $iteration); } $chrono->arreterEtAfficherChrono("Génération XML Test Set", $start); $testSet->save($conn); // Validation des éléments. $tableJDTS->validateStackElements($testSet->getId(), $conn); $conn->commit(); } catch (Exception $exc) { // TODO : à supprimer var_dump($exc->getMessage(), $exc->getTraceAsString()); $conn->rollback(); } } $chrono->arreterEtAfficherChrono("Génération de la fonction à la position " . $position, $globalCh); } }
/** * @param EiTestSet $testSet * @param EiTestSetBlockParam $parent * @param null $index * @param string $path * @return mixed */ public function generateTestSetParameters(EiTestSet $testSet = null, $parent = null, $index = null, $path = "", $deep = false, Doctrine_Connection $conn = null) { $conn = $conn == null ? Doctrine_Manager::connection() : $conn; $path .= "/" . $this->getName(); $chronometre = new Chronometre(); $recupStr = $chronometre->lancerChrono("Récupération structure param", true); // Vérification si l'élément existe. /** @var EiTestSetBlockParam $element */ $element = EiTestSetBlockParamTable::getInstance()->findOneByEiTestSetIdAndPath($testSet->getId(), $path); $chronometre->arreterEtAfficherChrono("Récupération structure param", $recupStr); $eltExists = $element == null ? false : true; if (!$eltExists) { $element = new EiTestSetBlockParam(); $element->setEiVersionStructureId($this->getId()); $element->setName($this->getName()); $element->setSlug($this->getSlug()); $element->setType($this->getType()); $element->setEiTestSetId($testSet->getId()); $element->setIndexRepetition($index); $element->setPath($path); if ($parent != null) { $element->setParentId($parent->getId()); } } $recupMap = $chronometre->lancerChrono("Récupération du mapping", true); /** @var EiBlockDataSetMapping $mapping */ $mapping = $this->getMapping(EiBlockDataSetMapping::$TYPE_IN); if ($mapping != null && $parent->getType() == EiVersionStructure::$TYPE_FOREACH) { /** @var EiMappingStructureSyncIn $iteratorMap */ $iteratorMap = $parent->getEiVersionStructure()->getIteratorMapping(); /** @var Doctrine_Node_NestedSet $node */ $node = $mapping != null ? $mapping->getEiDataSetStructureMapping()->getNode() : null; $indexToMap = !$node->isDescendantOf($iteratorMap->getEiDataSetStructureMapping()) ? 1 : $index; $value = $mapping->getValueFromTestSetJdd($testSet, $indexToMap, $parent); } elseif ($mapping != null) { $value = $mapping->getValueFromTestSetJdd($testSet, $index, $parent); } else { $value = ""; } $chronometre->arreterEtAfficherChrono("Récupération du mapping", $recupMap); // Sauvegarde de la valeur de l'élément. $element->setValue($value); $saveChro = $chronometre->lancerChrono("Sauvegarde paramètre de block", true); $element->save($conn); if (!$eltExists) { if (!$parent->getNode()->getChildren()) { $element->getNode()->insertAsFirstChildOf($parent); } else { $element->getNode()->insertAsNextSiblingOf($parent->getNode()->getLastChild()); } } $chronometre->arreterEtAfficherChrono("Sauvegarde paramètre de block", $saveChro); return $element; }
/** * Méthode permettant de localiser la partie du JDD à lier à l'élément du block. * * TODO: Unifier les deux méthodes en une seule. * TODO: A vérifier * * Liée à EiTestSetBlockStack->getDataFromDataSet * * @param EiTestSet $testSet * @param EiVersionStructure $block * @param EiTestSetBlockStack $previousStack * @param EiTestSetBlockStack $parentStack * @return mixed|null */ public function getDataFromDataSet(EiTestSet $testSet, EiVersionStructure $block, EiTestSetBlockStack $previousStack = null, EiTestSetBlockStack $parentStack = null) { /** @var EiTestSetDataSetTable $tableDSS */ $tableDSS = Doctrine_Core::getTable("EiTestSetDataSet"); $mapping = $block->getMappingDataSet(EiBlockDataSetMapping::$TYPE_IN); $dssStr = null; // Cas où il y a un mapping et que le parent est nul : On prend le premier élément que l'on trouve. if ($parentStack == null && $mapping != null) { $dssStr != null ? $tableDSS->getRelatedDataFromUniqueDataSetStructure($testSet->getId(), $mapping) : null; } elseif ($mapping != null) { // On vérifie que le block en question est une boucle. if ($block->isEiLoop()) { // On récupère le contexte du père. $contexte = $parentStack->getContext(); $index = 1; // var_dump("DataSet Père : " . $parentStack->getEiTestSetDatasetId()); // var_dump("Contexte DataSet Père : " . $contexte); // Si le block courant est de même nature que le block précédent if ($parentStack->getEiVersionStructureId() != $block->getId() && $block->getId() == $previousStack->getEiVersionStructureId()) { // var_dump("DataSet Structure CAS 1"); // On vérifie s'il s'agit de la même boucle mais concerne une partie différente. if ($previousStack->getPartIndex() < $previousStack->getPartsCount()) { $index = $previousStack->getRepetitionIndex(); $contexte .= "-" . $index; } else { $index = $previousStack->getRepetitionIndex() + 1; $contexte .= "-" . $index; } } elseif ($parentStack->getEiVersionStructureId() != $block->getId()) { // var_dump("DataSet Structure CAS 2"); $parentStr = $parentStack->getEiTestSetDataSet() != null ? $parentStack->getEiTestSetDataSet()->getEiDataSetStructure() : null; if ($parentStr != null && $mapping->getEiDataSetStructureMapping()->getNode()->isDescendantOf($parentStr)) { // var_dump("DataSet Structure CAS 2.1"); $parentMapping = $parentStr != null ? $parentStr->getId() : null; $myMappingParent = $mapping->getEiDataSetStructureMapping()->getEiDatasetStructureParentId(); if ($parentMapping == null || $myMappingParent == $parentMapping) { $contexte .= "-1"; } else { if (preg_match("/([0-9]+)\$/", $contexte, $matched)) { $length = strlen($matched[1]); } else { $length = 1; } $contexte = substr($contexte, 0, -$length) . 1; } } else { // var_dump("DataSet Structure CAS 2.2"); $contexteArray = array(); for ($cpt = 0; $cpt <= $mapping->getEiDataSetStructureMapping()->getLevel(); $cpt++) { $contexteArray[] = 1; } $contexte = implode("-", $contexteArray); // var_dump("New context : " . $contexte); } } else { // var_dump("DataSet Structure CAS 3"); if (preg_match("/([0-9]+)\$/", $contexte, $matched)) { $length = strlen($matched[1]); } else { $length = 1; } $contexte = substr($contexte, 0, -$length); // On vérifie s'il s'agit de la même boucle mais concerne une partie différente. if (!$parentStack->isComplete()) { $index = $parentStack->getRepetitionIndex(); } else { $index = $parentStack->getRepetitionIndex() + 1; } $contexte .= $index; // var_dump($parentStack->getEiVersionStructureId(), $block->getId()); // var_dump($contexte); } $dssStr = $tableDSS->getDataFromContext($testSet->getId(), $mapping->getEiDatasetStructureId(), $contexte, $index); } } return $dssStr; }
/** * @param EiTestSet $testSet * @param EiVersionStructure $block * @return mixed|null * * @createdAt 18/08/2015 * @updatedAt 18/08/2015 */ public function getParentBlock($testSet, $block) { // Récupération de la connexion BDD. $conn = Doctrine_Manager::connection(); try { // Définition requête SQL permettant de générer $searchSql = "\nSELECT id\nFROM " . $this->getTableName() . "\nWHERE ei_version_structure_id = " . $block->getId() . "\nAND ei_test_set_id = " . $testSet->getId() . "\nORDER BY lft DESC\nLIMIT 1;"; // Récupération du block parent. $blockId = $conn->execute($searchSql)->fetch(); if (!is_bool($blockId) && isset($blockId["id"])) { return $this->find($blockId["id"]); } } catch (Exception $exc) { return null; } }
/** * @param EiTestSet $testSet * @param EiProjet $project */ public function searchRelatedEiExecutionStackAndTaggedIt(EiTestSet $testSet, EiProjet $project) { /** @var EiExecutionStack $executionStack */ $executionStack = Doctrine_Core::getTable("EiExecutionStack")->search($testSet->getEiScenarioId(), $testSet->getEiDataSetId(), $testSet->getProfileRef(), $testSet->getProfileId(), $project->getRefId(), $project->getProjectId(), $testSet->getSfGuardUser()->getId()); if ($executionStack != null && $executionStack->getId() != "") { $executionStack->setEiTestSetId($testSet->getId()); $executionStack->save(); } }
/** * @param EiTestSet $testSet * @param null $parent * @param null $index * @param string $path * @param bool $deep * @param Doctrine_Connection $conn * * @return EiTestSetBlockParam|mixed|void */ public function generateTestSetParameters(EiTestSet $testSet = null, $parent = null, $index = null, $path = "", $deep = true, Doctrine_Connection $conn = null) { $conn = $conn == null ? Doctrine_Manager::connection() : $conn; $chronometre = new Chronometre(); $index = $index == null ? 1 : $index; $path .= "/" . $this->getName() . "[" . $index . "]"; // Vérification si l'élément existe. $element = EiTestSetBlockParamTable::getInstance()->findOneByEiTestSetIdAndPath($testSet->getId(), $path); if ($element == null) { // Création de l'élément. $element = new EiTestSetBlockParam(); $element->setEiVersionStructureId($this->getId()); $element->setName($this->getName()); $element->setSlug($this->getSlug()); $element->setType($this->getType()); $element->setEiTestSetId($testSet->getId()); $element->setIndexRepetition($index); $element->setPath($path); if ($parent != null) { $element->setParentId($parent->getId()); } $element->save($conn); if ($parent == null) { $element->setRootId($element->getId()); $element->setLft(1); $element->setRgt(2); $element->setLevel(0); $element->save($conn); } elseif ($parent != null) { /** @var EiTestSetBlockParam $parent */ $parent->refresh(true); if (!$parent->getNode()->getChildren()) { $element->getNode()->insertAsFirstChildOf($parent); } else { $element->getNode()->insertAsNextSiblingOf($parent->getNode()->getLastChild()); } } } $chronometre->lancerChrono("Récupération des paramètres"); /** @var EiBlockParam[] $parametres */ $parametres = $this->getParams(); $chronometre->arreterEtAfficherChrono(); $chronometre->lancerChrono("Génération des paramètres"); /** @var EiBlockParam $param */ foreach ($parametres as $param) { $param->generateTestSetParameters($testSet, $element, $index, $path); } $chronometre->arreterEtAfficherChrono(); /** @var EiVersionStructure[] $descendants */ $descendants = $this->getNode()->getDescendants(true); if ($deep === true && $descendants) { /** @var EiVersionStructure $descendant */ foreach ($descendants as $descendant) { /** @var EiBlock $descendant */ if ($descendant instanceof EiBlock || $descendant instanceof EiBlockForeach) { $descendant->generateTestSetParameters($testSet, $element, $index, $path, false, $conn); } } } else { return $element; } }
/** * Génère, à partir de l'arbre ITreeExplorer l'arborescence du jeu de données pour le JDT. * * @param ITreeExplorerItem $element */ private function generate(ITreeExplorerItem $element, $isParentRoot = false) { $elt = null; try { // On parcourt toutes les occurences de l'élément de la structure. foreach ($element->getOccurrences() as $occurrence) { $pid = $occurrence->getParent() != null ? $occurrence->getParent()->getId() : null; $pIndex = $occurrence->getParent() != null ? $occurrence->getParent()->getRepeatIndex() : $occurrence->getRepeatIndex(); // On crée l'objet. $elt = new EiTestSetDataSet(); // Puis, on lui affecte les quelques éléments en notre possession. $elt->setEiTestSetId($this->testSet->getId()); $elt->setEiDataSetStructureId($element->getId()); $elt->setIndexRepetition($occurrence->getRepeatIndex()); $elt->setParentIndexRepetition($pIndex); $elt->setType($element->getType() == "root" || $element->getType() == "node" ? EiDataSetStructure::$TYPE_NODE : EiDataSetStructure::$TYPE_LEAF); $elt->setName($element->getName()); $elt->setSlug($element->getSlug()); $elt->setValue($occurrence->getValue() != null ? $occurrence->getValue() : ""); if ($occurrence->getParent() != null && isset($this->registered[$occurrence->getParent()->getId()])) { $elt->setParentId($this->registered[$occurrence->getParent()->getId()]->getId()); } elseif (!(is_bool($isParentRoot) && $isParentRoot == false)) { $elt->setParentId($isParentRoot->getId()); } if ($element->getType() == "root") { $elt->setLft(1); $elt->setRgt(2); $elt->setLevel(0); $elt->save(); $elt->setRootId($elt->getId()); $elt->save(); $this->root_id = $elt->getId(); $this->root = $elt; } elseif (($pid != null || $pid == 0) && isset($this->registered[$pid])) { if ($element->getType() == "leaf") { $occurrence->setLeft($occurrence->getLeft() + ($pIndex - 1) * $occurrence->getRightNode()); $occurrence->setRight($occurrence->getRight() + ($pIndex - 1) * $occurrence->getRightNode()); if ($occurrence->getRight() > $this->maxRight) { $this->maxRight = $occurrence->getRight(); } } $elt->setLft($occurrence->getLeft()); $elt->setRgt($occurrence->getRight()); $elt->setLevel($occurrence->getLevel()); $elt->setRootId($this->root_id); $elt->save(); if (!isset($this->registeredChildren[$pid])) { $this->registeredChildren[$pid] = array(); $this->registeredChildren[$pid][] = $elt; } else { $this->registeredChildren[$pid][] = $elt; } } $this->registered[$occurrence->getId()] = $elt; } /** @var ITreeExplorerItem $child */ foreach ($element->getChildren() as $child) { $this->generate($child, $elt != null && $element->getType() == "root" ? $elt : false); } } catch (Exception $exc) { print_r($exc); } }
public function getTestSetParam(EiTestSet $ei_test_set) { $conn = Doctrine_Manager::connection(); $q = "\n \n SELECT p.*, f.* , fp.name\n\n FROM ei_test_set_param p\n LEFT JOIN ei_test_set_function f\n ON f.id = p.ei_test_set_function_id\n AND f.ei_test_set_id =p.ei_test_set_id\n \n LEFT JOIN ei_function_has_param fp\n ON fp.param_id = p.param_id\n \n WHERE p.ei_test_set_id= " . $ei_test_set->getId() . "\n \n ORDER BY f.position \n "; return $conn->fetchAll($q); }