/**
* Permet de définir si le formulaire de paramètre pour les versions est valide ou non
* @param type $values
* @return type
* @throws sfValidatorErrorSchema
*/
protected function doClean($values)
{
$errorSchema = new sfValidatorErrorSchema($this);
$name = MyFunction::sluggifyForXML($values['name']);
$id = isset($values["id"]) ? $values["id"] : -1;
/** @var EiVersionStructureTable $tableVersionStr */
$tableVersionStr = Doctrine_Core::getTable("EiVersionStructure");
if ($this->str->getEiVersionStructureParentId()) {
$existing = $tableVersionStr->findByEiVersionStructureParentIdAndSlug($this->str->getEiVersionStructureParentId(), $name);
/** @var Doctrine_Collection $existing */
if ($existing->count() > 0 && $this->isNew == false) {
// On retire l'élément si présent dans la liste.
foreach ($existing as $key => $elt) {
if ($elt->getId() == $this->str->getId()) {
$existing->remove($key);
}
}
}
} else {
$existing = $tableVersionStr->findByEiVersionStructureParentIdAndSlug("is null", $name);
}
$count = $existing->count();
if ($count > 0 && $this->isNew || $count >= 1 && !$this->isNew) {
$errorSchema->addError(new sfValidatorError($this, 'name'), 'name');
}
// ON VERIFIE S'IL S'AGIT D'UN BLOC FOREACH QU'UN NOEUD SOIT RENSEIGNE.
if ($this->str instanceof EiBlockForeach) {
if (isset($values["Iterator"]) && $values["Iterator"] != null && isset($values["Iterator"]["ei_dataset_structure_id"])) {
$idNode = $values["Iterator"]["ei_dataset_structure_id"];
/** @var EiNodeDataSet $node */
$node = Doctrine_Core::getTable("EiNodeDataSet")->find($idNode);
if (!$node) {
$errorSchema->addError(new sfValidatorError($this, 'iterator_invalid'), 'iterator');
} elseif (!($node->getType() == EiDataSetStructure::$TYPE_NODE && !$node->isRoot())) {
$errorSchema->addError(new sfValidatorError($this, 'iterator_type_invalid'), 'iterator');
}
} else {
$errorSchema->addError(new sfValidatorError($this, 'iterator_empty'), 'iterator');
}
}
// si l'on a trouvé des erreurs, alors on transmet une exception
if (count($errorSchema)) {
throw new sfValidatorErrorSchema($this, $errorSchema);
}
return $values;
}
/**
* @param EiVersionStructure $parent
* @return $this
*/
public function getCommonParent(EiVersionStructure $parent)
{
if ($parent->getId() == $this->getEiVersionStructureId()) {
return $this;
} elseif ($this->getEiTestSetBlockStackParent() != null) {
return $this->getEiTestSetBlockStackParent()->getCommonParent($parent);
} else {
return null;
}
}
/**
* 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 EiVersion $copie
* @param Doctrine_Connection $conn
* @param null $ei_scenario_id
* @param array $allowedTypes
* @return EiVersion
* @throws Exception
*/
public function createStructureCopy(EiVersion $copie, Doctrine_Connection $conn = null, $ei_scenario_id = null, array $allowedTypes = array())
{
/** @var sfLogger $logger */
$logger = sfContext::getInstance()->getLogger();
// Déclaration de la table EiVersionStructure.
/** @var EiVersionStructureTable $tableVersionStr */
$tableVersionStr = Doctrine_Core::getTable('EiVersionStructure');
// Tableau des correspondances.
$correspondances = array();
$correspondancesF = array();
$version_id = $this->old_version_id == false ? $this->getId() : $this->old_version_id;
$allowedTypes = count($allowedTypes) == 0 ? EiVersionStructure::getAllTypes() : $allowedTypes;
$ignored = 0;
//*******************************************************//
//********** COPIE STRUCTURE **********//
//*******************************************************//
$logger->info("--------------------------------------------");
$logger->info("---------- COPIE SCENARIO ----------");
$logger->info("--------------------------------------------");
// Création d'une collection de structure de version.
/** @var Doctrine_Collection $nouvelleStructure */
$nouvelleStructure = new Doctrine_Collection('EiVersionStructure');
// Variable temporaire contenant le noeud père.
/** @var EiVersionStructure $ei_version_str_prec */
$ei_version_str_prec = null;
// Variable temporaire contenant le niveau où l'on se situait dans l'arbre à la boucle précédente.
$level_prec = 0;
// Variables temporaires.
/** @var EiVersionStructure $parent */
$root_id = $parent = null;
// On récupère la structure complète de la version actuelle.
$currentVersionTree = $tableVersionStr->getEiVersionTree($version_id, $allowedTypes);
// On parcourt chaque élément.
/** @var EiVersionStructure $ei_version_str */
foreach ($currentVersionTree as $i => $ei_version_str) {
$logger->info("---------- PARCOURS ELT STRUCTURE N° " . $ei_version_str->getId() . " ----------");
if (in_array($ei_version_str->getType(), $allowedTypes)) {
//*************************************************************//
//********** DETERMINATION DU PERE **********//
//*************************************************************//
// Si le niveau précédent est inférieur au niveau parcouru, alors, le parent est la dernière version structure.
if ($ei_version_str->getLevel() > $level_prec) {
$parent = $ei_version_str_prec;
} elseif ($ei_version_str->getLevel() < $level_prec) {
// On réalise la différence entre les deux niveau.
$j = $level_prec - $ei_version_str->getLevel();
// On remonte d'autant de fois afin de récupérer le père.
while ($j > 0) {
$parent = $parent->getNode()->getParent();
$j--;
}
}
//*******************************************************************************//
//********** ENREGISTREMENT DES INFORMATIONS DE BASE **********//
//*******************************************************************************//
$strElementCopie = new EiVersionStructure();
$strElementCopie->setRootId($root_id);
$strElementCopie->setLft($ei_version_str->getLft());
$strElementCopie->setRgt($ei_version_str->getRgt());
$strElementCopie->setLevel($ei_version_str->getLevel());
$strElementCopie->setName($ei_version_str->getName());
$strElementCopie->setDescription($ei_version_str->getDescription());
$strElementCopie->setSlug($ei_version_str->getSlug());
$strElementCopie->setEiVersion($copie);
$strElementCopie->setType($ei_version_str->getType());
// Si l'élément possède un père, on le précise.
if ($parent) {
$strElementCopie->setEiVersionStructureParentId($parent->getId());
}
// On sauvegarde l'élément.
$strElementCopie->save($conn);
// Mise à jour du tableau des correspondances.
$correspondances[$ei_version_str->getId()] = $strElementCopie->getId();
//**********************************************************//
//********** CREATION FONCTION ***********//
//**********************************************************//
// S'il s'agit d'une fonction, on crée la copie.
if ($ei_version_str->isEiFonction()) {
$logger->info("---------- CREATION FONCTION ----------");
$fct = $ei_version_str->getEiFonction()->createCopie($strElementCopie, $conn);
$strElementCopie->setEiFonctionId($fct->getId());
$correspondancesF[$ei_version_str->getEiFonctionId()] = $fct->getId();
} elseif ($ei_version_str->isEiBlock()) {
$logger->info("---------- CREATION BLOCK ----------");
$ei_version_str_prec = $strElementCopie;
}
$level_prec = $ei_version_str->getLevel();
if ($i == 0) {
$root_id = $strElementCopie->getId();
$strElementCopie->setRootId($root_id);
$strElementCopie->save($conn);
}
$nouvelleStructure->add($strElementCopie);
}
}
foreach ($currentVersionTree as $i => $ei_version_str) {
//**********************************************************//
//********** CAS BLOCK FOREACH **********//
//**********************************************************//
if ($ei_version_str->getType() == EiVersionStructure::$TYPE_FOREACH) {
$logger->info("---------- CREATION FOREACH ----------");
/** @var EiMappingStructureSyncIn $oldMapping */
$oldMapping = $ei_version_str->getEiVersionStructureDataSetMapping()->getFirst();
$mapping = new EiMappingStructureSyncIn();
$mapping->setEiDatasetStructureId($oldMapping->getEiDatasetStructureId());
$mapping->setEiVersionStructureId($correspondances[$ei_version_str->getId()]);
$mapping->save($conn);
} elseif ($ei_version_str->isEiBlockParam()) {
$logger->info("---------- CREATION BLOCK PARAM ----------");
// Copie des mappings IN et OUT.
/** @var EiBlockDataSetMapping $oldMappingIn */
$oldMappingIn = $ei_version_str->getMappingDataSet(EiBlockDataSetMapping::$TYPE_IN);
/** @var EiBlockDataSetMapping $oldMappingOut */
$oldMappingOut = $ei_version_str->getMappingDataSet(EiBlockDataSetMapping::$TYPE_OUT);
if ($oldMappingIn != null) {
$logger->info("---------- MAPPING IN : " . $oldMappingIn->getEiDatasetStructureId() . " / " . $correspondances[$ei_version_str->getId()] . " ----------");
$newMappingIn = new EiMappingStructureSyncIn();
$newMappingIn->setEiDatasetStructureId($oldMappingIn->getEiDatasetStructureId());
$newMappingIn->setEiVersionStructureId($correspondances[$ei_version_str->getId()]);
$newMappingIn->save($conn);
}
if ($oldMappingOut != null) {
$logger->info("---------- MAPPING OUT : " . $oldMappingOut->getEiDatasetStructureId() . " / " . $correspondances[$ei_version_str->getId()] . " ----------");
$newMappingOut = new EiMappingStructureSyncOut();
$newMappingOut->setEiDatasetStructureId($oldMappingOut->getEiDatasetStructureId());
$newMappingOut->setEiVersionStructureId($correspondances[$ei_version_str->getId()]);
$newMappingOut->save($conn);
}
} elseif ($ei_version_str->isEiFonction() && in_array($ei_version_str->getType(), $allowedTypes)) {
$logger->info("---------- CREATION PARAM FONCTION ----------");
// Récupération de l'ensemble des paramètres OUT.
/** @var EiParamBlockFunctionMapping[] $outParams */
$outParams = $ei_version_str->getEiFonction()->getEiFunctionMapping();
$logger->info("---------- " . count($outParams) . " PARAMS.");
// Copie de chaque paramètre de mapping OUT.
/** @var EiParamBlockFunctionMapping $oldMapping */
foreach ($outParams as $oldMapping) {
if ($oldMapping->getEiFunctionId() != "" && $oldMapping->getEiParamFunctionId() != "") {
/** @var EiParamBlockFunctionMapping $mapping */
$mapping = new EiParamBlockFunctionMapping();
$mapping->setEiParamBlockId($oldMapping->getEiParamBlockId() == "" ? null : $correspondances[$oldMapping->getEiParamBlockId()]);
$mapping->setEiFunctionId($correspondancesF[$oldMapping->getEiFunctionId()]);
$mapping->setEiParamFunctionId($oldMapping->getEiParamFunctionId());
$mapping->save($conn);
}
}
} elseif (!in_array($ei_version_str->getType(), $allowedTypes)) {
$ignored++;
}
}
// On affecte à la copie la structure complète.
$copie->setEiVersionStructures($nouvelleStructure);
// Sauvegarde de la copie de version.
$copie->save($conn);
//*****************************************************//
//********** VERIFICATIONS **********//
//*****************************************************//
// On récupère l'arbre de la structure de la copie.
$arbreNouvelleVersion = $tableVersionStr->getEiVersionTree($copie->getId());
// On vérifie que le nombre d'éléments est le même de chaque côté sinon on lève une exception.
if (count($currentVersionTree) != count($arbreNouvelleVersion) + $ignored) {
throw new Exception('Version copie failed');
}
return $copie;
}
/**
* @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 EiBlockParam[] $parametres
*/
private function proceedStep2_2(array $parametres)
{
// Déclaration des variables contenant la liste des scénario structure parents manipulés et versions.
/** @var EiVersionStructure[] $parentsVersion */
$parentsVersion = array();
$last = array();
foreach ($parametres as $param) {
// On récupère la version parente.
/** @var EiVersionStructure $versionStrParente */
$versionStrParente = Doctrine_Core::getTable("EiVersionStructure")->find($param["vs_id"]);
$parentsVersion[$versionStrParente->getId()][] = $param["id"];
// Création du paramètre.
$paramVersion = new EiVersionStructure();
$paramVersion->setType(EiVersionStructure::$TYPE_BLOCK_PARAM);
$paramVersion->setEiVersionId($versionStrParente->getEiVersionId());
$paramVersion->setEiVersionStructureParentId($versionStrParente->getId());
$paramVersion->setName($param["name"]);
$paramVersion->setDescription($param["description"]);
$paramVersion->save();
$req = "UPDATE ei_version_structure SET ei_scenario_structure_id = " . $param["id"] . " WHERE id = " . $paramVersion->getId() . ";";
$this->connexion->execute($req);
$this->displayResultStep("Création du paramètre " . $param["name"] . " pour la version " . $versionStrParente->getEiVersionId());
if (count($parentsVersion[$versionStrParente->getId()]) == 1) {
$paramVersion->getNode()->insertAsFirstChildOf($versionStrParente);
} else {
$paramVersion->getNode()->insertAsNextSiblingOf($last[$versionStrParente->getId()]);
}
$last[$versionStrParente->getId()] = $paramVersion;
}
}
