PageRenderTime 33ms CodeModel.GetById 33ms RepoModel.GetById 1ms app.codeStats 0ms

/lib/functions/testplan.class.php

https://bitbucket.org/pfernandez/testlink1.9.6
PHP | 4095 lines | 2402 code | 453 blank | 1240 comment | 209 complexity | 0e0b90199993b6c3e7c62e0e24e2edc3 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, GPL-3.0 
    

  1. <?php

    2. 

  2. /** 

    3. 

  3.  * TestLink Open Source Project - http://testlink.sourceforge.net/

    4. 

  4.  * This script is distributed under the GNU General Public License 2 or later. 

    5. 

  5.  *

    6. 

  6.  * Manages test plan operations and related items like Custom fields, 

    7. 

  7.  * Builds, Custom fields, etc

    8. 

  8.  *

    9. 

  9.  * @package 	TestLink

    10. 

  10.  * @author 		franciscom

    11. 

  11.  * @copyright 	2007-2009, TestLink community 

    12. 

  12.  * @version    	CVS: $Id: testplan.class.php,v 1.209 2010/08/31 19:40:15 mx-julian Exp $

    13. 

  13.  * @link 		http://www.teamst.org/index.php

    14. 

  14.  *

    15. 

  15.  *

    16. 

  16.  * @internal Revisions:

    17. 

  17.  *	20100830 - franciscom - get_linked_tcversions() - missing cast to array	$my['filters']['exec_status']

    18. 

  18.  *							urgencyImportanceToPriorityLevel() - refactored

    19. 

  19.  *	20100827 - franciscom - new method wrapper - hasLinkedPlatforms()

    20. 

  20.  *  20100727 - asimon - BUGID 3629: modified statement in get_linked_tcversions()

    21. 

  21.  *  20100725 - asimon - BUGID 3497 and hopefully also 3530 fixed in unlink_tcversions()

    22. 

  22.  *  20100723 - asimon - commented out some old debug message in copy_linked_tcversions()

    23. 

  23.  *  20100722 - asimon - added missing $debugMsg to get_linked_items()

    24. 

  24.  *  20100721 - asimon - BUGID 3406: added user_assignments_per_build option to get_linked_tcversions()

    25. 

  25.  *	20100711 - franciscom - BUGID 3564 -> getPlatforms()

    26. 

  26.  *	20100614 - eloff - refactor getStatusTotalsByPriority() to same style as the other getStatusTotals...()

    27. 

  27.  *	20100610 - eloff - BUGID 3515 - getStatusTotals() now takes platforms into account

    28. 

  28.  *	20100602 - franciscom - copy_as() - force Platforms Link copy when user choose Test Case Copy

    29. 

  29.  *  20100527 - Julian - BUGID 3492 - Added execution notes to sql statement of get_linked_tcversions

    30. 

  30.  *  20100525 - Julian - changed default for steps_info option on get_linked_tcversions() to false

    31. 

  31.  *  					-> performance improvement because not all steps are loaded per default

    32. 

  32.  *	20100520 - franciscom - getTestCaseSiblings() join bug

    33. 

  33.  *	20100518 - franciscom - BUGID 3473

    34. 

  34.  *	20100516 - franciscom - BUGID 3465: Delete Test Project - User Execution Assignment is not deleted

    35. 

  35.  *	20100506 - franciscom - new method - get_linked_items_id(), that has perfomance advantages

    36. 

  36.  *							over get_linked_tcversions() when only info needed is test case id.

    37. 

  37.  *

    38. 

  38.  *	20100505 - franciscom - BUGID 3434 - get_keywords_map() - refactoring trying to improve performance

    39. 

  39.  *	20100505 - franciscom - BUGID 3430 - copy_milestones() - need to check if start date is NOT NULL

    40. 

  40.  *	20100425 - franciscom - BUGID 2463 - changes in getStatusTotalsByAssignedTesterPlatform()

    41. 

  41.  * 	20100417 - franciscom - get_linked_tcversions() added importance on output data

    42. 

  42.  *                          BUGID 3356: Failed Test Cases" report is not updated when a test case 

    43. 

  43.  *                                      has been changed from "Failed" to "Passed"		 

    44. 

  44.  *

    45. 

  45.  *  20100217 - asimon - added parameters open and active to getNumberOfBuilds()

    46. 

  46.  *  20100214 - franciscom - BUGID 2455, BUGID 3026 - Contribution by julian,asimon

    47. 

  47.  *  20100206 - eloff - BUGID 3060 - Adding getStatusTotalsByPriority()

    48. 

  48.  *  20100206 - eloff - BUGID 3060 - Adding urgencyImportanceToPriorityLevel() method

    49. 

  49.  *  20100201 - franciscom - BUGID 3121 - Adding Platform to test plan after the execution completed,

    50. 

  50.  *                                       reports are not shown appropriate 	

    51. 

  51.  *  20100112 - franciscom - getPlatforms() - interface changes

    52. 

  52.  *	20100106 - franciscom - Multiple Test Case Steps Feature

    53. 

  53.  *                          Affected Methods: get_linked_tcversions()

    54. 

  54.  *	20091111 - franciscom - BUGID 2938 - getTestCaseSiblings(), getTestCaseNextSibling()

    55. 

  55.  *  20091031 - franciscom - tallyResultsForReport()

    56. 

  56.  *  20091027 - franciscom - BUGID 2500 - get_linked_tcversions()

    57. 

  57.  *  20091025 - franciscom - new method - getStatusTotalsByPlatform()

    58. 

  58.  *                          bug found on getNotExecutedLinkedTCVersionsDetailed()

    59. 

  59.  *                          missing testplan_id on execution join

    60. 

  60.  *

    61. 

  61.  *	20091010 - franciscom - getNotExecutedLinkedTCVersionsDetailed() new options

    62. 

  62.  *  20091004 - franciscom - get_linked_tcversions() - fixed query when requesting exec status filtering.

    63. 

  63.  *                                                  - added more columns to output record set

    64. 

  64.  *  20090923 - franciscom - link_tcversions() - will return data

    65. 

  65.  *  20090920 - franciscom - getStatusTotals(), will replace some result.class method

    66. 

  66.  *  20090919 - franciscom - copy_as(), copy_linked_tcversions() added contribution (refactored)

    67. 

  67.  *                          to copy user assignment.

    68. 

  68.  *

    69. 

  69.  * 	20090822 - franciscom - changeLinkedTCVersionsPlatform() - new method

    70. 

  70.  *                          countLinkedTCVersionsByPlatform() - new method

    71. 

  71.  *  20090814 - franciscom - link_tcversions() - interface changes - due to platform feature

    72. 

  72.  *  20090516 - franciscom - BUGID - is_public

    73. 

  73.  *                          create(),update() changed

    74. 

  74.  *  20090509 - franciscom - BUGID - build class manage release_date

    75. 

  75.  *  20090411 - franciscom - BUGID 2369 - link_tcversions() - interface changes

    76. 

  76.  *  20090214 - franciscom - BUGID 2099 - get_linked_tcversions() - added new columns in output recordset

    77. 

  77.  *  20090208 - franciscom - testplan class - new method get_build_by_id()

    78. 

  78.  *  20090201 - franciscom - copy_milestones() - wrong SQL sentece 

    79. 

  79.  *                          A,B,C fields renamed to lower case a,b,c to avoid problems

    80. 

  80.  *                          between differnt database (case and no case sensitive)

    81. 

  81.  *  20081227 - franciscom - BUGID 1913 - filter by same results on ALL previous builds

    82. 

  82.  *                          get_same_status_for_build_set(), get_prev_builds()

    83. 

  83.  *

    84. 

  84.  *  20081214 - franciscom - Thanks to postgres found missing CAST() on SUM() 

    85. 

  85.  *  20081206 - franciscom - BUGID 1910 - get_estimated_execution_time() - added new filter

    86. 

  86.  *                                       get_linked_tcversions() - added test suites filter 

    87. 

  87.  *  20080820 - franciscom - added get_estimated_execution_time() as result of contributed idea.

    88. 

  88.  *

    89. 

  89.  *  20080811 - franciscom - BUGID 1650 (REQ)

    90. 

  90.  *  20080614 - franciscom - get_linked_and_newest_tcversions() - fixed bug  (thanks to PostGres)

    91. 

  91.  *  20080428 - franciscom - supporting multiple keywords in get_linked_tcversions()

    92. 

  92.  *                          (based on contribution by Eugenia Drosdezki)

    93. 

  93.  *  20080310 - sbouffard - contribution added NHB.name to recordset (useful for API methods).  

    94. 

  94.  *  20071010 - franciscom - BUGID     MSSQL reserved word problem - open

    95. 

  95.  *  20070927 - franciscom - BUGID 1069

    96. 

  96.  *                          added _natsort_builds() (see natsort info on PHP manual).

    97. 

  97.  *                          get_builds() add call to _natsort_builds()

    98. 

  98.  *                          get_builds_for_html_options() add call to natsort()

    99. 

  99.  *  20070310 - franciscom - BUGID 731

    100. 

  100.  *  20070306 - franciscom - BUGID 705 - changes in get_linked_tcversions()

    101. 

  101.  **/

    102. 

  102. 

    103. 

  103. /** related functionality */

    104. 

  104. require_once( dirname(__FILE__) . '/tree.class.php' );

    105. 

  105. require_once( dirname(__FILE__) . '/assignment_mgr.class.php' );

    106. 

  106. require_once( dirname(__FILE__) . '/attachments.inc.php' );

    107. 

  107. 

    108. 

  108. /**

    109. 

  109.  * class to coordinate and manage Test Plans

    110. 

  110.  * @package 	TestLink

    111. 

  111.  * @todo havlatm: create class testplanEdit (as extension of testplan class) and 

    112. 

  112.  *		move here create,edit,delete,copy related stuff

    113. 

  113.  * @TODO franciscom - absolutely disagree with suggested approach, see no value - 20090611

    114. 

  114.  */

    115. 

  115. class testplan extends tlObjectWithAttachments

    116. 

  116. {

    117. 

  117. 	/** query options */

    118. 

  118. 	const GET_ALL=null;

    119. 

  119. 	const GET_ACTIVE_BUILD=1;

    120. 

  120. 	const GET_INACTIVE_BUILD=0;

    121. 

  121. 	const GET_OPEN_BUILD=1;

    122. 

  122. 	const GET_CLOSED_BUILD=0;

    123. 

  123. 	const ACTIVE_BUILDS=1;

    124. 

  124. 	const ENABLED=1;

    125. 

  125. 

    126. 

  126. 	/** @var database handler */

    127. 

  127. 	var $db;

    128. 

  128. 

    129. 

  129. 	var $tree_manager;

    130. 

  130. 	var $assignment_mgr;

    131. 

  131. 	var $cfield_mgr;

    132. 

  132. 	var $tcase_mgr;

    133. 

  133.    

    134. 

  134. 	var $assignment_types;

    135. 

  135. 	var $assignment_status;

    136. 

  136. 

    137. 

  137. 	/** message to show on GUI */

    138. 

  138. 	var $user_feedback_message = '';

    139. 

  139. 

    140. 

  140. 	var $node_types_descr_id;

    141. 

  141. 	var $node_types_id_descr;

    142. 

  142. 	

    143. 

  143. 	/**

    144. 

  144. 	 * testplan class constructor

    145. 

  145. 	 * 

    146. 

  146. 	 * @param resource &$db reference to database handler

    147. 

  147. 	 */

    148. 

  148. 	function __construct(&$db)

    149. 

  149. 	{

    150. 

  150. 	    $this->db = &$db;

    151. 

  151. 	    $this->tree_manager = New tree($this->db);

    152. 

  152. 		$this->node_types_descr_id=$this->tree_manager->get_available_node_types();

    153. 

  153. 		$this->node_types_id_descr=array_flip($this->node_types_descr_id);

    154. 

  154.       

    155. 

  155. 	    $this->assignment_mgr = new assignment_mgr($this->db);

    156. 

  156. 	    $this->assignment_types = $this->assignment_mgr->get_available_types();

    157. 

  157. 	    $this->assignment_status = $this->assignment_mgr->get_available_status();

    158. 

  158. 

    159. 

  159.     	$this->cfield_mgr = new cfield_mgr($this->db);

    160. 

  160.     	$this->tcase_mgr = New testcase($this->db);

    161. 

  161. 		$this->platform_mgr = new tlPlatform($this->db);

    162. 

  162.    	

    163. 

  163. 	    tlObjectWithAttachments::__construct($this->db,'testplans');

    164. 

  164. 	}

    165. 

  165. 

    166. 

  166. 

    167. 

  167. 	/**

    168. 

  168. 	 * creates a tesplan on Database, for a testproject.

    169. 

  169. 	 * 

    170. 

  170. 	 * @param string $name: testplan name

    171. 

  171. 	 * @param string $notes: testplan notes

    172. 

  172. 	 * @param string $testproject_id: testplan parent

    173. 

  173. 	 * 

    174. 

  174. 	 * @return integer status code

    175. 

  175. 	 * 		if everything ok -> id of new testplan (node id).

    176. 

  176. 	 * 		if problems -> 0.

    177. 

  177. 	 */

    178. 

  178. 	function create($name,$notes,$testproject_id,$is_active=1,$is_public=1)

    179. 

  179. 	{

    180. 

  180. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    181. 

  181. 

    182. 

  182. 		$node_types=$this->tree_manager->get_available_node_types();

    183. 

  183. 		$tplan_id = $this->tree_manager->new_node($testproject_id,$node_types['testplan'],$name);

    184. 

  184. 		

    185. 

  185. 		$active_status=intval($is_active) > 0 ? 1 : 0;

    186. 

  186. 		$public_status=intval($is_public) > 0 ? 1 : 0;

    187. 

  187. 		

    188. 

  188. 		$sql = "/* $debugMsg */ " . 

    189. 

  189. 		       " INSERT INTO {$this->tables['testplans']} (id,notes,testproject_id,active,is_public) " .

    190. 

  190. 			   " VALUES ( {$tplan_id} " . ", '" . $this->db->prepare_string($notes) . "'," . 

    191. 

  191. 			   $testproject_id . "," . $active_status . "," . $public_status . ")";

    192. 

  192. 		$result = $this->db->exec_query($sql);

    193. 

  193. 		$id = 0;

    194. 

  194. 		if ($result)

    195. 

  195. 		{

    196. 

  196. 			$id = $tplan_id;

    197. 

  197. 		}

    198. 

  198. 

    199. 

  199. 		return $id;

    200. 

  200. 	}

    201. 

  201. 

    202. 

  202. 

    203. 

  203. 	/**

    204. 

  204. 	 * update testplan information

    205. 

  205. 	 * 

    206. 

  206. 	 * @param integer $id Test plan identifier

    207. 

  207. 	 * @param string $name: testplan name

    208. 

  208. 	 * @param string $notes: testplan notes

    209. 

  209. 	 * @param boolean $is_active

    210. 

  210. 	 * 

    211. 

  211. 	 * @return integer result code (1=ok)

    212. 

  212. 	 */

    213. 

  213. 	function update($id,$name,$notes,$is_active=null,$is_public=null)

    214. 

  214. 	{

    215. 

  215. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    216. 

  216. 		$do_update = 1;

    217. 

  217. 		$result = null;

    218. 

  218. 		// $active = to_boolean($is_active);

    219. 

  219. 		$name = trim($name);

    220. 

  220. 		

    221. 

  221. 		// two tables to update and we have no transaction yet.

    222. 

  222. 		$rsa = $this->get_by_id($id);

    223. 

  223. 		$duplicate_check = (strcmp($rsa['name'],$name) != 0 );

    224. 

  224. 		

    225. 

  225. 		if($duplicate_check)

    226. 

  226. 		{

    227. 

  227. 			$rs = $this->get_by_name($name,$rsa['parent_id']);

    228. 

  228. 			$do_update = is_null($rs);

    229. 

  229. 		}

    230. 

  230. 		

    231. 

  231. 		if($do_update)

    232. 

  232. 		{

    233. 

  233. 			// Update name

    234. 

  234.             $sql = "/* $debugMsg */ ";

    235. 

  235. 			$sql .= "UPDATE {$this->tables['nodes_hierarchy']} " .

    236. 

  236. 				    "SET name='" . $this->db->prepare_string($name) . "'" .

    237. 

  237. 				    "WHERE id={$id}";

    238. 

  238. 			$result = $this->db->exec_query($sql);

    239. 

  239. 			

    240. 

  240. 			if($result)

    241. 

  241. 			{

    242. 

  242. 				$add_upd='';

    243. 

  243. 				if( !is_null($is_active) )

    244. 

  244. 				{

    245. 

  245. 					$add_upd .=',active=' . (intval($is_active) > 0 ? 1 : 0);

    246. 

  246. 				}

    247. 

  247. 				if( !is_null($is_public) )

    248. 

  248. 				{

    249. 

  249. 					$add_upd .=',is_public=' . (intval($is_public) > 0 ? 1:0);

    250. 

  250. 				}

    251. 

  251. 				

    252. 

  252. 				$sql = " UPDATE {$this->tables['testplans']} " .

    253. 

  253. 					" SET notes='" . $this->db->prepare_string($notes). "' " .

    254. 

  254. 					" {$add_upd} WHERE id=" . $id;

    255. 

  255. 				$result = $this->db->exec_query($sql);

    256. 

  256. 			}

    257. 

  257. 		}

    258. 

  258. 		return ($result ? 1 : 0);

    259. 

  259. 	}

    260. 

  260. 

    261. 

  261. 

    262. 

  262. 	/*

    263. 

  263. 	 function: get_by_name

    264. 

  264. 	 get information about a testplan using name as access key.

    265. 

  265. 	 Search can be narrowed, givin a testproject id as filter criteria.

    266. 

  266. 	 

    267. 

  267. 	 args: name: testplan name

    268. 

  268. 	 [tproject_id]: default:0 -> system wide search i.e. inside all testprojects

    269. 

  269. 	 

    270. 

  270. 	 returns: if nothing found -> null

    271. 

  271. 	 if found -> array where every element is a map with following keys:

    272. 

  272. 	 id: testplan id

    273. 

  273. 	 notes:

    274. 

  274. 	 active: active status

    275. 

  275. 	 is_open: open status

    276. 

  276. 	 name: testplan name

    277. 

  277. 	 testproject_id

    278. 

  278. 	 */

    279. 

  279. 	function get_by_name($name,$tproject_id = 0)

    280. 

  280. 	{

    281. 

  281. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    282. 

  282.         $sql = "/* $debugMsg */ ";

    283. 

  283. 		$sql .= " SELECT testplans.*, NH.name " .

    284. 

  284. 			    " FROM {$this->tables['testplans']} testplans, " .

    285. 

  285. 			    " {$this->tables['nodes_hierarchy']} NH" .

    286. 

  286. 			    " WHERE testplans.id=NH.id " .

    287. 

  287. 			    " AND NH.name = '" . $this->db->prepare_string($name) . "'";

    288. 

  288. 		

    289. 

  289. 		if($tproject_id > 0 )

    290. 

  290. 		{

    291. 

  291. 			$sql .= " AND NH.parent_id={$tproject_id}";

    292. 

  292. 		}

    293. 

  293. 		

    294. 

  294. 		$recordset = $this->db->get_recordset($sql);

    295. 

  295. 		return($recordset);

    296. 

  296. 	}

    297. 

  297. 

    298. 

  298. 

    299. 

  299. 	/*

    300. 

  300. 	 function: get_by_id

    301. 

  301. 	 

    302. 

  302. 	 args : id: testplan id

    303. 

  303. 	 

    304. 

  304. 	 returns: map with following keys:

    305. 

  305. 	 id: testplan id

    306. 

  306. 	 name: testplan name

    307. 

  307. 	 notes: testplan notes

    308. 

  308. 	 testproject_id

    309. 

  309. 	 active

    310. 

  310. 	 is_open

    311. 

  311. 	 parent_id

    312. 

  312. 	 */

    313. 

  313. 	function get_by_id($id)

    314. 

  314. 	{

    315. 

  315. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    316. 

  316.         $sql = "/* $debugMsg */ " .

    317. 

  317. 		       " SELECT testplans.*,NH.name,NH.parent_id " .

    318. 

  318. 			   " FROM {$this->tables['testplans']} testplans, " .

    319. 

  319. 			   " {$this->tables['nodes_hierarchy']} NH " .

    320. 

  320. 			   " WHERE testplans.id = NH.id AND  testplans.id = {$id}";

    321. 

  321. 		$recordset = $this->db->get_recordset($sql);

    322. 

  322. 		return($recordset ? $recordset[0] : null);

    323. 

  323. 	}

    324. 

  324. 

    325. 

  325. 

    326. 

  326. 	/*

    327. 

  327.   		function: get_all

    328. 

  328.             get array of info for every test plan,

    329. 

  329.             without considering Test Project and any other kind of filter.

    330. 

  330.             Every array element contains an assoc array

    331. 

  331. 

    332. 

  332.   		args : -

    333. 

  333. 

    334. 

  334.   		returns: array, every element is a  map with following keys:

    335. 

  335.            id: testplan id

    336. 

  336.            name: testplan name

    337. 

  337.            notes: testplan notes

    338. 

  338.            testproject_id

    339. 

  339.            active

    340. 

  340.            is_open

    341. 

  341.            parent_id

    342. 

  342. 	*/

    343. 

  343. 	function get_all()

    344. 

  344. 	{

    345. 

  345. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    346. 

  346.         $sql = "/* $debugMsg */ " .

    347. 

  347. 		       " SELECT testplans.*, NH.name " .

    348. 

  348. 			   " FROM {$this->tables['testplans']} testplans, " .

    349. 

  349. 			   " {$this->tables['nodes_hierarchy']} NH " .

    350. 

  350. 			   " WHERE testplans.id=NH.id";

    351. 

  351. 		$recordset = $this->db->get_recordset($sql);

    352. 

  352. 		return $recordset;

    353. 

  353. 	}

    354. 

  354. 

    355. 

  355. 	/*

    356. 

  356. 	  function: count_testcases

    357. 

  357.             get number of testcases linked to a testplan

    358. 

  358. 

    359. 

  359. 	  args: id: testplan id

    360. 

  360. 

    361. 

  361.             [platform_id]: null => do not filter by platform

    362. 

  362.             

    363. 

  363. 	  returns: number

    364. 

  364. 	*/

    365. 

  365. 	public function count_testcases($id,$platform_id=null)

    366. 

  366. 	{

    367. 

  367. 		$sql_filter = '';

    368. 

  368. 		if( !is_null($platform_id) )

    369. 

  369. 		{

    370. 

  370. 			$sql_filter = " AND platform_id={$platform_id} ";

    371. 

  371. 		}

    372. 

  372. 		

    373. 

  373. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    374. 

  374.         $sql = "/* $debugMsg */ " .

    375. 

  375. 	           " SELECT COUNT(testplan_id) AS qty " .

    376. 

  376. 		       " FROM {$this->tables['testplan_tcversions']} " .

    377. 

  377. 			   " WHERE testplan_id={$id} {$sql_filter}";

    378. 

  378. 		$recordset = $this->db->get_recordset($sql);

    379. 

  379. 		$qty = 0;

    380. 

  380. 		if(!is_null($recordset))

    381. 

  381. 		{

    382. 

  382. 			$qty = $recordset[0]['qty'];

    383. 

  383. 		}

    384. 

  384. 		return $qty;

    385. 

  385. 	}

    386. 

  386. 

    387. 

  387. 

    388. 

  388. 	/*

    389. 

  389. 	  function: tcversionInfoForAudit

    390. 

  390.             get info regarding tcversions, to generate useful audit messages

    391. 

  391.             

    392. 

  392. 

    393. 

  393. 	  args :

    394. 

  394.         $tplan_id: test plan id

    395. 

  395.         $items_to_link: map key=tc_id 

    396. 

  396.                         value: tcversion_id

    397. 

  397. 	  returns: -

    398. 

  398. 

    399. 

  399. 	  rev: 20080629 - franciscom - audit message improvements

    400. 

  400. 	*/

    401. 

  401. 	function tcversionInfoForAudit($tplan_id,&$items)

    402. 

  402. 	{

    403. 

  403. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    404. 

  404. 		

    405. 

  405. 		// Get human readeable info for audit

    406. 

  406. 		$ret=array();

    407. 

  407. 		$tcase_cfg = config_get('testcase_cfg');

    408. 

  408. 		$dummy=reset($items);

    409. 

  409. 		

    410. 

  410. 		list($ret['tcasePrefix'],$tproject_id) = $this->tcase_mgr->getPrefix($dummy);

    411. 

  411. 		$ret['tcasePrefix'] .= $tcase_cfg->glue_character;

    412. 

  412. 		

    413. 

  413.         $sql = "/* $debugMsg */ " .

    414. 

  414. 		       " SELECT TCV.id, tc_external_id, version, NHB.name " .

    415. 

  415. 			   " FROM {$this->tables['tcversions']} TCV,{$this->tables['nodes_hierarchy']} NHA, " .

    416. 

  416. 			   " {$this->tables['nodes_hierarchy']} NHB " .

    417. 

  417. 			   " WHERE NHA.id=TCV.id " .

    418. 

  418. 			   " AND NHB.id=NHA.parent_id  " .

    419. 

  419. 			   " AND TCV.id IN (" . implode(',',$items) . ")";

    420. 

  420. 		

    421. 

  421. 		$ret['info']=$this->db->fetchRowsIntoMap($sql,'id');  

    422. 

  422. 		$ret['tplanInfo']=$this->get_by_id($tplan_id);                                                          

    423. 

  423. 		

    424. 

  424. 		return $ret;

    425. 

  425. 	}

    426. 

  426. 

    427. 

  427. 

    428. 

  428. 	/**

    429. 

  429. 	 * associates version of different test cases to a test plan.

    430. 

  430. 	 * this is the way to populate a test plan

    431. 

  431. 

    432. 

  432.  	 args :

    433. 

  433.         $id: test plan id

    434. 

  434.         $items_to_link: map key=tc_id 

    435. 

  435.                         value= map with

    436. 

  436.                                key: platform_id (can be 0)

    437. 

  437.                                value: tcversion_id

    438. 

  438.                         passed by reference for speed

    439. 

  439. 	  returns: -

    440. 

  440. 

    441. 

  441. 	  rev: 20080629 - franciscom - audit message improvements

    442. 

  442. 	*/

    443. 

  443. 	function link_tcversions($id,&$items_to_link,$userId)

    444. 

  444. 	{

    445. 

  445. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    446. 

  446. 		

    447. 

  447. 		// Get human readeable info for audit

    448. 

  448. 		$title_separator = config_get('gui_title_separator_1');

    449. 

  449. 		$auditInfo=$this->tcversionInfoForAudit($id,$items_to_link['tcversion']);

    450. 

  450. 		$platformInfo = $this->platform_mgr->getLinkedToTestplanAsMap($id);

    451. 

  451. 		$platformLabel = lang_get('platform');

    452. 

  452. 		

    453. 

  453. 		// Important: MySQL do not support default values on datetime columns that are functions

    454. 

  454. 		// that's why we are using db_now().

    455. 

  455. 		$sql = "/* $debugMsg */ " .

    456. 

  456. 		       "INSERT INTO {$this->tables['testplan_tcversions']} " .

    457. 

  457. 			   "(testplan_id,author_id,creation_ts,tcversion_id,platform_id) " . 

    458. 

  458. 			   " VALUES ({$id},{$userId},{$this->db->db_now()},";

    459. 

  459.         $features=null;

    460. 

  460. 		foreach($items_to_link['items'] as $tcase_id => $items)

    461. 

  461. 		{

    462. 

  462. 			foreach($items as $platform_id => $tcversion)

    463. 

  463. 			{

    464. 

  464. 				$addInfo='';

    465. 

  465. 				$result = $this->db->exec_query($sql . "{$tcversion}, {$platform_id})");

    466. 

  466. 				if ($result)

    467. 

  467. 				{

    468. 

  468.                     $features[$platform_id][$tcversion]=$this->db->insert_id($this->tables['testplan_tcversions']);					

    469. 

  469. 					if( isset($platformInfo[$platform_id]) )

    470. 

  470. 					{

    471. 

  471. 						$addInfo = ' - ' . $platformLabel . ':' . $platformInfo[$platform_id];

    472. 

  472. 					}

    473. 

  473. 					$auditMsg=TLS("audit_tc_added_to_testplan",

    474. 

  474. 								  $auditInfo['tcasePrefix'] . $auditInfo['info'][$tcversion]['tc_external_id'] . 

    475. 

  475. 								  $title_separator . $auditInfo['info'][$tcversion]['name'],

    476. 

  476. 								  $auditInfo['info'][$tcversion]['version'],

    477. 

  477. 								  $auditInfo['tplanInfo']['name'] . $addInfo );

    478. 

  478. 					

    479. 

  479. 					logAuditEvent($auditMsg,"ASSIGN",$id,"testplans");

    480. 

  480. 				}	

    481. 

  481. 			}

    482. 

  482. 		}

    483. 

  483. 		return $features;

    484. 

  484. 	}

    485. 

  485. 

    486. 

  486. 

    487. 

  487. 	/*

    488. 

  488. 	  function: setExecutionOrder

    489. 

  489. 

    490. 

  490.   	args :

    491. 

  491.         $id: test plan id

    492. 

  492.         $executionOrder: assoc array key=tcversion_id value=order

    493. 

  493.                          passed by reference for speed

    494. 

  494. 

    495. 

  495.   	returns: -

    496. 

  496. 	*/

    497. 

  497. 	function setExecutionOrder($id,&$executionOrder)

    498. 

  498. 	{

    499. 

  499. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    500. 

  500. 		foreach($executionOrder as $tcVersionID => $execOrder)

    501. 

  501. 		{

    502. 

  502. 			$execOrder=intval($execOrder);

    503. 

  503. 			$sql="/* $debugMsg */ UPDATE {$this->tables['testplan_tcversions']} " .

    504. 

  504. 				 "SET node_order={$execOrder} " .

    505. 

  505. 				 "WHERE testplan_id={$id} " .

    506. 

  506. 				 "AND tcversion_id={$tcVersionID}";

    507. 

  507. 			$result = $this->db->exec_query($sql);

    508. 

  508. 		}

    509. 

  509. 	}

    510. 

  510. 	

    511. 

  511. 

    512. 

  512. 	/**

    513. 

  513. 	 *

    514. 

  514. 	 * @internal revisions:

    515. 

  515. 	 *   20100722 - asimon - added missing $debugMsg

    516. 

  516. 	 */

    517. 

  517. 	function get_linked_items_id($id)

    518. 

  518. 	{

    519. 

  519. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    520. 

  520. 		$sql = " /* $debugMsg */ ". 

    521. 

  521. 			   " SELECT DISTINCT parent_id FROM {$this->tables['nodes_hierarchy']} NHTC " .

    522. 

  522. 			   " JOIN {$this->tables['testplan_tcversions']} TPTCV ON TPTCV.tcversion_id = NHTC.id " .

    523. 

  523. 			   " WHERE TPTCV.testplan_id = {$id} ";

    524. 

  524. 			   

    525. 

  525. 		$linked_items = $this->db->fetchRowsIntoMap($sql,'parent_id');			     

    526. 

  526. 		return $linked_items;

    527. 

  527. 	}

    528. 

  528. 

    529. 

  529. 

    530. 

  530. 	/*

    531. 

  531.   	function: get_linked_tcversions

    532. 

  532.             get information about testcases linked to a testplan.

    533. 

  533. 

    534. 

  534.   	args :

    535. 

  535.          id: testplan id

    536. 

  536.          [filters]: map with following keys

    537. 

  537.          	[tcase_id]: default null => get any testcase

    538. 

  538.          	            numeric      => just get info for this testcase

    539. 

  539.          	

    540. 

  540.          	[keyword_id]: default 0 => do not filter by keyword id

    541. 

  541.          	              numeric   => filter by keyword id

    542. 

  542.          	

    543. 

  543.          	

    544. 

  544.          	[assigned_to]: default NULL => do not filter by user assign.

    545. 

  545.          	               array() with user id to be used on filter

    546. 

  546.          	

    547. 

  547.          	[exec_status]: default NULL => do not filter by execution status

    548. 

  548.          	               character or array => filter by execution status=character

    549. 

  549.          	

    550. 

  550.          	[build_id]: default 0 => do not filter by build id

    551. 

  551.          	            numeric   => filter by build id

    552. 

  552.          	

    553. 

  553.          	[cf_hash]: default null => do not filter by Custom Fields values

    554. 

  554.          	

    555. 

  555. 		 	

    556. 

  556. 		 	[urgencyImportance] : filter only Tc's with certain (urgency*importance)-value 

    557. 

  557. 		 	

    558. 

  558. 		 	[tsuites_id]: default null.

    559. 

  559. 		 	              If present only tcversions that are children of this testsuites

    560. 

  560. 		 	              will be included

    561. 

  561. 		 	[exec_type] default null -> all types. 

    562. 

  562. 		 	[platform_id]              

    563. 

  563. 		     		

    564. 

  564.          [options]: map with following keys

    565. 

  565.          	[output]: controls data type returned

    566. 

  566.          	          default: map -> map indexed by test case id (original return type)

    567. 

  567.          	                          Using this option is (in a certain way) as having

    568. 

  568.          	                          added DISTINCT on SQL clause.

    569. 

  569.          	                          YOU WILL GET ONLY LAST EXECUTION (means one record)

    570. 

  570.          	                          of each test case.

    571. 

  571.          	                          

    572. 

  572.          	                   mapOfMap: first key testcase_id, second key platform_id               

    573. 

  573.          	                            You GET ONLY LAST EXECUTION (means one record)

    574. 

  574.          	                            of each test case.

    575. 

  575. 

    576. 

  576.          	                   mapOfArray -> indexed by test case id but with an array

    577. 

  577.          	                                 where each element contains information

    578. 

  578.          	                                 according to Platform.

    579. 

  579.          	                                 Be carefull if you have multiple executions

    580. 

  580.          	                                 for same (testcase,platform) YOU WILL GET

    581. 

  581.          	                                 MULTIPLE ELEMENTS IN ARRAY

    582. 

  582.          	                                 

    583. 

  583.          	                  array -> indexed sequentially. 

    584. 

  584.          	                  

    585. 

  585.          	                            

    586. 

  586.          	          

    587. 

  587.          	[only_executed]: default false => get executed and NOT executed

    588. 

  588.          	                                  get only executed tcversions

    589. 

  589.          

    590. 

  590.          	[execution_details]: default NULL => by platftorm

    591. 

  591.          	                     add_build => by build AND platform

    592. 

  592.          	                             

    593. 

  593.          	[last_execution]: default false => return all executions

    594. 

  594.          	                          true => last execution ( MAX(E.id))

    595. 

  595.          	                          

    596. 

  596.          	[include_unassigned]: has effects only if [assigned_to] <> null.

    597. 

  597.          	                      default: false

    598. 

  598.          	                      true: also testcase not assigned will be retreived

    599. 

  599.          	

    600. 

  600.          	[details]: controls columns returned

    601. 

  601.          	           default 'simple'

    602. 

  602.          	           'full': add summary, steps and expected_results, and test suite name

    603. 

  603.          	           'summary': add summary 

    604. 

  604. 		 	[steps_info]: controls if step info has to be added on output    

    605. 

  605.          	           default true

    606. 

  606. 		 	[user_assignments_per_build]: contains a build ID, for which the

    607. 

  607. 		 	                              assigned user shall get loaded    

    608. 

  608. 		 	    

    609. 

  609. 		 	    

    610. 

  610. 	  returns: changes according options['output'] (see above)

    611. 

  611. 

    612. 

  612.            Notice:

    613. 

  613.            executed field: will take the following values

    614. 

  614.                            - NULL if the tc version has not been executed in THIS test plan.

    615. 

  615.                            - tcversion_id if has executions.

    616. 

  616. 

    617. 

  617. 	rev :

    618. 

  618. 		 20100727 - asimon - BUGID 3629: modified statement

    619. 

  619. 		 20100721 - asimon - BUGID 3406: added user_assignments_per_build option

    620. 

  620. 		 20100520 - franciscom - added option steps_info, to try to solve perfomance problems

    621. 

  621. 		 						 allowing caller to ask for NO INFO ABOUT STEPS	

    622. 

  622. 		 20100417 - franciscom - added importance on output data

    623. 

  623. 		 		  				 BUGID 3356: "Failed Test Cases" report is not updated when a test case 

    624. 

  624. 		 		  				 			  has been changed from "Failed" to "Passed"		 

    625. 

  625. 		 		  				 			  

    626. 

  626.          20090814 - franciscom - interface changes due to platform feature

    627. 

  627. 	*/

    628. 

  628. 	public function get_linked_tcversions($id,$filters=null,$options=null)

    629. 

  629. 	{

    630. 

  630. 		$debugMsg = 'Class: ' . __CLASS__ . ' - Method:' . __FUNCTION__;

    631. 

  631. 		

    632. 

  632.         $my = array ('filters' => '', 'options' => '');

    633. 

  633. 		$tcversion_exec_type = array('join' => '', 'filter' => '');

    634. 

  634. 		$tc_id = array('join' => '', 'filter' => '');

    635. 

  635. 		$builds = array('join' => '', 'filter' => '');

    636. 

  636. 		$keywords = array('join' => '', 'filter' => '');

    637. 

  637. 		$executions = array('join' => '', 'filter' => '');

    638. 

  638. 		$platforms = array('join' => '', 'filter' => '');

    639. 

  639. 		

    640. 

  640.         $my['filters'] = array('tcase_id' => null, 'keyword_id' => 0,

    641. 

  641.                                'assigned_to' => null, 'exec_status' => null,

    642. 

  642.                                'build_id' => 0, 'cf_hash' => null,

    643. 

  643.                                'urgencyImportance' => null, 'tsuites_id' => null,

    644. 

  644.                                'platform_id' => null, 'exec_type' => null);

    645. 

  645.                                

    646. 

  646.         $my['options'] = array('only_executed' => false, 'include_unassigned' => false,

    647. 

  647.                                'output' => 'map', 'details' => 'simple', 'steps_info' => false, 

    648. 

  648.                                'execution_details' => null, 'last_execution' => false);

    649. 

  649. 

    650. 

  650.  		// Cast to array to handle $options = null

    651. 

  651. 		$my['filters'] = array_merge($my['filters'], (array)$filters);

    652. 

  652. 		$my['options'] = array_merge($my['options'], (array)$options);

    653. 

  653. 		

    654. 

  654. 		// 20100830 - franciscom - bug found by Julian

    655. 

  655. 		$my['filters']['exec_status'] = (array)$my['filters']['exec_status'];

    656. 

  656. 

    657. 

  657. 		// new dBug($my['filters']);

    658. 

  658. 		// new dBug($my['options']);

    659. 

  659. 

    660. 

  660. 		$groupByPlatform=($my['options']['output']=='mapOfMap' || 

    661. 

  661. 		                  $my['options']['output']=='mapOfMapExecPlatform') ? ',platform_id' : '';

    662. 

  662. 		$groupByBuild=($my['options']['execution_details'] == 'add_build') ? ',build_id' : '';

    663. 

  663. 

    664. 

  664. 		// BUGID 3406: user assignments per build 

    665. 

  665. 		$ua_build = isset($my['options']['user_assignments_per_build']) ? 

    666. 

  666. 		            $my['options']['user_assignments_per_build'] : 0;

    667. 

  667. 		

    668. 

  668. 		// BUGID 3629

    669. 

  669. 		$ua_build_sql = $ua_build && is_numeric($ua_build) ? " AND UA.build_id={$ua_build} " : " ";

    670. 

  670. 		

    671. 

  671.         // @TODO - 20091004 - franciscom

    672. 

  672.         // Think that this subquery in not good when we add execution filter

    673. 

  673. 		// $last_exec_subquery = " AND E.id IN ( SELECT MAX(id) " .

    674. 

  674. 		// 	 		             "               FROM  {$this->tables['executions']} executions " .

    675. 

  675. 		// 			             "               WHERE testplan_id={$id} %EXECSTATUSFILTER%" .

    676. 

  676. 		// 			             " GROUP BY tcversion_id,testplan_id {$groupByPlatform} {$groupByBuild} )";

    677. 

  677. 

    678. 

  678. 		// I've had confirmation of BAD query;

    679. 

  679. 		// BUGID 3356: "Failed Test Cases" report is not updated when a test case 

    680. 

  680. 		// 		  				 			  has been changed from "Failed" to "Passed"		 

    681. 

  681. 		//

    682. 

  682.         // SUBQUERY CAN NOT HAVE ANY KIND OF FILTERING other that test plan.

    683. 

  683.         // Adding exec status, means that we will get last exec WITH THIS STATUS, and not THE LATEST EXEC   

    684. 

  684. 		$last_exec_subquery = " AND E.id IN ( SELECT MAX(id) " .

    685. 

  685. 			 		          "               FROM  {$this->tables['executions']} executions " .

    686. 

  686. 					          "               WHERE testplan_id={$id} " .

    687. 

  687. 					          " GROUP BY tcversion_id,testplan_id {$groupByPlatform} {$groupByBuild} )";

    688. 

  688.            

    689. 

  689.            

    690. 

  690.            

    691. 

  691. 		$resultsCfg = config_get('results');

    692. 

  692. 		$status_not_run=$resultsCfg['status_code']['not_run'];

    693. 

  693. 		$sql_subquery='';

    694. 

  694. 		

    695. 

  695. 		// franciscom

    696. 

  696. 		// WARNING: 

    697. 

  697. 		// Order of analisys seems to be critic, because $executions['filter'] is overwritten

    698. 

  698. 		// on some situation below if filtering on execution status is requested

    699. 

  699. 		if( $my['options']['last_execution'] )

    700. 

  700. 		{

    701. 

  701. 			$executions['filter'] = " {$last_exec_subquery} ";

    702. 

  702. 			// 20100417 - franciscom - BUGID 3356

    703. 

  703. 			// $executions['filter'] = str_ireplace("%EXECSTATUSFILTER%", "", $executions['filter']);

    704. 

  704. 		}

    705. 

  705. 		

    706. 

  706. 		if( !is_null($my['filters']['platform_id']) )

    707. 

  707. 		{

    708. 

  708. 			$platforms['filter'] = " AND T.platform_id = {$my['filters']['platform_id']} ";

    709. 

  709. 	    }

    710. 

  710. 		

    711. 

  711. 		// 20100417- Why to use a list ? - must be checked if is on

    712. 

  712. 		if( !is_null($my['filters']['exec_type']) )

    713. 

  713. 		{

    714. 

  714. 			$tcversion_exec_type['filter'] = "AND TCV.execution_type IN (" . 

    715. 

  715. 			                                 implode(",",(array)$my['filters']['exec_type']) . " ) ";     

    716. 

  716. 		}

    717. 

  717. 		

    718. 

  718. 		// Based on work by Eugenia Drosdezki

    719. 

  719. 		if( is_array($my['filters']['keyword_id']) )

    720. 

  720. 		{

    721. 

  721. 			// 0 -> no keyword, remove 

    722. 

  722. 			if( $my['filters']['keyword_id'][0] == 0 )

    723. 

  723. 			{

    724. 

  724. 				array_shift($my['filters']['keyword_id']);

    725. 

  725. 			}

    726. 

  726. 			

    727. 

  727. 			if(count($my['filters']['keyword_id']))

    728. 

  728. 			{

    729. 

  729. 				$keywords['filter'] = " AND TK.keyword_id IN (" . implode(',',$my['filters']['keyword_id']) . ")";          	

    730. 

  730. 			}  

    731. 

  731. 		}

    732. 

  732. 		else if($my['filters']['keyword_id'] > 0)

    733. 

  733. 		{

    734. 

  734. 			$keywords['filter'] = " AND TK.keyword_id = {$my['filters']['keyword_id']} ";

    735. 

  735. 		}

    736. 

  736. 		

    737. 

  737. 		if(trim($keywords['filter']) != "")

    738. 

  738. 		{

    739. 

  739. 			$keywords['join'] = " JOIN {$this->tables['testcase_keywords']} TK ON NHA.parent_id = TK.testcase_id ";

    740. 

  740. 		}

    741. 

  741. 		

    742. 

  742. 		if (!is_null($my['filters']['tcase_id']) )

    743. 

  743. 		{

    744. 

  744. 			if( is_array($my['filters']['tcase_id']) )

    745. 

  745. 			{

    746. 

  746. 				$tc_id['filter'] = " AND NHA.parent_id IN (" . implode(',',$my['filters']['tcase_id']) . ")";          	

    747. 

  747. 			}

    748. 

  748. 			else if ($my['filters']['tcase_id'] > 0 )

    749. 

  749. 			{

    750. 

  750. 				$tc_id['filter'] = " AND NHA.parent_id = {$my['filters']['tcase_id']} ";

    751. 

  751. 			}

    752. 

  752. 		}

    753. 

  753. 		

    754. 

  754. 		// --------------------------------------------------------------

    755. 

  755. 		if(!is_null($my['filters']['exec_status']) )

    756. 

  756. 		{

    757. 

  757. 			$executions['filter'] = '';

    758. 

  758. 			$notrun['filter'] = null;

    759. 

  759. 			$otherexec['filter'] = null;

    760. 

  760. 			

    761. 

  761. 			$notRunPresent = array_search($status_not_run,$my['filters']['exec_status']); 

    762. 

  762. 			if($notRunPresent !== false)

    763. 

  763. 			{

    764. 

  764. 				$notrun['filter'] = " E.status IS NULL ";

    765. 

  765. 				unset($my['filters']['exec_status'][$notRunPresent]);  

    766. 

  766. 			}

    767. 

  767. 			

    768. 

  768. 			if(count($my['filters']['exec_status']) > 0)

    769. 

  769. 			{

    770. 

  770. 				$otherexec['filter']=" E.status IN ('" . implode("','",$my['filters']['exec_status']) . "') ";

    771. 

  771. 				

    772. 

  772. 				// 20100417 - franciscom - BUGID 3356

    773. 

  773. 				// $status_filter=str_ireplace("E.", "executions.", $otherexec['filter']);

    774. 

  774. 			    // $sql_subquery = str_ireplace("%EXECSTATUSFILTER%", "AND {$status_filter}", $last_exec_subquery);

    775. 

  775. 

    776. 

  776. 				// code commented before BUGID 3356

    777. 

  777. 			    // $sql_subquery = str_ireplace("E.", "executions.", $sql_subquery);

    778. 

  778. 				// $sql_subquery = $last_exec_subquery;

    779. 

  779. 				

    780. 

  780. 				// 20100417 - franciscom - BUGID 3356

    781. 

  781. 				// $executions['filter'] = " ( {$otherexec['filter']} {$sql_subquery} ) ";  

    782. 

  782. 				$executions['filter'] = " ( {$otherexec['filter']} {$last_exec_subquery} ) ";  

    783. 

  783. 			}

    784. 

  784. 			if( !is_null($notrun['filter']) )

    785. 

  785. 			{

    786. 

  786. 				if($executions['filter'] != "")

    787. 

  787. 				{

    788. 

  788. 					$executions['filter'] .= " OR ";

    789. 

  789. 				}

    790. 

  790. 				$executions['filter'] .= $notrun['filter'];

    791. 

  791. 			}

    792. 

  792. 			

    793. 

  793. 			if($executions['filter'] != "")

    794. 

  794. 			{

    795. 

  795.                 // Just add the AND 

    796. 

  796. 				$executions['filter'] = " AND ({$executions['filter']} )";     

    797. 

  797. 			}

    798. 

  798. 		}

    799. 

  799. 		

    800. 

  800. 		// --------------------------------------------------------------

    801. 

  801. 		if( $my['filters']['build_id'] > 0 )

    802. 

  802. 		{

    803. 

  803. 			$builds['filter'] = " AND E.build_id={$my['filters']['build_id']} ";

    804. 

  804. 		}

    805. 

  805. 		

    806. 

  806. 		// there are several situation where you need to use LEFT OUTER

    807. 

  807. 		if(!$my['options']['only_executed'])

    808. 

  808. 		{

    809. 

  809. 			$executions['join'] = " LEFT OUTER ";

    810. 

  810. 		}

    811. 

  811. 		

    812. 

  812. 		

    813. 

  813. 		// platform feature

    814. 

  814. 		$executions['join'] .= " JOIN {$this->tables['executions']} E ON " .

    815. 

  815. 			                   " (NHA.id = E.tcversion_id AND " .

    816. 

  816. 			                   " E.platform_id=T.platform_id AND " .

    817. 

  817. 			                   " E.testplan_id=T.testplan_id {$builds['filter']}) ";

    818. 

  818. 		// --------------------------------------------------------------

    819. 

  819. 		

    820. 

  820. 		$more_tcase_fields = '';

    821. 

  821. 		$join_for_parent = '';

    822. 

  822. 		$more_parent_fields = '';

    823. 

  823. 		$more_exec_fields='';

    824. 

  824. 		switch($my['options']['details'])

    825. 

  825. 		{

    826. 

  826. 			case 'full':

    827. 

  827. 			$more_tcase_fields .= 'TCV.summary,';

    828. 

  828. 			$join_for_parent .= " JOIN {$this->tables['nodes_hierarchy']} NHC ON NHB.parent_id = NHC.id ";

    829. 

  829. 			$more_parent_fields .= 'NHC.name as tsuite_name,';

    830. 

  830. 			break;

    831. 

  831. 			

    832. 

  832. 			case 'summary':

    833. 

  833. 			$more_tcase_fields .= 'TCV.summary,';

    834. 

  834. 			break;

    835. 

  835. 		

    836. 

  836. 		}

    837. 

  837. 		if($my['options']['execution_details'] == 'add_build')

    838. 

  838. 		{

    839. 

  839. 			$more_exec_fields .= 'E.build_id,B.name AS build_name,';	

    840. 

  840. 			$builds['join']=" LEFT OUTER JOIN {$this->tables['builds']} B ON B.id=E.build_id ";

    841. 

  841. 	    }

    842. 

  842. 		

    843. 

  843. 	    // BUGID 3406 - assignments per build

    844. 

  844. 	    // BUGID 3492 - Added execution notes to sql statement of get_linked_tcversions

    845. 

  845. 		$sql = "/* $debugMsg */ " .

    846. 

  846. 		       " SELECT NHB.parent_id AS testsuite_id, {$more_tcase_fields} {$more_parent_fields}" .

    847. 

  847. 			   " NHA.parent_id AS tc_id, NHB.node_order AS z, NHB.name," .

    848. 

  848. 			   " T.platform_id, PLAT.name as platform_name ,T.id AS feature_id, T.tcversion_id AS tcversion_id,  " .

    849. 

  849. 			   " T.node_order AS execution_order, T.creation_ts AS linked_ts, T.author_id AS linked_by," .

    850. 

  850. 			   " TCV.version AS version, TCV.active," .

    851. 

  851. 			   " TCV.tc_external_id AS external_id, TCV.execution_type,TCV.importance," .

    852. 

  852. 			   " E.id AS exec_id, E.tcversion_number," .

    853. 

  853. 			   " E.tcversion_id AS executed, E.testplan_id AS exec_on_tplan, {$more_exec_fields}" .

    854. 

  854. 			   " E.execution_type AS execution_run_type, E.testplan_id AS exec_on_tplan, " .

    855. 

  855. 			   " E.execution_ts, E.tester_id, E.notes as execution_notes, ".

    856. 

  856. 		       " UA.build_id as assigned_build_id, " . // 3406

    857. 

  857. 			   " UA.user_id,UA.type,UA.status,UA.assigner_id,T.urgency, " .

    858. 

  858. 			   " COALESCE(E.status,'" . $status_not_run . "') AS exec_status, ".

    859. 

  859. 			   " (urgency * importance) AS priority " .

    860. 

  860. 			   " FROM {$this->tables['nodes_hierarchy']} NHA " .

    861. 

  861. 			   " JOIN {$this->tables['nodes_hierarchy']} NHB ON NHA.parent_id = NHB.id " .

    862. 

  862. 			   $join_for_parent .

    863. 

  863. 			   " JOIN {$this->tables['testplan_tcversions']} T ON NHA.id = T.tcversion_id " .

    864. 

  864. 			   " JOIN  {$this->tables['tcversions']} TCV ON NHA.id = TCV.id {$tcversion_exec_type['filter']} " .

    865. 

  865. 			   " {$executions['join']} " .

    866. 

  866. 			   " {$keywords['join']} " .

    867. 

  867. 			   " {$builds['join']} " .

    868. 

  868. 			   " LEFT OUTER JOIN {$this->tables['platforms']} PLAT ON PLAT.id = T.platform_id " .

    869. 

  869. 			   " LEFT OUTER JOIN {$this->tables['user_assignments']} UA ON UA.feature_id = T.id " .

    870. 

  870. 			   " {$ua_build_sql} " . // 3406

    871. 

  871. 			   " WHERE T.testplan_id={$id} {$keywords['filter']} {$tc_id['filter']} {$platforms['filter']}" .

    872. 

  872. 			   " AND (UA.type={$this->assignment_types['testcase_execution']['id']} OR UA.type IS NULL) " . 

    873. 

  873. 			   $executions['filter'];

    874. 

  874. 		

    875. 

  875. 		// 20081220 - franciscom

    876. 

  876. 		// if (!is_null($assigned_to) && $assigned_to > 0)

    877. 

  877. 		// {

    878. 

  878. 		//

    879. 

  879. 		// If special user id TL_USER_ANYBODY is present in set of user id,

    880. 

  880. 		// we will DO NOT FILTER by user ID

    881. 

  881. 		if( !is_null($my['filters']['assigned_to']) && 

    882. 

  882. 		    !in_array(TL_USER_ANYBODY,(array)$my['filters']['assigned_to']) )

    883. 

  883. 		{  

    884. 

  884. 			$sql .= " AND ";

    885. 

  885. 			

    886. 

  886. 			// Warning!!!:

    887. 

  887. 			// If special user id TL_USER_NOBODY is present in set of user id

    888. 

  888. 			// we will ignore any other user id present on set.

    889. 

  889. 			if( in_array(TL_USER_NOBODY,(array)$my['filters']['assigned_to']) )

    890. 

  890. 			{

    891. 

  891. 				$sql .= " UA.user_id IS NULL "; 

    892. 

  892. 			} 

    893. 

  893. 			// BUGID 2455

    894. 

  894.             // new user filter "somebody" --> all asigned testcases

    895. 

  895. 			else if( in_array(TL_USER_SOMEBODY,(array)$my['filters']['assigned_to']) )

    896. 

  896. 			{

    897. 

  897. 				$sql .= " UA.user_id IS NOT NULL "; 

    898. 

  898. 			}

    899. 

  899. 			else

    900. 

  900. 			{

    901. 

  901. 				$sql_unassigned="";

    902. 

  902. 				if( $my['options']['include_unassigned'] )

    903. 

  903. 				{

    904. 

  904. 					$sql .= "(";

    905. 

  905. 					$sql_unassigned=" OR UA.user_id IS NULL)";

    906. 

  906. 				}

    907. 

  907. 				// BUGID 2500

    908. 

  908. 				$sql .= " UA.user_id IN (" . implode(",",(array)$my['filters']['assigned_to']) . ") " . $sql_unassigned;

    909. 

  909. 			}

    910. 

  910. 		}

    911. 

  911. 		

    912. 

  912. 		if (!is_null($my['filters']['urgencyImportance']))

    913. 

  913. 		{

    914. 

  914. 			$urgencyImportanceCfg = config_get("urgencyImportance");

    915. 

  915. 			if ($my['filters']['urgencyImportance'] == HIGH)

    916. 

  916. 			{

    917. 

  917. 				$sql .= " AND (urgency * importance) >= " . $urgencyImportanceCfg->threshold['high'];

    918. 

  918. 			}

    919. 

  919. 			else if($my['filters']['urgencyImportance'] == LOW)

    920. 

  920. 			{

    921. 

  921. 				$sql .= " AND (urgency * importance) < " . $urgencyImportanceCfg->threshold['low'];

    922. 

  922. 			}

    923. 

  923. 			else

    924. 

  924. 			{

    925. 

  925. 				$sql .= " AND ( ((urgency * importance) >= " . $urgencyImportanceCfg->threshold['low'] . 

    926. 

  926. 					    " AND  ((urgency * importance) < " . $urgencyImportanceCfg->threshold['high']."))) ";

    927. 

  927. 			}		

    928. 

  928. 		}

    929. 

  929. 		

    930. 

  930. 		// test suites filter

    931. 

  931. 		if (!is_null($my['filters']['tsuites_id']))

    932. 

  932. 		{

    933. 

  933. 			$tsuiteSet = is_array($my['filters']['tsuites_id']) ? $my['filters']['tsuites_id'] : array($my['filters']['tsuites_id']);

    934. 

  934. 			$sql .= " AND NHB.parent_id IN (" . implode(',',$tsuiteSet) . ")";

    935. 

  935. 		}

    936. 

  936. 		$sql .= " ORDER BY testsuite_id,NHB.node_order,tc_id,platform_id,E.id ASC";

    937. 

  937. 

    938. 

  938.  		switch($my['options']['output'])

    939. 

  939. 		{ 

    940. 

  940. 			case 'array':

    941. 

  941. 			$recordset = $this->db->get_recordset($sql);

    942. 

  942. 			break;

    943. 

  943. 

    944. 

  944. 			case 'mapOfArray':

    945. 

  945. 			$recordset = $this->db->fetchRowsIntoMap($sql,'tc_id',database::CUMULATIVE);

    946. 

  946. 			break;

    947. 

  947. 			

    948. 

  948. 			case 'mapOfMap':

    949. 

  949. 			// with this option we got just one record for each (testcase,platform)

    950. 

  950. 			// no matter how many executions has been done

    951. 

  951. 			

    952. 

  952. 			$recordset = $this->db->fetchMapRowsIntoMap($sql,'tc_id','platform_id');

    953. 

  953. 			break;

    954. 

  954. 			

    955. 

  955. 			case 'mapOfMapExecPlatform':

    956. 

  956. 			// with this option we got just one record for each (platform, build)

    957. 

  957. 			

    958. 

  958. 			$recordset = $this->db->fetchMapRowsIntoMap($sql,'exec_id','platform_id');

    959. 

  959. 			break;

    960. 

  960. 			

    961. 

  961. 			case 'map':

    962. 

  962. 			default:

    963. 

  963. 			$recordset = $this->db->fetchRowsIntoMap($sql,'tc_id');

    964. 

  964. 			

    965. 

  965. 			// 20070913 - jbarchibald

    966. 

  966. 			// here we add functionality to filter out the custom field selections

    967. 

  967. 			//

    968. 

  968. 			// After addition of platform feature, this filtering can not be done

    969. 

  969. 			// always with original filter_cf_selection().

    970. 

  970. 			// Fisrt choice:

    971. 

  971. 			// Enable this feature only if recordset maintains original structured

    972. 

  972. 			//

    973. 

  973. 			if (!is_null($my['filters']['cf_hash'])) {

    974. 

  974. 				$recordset = $this->filter_cf_selection($recordset, $my['filters']['cf_hash']);

    975. 

  975. 			}

    976. 

  976. 			break;

    977. 

  977. 		}

    978. 

  978. 		

    979. 

  979.         // Multiple Test Case Steps Feature

    980. 

  980.         // added after Julian mail regarding perf problems building exec tree

    981. 

  981.         if( !is_null($recordset) && $my['options']['steps_info'])

    982. 

  982.         {

    983. 

  983. 		    $itemSet = array_keys($recordset);

    984. 

  984. 			switch($my['options']['output'])

    985. 

  985. 			{ 

    986. 

  986.         	

    987. 

  987. 				case 'mapOfArray':

    988. 

  988. 				case 'mapOfMap':

    989. 

  989. 	  				foreach($itemSet as $itemKey)

    990. 

  990. 	  				{

    991. 

  991. 	  					$keySet = array_keys($recordset[$itemKey]);

    992. 

  992. 	  					$target = &$recordset[$itemKey];

    993. 

  993. 	  					foreach($keySet as $accessKey)

    994. 

  994. 	  					{

    995. 

  995. 	  						$step_set = $this->tcase_mgr->get_steps($target[$accessKey]['tcversion_id']);

    996. 

  996. 	  						$target[$accessKey]['steps'] = $step_set;

    997. 

  997. 	  					}

    998. 

  998. 	  				}

    999. 

  999. 				break;

    1000. 

  1000. 				

    1001. 

  1001. 				case 'array':

    1002. 

  1002. 				case 'map':

    1003. 

  1003. 				default:

    1004. 

  1004.   					foreach($itemSet as $accessKey)

    1005. 

  1005.   					{

    1006. 

  1006. 	  					$step_set = $this->tcase_mgr->get_steps($recordset[$accessKey]['tcversion_id']);

    1007. 

  1007. 	  					$recordset[$accessKey]['steps'] = $step_set;

    1008. 

  1008. 	  				} 

    1009. 

  1009. 				break;

    1010. 

  1010. 			}

    1011. 

  1011.         }

    1012. 

  1012. 

    1013. 

  1013. 		

    1014. 

  1014. 		return $recordset;

    1015. 

  1015. 	}

    1016. 

  1016. 

    1017. 

  1017. 

    1018. 

  1018. /*

    1019. 

  1019.   function: get_linked_and_newest_tcversions

    1020. 

  1020.             returns for every test case in a test plan

    1021. 

  1021.             the tc version linked and the newest available version

    1022. 

  1022. 

    1023. 

  1023.   args: id: testplan id

    1024. 

  1024.         [tcase_id]: default null => all testcases linked to testplan

    1025. 

  1025. 

    1026. 

  1026.   returns: map key: testcase internal id

    1027. 

  1027.            values: map with following keys:

    1028. 

  1028. 

    1029. 

  1029.             [name]

    1030. 

  1030.             [tc_id] (internal id)

    1031. 

  1031.             [tcversion_id]

    1032. 

  1032.             [newest_tcversion_id]

    1033. 

  1033.             [tc_external_id]

    1034. 

  1034.             [version] (for humans)

    1035. 

  1035.             [newest_version] (for humans)

    1036. 

  1036. 

    1037. 

  1037.   rev:

    1038. 

  1038.       20080614 - franciscom - fixed bug on SQL generated while

    1039. 

  1039.                               adding tc_external_id on results.

    1040. 

  1040.       20080126 - franciscom - added tc_external_id on results

    1041. 

  1041. */

    1042. 

  1042. 	function get_linked_and_newest_tcversions($id,$tcase_id=null)

    1043. 

  1043. 	{

    1044. 

  1044. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1045. 

  1045. 		

    1046. 

  1046. 		$tc_id_filter = " ";

    1047. 

  1047. 		if (!is_null($tcase_id) )

    1048. 

  1048. 		{

    1049. 

  1049. 			if( is_array($tcase_id) )

    1050. 

  1050. 			{

    1051. 

  1051. 				// ??? implement as in ?

    1052. 

  1052. 			}

    1053. 

  1053. 			else if ($tcase_id > 0 )

    1054. 

  1054. 			{

    1055. 

  1055. 				$tc_id_filter = " AND NHA.parent_id = {$tcase_id} ";

    1056. 

  1056. 			}

    1057. 

  1057. 		}

    1058. 

  1058. 		

    1059. 

  1059. 		// 20080614 - franciscom

    1060. 

  1060. 		// Peter Rooms found bug due to wrong SQL, accepted by MySQL but not by PostGres

    1061. 

  1061. 		// Missing column in GROUP BY Clause

    1062. 

  1062. 		

    1063. 

  1063. 		$sql = " SELECT MAX(NHB.id) AS newest_tcversion_id, " .

    1064. 

  1064. 			   " NHA.parent_id AS tc_id, NHC.name, T.tcversion_id AS tcversion_id," .

    1065. 

  1065. 			   " TCVA.tc_external_id AS tc_external_id, TCVA.version AS version " .

    1066. 

  1066. 			   " FROM {$this->tables['nodes_hierarchy']} NHA " .

    1067. 

  1067. 			

    1068. 

  1068. 			// NHA - will contain ONLY nodes of type testcase_version that are LINKED to test plan

    1069. 

  1069. 			" JOIN {$this->tables['testplan_tcversions']} T ON NHA.id = T.tcversion_id " . 

    1070. 

  1070. 			

    1071. 

  1071. 			// Get testcase_version data for LINKED VERSIONS

    1072. 

  1072. 			" JOIN {$this->tables['tcversions']} TCVA ON TCVA.id = T.tcversion_id" .

    1073. 

  1073. 			

    1074. 

  1074. 			// Work on Sibblings - Start

    1075. 

  1075. 			// NHB - Needed to get ALL testcase_version sibblings nodes

    1076. 

  1076. 			" JOIN {$this->tables['nodes_hierarchy']} NHB ON NHB.parent_id = NHA.parent_id " .

    1077. 

  1077. 			

    1078. 

  1078. 			// Want only ACTIVE Sibblings

    1079. 

  1079. 			" JOIN {$this->tables['tcversions']} TCVB ON TCVB.id = NHB.id AND TCVB.active=1 " . 

    1080. 

  1080. 			// Work on Sibblings - STOP 

    1081. 

  1081. 			

    1082. 

  1082. 			// NHC will contain - nodes of type TESTCASE (parent of testcase versions we are working on)

    1083. 

  1083. 			// we use NHC to get testcase NAME ( testcase version nodes have EMPTY NAME)

    1084. 

  1084. 			" JOIN {$this->tables['nodes_hierarchy']} NHC ON NHC.id = NHA.parent_id " .

    1085. 

  1085. 			

    1086. 

  1086. 			// Want to get only testcase version with id (NHB.id) greater than linked one (NHA.id)

    1087. 

  1087. 			" WHERE T.testplan_id={$id} AND NHB.id > NHA.id" . $tc_id_filter .

    1088. 

  1088. 			" GROUP BY NHA.parent_id, NHC.name, T.tcversion_id, TCVA.tc_external_id, TCVA.version  ";

    1089. 

  1089. 		

    1090. 

  1090. 		$sql2 = " SELECT SUBQ.name, SUBQ.newest_tcversion_id, SUBQ.tc_id, " .

    1091. 

  1091. 			    " SUBQ.tcversion_id, SUBQ.version, SUBQ.tc_external_id, " .

    1092. 

  1092. 			    " TCV.version AS newest_version " .

    1093. 

  1093. 			    " FROM {$this->tables['tcversions']} TCV, ( $sql ) AS SUBQ " .

    1094. 

  1094. 			    " WHERE SUBQ.newest_tcversion_id = TCV.id " .

    1095. 

  1095. 			    " ORDER BY SUBQ.tc_id ";

    1096. 

  1096. 		

    1097. 

  1097. 		return $this->db->fetchRowsIntoMap($sql2,'tc_id');

    1098. 

  1098. 	}

    1099. 

  1099. 

    1100. 

  1100. 

    1101. 

  1101. 	/**

    1102. 

  1102. 	 * Remove of records from user_assignments table

    1103. 

  1103. 	 * @author franciscom

    1104. 

  1104. 	 * 

    1105. 

  1105. 	 * @param integer $id   : test plan id

    1106. 

  1106. 	 * @param array $items: assoc array key=tc_id value=tcversion_id

    1107. 

  1107. 	 * 

    1108. 

  1108. 	 * @internal revisions:

    1109. 

  1109. 	 *    20100725 - asimon - BUGID 3497 and hopefully also 3530

    1110. 

  1110. 	 */

    1111. 

  1111. 	function unlink_tcversions($id,&$items)

    1112. 

  1112. 	{

    1113. 

  1113. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1114. 

  1114. 		if(is_null($items))

    1115. 

  1115. 		{

    1116. 

  1116. 			return;

    1117. 

  1117. 		}

    1118. 

  1118. 		

    1119. 

  1119. 		// Get human readeable info for audit

    1120. 

  1120. 		$gui_cfg = config_get('gui');

    1121. 

  1121. 		$title_separator = config_get('gui_title_separator_1');

    1122. 

  1122. 		$auditInfo=$this->tcversionInfoForAudit($id,$items['tcversion']);

    1123. 

  1123. 		$platformInfo = $this->platform_mgr->getLinkedToTestplanAsMap($id);

    1124. 

  1124. 		$platformLabel = lang_get('platform');

    1125. 

  1125. 

    1126. 

  1126.         $dummy = null;

    1127. 

  1127. 		foreach($items['items'] as $tcase_id => $elem) 

    1128. 

  1128. 		{

    1129. 

  1129. 			foreach($elem as $platform_id => $tcversion_id) 

    1130. 

  1130. 			{

    1131. 

  1131. 				$dummy[] = "(tcversion_id = {$tcversion_id} AND platform_id = {$platform_id})";

    1132. 

  1132. 			}

    1133. 

  1133. 		}

    1134. 

  1134. 		$where_clause = implode(" OR ", $dummy);

    1135. 

  1135. 		

    1136. 

  1136. 		/*

    1137. 

  1137. 		 * asimon - BUGID 3497 and hopefully also 3530

    1138. 

  1138. 		 * A very litte error, missing braces in the $where_clause, was causing this bug. 

    1139. 

  1139. 		 * When one set of testcases is linked to two testplans, this statement should check 

    1140. 

  1140. 		 * that the combination of testplan_id, tcversion_id and platform_id was the same, 

    1141. 

  1141. 		 * but instead it checked for either testplan_id OR tcversion_id and platform_id.

    1142. 

  1142. 		 * So every linked testcase with fitting tcversion_id and platform_id without execution

    1143. 

  1143. 		 * was deleted, regardless of testplan_id.

    1144. 

  1144. 		 * Simply adding braces around the where clause solves this.

    1145. 

  1145. 		 * So innstead of: 

    1146. 

  1146. 		 * SELECT id AS link_id FROM testplan_tcversions  

    1147. 

  1147. 		 * WHERE testplan_id=12 AND (tcversion_id = 5 AND platform_id = 0) 

    1148. 

  1148. 		 * OR (tcversion_id = 7 AND platform_id = 0) 

    1149. 

  1149. 		 * OR (tcversion_id = 9 AND platform_id = 0) 

    1150. 

  1150. 		 * OR (tcversion_id = 11 AND platform_id = 0)

    1151. 

  1151. 		 * we need this:

    1152. 

  1152. 		 * SELECT ... WHERE testplan_id=12 AND (... OR ...)

    1153. 

  1153. 		 */ 

    1154. 

  1154. 		$where_clause = " ( {$where_clause} ) ";

    1155. 

  1155. 		

    1156. 

  1156. 		// First get the executions id if any exist

    1157. 

  1157. 		$sql=" SELECT id AS execution_id " .

    1158. 

  1158. 			 " FROM {$this->tables['executions']} " .

    1159. 

  1159. 			 " WHERE testplan_id = {$id} AND ${where_clause}";

    1160. 

  1160. 		$exec_ids = $this->db->fetchRowsIntoMap($sql,'execution_id');

    1161. 

  1161. 		

    1162. 

  1162. 		if( !is_null($exec_ids) and count($exec_ids) > 0 )

    1163. 

  1163. 		{

    1164. 

  1164. 			// has executions

    1165. 

  1165. 			$exec_ids = array_keys($exec_ids);

    1166. 

  1166. 			$exec_id_where= " WHERE execution_id IN (" . implode(",",$exec_ids) . ")";

    1167. 

  1167. 			

    1168. 

  1168. 			// Remove bugs if any exist

    1169. 

  1169. 			$sql=" DELETE FROM {$this->tables['execution_bugs']} {$exec_id_where} ";

    1170. 

  1170. 			$result = $this->db->exec_query($sql);

    1171. 

  1171. 			

    1172. 

  1172. 			// now remove executions

    1173. 

  1173. 			$sql=" DELETE FROM {$this->tables['executions']} " .

    1174. 

  1174. 				 " WHERE testplan_id = {$id} AND ${where_clause}";

    1175. 

  1175. 			$result = $this->db->exec_query($sql);

    1176. 

  1176. 		}

    1177. 

  1177. 		

    1178. 

  1178. 		// ----------------------------------------------------------------

    1179. 

  1179. 		// to remove the assignment to users (if any exists) we need the list of id

    1180. 

  1180. 		$sql=" SELECT id AS link_id FROM {$this->tables['testplan_tcversions']} " .

    1181. 

  1181. 			 " WHERE testplan_id={$id} AND {$where_clause} ";

    1182. 

  1182. 		$link_ids = $this->db->fetchRowsIntoMap($sql,'link_id');

    1183. 

  1183. 		$features = array_keys($link_ids);

    1184. 

  1184. 		if( count($features) == 1)

    1185. 

  1185. 		{

    1186. 

  1186. 			$features=$features[0];

    1187. 

  1187. 		}

    1188. 

  1188. 		$this->assignment_mgr->delete_by_feature_id($features);

    1189. 

  1189. 		// ----------------------------------------------------------------

    1190. 

  1190. 		

    1191. 

  1191. 		// Delete from link table

    1192. 

  1192. 		$sql=" DELETE FROM {$this->tables['testplan_tcversions']} " .

    1193. 

  1193. 			 " WHERE testplan_id={$id} AND {$where_clause} ";

    1194. 

  1194. 		$result = $this->db->exec_query($sql);

    1195. 

  1195. 		

    1196. 

  1196. 		foreach($items['items'] as $tcase_id => $elem)

    1197. 

  1197. 		{

    1198. 

  1198. 			foreach($elem as $platform_id => $tcversion)

    1199. 

  1199. 			{

    1200. 

  1200. 				$addInfo='';

    1201. 

  1201. 				if( isset($platformInfo[$platform_id]) )

    1202. 

  1202. 				{

    1203. 

  1203. 					$addInfo = ' - ' . $platformLabel . ':' . $platformInfo[$platform_id];

    1204. 

  1204. 				}

    1205. 

  1205. 				$auditMsg=TLS("audit_tc_removed_from_testplan",

    1206. 

  1206. 							  $auditInfo['tcasePrefix'] . $auditInfo['info'][$tcversion]['tc_external_id'] . 

    1207. 

  1207. 							  $title_separator . $auditInfo['info'][$tcversion]['name'],

    1208. 

  1208. 							  $auditInfo['info'][$tcversion]['version'],

    1209. 

  1209. 							  $auditInfo['tplanInfo']['name'] . $addInfo );

    1210. 

  1210. 				

    1211. 

  1211. 				logAuditEvent($auditMsg,"UNASSIGN",$id,"testplans");

    1212. 

  1212. 			}

    1213. 

  1213. 		}

    1214. 

  1214. 		

    1215. 

  1215. 	} // end function unlink_tcversions

    1216. 

  1216. 

    1217. 

  1217. 

    1218. 

  1218. 

    1219. 

  1219. 	/**

    1220. 

  1220. 	 * 

    1221. 

  1221. 	 * @internal revisions

    1222. 

  1222. 	 * 20100505 - franciscom - BUGID 3434

    1223. 

  1223. 	 */

    1224. 

  1224. 	function get_keywords_map($id,$order_by_clause='')

    1225. 

  1225. 	{

    1226. 

  1226. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1227. 

  1227. 		$map_keywords=null;

    1228. 

  1228. 		

    1229. 

  1229. 		// keywords are associated to testcase id, then first

    1230. 

  1230. 		// we need to get the list of testcases linked to the testplan

    1231. 

  1231. 		// 

    1232. 

  1232. 		// 20100505 - according to user report (BUGID 3434) seems that 

    1233. 

  1233. 		// $linked_items = $this->get_linked_tcversions($id);

    1234. 

  1234. 		// has performance problems.

    1235. 

  1235. 		// Then make a choice do simple query here.

    1236. 

  1236. 		//

    1237. 

  1237. 		$sql = " /* $debugMsg */ ". 

    1238. 

  1238. 			   " SELECT DISTINCT parent_id FROM {$this->tables['nodes_hierarchy']} NHTC " .

    1239. 

  1239. 			   " JOIN {$this->tables['testplan_tcversions']} TPTCV ON TPTCV.tcversion_id = NHTC.id " .

    1240. 

  1240. 			   " WHERE TPTCV.testplan_id = {$id} ";

    1241. 

  1241. 			   

    1242. 

  1242. 		$linked_items = $this->db->fetchRowsIntoMap($sql,'parent_id');			     

    1243. 

  1243. 		

    1244. 

  1244. 		if( !is_null($linked_items) )

    1245. 

  1245. 		{

    1246. 

  1246. 			$tc_id_list = implode(",",array_keys($linked_items));

    1247. 

  1247. 			

    1248. 

  1248. 			$sql = " /* $debugMsg */ " .

    1249. 

  1249. 				   " SELECT DISTINCT TCKW.keyword_id,KW.keyword " .

    1250. 

  1250. 				   " FROM {$this->tables['testcase_keywords']} TCKW, " .

    1251. 

  1251. 				   " {$this->tables['keywords']} KW " .

    1252. 

  1252. 				   " WHERE TCKW.keyword_id = KW.id " .

    1253. 

  1253. 				   " AND TCKW.testcase_id IN ( {$tc_id_list} ) " .

    1254. 

  1254. 				   " {$order_by_clause} ";

    1255. 

  1255. 			$map_keywords = $this->db->fetchColumnsIntoMap($sql,'keyword_id','keyword');

    1256. 

  1256. 		}

    1257. 

  1257. 		return ($map_keywords);

    1258. 

  1258. 	}

    1259. 

  1259. 	

    1260. 

  1260. 

    1261. 

  1261. /*

    1262. 

  1262.   args :

    1263. 

  1263.         [$keyword_id]: can be an array

    1264. 

  1264. */

    1265. 

  1265. 	function get_keywords_tcases($id,$keyword_id=0)

    1266. 

  1266. 	{

    1267. 

  1267. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1268. 

  1268. 

    1269. 

  1269. 		$CUMULATIVE=1;

    1270. 

  1270. 		$map_keywords=null;

    1271. 

  1271. 		

    1272. 

  1272. 		// keywords are associated to testcase id, then first

    1273. 

  1273. 		// we need to get the list of testcases linked to the testplan

    1274. 

  1274. 		$linked_items = $this->get_linked_items_id($id);

    1275. 

  1275. 		if( !is_null($linked_items) )

    1276. 

  1276. 		{

    1277. 

  1277. 			$keyword_filter= '' ;

    1278. 

  1278. 			

    1279. 

  1279. 			if( is_array($keyword_id) )

    1280. 

  1280. 			{

    1281. 

  1281. 				$keyword_filter = " AND keyword_id IN (" . implode(',',$keyword_id) . ")"; 

    1282. 

  1282. 			}

    1283. 

  1283. 			else if( $keyword_id > 0 )

    1284. 

  1284. 			{

    1285. 

  1285. 				$keyword_filter = " AND keyword_id = {$keyword_id} ";

    1286. 

  1286. 			}

    1287. 

  1287. 			

    1288. 

  1288. 			

    1289. 

  1289. 			$tc_id_list = implode(",",array_keys($linked_items));

    1290. 

  1290. 			

    1291. 

  1291. 			// 20081116 - franciscom -

    1292. 

  1292. 			// Does DISTINCT is needed ? Humm now I think no.

    1293. 

  1293. 			$sql = "SELECT DISTINCT testcase_id,keyword_id,keyword

    1294. 

  1294. 				FROM {$this->tables['testcase_keywords']} testcase_keywords,

    1295. 

  1295. 				{$this->tables['keywords']} keywords

    1296. 

  1296. 				WHERE keyword_id = keywords.id

    1297. 

  1297. 				AND testcase_id IN ( {$tc_id_list} )

    1298. 

  1298. 				{$keyword_filter}

    1299. 

  1299. 				ORDER BY keyword ASC ";

    1300. 

  1300. 			

    1301. 

  1301. 			// 20081116 - franciscom

    1302. 

  1302. 			// CUMULATIVE is needed to get all keywords assigned to each testcase linked to testplan	       

    1303. 

  1303. 			$map_keywords = $this->db->fetchRowsIntoMap($sql,'testcase_id',$CUMULATIVE);

    1304. 

  1304. 		}

    1305. 

  1305. 		

    1306. 

  1306. 		return ($map_keywords);

    1307. 

  1307. 	} // end function

    1308. 

  1308. 

    1309. 

  1309. 

    1310. 

  1310. 	/*

    1311. 

  1311.   	function: copy_as

    1312. 

  1312.             creates a new test plan using an existent one as source.

    1313. 

  1313. 	Note:	copy_test_urgency is not appropriate to copy

    1314. 

  1314. 

    1315. 

  1315. 

    1316. 

  1316.   	args: id: source testplan id

    1317. 

  1317.         new_tplan_id: destination

    1318. 

  1318.         [tplan_name]: default null.

    1319. 

  1319.                       != null => set this as the new name

    1320. 

  1320. 

    1321. 

  1321.         [tproject_id]: default null.

    1322. 

  1322.                        != null => set this as the new testproject for the testplan

    1323. 

  1323.                               this allow us to copy testplans to differents test projects.

    1324. 

  1324. 

    1325. 

  1325.         [user_id]

    1326. 

  1326.         [options]: default null

    1327. 

  1327.                    allowed keys:

    1328. 

  1328.                    items2copy: 

    1329. 

  1329.                    	          null: do a deep copy => copy following test plan child elements:

    1330. 

  1330.                               builds,linked tcversions,milestones,user_roles,priorities,

    1331. 

  1331.                               platforms,execution assignment.

    1332. 

  1332.                               

    1333. 

  1333.                               != null, a map with keys that controls what child elements to copy

    1334. 

  1334. 

    1335. 

  1335. 				   copy_assigned_to:

    1336. 

  1336. 				   tcversion_type: 

    1337. 

  1337. 				                  null/'current' -> use same version present on source testplan

    1338. 

  1338.                                   'lastest' -> for every testcase linked to source testplan

    1339. 

  1339.                                                use lastest available version

    1340. 

  1340.                                                

    1341. 

  1341.        [mappings]: need to be documented                                        

    1342. 

  1342.   	returns: N/A

    1343. 

  1343. 	*/

    1344. 

  1344. 	function copy_as($id,$new_tplan_id,$tplan_name=null,$tproject_id=null,$user_id=null,

    1345. 

  1345.                      $options=null,$mappings=null)

    1346. 

  1346. 	{

    1347. 

  1347. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1348. 

  1348. 

    1349. 

  1349. 		$cp_methods = array('copy_milestones' => 'copy_milestones',

    1350. 

  1350. 			                'copy_user_roles' => 'copy_user_roles',

    1351. 

  1351. 			                'copy_platforms_links' => 'copy_platforms_links',

    1352. 

  1352. 			                'copy_builds' => 'copy_builds');

    1353. 

  1353. 

    1354. 

  1354. 		$mapping_methods = array('copy_platforms_links' => 'platforms');

    1355. 

  1355. 

    1356. 

  1356. 		$my['options'] = array();

    1357. 

  1357. 

    1358. 

  1358. 		// Configure here only elements that has his own table.

    1359. 

  1359. 		$my['options']['items2copy']= array('copy_tcases' => 1,'copy_milestones' => 1, 'copy_user_roles' => 1, 

    1360. 

  1360. 		                                    'copy_builds' => 1, 'copy_platforms_links' => 1);

    1361. 

  1361. 

    1362. 

  1362. 		$my['options']['copy_assigned_to'] = 0;

    1363. 

  1363. 		$my['options']['tcversion_type'] = null;

    1364. 

  1364. 

    1365. 

  1365. 		$my['options'] = array_merge($my['options'], (array)$options);

    1366. 

  1366. 		

    1367. 

  1367. 		// get source testplan general info

    1368. 

  1368. 		$rs_source=$this->get_by_id($id);

    1369. 

  1369. 		

    1370. 

  1370. 		if(!is_null($tplan_name))

    1371. 

  1371. 		{

    1372. 

  1372. 			$sql="/* $debugMsg */ UPDATE {$this->tables['nodes_hierarchy']} " .

    1373. 

  1373. 				 "SET name='" . $this->db->prepare_string(trim($tplan_name)) . "' " .

    1374. 

  1374. 				 "WHERE id={$new_tplan_id}";

    1375. 

  1375. 			$this->db->exec_query($sql);

    1376. 

  1376. 		}

    1377. 

  1377. 		

    1378. 

  1378. 		if(!is_null($tproject_id))

    1379. 

  1379. 		{

    1380. 

  1380. 			$sql="/* $debugMsg */ UPDATE {$this->tables['testplans']} SET testproject_id={$tproject_id} " .

    1381. 

  1381. 				 "WHERE id={$new_tplan_id}";

    1382. 

  1382. 			$this->db->exec_query($sql);

    1383. 

  1383. 		}

    1384. 

  1384. 		

    1385. 

  1385. 		

    1386. 

  1386. 		// Important Notice:

    1387. 

  1387. 		// Since the addition of Platforms, test case versions are linked to Test Plan AND Platforms

    1388. 

  1388. 		// this means, that not matter user choice, we will force Platforms COPY.

    1389. 

  1389. 		// This is a lazy approach, instead of complex one that requires understand what Platforms

    1390. 

  1390. 		// have been used on SOURCE Test Plan.

    1391. 

  1391. 		//

    1392. 

  1392. 		// copy test cases is an special copy

    1393. 

  1393. 		if( $my['options']['items2copy']['copy_tcases'] )

    1394. 

  1394. 		{

    1395. 

  1395. 			$my['options']['items2copy']['copy_platforms_links'] = 1;

    1396. 

  1396. 			$this->copy_linked_tcversions($id,$new_tplan_id,$user_id,$my['options'],$mappings);

    1397. 

  1397. 		}

    1398. 

  1398. 		

    1399. 

  1399. 		foreach( $my['options']['items2copy'] as $key => $do_copy )

    1400. 

  1400. 		{

    1401. 

  1401. 			if( $do_copy )

    1402. 

  1402. 			{

    1403. 

  1403. 				if( isset($cp_methods[$key]) )

    1404. 

  1404. 				{

    1405. 

  1405. 					$copy_method=$cp_methods[$key];

    1406. 

  1406. 					if( isset($mapping_methods[$key]) && isset($mappings[$mapping_methods[$key]]))

    1407. 

  1407. 					{

    1408. 

  1408. 						$this->$copy_method($id,$new_tplan_id,$mappings[$mapping_methods[$key]]);

    1409. 

  1409. 					}

    1410. 

  1410. 					else

    1411. 

  1411. 					{

    1412. 

  1412. 						$this->$copy_method($id,$new_tplan_id);

    1413. 

  1413. 					}	

    1414. 

  1414. 				}

    1415. 

  1415. 			}

    1416. 

  1416. 		}

    1417. 

  1417. 	} // end function copy_as

    1418. 

  1418. 

    1419. 

  1419. 

    1420. 

  1420. 

    1421. 

  1421. 	/**

    1422. 

  1422. 	 * $id: source testplan id

    1423. 

  1423. 	 * $new_tplan_id: destination

    1424. 

  1424. 	 */

    1425. 

  1425. 	private function copy_builds($id,$new_tplan_id)

    1426. 

  1426. 	{

    1427. 

  1427. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1428. 

  1428. 		$rs=$this->get_builds($id);

    1429. 

  1429. 		

    1430. 

  1430. 		if(!is_null($rs))

    1431. 

  1431. 		{

    1432. 

  1432. 			foreach($rs as $build)

    1433. 

  1433. 			{

    1434. 

  1434. 				$sql="INSERT INTO {$this->tables['builds']} (name,notes,testplan_id) " .

    1435. 

  1435. 					"VALUES ('" . $this->db->prepare_string($build['name']) ."'," .

    1436. 

  1436. 					"'" . $this->db->prepare_string($build['notes']) ."',{$new_tplan_id})";

    1437. 

  1437. 				

    1438. 

  1438. 				$this->db->exec_query($sql);

    1439. 

  1439. 			}

    1440. 

  1440. 		}

    1441. 

  1441. 	}

    1442. 

  1442. 

    1443. 

  1443. 

    1444. 

  1444. 	/*

    1445. 

  1445.   	function: copy_linked_tcversions

    1446. 

  1446. 

    1447. 

  1447.   	args: id: source testplan id

    1448. 

  1448.         new_tplan_id: destination

    1449. 

  1449.         [options]

    1450. 

  1450.         	[tcversion_type]: default null -> use same version present on source testplan

    1451. 

  1451.                               'lastest' -> for every testcase linked to source testplan

    1452. 

  1452.                                       use lastest available version

    1453. 

  1453.         	[copy_assigned_to]: 1 -> copy execution assignments without role control                              

    1454. 

  1454. 

    1455. 

  1455. 		[$mappings] useful when this method is called due to a Test Project COPY AS (yes PROJECT no PLAN)

    1456. 

  1456. 					

    1457. 

  1457.   	returns:

    1458. 

  1458.   

    1459. 

  1459.  	 Note: test urgency is set to default in the new Test plan (not copied)

    1460. 

  1460. 	*/

    1461. 

  1461. 	private function copy_linked_tcversions($id,$new_tplan_id,$user_id=-1, $options=null,$mappings=null)

    1462. 

  1462. 	

    1463. 

  1463. 	{

    1464. 

  1464. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1465. 

  1465.     

    1466. 

  1466. 		$my['options']['tcversion_type'] = null;

    1467. 

  1467. 	    $my['options']['copy_assigned_to'] = 0;

    1468. 

  1468. 		$my['options'] = array_merge($my['options'], (array)$options);

    1469. 

  1469.         $now_ts = $this->db->db_now();

    1470. 

  1470. 

    1471. 

  1471. 		$sql="/* $debugMsg */ "; 

    1472. 

  1472. 		if($my['options']['copy_assigned_to'])

    1473. 

  1473. 		{

    1474. 

  1474. 			$sql .= " SELECT TPTCV.*, COALESCE(UA.user_id,-1) AS tester " .

    1475. 

  1475. 			        " FROM {$this->tables['testplan_tcversions']} TPTCV " .

    1476. 

  1476. 			        " LEFT OUTER JOIN {$this->tables['user_assignments']} UA ON " .

    1477. 

  1477. 			        " UA.feature_id = TPTCV.id " .

    1478. 

  1478. 			        " WHERE testplan_id={$id} ";

    1479. 

  1479. 		}

    1480. 

  1480. 		else

    1481. 

  1481. 		{

    1482. 

  1482. 			$sql .= " SELECT TPTCV.* FROM {$this->tables['testplan_tcversions']} TPTCV" .

    1483. 

  1483. 			        " WHERE testplan_id={$id} ";

    1484. 

  1484. 	    }

    1485. 

  1485. 

    1486. 

  1486. 		$rs=$this->db->get_recordset($sql);

    1487. 

  1487. 		if(!is_null($rs))

    1488. 

  1488. 		{

    1489. 

  1489. 			$tcase_mgr = new testcase($this->db);

    1490. 

  1490. 			$doMappings = !is_null($mappings);

    1491. 

  1491. 			foreach($rs as $elem)

    1492. 

  1492. 			{

    1493. 

  1493. 				$tcversion_id = $elem['tcversion_id'];

    1494. 

  1494. 				

    1495. 

  1495. 				// Seems useless - 20100204

    1496. 

  1496. 				$feature_id = $elem['id'];

    1497. 

  1497. 				if( !is_null($my['options']['tcversion_type']) )

    1498. 

  1498. 				{

    1499. 

  1499. 					$sql="/* $debugMsg */ SELECT * FROM {$this->tables['nodes_hierarchy']} WHERE id={$tcversion_id} ";

    1500. 

  1500. 					$rs2=$this->db->get_recordset($sql);

    1501. 

  1501. 					$last_version_info = $tcase_mgr->get_last_version_info($rs2[0]['parent_id']);

    1502. 

  1502. 					$tcversion_id = $last_version_info ? $last_version_info['id'] : $tcversion_id ;

    1503. 

  1503. 				}

    1504. 

  1504. 				

    1505. 

  1505. 				// mapping need to be done with:

    1506. 

  1506. 				// platforms

    1507. 

  1507. 				// test case versions

    1508. 

  1508. 				$platform_id = $elem['platform_id'];

    1509. 

  1509. 				if( $doMappings )

    1510. 

  1510. 				{

    1511. 

  1511. 					if( isset($mappings['platforms'][$platform_id]) )

    1512. 

  1512. 					{

    1513. 

  1513. 						$platform_id = $mappings['platforms'][$platform_id]; 

    1514. 

  1514. 					}

    1515. 

  1515. 					if( isset($mappings['test_spec'][$tcversion_id]) )

    1516. 

  1516. 					{

    1517. 

  1517. 						$tcversion_id = $mappings['test_spec'][$tcversion_id]; 

    1518. 

  1518. 					}

    1519. 

  1519. 				}

    1520. 

  1520. 				

    1521. 

  1521. 				

    1522. 

  1522. 				$sql = "/* $debugMsg */ " . 

    1523. 

  1523. 				       " INSERT INTO {$this->tables['testplan_tcversions']} " .

    1524. 

  1524. 					   " (testplan_id,tcversion_id,platform_id,node_order,urgency) " .

    1525. 

  1525. 					   " VALUES({$new_tplan_id},{$tcversion_id},{$platform_id}," .

    1526. 

  1526. 					   " {$elem['node_order']},{$elem['urgency']})";

    1527. 

  1527. 					   

    1528. 

  1528.  				 //echo "<br>debug - <b><i>" . __FUNCTION__ . "</i></b><br><b>" . $sql . "</b><br>";

    1529. 

  1529. 	   

    1530. 

  1530. 				$this->db->exec_query($sql);

    1531. 

  1531. 				$new_feature_id = $this->db->insert_id($this->tables['testplan_tcversions']);

    1532. 

  1532. 				

    1533. 

  1533. 				if($my['options']['copy_assigned_to'] && $elem['tester'] > 0)

    1534. 

  1534. 				{

    1535. 

  1535. 					$features_map = array();

    1536. 

  1536. 					$feature_id=$new_feature_id;

    1537. 

  1537. 					$features_map[$feature_id]['user_id'] = $elem['tester'];

    1538. 

  1538. 					$features_map[$feature_id]['type'] = $this->assignment_types['testcase_execution']['id'];

    1539. 

  1539. 					$features_map[$feature_id]['status']  = $this->assignment_status['open']['id'];

    1540. 

  1540. 					$features_map[$feature_id]['creation_ts'] = $now_ts;

    1541. 

  1541. 					$features_map[$feature_id]['assigner_id'] = $user_id;

    1542. 

  1542. 					

    1543. 

  1543. 					$this->assignment_mgr->assign($features_map);

    1544. 

  1544. 				}

    1545. 

  1545. 				

    1546. 

  1546. 			}

    1547. 

  1547. 		}

    1548. 

  1548. 	}

    1549. 

  1549. 

    1550. 

  1550. 

    1551. 

  1551. /*

    1552. 

  1552.   function: copy_milestones

    1553. 

  1553. 

    1554. 

  1554.   args: id: source testplan id

    1555. 

  1555.         new_tplan_id: destination

    1556. 

  1556. 

    1557. 

  1557.   returns:

    1558. 

  1558. 

    1559. 

  1559.   rev : 

    1560. 

  1560.         20090910 - franciscom - added start_date

    1561. 

  1561.         

    1562. 

  1562.         20070519 - franciscom

    1563. 

  1563.         changed date to target_date, because date is an Oracle reverved word.

    1564. 

  1564. */

    1565. 

  1565. 	private function copy_milestones($tplan_id,$new_tplan_id)

    1566. 

  1566. 	{

    1567. 

  1567. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1568. 

  1568. 		$rs=$this->get_milestones($tplan_id);

    1569. 

  1569. 		if(!is_null($rs))

    1570. 

  1570. 		{

    1571. 

  1571. 			foreach($rs as $mstone)

    1572. 

  1572. 			{

    1573. 

  1573. 				// BUGID 3430 - need to check if start date is NOT NULL

    1574. 

  1574. 				$add2fields = '';

    1575. 

  1575. 				$add2values = '';

    1576. 

  1576. 				$use_start_date = strlen(trim($mstone['start_date'])) > 0;

    1577. 

  1577. 				if( $use_start_date )

    1578. 

  1578. 				{

    1579. 

  1579. 					$add2fields = 'start_date,';

    1580. 

  1580. 					$add2values = "'" . $mstone['start_date'] . "',";

    1581. 

  1581. 				}

    1582. 

  1582. 

    1583. 

  1583. 				$sql = "INSERT INTO {$this->tables['milestones']} (name,a,b,c,target_date,{$add2fields} testplan_id)";				

    1584. 

  1584.                 $sql .= " VALUES ('" . $this->db->prepare_string($mstone['name']) ."'," .

    1585. 

  1585. 					    $mstone['high_percentage'] . "," . $mstone['medium_percentage'] . "," . 

    1586. 

  1586. 					    $mstone['low_percentage'] . ",'" . $mstone['target_date'] . "', {$add2values}{$new_tplan_id})";

    1587. 

  1587. 				$this->db->exec_query($sql);

    1588. 

  1588. 			}

    1589. 

  1589. 		}

    1590. 

  1590. 	}

    1591. 

  1591. 

    1592. 

  1592. 

    1593. 

  1593. 	/**

    1594. 

  1594. 	 * Get all milestones for a Test Plan

    1595. 

  1595. 	 * @param int $tplan_id Test Plan identificator

    1596. 

  1596. 	 * @return array of arrays TBD fields description 

    1597. 

  1597. 	 */

    1598. 

  1598. 	function get_milestones($tplan_id)

    1599. 

  1599. 	{

    1600. 

  1600. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1601. 

  1601. 		

    1602. 

  1602. 		$sql="SELECT id, name, a AS high_percentage, b AS medium_percentage, c AS low_percentage, " .

    1603. 

  1603. 		     "target_date, start_date,testplan_id " .       

    1604. 

  1604. 		     "FROM {$this->tables['milestones']} " .

    1605. 

  1605. 		     "WHERE testplan_id={$tplan_id} ORDER BY target_date,name";

    1606. 

  1606. 		return $this->db->get_recordset($sql);

    1607. 

  1607. 	}

    1608. 

  1608. 

    1609. 

  1609. 

    1610. 

  1610. 	/**

    1611. 

  1611. 	 * Copy user roles to a new Test Plan

    1612. 

  1612. 	 * 

    1613. 

  1613. 	 * @param int $source_id original Test Plan id

    1614. 

  1614. 	 * @param int $target_id new Test Plan id

    1615. 

  1615. 	 */

    1616. 

  1616. 	private function copy_user_roles($source_id, $target_id)

    1617. 

  1617. 	{

    1618. 

  1618. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1619. 

  1619. 		$sql = "/* $debugMsg */ SELECT user_id,role_id FROM {$this->tables['user_testplan_roles']} " .

    1620. 

  1620. 		       " WHERE testplan_id={$source_id} ";

    1621. 

  1621. 		$rs = $this->db->get_recordset($sql);

    1622. 

  1622. 		if(!is_null($rs))

    1623. 

  1623. 		{

    1624. 

  1624. 	    	foreach($rs as $elem)

    1625. 

  1625. 	    	{

    1626. 

  1626. 	      		$sql="INSERT INTO {$this->tables['user_testplan_roles']}  " .

    1627. 

  1627. 	           		"(testplan_id,user_id,role_id) " .

    1628. 

  1628. 	           		"VALUES({$target_id}," . $elem['user_id'] ."," . $elem['role_id'] . ")";

    1629. 

  1629. 	      		$this->db->exec_query($sql);

    1630. 

  1630. 			}

    1631. 

  1631. 		}

    1632. 

  1632. 	}

    1633. 

  1633. 

    1634. 

  1634. 

    1635. 

  1635. 	/**

    1636. 

  1636. 	 * Gets all testplan related user roles

    1637. 

  1637. 	 *

    1638. 

  1638. 	 * @param integer $id the testplan id

    1639. 

  1639. 	 * @return array assoc map with keys taken from the user_id column

    1640. 

  1640. 	 **/

    1641. 

  1641. 	function getUserRoleIDs($id)

    1642. 

  1642. 	{

    1643. 

  1643. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1644. 

  1644. 

    1645. 

  1645. 		$sql = "SELECT user_id,role_id FROM {$this->tables['user_testplan_roles']} " .

    1646. 

  1646. 		       "WHERE testplan_id = {$id}";

    1647. 

  1647. 		$roles = $this->db->fetchRowsIntoMap($sql,'user_id');

    1648. 

  1648. 		return $roles;

    1649. 

  1649. 	}

    1650. 

  1650. 

    1651. 

  1651. 

    1652. 

  1652. 	/**

    1653. 

  1653. 	 * Inserts a testplan related role for a given user

    1654. 

  1654. 	 *

    1655. 

  1655. 	 * @param int $userID the id of the user

    1656. 

  1656. 	 * @param int $id the testplan id

    1657. 

  1657. 	 * @param int $roleID the role id

    1658. 

  1658. 	 * 

    1659. 

  1659. 	 * @return integer returns tl::OK on success, tl::ERROR else

    1660. 

  1660. 	 **/

    1661. 

  1661. 	

    1662. 

  1662. 	function addUserRole($userID,$id,$roleID)

    1663. 

  1663. 	{

    1664. 

  1664. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1665. 

  1665. 

    1666. 

  1666. 		$status = tl::ERROR;

    1667. 

  1667. 		$sql = "INSERT INTO {$this->tables['user_testplan_roles']} (user_id,testplan_id,role_id) VALUES " .

    1668. 

  1668. 			   " ({$userID},{$id},{$roleID})";

    1669. 

  1669. 		if ($this->db->exec_query($sql))

    1670. 

  1670. 		{

    1671. 

  1671. 			$testPlan = $this->get_by_id($id);

    1672. 

  1672. 			$role = tlRole::getByID($this->db,$roleID,tlRole::TLOBJ_O_GET_DETAIL_MINIMUM);

    1673. 

  1673. 			$user = tlUser::getByID($this->db,$userID,tlUser::TLOBJ_O_GET_DETAIL_MINIMUM);

    1674. 

  1674. 			if ($user && $testPlan && $role)

    1675. 

  1675. 			{

    1676. 

  1676. 				logAuditEvent(TLS("audit_users_roles_added_testplan",$user->getDisplayName(),

    1677. 

  1677. 				              $testPlan['name'],$role->name),"ASSIGN",$id,"testplans");

    1678. 

  1678. 			}

    1679. 

  1679. 			$status = tl::OK;

    1680. 

  1680. 		}

    1681. 

  1681. 		return $status;

    1682. 

  1682. 	}

    1683. 

  1683. 

    1684. 

  1684. 

    1685. 

  1685. 	/**

    1686. 

  1686. 	 * Deletes all testplan related role assignments for a given testplan

    1687. 

  1687. 	 *

    1688. 

  1688. 	 * @param int $id the testplan id

    1689. 

  1689. 	 * @return tl::OK  on success, tl::FALSE else

    1690. 

  1690. 	 **/

    1691. 

  1691. 	function deleteUserRoles($id)

    1692. 

  1692. 	{

    1693. 

  1693. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1694. 

  1694. 

    1695. 

  1695. 		$status = tl::ERROR;

    1696. 

  1696. 		$sql = "DELETE FROM {$this->tables['user_testplan_roles']} " .

    1697. 

  1697. 		       " WHERE testplan_id = {$id}";

    1698. 

  1698. 		if ($this->db->exec_query($sql))

    1699. 

  1699. 		{

    1700. 

  1700. 			$testPlan = $this->get_by_id($id);

    1701. 

  1701. 			if ($testPlan)

    1702. 

  1702. 			{

    1703. 

  1703. 				logAuditEvent(TLS("audit_all_user_roles_removed_testplan",

    1704. 

  1704. 				              $testPlan['name']),"ASSIGN",$id,"testplans");

    1705. 

  1705. 			}

    1706. 

  1706. 			$status = tl::OK;

    1707. 

  1707. 		}

    1708. 

  1708. 		return $status;

    1709. 

  1709. 	}

    1710. 

  1710. 

    1711. 

  1711. 

    1712. 

  1712. 	/**

    1713. 

  1713. 	 * Delete test plan and all related link to other items

    1714. 

  1714. 	 *

    1715. 

  1715.  	 */

    1716. 

  1716. 	function delete($id)

    1717. 

  1717. 	{

    1718. 

  1718. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1719. 

  1719. 

    1720. 

  1720. 		$the_sql=array();

    1721. 

  1721. 		$main_sql=array();

    1722. 

  1722. 		

    1723. 

  1723. 		$this->deleteUserRoles($id);

    1724. 

  1724. 		$getFeaturesSQL = " SELECT id FROM {$this->tables['testplan_tcversions']} WHERE testplan_id={$id} "; 

    1725. 

  1725. 		$the_sql[]="DELETE FROM {$this->tables['milestones']} WHERE testplan_id={$id}";

    1726. 

  1726. 		

    1727. 

  1727. 		// CF used on testplan_design are linked by testplan_tcversions.id

    1728. 

  1728. 		$the_sql[]="DELETE FROM {$this->tables['cfield_testplan_design_values']} WHERE link_id ".

    1729. 

  1729. 			       "IN ({$getFeaturesSQL})";

    1730. 

  1730. 

    1731. 

  1731. 		// BUGID 3465: Delete Test Project - User Execution Assignment is not deleted

    1732. 

  1732. 		$the_sql[]="DELETE FROM {$this->tables['user_assignments']} WHERE feature_id ".

    1733. 

  1733. 			       "IN ({$getFeaturesSQL})";

    1734. 

  1734. 		

    1735. 

  1735. 		$the_sql[]="DELETE FROM {$this->tables['risk_assignments']} WHERE testplan_id={$id}";

    1736. 

  1736. 		$the_sql[]="DELETE FROM {$this->tables['testplan_platforms']} WHERE testplan_id={$id}";

    1737. 

  1737. 

    1738. 

  1738. 		$the_sql[]="DELETE FROM {$this->tables['testplan_tcversions']} WHERE testplan_id={$id}";

    1739. 

  1739. 		$the_sql[]="DELETE FROM {$this->tables['builds']} WHERE testplan_id={$id}";

    1740. 

  1740. 		$the_sql[]="DELETE FROM {$this->tables['cfield_execution_values']} WHERE testplan_id={$id}";

    1741. 

  1741. 		$the_sql[]="DELETE FROM {$this->tables['user_testplan_roles']} WHERE testplan_id={$id}";

    1742. 

  1742. 		

    1743. 

  1743. 		

    1744. 

  1744. 		// When deleting from executions, we need to clean related tables

    1745. 

  1745. 		$the_sql[]="DELETE FROM {$this->tables['execution_bugs']} WHERE execution_id ".

    1746. 

  1746. 				   "IN (SELECT id FROM {$this->tables['executions']} WHERE testplan_id={$id})";

    1747. 

  1747. 		$the_sql[]="DELETE FROM {$this->tables['executions']} WHERE testplan_id={$id}";

    1748. 

  1748. 		

    1749. 

  1749. 		

    1750. 

  1750. 		foreach($the_sql as $sql)

    1751. 

  1751. 		{

    1752. 

  1752. 			$this->db->exec_query($sql);

    1753. 

  1753. 		}

    1754. 

  1754. 		

    1755. 

  1755. 		$this->deleteAttachments($id);

    1756. 

  1756. 		

    1757. 

  1757. 		$this->cfield_mgr->remove_all_design_values_from_node($id);

    1758. 

  1758. 		// ------------------------------------------------------------------------

    1759. 

  1759. 		

    1760. 

  1760. 		// Finally delete from main table

    1761. 

  1761. 		$main_sql[]="DELETE FROM {$this->tables['testplans']} WHERE id={$id}";

    1762. 

  1762. 		$main_sql[]="DELETE FROM {$this->tables['nodes_hierarchy']} WHERE id={$id}";

    1763. 

  1763. 		

    1764. 

  1764. 		foreach($main_sql as $sql)

    1765. 

  1765. 		{

    1766. 

  1766. 			$this->db->exec_query($sql);

    1767. 

  1767. 		}

    1768. 

  1768. 	} // end delete()

    1769. 

  1769. 

    1770. 

  1770. 

    1771. 

  1771. 

    1772. 

  1772. 	// --------------------------------------------------------------------------------------

    1773. 

  1773. 	// Build related methods

    1774. 

  1774. 	// --------------------------------------------------------------------------------------

    1775. 

  1775. 	

    1776. 

  1776. 	/*

    1777. 

  1777. 	  function: get_builds_for_html_options()

    1778. 

  1778. 	

    1779. 

  1779. 	

    1780. 

  1780. 	  args :

    1781. 

  1781. 	        $id     : test plan id.

    1782. 

  1782. 	        [active]: default:null -> all, 1 -> active, 0 -> inactive BUILDS

    1783. 

  1783. 	        [open]  : default:null -> all, 1 -> open  , 0 -> closed/completed BUILDS

    1784. 

  1784. 	

    1785. 

  1785. 	  returns:

    1786. 

  1786. 	

    1787. 

  1787. 	  rev :

    1788. 

  1788. 	        20070129 - franciscom - order to ASC

    1789. 

  1789. 	        20070120 - franciscom

    1790. 

  1790. 	        added active, open

    1791. 

  1791. 	*/

    1792. 

  1792. 	function get_builds_for_html_options($id,$active=null,$open=null)

    1793. 

  1793. 	{

    1794. 

  1794. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1795. 

  1795. 

    1796. 

  1796. 		$sql = " SELECT id, name " .

    1797. 

  1797. 			" FROM {$this->tables['builds']} WHERE testplan_id = {$id} ";

    1798. 

  1798. 		

    1799. 

  1799. 		// 20070120 - franciscom

    1800. 

  1800. 		if( !is_null($active) )

    1801. 

  1801. 		{

    1802. 

  1802. 			$sql .= " AND active=" . intval($active) . " ";

    1803. 

  1803. 		}

    1804. 

  1804. 		if( !is_null($open) )

    1805. 

  1805. 		{

    1806. 

  1806. 			$sql .= " AND is_open=" . intval($open) . " ";

    1807. 

  1807. 		}

    1808. 

  1808. 		

    1809. 

  1809. 		$sql .= " ORDER BY name ASC";

    1810. 

  1810. 		

    1811. 

  1811. 		

    1812. 

  1812. 		// BUGID

    1813. 

  1813. 		$recordset=$this->db->fetchColumnsIntoMap($sql,'id','name');

    1814. 

  1814. 		if( !is_null($recordset) )

    1815. 

  1815. 		{

    1816. 

  1816. 			natsort($recordset);

    1817. 

  1817. 		}

    1818. 

  1818. 		

    1819. 

  1819. 		return $recordset;

    1820. 

  1820. 	}

    1821. 

  1821. 

    1822. 

  1822. 

    1823. 

  1823. 	/*

    1824. 

  1824. 	  function: get_max_build_id

    1825. 

  1825. 	

    1826. 

  1826. 	  args :

    1827. 

  1827. 	        $id     : test plan id.

    1828. 

  1828. 	

    1829. 

  1829. 	  returns:

    1830. 

  1830. 	*/

    1831. 

  1831. 	function get_max_build_id($id,$active = null,$open = null)

    1832. 

  1832. 	{

    1833. 

  1833. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1834. 

  1834. 

    1835. 

  1835. 		$sql = " SELECT MAX(id) AS maxbuildid " .

    1836. 

  1836. 			" FROM {$this->tables['builds']} " .

    1837. 

  1837. 			" WHERE testplan_id = {$id}";

    1838. 

  1838. 		

    1839. 

  1839. 		if(!is_null($active))

    1840. 

  1840. 		{

    1841. 

  1841. 			$sql .= " AND active = " . intval($active) . " ";

    1842. 

  1842. 		}

    1843. 

  1843. 		if( !is_null($open) )

    1844. 

  1844. 		{

    1845. 

  1845. 			$sql .= " AND is_open = " . intval($open) . " ";

    1846. 

  1846. 		}

    1847. 

  1847. 		

    1848. 

  1848. 		$recordset = $this->db->get_recordset($sql);

    1849. 

  1849. 		$maxBuildID = 0;

    1850. 

  1850. 		if ($recordset)

    1851. 

  1851. 		{

    1852. 

  1852. 			$maxBuildID = intval($recordset[0]['maxbuildid']);

    1853. 

  1853. 		}

    1854. 

  1854. 		return $maxBuildID;

    1855. 

  1855. 	}

    1856. 

  1856. 

    1857. 

  1857. 	/*

    1858. 

  1858. 	   function: get_testsuites

    1859. 

  1859. 	    args :

    1860. 

  1860. 		$id     : test plan id.

    1861. 

  1861. 	    returns: returns flat list of names of test suites (including nest test suites)  No particular Order.

    1862. 

  1862. 	*/

    1863. 

  1863. 	function get_testsuites($id)

    1864. 

  1864. 	{

    1865. 

  1865. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1866. 

  1866. 

    1867. 

  1867. 		// BUGID 0002776

    1868. 

  1868. 		$sql = " SELECT NHTSUITE.name, NHTSUITE.id, NHTSUITE.parent_id" . 

    1869. 

  1869. 			   " FROM {$this->tables['testplan_tcversions']}  TPTCV, {$this->tables['nodes_hierarchy']}  NHTCV, " .

    1870. 

  1870. 			   " {$this->tables['nodes_hierarchy']} NHTCASE, {$this->tables['nodes_hierarchy']} NHTSUITE " . 

    1871. 

  1871. 			   " WHERE TPTCV.tcversion_id = NHTCV.id " .

    1872. 

  1872. 			   " AND NHTCV.parent_id = NHTCASE.id " .

    1873. 

  1873. 			   " AND NHTCASE.parent_id = NHTSUITE.id " .

    1874. 

  1874. 			   " AND TPTCV.testplan_id = " . $id . " " .

    1875. 

  1875. 			   " GROUP BY NHTSUITE.name,NHTSUITE.id,NHTSUITE.parent_id " .

    1876. 

  1876. 			   " ORDER BY NHTSUITE.name" ;

    1877. 

  1877. 		

    1878. 

  1878. 		$recordset = $this->db->get_recordset($sql);

    1879. 

  1879. 		

    1880. 

  1880. 		// Now the recordset contains testsuites that have child test cases.

    1881. 

  1881. 		// However there could potentially be testsuites that only have grandchildren/greatgrandchildren

    1882. 

  1882. 		// this will iterate through found test suites and check for 

    1883. 

  1883. 		$superset = $recordset;

    1884. 

  1884. 		foreach($recordset as $value)

    1885. 

  1885. 		{

    1886. 

  1886. 			$superset = array_merge($superset, $this->get_parenttestsuites($value['id']));

    1887. 

  1887. 		}    

    1888. 

  1888. 		

    1889. 

  1889. 		// At this point there may be duplicates

    1890. 

  1890. 		$dup_track = array();

    1891. 

  1891. 		foreach($superset as $value)

    1892. 

  1892. 		{

    1893. 

  1893. 			if (!array_key_exists($value['id'],$dup_track))

    1894. 

  1894. 			{

    1895. 

  1895. 				$dup_track[$value['id']] = true;

    1896. 

  1896. 				$finalset[] = $value;

    1897. 

  1897. 			}        

    1898. 

  1898. 		}    

    1899. 

  1899. 		

    1900. 

  1900. 		// Needs to be alphabetical based upon name attribute 

    1901. 

  1901. 		usort($finalset, array("testplan", "compare_name"));

    1902. 

  1902. 		return $finalset;

    1903. 

  1903. 	}

    1904. 

  1904. 

    1905. 

  1905. 

    1906. 

  1906. 	/*

    1907. 

  1907. 	 function: compare_name

    1908. 

  1908. 	Used for sorting a list by nest name attribute

    1909. 

  1909. 	

    1910. 

  1910. 	  args :

    1911. 

  1911. 		$a     : first array to compare

    1912. 

  1912. 		$b       : second array to compare

    1913. 

  1913. 	  

    1914. 

  1914. 	  returns: an integer indicating the result of the comparison

    1915. 

  1915. 	 */

    1916. 

  1916. 	private function compare_name($a, $b)

    1917. 

  1917. 	{

    1918. 

  1918. 	    return strcasecmp($a['name'], $b['name']);

    1919. 

  1919. 	}

    1920. 

  1920. 

    1921. 

  1921. 

    1922. 

  1922. 	/*

    1923. 

  1923. 	 function: get_parenttestsuites

    1924. 

  1924. 	

    1925. 

  1925. 	Used by get_testsuites

    1926. 

  1926. 	 

    1927. 

  1927. 	Recursive function used to get all the parent test suites of potentially testcase free testsuites.

    1928. 

  1928. 	If passed node id isn't the product then it's merged into result set.

    1929. 

  1929. 	

    1930. 

  1930. 	  args :

    1931. 

  1931. 		$id     : $id of potential testsuite

    1932. 

  1932. 	  

    1933. 

  1933. 	  returns: an array of all testsuite ancestors of $id

    1934. 

  1934. 	 */

    1935. 

  1935. 	private function get_parenttestsuites($id)

    1936. 

  1936. 	{

    1937. 

  1937. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1938. 

  1938. 

    1939. 

  1939. 	    $sql = "SELECT name, id, parent_id " .

    1940. 

  1940. 		       "FROM {$this->tables['nodes_hierarchy']}  NH " .

    1941. 

  1941. 		       "WHERE NH.node_type_id <> {$this->node_types_descr_id['testproject']} " .

    1942. 

  1942. 		       "AND NH.id = " . $id;

    1943. 

  1943. 		    

    1944. 

  1944. 	    $recordset = $this->db->get_recordset($sql);

    1945. 

  1945. 	    $myarray = array();

    1946. 

  1946. 	    if (count($recordset) > 0)

    1947. 

  1947. 	    {        

    1948. 

  1948. 		    // 20100611 - franciscom

    1949. 

  1949. 		    // $myarray = array(array('name'=>$recordset[0]['name'], 'id'=>$recordset[0]['id']));

    1950. 

  1950. 		    $myarray = array($recordset[0]);

    1951. 

  1951. 		    $myarray = array_merge($myarray, $this->get_parenttestsuites($recordset[0]['parent_id'])); 

    1952. 

  1952. 	    }

    1953. 

  1953. 	    

    1954. 

  1954. 	    return $myarray;            

    1955. 

  1955. 	}

    1956. 

  1956. 

    1957. 

  1957. 

    1958. 

  1958. 	/*

    1959. 

  1959. 	  function: get_builds

    1960. 

  1960. 	            get info about builds defined for a testlan.

    1961. 

  1961. 	            Build can be filtered by active and open status.

    1962. 

  1962. 	

    1963. 

  1963. 	  args :

    1964. 

  1964. 	        id: test plan id.

    1965. 

  1965. 	        [active]: default:null -> all, 1 -> active, 0 -> inactive BUILDS

    1966. 

  1966. 	        [open]: default:null -> all, 1 -> open  , 0 -> closed/completed BUILDS

    1967. 

  1967. 	

    1968. 

  1968. 	  returns: map, where elements are ordered by build name, using variant of nasort php function.

    1969. 

  1969. 	           key: build id

    1970. 

  1970. 	           value: map with following keys

    1971. 

  1971. 	                  id: build id

    1972. 

  1972. 	                  name: build name

    1973. 

  1973. 	                  notes: build notes

    1974. 

  1974. 	                  active: build active status

    1975. 

  1975. 	                  is_open: build open status

    1976. 

  1976. 	                  testplan_id

    1977. 

  1977. 	                  release_date

    1978. 

  1978. 	

    1979. 

  1979. 	  rev :

    1980. 

  1980. 	*/

    1981. 

  1981. 	function get_builds($id,$active=null,$open=null)

    1982. 

  1982. 	{

    1983. 

  1983. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    1984. 

  1984. 

    1985. 

  1985. 		$sql = " SELECT id,testplan_id, name, notes, active, is_open,release_date " .

    1986. 

  1986. 			" FROM {$this->tables['builds']} WHERE testplan_id = {$id} " ;

    1987. 

  1987. 		

    1988. 

  1988. 		if( !is_null($active) )

    1989. 

  1989. 		{

    1990. 

  1990. 			$sql .= " AND active=" . intval($active) . " ";

    1991. 

  1991. 		}

    1992. 

  1992. 		if( !is_null($open) )

    1993. 

  1993. 		{

    1994. 

  1994. 			$sql .= " AND is_open=" . intval($open) . " ";

    1995. 

  1995. 		}

    1996. 

  1996. 		

    1997. 

  1997. 		$sql .= "  ORDER BY name ASC";

    1998. 

  1998. 		

    1999. 

  1999. 		$recordset = $this->db->fetchRowsIntoMap($sql,'id');

    2000. 

  2000. 		

    2001. 

  2001. 		if( !is_null($recordset) )

    2002. 

  2002. 		{

    2003. 

  2003. 			$recordset = $this->_natsort_builds($recordset);

    2004. 

  2004. 		}

    2005. 

  2005. 		

    2006. 

  2006. 		return $recordset;

    2007. 

  2007. 	}

    2008. 

  2008. 

    2009. 

  2009. 

    2010. 

  2010. 	/**

    2011. 

  2011. 	 * Get a build belonging to a test plan, using build name as access key

    2012. 

  2012. 	 *

    2013. 

  2013. 	 * @param int $id test plan id

    2014. 

  2014. 	 * @param string $build_name

    2015. 

  2015. 	 * 

    2016. 

  2016. 	 * @return array [id,testplan_id, name, notes, active, is_open]

    2017. 

  2017. 	 */

    2018. 

  2018. 	function get_build_by_name($id,$build_name)

    2019. 

  2019. 	{

    2020. 

  2020. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2021. 

  2021. 

    2022. 

  2022. 		$safe_build_name=$this->db->prepare_string(trim($build_name));

    2023. 

  2023. 		

    2024. 

  2024. 		$sql = " SELECT id,testplan_id, name, notes, active, is_open " .

    2025. 

  2025. 			" FROM {$this->tables['builds']} " .

    2026. 

  2026. 			" WHERE testplan_id = {$id} AND name='{$safe_build_name}'";

    2027. 

  2027. 		

    2028. 

  2028. 		

    2029. 

  2029. 		$recordset = $this->db->get_recordset($sql);

    2030. 

  2030. 		$rs=null;

    2031. 

  2031. 		if( !is_null($recordset) )

    2032. 

  2032. 		{

    2033. 

  2033. 			$rs=$recordset[0];

    2034. 

  2034. 		}

    2035. 

  2035. 		return $rs;

    2036. 

  2036. 	}

    2037. 

  2037. 

    2038. 

  2038. 

    2039. 

  2039. 	/**

    2040. 

  2040. 	 * Get a build belonging to a test plan, using build id as access key

    2041. 

  2041. 	 *

    2042. 

  2042. 	 * @param int $id test plan id

    2043. 

  2043. 	 * @param int $build_id

    2044. 

  2044. 	 *

    2045. 

  2045. 	 * @return array [id,testplan_id, name, notes, active, is_open]

    2046. 

  2046. 	 */

    2047. 

  2047. 	function get_build_by_id($id,$build_id)

    2048. 

  2048. 	{

    2049. 

  2049. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2050. 

  2050. 

    2051. 

  2051. 		$sql = " SELECT id,testplan_id, name, notes, active, is_open " .

    2052. 

  2052. 			" FROM {$this->tables['builds']} BUILDS " .

    2053. 

  2053. 			" WHERE testplan_id = {$id} AND BUILDS.id={$build_id}";

    2054. 

  2054. 		

    2055. 

  2055. 		$recordset = $this->db->get_recordset($sql);

    2056. 

  2056. 		$rs=null;

    2057. 

  2057. 		if( !is_null($recordset) )

    2058. 

  2058. 		{

    2059. 

  2059. 			$rs=$recordset[0];

    2060. 

  2060. 		}

    2061. 

  2061. 		return $rs;

    2062. 

  2062. 	}

    2063. 

  2063. 

    2064. 

  2064. 

    2065. 

  2065. 	/**

    2066. 

  2066. 	 * Get the number of builds of a given Testplan

    2067. 

  2067. 	 *

    2068. 

  2068. 	 * @param int tplanID test plan id

    2069. 

  2069. 	 *

    2070. 

  2070. 	 * @return int number of builds

    2071. 

  2071. 	 * 

    2072. 

  2072. 	 * @internal revisions:

    2073. 

  2073. 	 * 20100217 - asimon - added parameters active and open to get only number of active/open builds

    2074. 

  2074. 	 */

    2075. 

  2075. 	function getNumberOfBuilds($tplanID, $active = null, $open = null)

    2076. 

  2076. 	{

    2077. 

  2077. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2078. 

  2078. 		

    2079. 

  2079. 		$sql = "/* $debugMsg */ SELECT count(id) AS num_builds FROM {$this->tables['builds']} builds " .

    2080. 

  2080. 			       "WHERE builds.testplan_id = " . $tplanID;

    2081. 

  2081. 		

    2082. 

  2082. 		if( !is_null($active) )

    2083. 

  2083. 	 	{

    2084. 

  2084. 	 	   $sql .= " AND builds.active=" . intval($active) . " ";

    2085. 

  2085. 	 	}

    2086. 

  2086. 	 	if( !is_null($open) )

    2087. 

  2087. 	 	{

    2088. 

  2088. 	 	   $sql .= " AND builds.is_open=" . intval($open) . " ";

    2089. 

  2089. 	 	}

    2090. 

  2090. 		

    2091. 

  2091. 	 	return $this->db->fetchOneValue($sql);

    2092. 

  2092. 	}

    2093. 

  2093. 

    2094. 

  2094. 	

    2095. 

  2095. 	function _natsort_builds($builds_map)

    2096. 

  2096. 	{

    2097. 

  2097. 		// BUGID - sort in natural order (see natsort in PHP manual)

    2098. 

  2098. 		foreach($builds_map as $key => $value)

    2099. 

  2099. 		{

    2100. 

  2100. 			$vk[$value['name']]=$key;

    2101. 

  2101. 			$build_names[$key]=$value['name'];

    2102. 

  2102. 		}

    2103. 

  2103. 		

    2104. 

  2104. 		natsort($build_names);

    2105. 

  2105. 		$build_num=count($builds_map);

    2106. 

  2106. 		foreach($build_names as $key => $value)

    2107. 

  2107. 		{

    2108. 

  2108. 			$dummy[$key]=$builds_map[$key];

    2109. 

  2109. 		}

    2110. 

  2110. 		return $dummy;

    2111. 

  2111. 	}

    2112. 

  2112. 

    2113. 

  2113. 

    2114. 

  2114. 	/*

    2115. 

  2115. 	  function: check_build_name_existence

    2116. 

  2116. 	

    2117. 

  2117. 	  args:

    2118. 

  2118. 	       tplan_id: test plan id.

    2119. 

  2119. 	       build_name

    2120. 

  2120. 	      [build_id}: default: null

    2121. 

  2121. 	                  when is not null we add build_id as filter, this is useful

    2122. 

  2122. 	                  to understand if is really a duplicate when using this method

    2123. 

  2123. 	                  while managing update operations via GUI

    2124. 

  2124. 	

    2125. 

  2125. 	  returns: 1 => name exists

    2126. 

  2126. 	

    2127. 

  2127. 	  rev: 20080217 - franciscom - added build_id argument

    2128. 

  2128. 	

    2129. 

  2129. 	*/

    2130. 

  2130. 	function check_build_name_existence($tplan_id,$build_name,$build_id=null,$case_sensitive=0)

    2131. 

  2131. 	{

    2132. 

  2132. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2133. 

  2133. 

    2134. 

  2134. 		$sql = " SELECT id, name, notes " .

    2135. 

  2135. 			" FROM {$this->tables['builds']} " .

    2136. 

  2136. 			" WHERE testplan_id = {$tplan_id} ";

    2137. 

  2137. 		

    2138. 

  2138. 		

    2139. 

  2139. 		if($case_sensitive)

    2140. 

  2140. 		{

    2141. 

  2141. 			$sql .= " AND name=";

    2142. 

  2142. 		}

    2143. 

  2143. 		else

    2144. 

  2144. 		{

    2145. 

  2145. 			$build_name=strtoupper($build_name);

    2146. 

  2146. 			$sql .= " AND UPPER(name)=";

    2147. 

  2147. 		}

    2148. 

  2148. 		$sql .= "'" . $this->db->prepare_string($build_name) . "'";

    2149. 

  2149. 		

    2150. 

  2150. 		if( !is_null($build_id) )

    2151. 

  2151. 		{

    2152. 

  2152. 			$sql .= " AND id <> " . $this->db->prepare_int($build_id);

    2153. 

  2153. 		}

    2154. 

  2154. 		

    2155. 

  2155. 		

    2156. 

  2156. 		$result = $this->db->exec_query($sql);

    2157. 

  2157. 		$status= $this->db->num_rows($result) ? 1 : 0;

    2158. 

  2158. 		

    2159. 

  2159. 		return $status;

    2160. 

  2160. 	}

    2161. 

  2161. 

    2162. 

  2162. 

    2163. 

  2163. 	/*

    2164. 

  2164. 	  function: get_build_id_by_name

    2165. 

  2165. 	

    2166. 

  2166. 	Ignores case

    2167. 

  2167. 	

    2168. 

  2168. 	  args :

    2169. 

  2169. 		$tplan_id     : test plan id. 

    2170. 

  2170. 		$build_name   : build name. 

    2171. 

  2171. 	  

    2172. 

  2172. 	  returns: 

    2173. 

  2173. 	  The ID of the build name specified regardless of case.

    2174. 

  2174. 	

    2175. 

  2175. 	  rev :

    2176. 

  2176. 	*/

    2177. 

  2177. 	//@TODO: schlundus, this is only a special case of get_build_by_name, so it should be refactored

    2178. 

  2178. 	function get_build_id_by_name($tplan_id,$build_name)

    2179. 

  2179. 	{

    2180. 

  2180. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2181. 

  2181. 

    2182. 

  2182. 		$sql = " SELECT builds.id, builds.name, builds.notes " .

    2183. 

  2183. 			" FROM {$this->tables['builds']} builds " .

    2184. 

  2184. 			" WHERE builds.testplan_id = {$tplan_id} ";

    2185. 

  2185. 		

    2186. 

  2186. 		$build_name=strtoupper($build_name);        

    2187. 

  2187. 		$sql .= " AND UPPER(builds.name)=";

    2188. 

  2188. 		$sql .= "'" . $this->db->prepare_string($build_name) . "'";    

    2189. 

  2189. 		

    2190. 

  2190. 		//$result = $this->db->exec_query($sql);

    2191. 

  2191. 		

    2192. 

  2192. 		$recordset = $this->db->get_recordset($sql);

    2193. 

  2193. 		$BuildID = 0;

    2194. 

  2194. 		if ($recordset)

    2195. 

  2195. 			$BuildID = intval($recordset[0]['id']);

    2196. 

  2196. 		

    2197. 

  2197. 		return $BuildID;  

    2198. 

  2198. 	}

    2199. 

  2199. 

    2200. 

  2200. 

    2201. 

  2201. 	/*

    2202. 

  2202. 	  function: create_build

    2203. 

  2203. 	

    2204. 

  2204. 	  args :

    2205. 

  2205. 	        $tplan_id

    2206. 

  2206. 	        $name

    2207. 

  2207. 	        $notes

    2208. 

  2208. 	        [$active]: default: 1

    2209. 

  2209. 	        [$open]: default: 1

    2210. 

  2210. 	

    2211. 

  2211. 	

    2212. 

  2212. 	

    2213. 

  2213. 	  returns:

    2214. 

  2214. 	

    2215. 

  2215. 	  rev :

    2216. 

  2216. 	*/

    2217. 

  2217. 	function create_build($tplan_id,$name,$notes = '',$active=1,$open=1)

    2218. 

  2218. 	{

    2219. 

  2219. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2220. 

  2220. 

    2221. 

  2221. 		$sql = " INSERT INTO {$this->tables['builds']} (testplan_id,name,notes,active,is_open) " .

    2222. 

  2222. 			" VALUES ('". $tplan_id . "','" .

    2223. 

  2223. 			$this->db->prepare_string($name) . "','" .

    2224. 

  2224. 			$this->db->prepare_string($notes) . "'," .

    2225. 

  2225. 			"{$active},{$open})";

    2226. 

  2226. 		

    2227. 

  2227. 		$new_build_id = 0;

    2228. 

  2228. 		$result = $this->db->exec_query($sql);

    2229. 

  2229. 		if ($result)

    2230. 

  2230. 		{

    2231. 

  2231. 			$new_build_id = $this->db->insert_id($this->tables['builds']);

    2232. 

  2232. 		}

    2233. 

  2233. 		

    2234. 

  2234. 		return $new_build_id;

    2235. 

  2235. 	}

    2236. 

  2236. 	

    2237. 

  2237. 

    2238. 

  2238. 	// --------------------------------------------------------------------------------------

    2239. 

  2239. 	// Custom field related methods

    2240. 

  2240. 	// --------------------------------------------------------------------------------------

    2241. 

  2241. 	/*

    2242. 

  2242. 	  function: get_linked_cfields_at_design

    2243. 

  2243. 	

    2244. 

  2244. 	  args: $id

    2245. 

  2245. 	        [$parent_id]: testproject id

    2246. 

  2246. 	        [$show_on_execution]: default: null

    2247. 

  2247. 	                              1 -> filter on field show_on_execution=1

    2248. 

  2248. 	                              0 or null -> don't filter

    2249. 

  2249. 	

    2250. 

  2250. 	  returns: hash

    2251. 

  2251. 	

    2252. 

  2252. 	  rev :

    2253. 

  2253. 	        20061231 - franciscom - added $parent_id

    2254. 

  2254. 	*/

    2255. 

  2255. 	function get_linked_cfields_at_design($id,$parent_id=null,$show_on_execution=null)

    2256. 

  2256. 	{

    2257. 

  2257. 		$path_len=0;

    2258. 

  2258. 		if( is_null($parent_id) )

    2259. 

  2259. 		{

    2260. 

  2260. 			// Need to get testplan parent (testproject id) in order to get custom fields

    2261. 

  2261. 			// 20081122 - franciscom - need to check when we can call this with ID=NULL

    2262. 

  2262. 			$the_path = $this->tree_manager->get_path(!is_null($id) ? $id : $parent_id);

    2263. 

  2263. 			$path_len = count($the_path);

    2264. 

  2264. 		}

    2265. 

  2265. 		$tproject_id = ($path_len > 0)? $the_path[$path_len-1]['parent_id'] : $parent_id; 

    2266. 

  2266. 		

    2267. 

  2267. 		$cf_map = $this->cfield_mgr->get_linked_cfields_at_design($tproject_id,self::ENABLED,

    2268. 

  2268. 			                                                      $show_on_execution,'testplan',$id);

    2269. 

  2269. 		

    2270. 

  2270. 		return $cf_map;

    2271. 

  2271. 	}

    2272. 

  2272. 

    2273. 

  2273. 

    2274. 

  2274. 	/*

    2275. 

  2275. 	  function: get_linked_cfields_at_execution

    2276. 

  2276. 	

    2277. 

  2277. 	  args: $id

    2278. 

  2278. 	        [$parent_id]: if present is testproject id

    2279. 

  2279. 	        [$show_on_execution]: default: null

    2280. 

  2280. 	                              1 -> filter on field show_on_execution=1

    2281. 

  2281. 	                              0 or null -> don't filter

    2282. 

  2282. 	

    2283. 

  2283. 	  returns: hash

    2284. 

  2284. 	

    2285. 

  2285. 	  rev :

    2286. 

  2286. 	        20061231 - franciscom - added $parent_id

    2287. 

  2287. 	*/

    2288. 

  2288. 	function get_linked_cfields_at_execution($id,$parent_id=null,$show_on_execution=null)

    2289. 

  2289. 	{

    2290. 

  2290. 		$path_len=0;

    2291. 

  2291. 		if( is_null($parent_id) )

    2292. 

  2292. 		{

    2293. 

  2293. 			// Need to get testplan parent (testproject id) in order to get custom fields

    2294. 

  2294. 			// 20081122 - franciscom - need to check when we can call this with ID=NULL

    2295. 

  2295. 			$the_path = $this->tree_manager->get_path(!is_null($id) ? $id : $parent_id);

    2296. 

  2296. 			$path_len = count($the_path);

    2297. 

  2297. 		}

    2298. 

  2298. 		$tproject_id = ($path_len > 0)? $the_path[$path_len-1]['parent_id'] : $parent_id; 

    2299. 

  2299. 		

    2300. 

  2300. 		// 20081122 - franciscom - humm!! need to look better IMHO this call is done to wrong function

    2301. 

  2301. 		$cf_map=$this->cfield_mgr->get_linked_cfields_at_execution($tproject_id,self::ENABLED,

    2302. 

  2302. 			$show_on_execution,'testplan',$id);

    2303. 

  2303. 		return($cf_map);

    2304. 

  2304. 	}

    2305. 

  2305. 

    2306. 

  2306. 

    2307. 

  2307. 	/* Get Custom Fields  Detail which are enabled on Execution of a TestCase/TestProject.

    2308. 

  2308. 	  function: get_linked_cfields_id

    2309. 

  2309. 	

    2310. 

  2310. 	  args: $testproject_id 

    2311. 

  2311. 	

    2312. 

  2312. 	  returns: hash map of id : label

    2313. 

  2313. 	

    2314. 

  2314. 	  rev :

    2315. 

  2315. 	

    2316. 

  2316. 	*/

    2317. 

  2317. 	

    2318. 

  2318. 	function get_linked_cfields_id($tproject_id)

    2319. 

  2319. 	{

    2320. 

  2320. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2321. 

  2321. 

    2322. 

  2322. 		$field_map = new stdClass();

    2323. 

  2323. 		

    2324. 

  2324. 		$sql = "SELECT field_id,label

    2325. 

  2325. 			FROM {$this->tables['cfield_testprojects']} cfield_testprojects, 

    2326. 

  2326. 			{$this->tables['custom_fields']} custom_fields

    2327. 

  2327. 			WHERE

    2328. 

  2328. 			custom_fields.id = cfield_testprojects.field_id 

    2329. 

  2329. 			and cfield_testprojects.active = 1 

    2330. 

  2330. 			and custom_fields.enable_on_execution = 1 

    2331. 

  2331. 			and custom_fields.show_on_execution = 1 

    2332. 

  2332. 			and cfield_testprojects.testproject_id = {$tproject_id}

    2333. 

  2333. 			order by field_id";

    2334. 

  2334. 		

    2335. 

  2335. 		$field_map = $this->db->fetchColumnsIntoMap($sql,'field_id','label');

    2336. 

  2336. 		return($field_map);

    2337. 

  2337. 	}

    2338. 

  2338. 

    2339. 

  2339. 

    2340. 

  2340. 	/*

    2341. 

  2341. 	  function: html_table_of_custom_field_inputs

    2342. 

  2342. 	

    2343. 

  2343. 	  args: $id

    2344. 

  2344. 	        [$parent_id]: need when you call this method during the creation

    2345. 

  2345. 	                      of a test suite, because the $id will be 0 or null.

    2346. 

  2346. 	

    2347. 

  2347. 	        [$scope]: 'design','execution'

    2348. 

  2348. 	

    2349. 

  2349. 	  returns: html string

    2350. 

  2350. 	*/

    2351. 

  2351. 	function html_table_of_custom_field_inputs($id,$parent_id=null,$scope='design')

    2352. 

  2352. 	{

    2353. 

  2353. 		$cf_smarty='';

    2354. 

  2354. 		

    2355. 

  2355. 		if( $scope=='design' )

    2356. 

  2356. 		{

    2357. 

  2357. 			$cf_map = $this->get_linked_cfields_at_design($id,$parent_id);

    2358. 

  2358. 		}

    2359. 

  2359. 		else

    2360. 

  2360. 		{

    2361. 

  2361. 			$cf_map=$this->get_linked_cfields_at_execution($id,$parent_id);

    2362. 

  2362. 		}

    2363. 

  2363. 		

    2364. 

  2364. 		if( !is_null($cf_map) )

    2365. 

  2365. 		{

    2366. 

  2366. 			foreach($cf_map as $cf_id => $cf_info)

    2367. 

  2367. 			{

    2368. 

  2368. 				$label=str_replace(TL_LOCALIZE_TAG,'',lang_get($cf_info['label'],null,true));

    2369. 

  2369. 				$cf_smarty .= '<tr><td class="labelHolder">' . htmlspecialchars($label) . "</td><td>" .

    2370. 

  2370. 					$this->cfield_mgr->string_custom_field_input($cf_info) . "</td></tr>\n";

    2371. 

  2371. 			} //foreach($cf_map

    2372. 

  2372. 		}

    2373. 

  2373. 		

    2374. 

  2374. 		

    2375. 

  2375. 		if($cf_smarty != '')

    2376. 

  2376. 		{

    2377. 

  2377. 			$cf_smarty = "<table>" . $cf_smarty . "</table>";

    2378. 

  2378. 		}

    2379. 

  2379. 		return($cf_smarty);

    2380. 

  2380. 	}

    2381. 

  2381. 

    2382. 

  2382. 

    2383. 

  2383. 	/*

    2384. 

  2384. 	  function: html_table_of_custom_field_values

    2385. 

  2385. 	

    2386. 

  2386. 	  args: $id

    2387. 

  2387. 	        [$scope]: 'design','execution'

    2388. 

  2388. 	        

    2389. 

  2389. 	        [$filters]:default: null

    2390. 

  2390. 	                            

    2391. 

  2391. 	                           map with keys:

    2392. 

  2392. 	        

    2393. 

  2393. 	                           [show_on_execution]: default: null

    2394. 

  2394. 	                                                1 -> filter on field show_on_execution=1

    2395. 

  2395. 	                                                     include ONLY custom fields that can be viewed

    2396. 

  2396. 	                                                     while user is execution testcases.

    2397. 

  2397. 	                           

    2398. 

  2398. 	                                                0 or null -> don't filter

    2399. 

  2399. 	

    2400. 

  2400. 	  returns: html string

    2401. 

  2401. 	

    2402. 

  2402. 	  rev :

    2403. 

  2403. 	       20080811 - franciscom - BUGID 1650 (REQ)

    2404. 

  2404. 	       20070701 - franciscom - fixed return string when there are no custom fields.

    2405. 

  2405. 	*/

    2406. 

  2406. 	function html_table_of_custom_field_values($id,$scope='design',$filters=null,$formatOptions=null)

    2407. 

  2407. 	{

    2408. 

  2408. 		$cf_smarty='';

    2409. 

  2409. 		$parent_id=null;

    2410. 

  2410. 		$td_style='class="labelHolder"' ;

    2411. 

  2411. 		$add_table=true;

    2412. 

  2412. 		$table_style='';

    2413. 

  2413. 		if( !is_null($formatOptions) )

    2414. 

  2414. 		{

    2415. 

  2415. 			$td_style=isset($formatOptions['td_css_style']) ? $formatOptions['td_css_style'] : $td_style;

    2416. 

  2416. 			$add_table=isset($formatOptions['add_table']) ? $formatOptions['add_table'] : true;

    2417. 

  2417. 			$table_style=isset($formatOptions['table_css_style']) ? $formatOptions['table_css_style'] : $table_style;

    2418. 

  2418. 		} 

    2419. 

  2419. 		

    2420. 

  2420. 		

    2421. 

  2421. 		if( $scope=='design' )

    2422. 

  2422. 		{

    2423. 

  2423. 			$cf_map=$this->get_linked_cfields_at_design($id,$parent_id,$filters);

    2424. 

  2424. 		}

    2425. 

  2425. 		else

    2426. 

  2426. 		{

    2427. 

  2427. 			$cf_map=$this->get_linked_cfields_at_execution($id);

    2428. 

  2428. 		}

    2429. 

  2429. 		

    2430. 

  2430. 		if( !is_null($cf_map) )

    2431. 

  2431. 		{

    2432. 

  2432. 			foreach($cf_map as $cf_id => $cf_info)

    2433. 

  2433. 			{

    2434. 

  2434. 				// if user has assigned a value, then node_id is not null

    2435. 

  2435. 				if(isset($cf_info['node_id']) && $cf_info['node_id'])

    2436. 

  2436. 				{

    2437. 

  2437. 					// true => do not create input in audit log

    2438. 

  2438. 					$label=str_replace(TL_LOCALIZE_TAG,'',lang_get($cf_info['label'],null,true));

    2439. 

  2439. 					$cf_smarty .= "<tr><td {$td_style}>" . htmlspecialchars($label) . "</td><td>" .

    2440. 

  2440. 						$this->cfield_mgr->string_custom_field_value($cf_info,$id) . "</td></tr>\n";

    2441. 

  2441. 				}

    2442. 

  2442. 			}

    2443. 

  2443. 		}

    2444. 

  2444. 		

    2445. 

  2445. 		if($cf_smarty != '' && $add_table)

    2446. 

  2446. 		{

    2447. 

  2447. 			$cf_smarty = "<table {$table_style}>" . $cf_smarty . "</table>";

    2448. 

  2448. 		}

    2449. 

  2449. 		return($cf_smarty);

    2450. 

  2450. 	} // function end

    2451. 

  2451. 

    2452. 

  2452. 

    2453. 

  2453. 	/*

    2454. 

  2454. 	  function: filter_cf_selection

    2455. 

  2455. 	

    2456. 

  2456. 	  args :

    2457. 

  2457. 	        $tp_tcs - this comes from get_linked_tcversion

    2458. 

  2458. 	        $cf_hash [cf_id] = value of cfields to filter by.

    2459. 

  2459. 	

    2460. 

  2460. 	  returns: array filtered by selected custom fields.

    2461. 

  2461. 	

    2462. 

  2462. 	  rev :

    2463. 

  2463. 	*/

    2464. 

  2464. 	function filter_cf_selection ($tp_tcs, $cf_hash)

    2465. 

  2465. 	{

    2466. 

  2466. 		$new_tp_tcs = null;

    2467. 

  2467. 		

    2468. 

  2468. 		foreach ($tp_tcs as $tc_id => $tc_value)

    2469. 

  2469. 		{

    2470. 

  2470. 			

    2471. 

  2471. 			foreach ($cf_hash as $cf_id => $cf_value)

    2472. 

  2472. 			{

    2473. 

  2473. 				$passed = 0;

    2474. 

  2474. 				// there will never be more than one record that has a field_id / node_id combination

    2475. 

  2475. 				$sql = "SELECT value FROM {$this->tables['cfield_design_values']} " .

    2476. 

  2476. 					"WHERE field_id = $cf_id " .

    2477. 

  2477. 					"AND node_id = $tc_id ";

    2478. 

  2478. 				

    2479. 

  2479. 				$result = $this->db->exec_query($sql);

    2480. 

  2480. 				$myrow = $this->db->fetch_array($result);

    2481. 

  2481. 				

    2482. 

  2482. 				// push both to arrays so we can compare

    2483. 

  2483. 				$possibleValues = explode ('|', $myrow['value']);

    2484. 

  2484. 				$valuesSelected = explode ('|', $cf_value);

    2485. 

  2485. 				

    2486. 

  2486. 				// we want to match any selected item from list and checkboxes.

    2487. 

  2487. 				if ( count($valuesSelected) ) {

    2488. 

  2488. 					foreach ($valuesSelected as $vs_id => $vs_value) {

    2489. 

  2489. 						$found = array_search($vs_value, $possibleValues);

    2490. 

  2490. 						if (is_int($found)) {

    2491. 

  2491. 							$passed = 1;

    2492. 

  2492. 						} else {

    2493. 

  2493. 							$passed = 0;

    2494. 

  2494. 							break;

    2495. 

  2495. 						}

    2496. 

  2496. 					}

    2497. 

  2497. 				}

    2498. 

  2498. 				// if we don't match, fall out of the foreach.

    2499. 

  2499. 				// this gives a "and" search for all cf's, if this is removed then it responds

    2500. 

  2500. 				// as an "or" search

    2501. 

  2501. 				// perhaps this could be parameterized.

    2502. 

  2502. 				if ($passed == 0) {

    2503. 

  2503. 					break;

    2504. 

  2504. 				}

    2505. 

  2505. 			}

    2506. 

  2506. 			if ($passed) {

    2507. 

  2507. 				$new_tp_tcs[$tc_id] = $tp_tcs[$tc_id];

    2508. 

  2508. 			}

    2509. 

  2509. 		}

    2510. 

  2510. 		return ($new_tp_tcs);

    2511. 

  2511. 	}

    2512. 

  2512. 

    2513. 

  2513. 

    2514. 

  2514. 	/*

    2515. 

  2515. 	  function: get_estimated_execution_time

    2516. 

  2516. 	            Created after a contributed code (BUGID 1670)

    2517. 

  2517. 	

    2518. 

  2518. 	            Takes all testcases linked to testplan and computes

    2519. 

  2519. 	            SUM of values assigned AT DESIGN TIME to customa field

    2520. 

  2520. 	            named CF_ESTIMATED_EXEC_TIME

    2521. 

  2521. 	

    2522. 

  2522. 	            IMPORTANT:

    2523. 

  2523. 	            1. at time of this writting (20080820) this CF can be of type: string,numeric or float.

    2524. 

  2524. 	            2. YOU NEED TO USE . (dot) as decimal separator (US decimal separator?) or

    2525. 

  2525. 	               sum will be wrong. 

    2526. 

  2526. 	         

    2527. 

  2527. 	            

    2528. 

  2528. 	            

    2529. 

  2529. 	  args:id testplan id

    2530. 

  2530. 	       tcase_set: default null

    2531. 

  2531. 	

    2532. 

  2532. 	  returns: sum of CF values for all testcases linked to testplan

    2533. 

  2533. 	

    2534. 

  2534. 	  rev: 20080820 - franciscom

    2535. 

  2535. 	*/

    2536. 

  2536. 	function get_estimated_execution_time($id,$tcase_set=null)

    2537. 

  2537. 	{

    2538. 

  2538. 		// Get list of test cases on test plan

    2539. 

  2539. 		$estimated=0;

    2540. 

  2540. 		$cf_info = $this->cfield_mgr->get_by_name('CF_ESTIMATED_EXEC_TIME');

    2541. 

  2541. 		

    2542. 

  2542. 		// CF exists ?

    2543. 

  2543. 		if( ($status_ok=!is_null($cf_info)) )

    2544. 

  2544. 		{

    2545. 

  2545. 			$cfield_id=key($cf_info);

    2546. 

  2546. 		}

    2547. 

  2547. 		

    2548. 

  2548. 		if( $status_ok)

    2549. 

  2549. 		{

    2550. 

  2550. 			if( is_null($tcase_set) )

    2551. 

  2551. 			{

    2552. 

  2552. 				// we will compute time for ALL linked test cases

    2553. 

  2553. 				// $linked_testcases=$this->get_linked_tcversions($id);  

    2554. 

  2554. 				// Test done due to BUGID 3434 has shown that:

    2555. 

  2555. 				// get_linked_items_id($id) has better performance than get_linked_tcversions($id);

    2556. 

  2556. 				$linked_testcases=$this->get_linked_items_id($id);  

    2557. 

  2557. 				if( ($status_ok=!is_null($linked_testcases)) )

    2558. 

  2558. 				{

    2559. 

  2559. 					$tcase_ids=array_keys($linked_testcases);

    2560. 

  2560. 				}    

    2561. 

  2561. 			}

    2562. 

  2562. 			else

    2563. 

  2563. 			{

    2564. 

  2564. 				$tcase_ids=$tcase_set;  

    2565. 

  2565. 			}

    2566. 

  2566. 		}  

    2567. 

  2567. 		

    2568. 

  2568. 		if($status_ok)

    2569. 

  2569. 		{

    2570. 

  2570. 			$sql="SELECT SUM(CAST(value AS NUMERIC)) ";

    2571. 

  2571. 			if( DB_TYPE == 'mysql')

    2572. 

  2572. 			{

    2573. 

  2573. 				$sql="SELECT SUM(value) ";

    2574. 

  2574. 			} 

    2575. 

  2575. 			else if ( DB_TYPE == 'postgres')

    2576. 

  2576. 			{

    2577. 

  2577. 				$sql="SELECT SUM(CAST(value AS NUMERIC)) ";

    2578. 

  2578. 			}        

    2579. 

  2579. 			$sql .= " AS SUM_VALUE FROM {$this->tables['cfield_design_values']} CFDV " .

    2580. 

  2580. 				" WHERE CFDV.field_id={$cfield_id} " .

    2581. 

  2581. 				" AND node_id IN (" . implode(',',$tcase_ids) . ")";

    2582. 

  2582. 			$estimated=$this->db->fetchOneValue($sql);

    2583. 

  2583. 			$estimated=is_null($estimated) ? 0 :$estimated;

    2584. 

  2584. 		}

    2585. 

  2585. 		

    2586. 

  2586. 		return $estimated;

    2587. 

  2587. 	}    

    2588. 

  2588. 

    2589. 

  2589. 

    2590. 

  2590. 	/*

    2591. 

  2591. 	  function: get_execution_time

    2592. 

  2592. 	            Takes all testcases (or a subset of executions) linked to testplan 

    2593. 

  2593. 	            that has been executed and computes SUM of values assigned AT EXECUTION TIME 

    2594. 

  2594. 	            to customa field named CF_EXEC_TIME

    2595. 

  2595. 	

    2596. 

  2596. 	            IMPORTANT:

    2597. 

  2597. 	            1. at time of this writting (20081207) this CF can be of type: string,numeric or float.

    2598. 

  2598. 	            2. YOU NEED TO USE . (dot) as decimal separator (US decimal separator?) or

    2599. 

  2599. 	               sum will be wrong. 

    2600. 

  2600. 	            

    2601. 

  2601. 	  args:id testplan id

    2602. 

  2602. 	       $execution_set: default null

    2603. 

  2603. 	

    2604. 

  2604. 	  returns: sum of CF values for all testcases linked to testplan

    2605. 

  2605. 	

    2606. 

  2606. 	  rev: 20081207 - franciscom

    2607. 

  2607. 	*/

    2608. 

  2608. 	function get_execution_time($id,$execution_set=null)

    2609. 

  2609. 	{

    2610. 

  2610. 		$total_time=0;

    2611. 

  2611. 		$cf_info = $this->cfield_mgr->get_by_name('CF_EXEC_TIME');

    2612. 

  2612. 		

    2613. 

  2613. 		// CF exists ?

    2614. 

  2614. 		if( ($status_ok=!is_null($cf_info)) )

    2615. 

  2615. 		{

    2616. 

  2616. 			$cfield_id=key($cf_info);

    2617. 

  2617. 		}

    2618. 

  2618. 		

    2619. 

  2619. 		if( $status_ok)

    2620. 

  2620. 		{

    2621. 

  2621. 			if( is_null($execution_set) )

    2622. 

  2622. 			{

    2623. 

  2623. 				// we will compute time for ALL linked and executed test cases,

    2624. 

  2624. 				// just for LAST executed TCVERSION

    2625. 

  2625. 				// $linked_executed=$this->get_linked_tcversions($id,null,0,'just_executed'); 

    2626. 

  2626. 				$options = array('only_executed' => true);

    2627. 

  2627. 				$linked_executed=$this->get_linked_tcversions($id,null,$options); 

    2628. 

  2628. 				if( ($status_ok=!is_null($linked_executed)) )

    2629. 

  2629. 				{

    2630. 

  2630. 					foreach($linked_executed as $tcase_id => $info)

    2631. 

  2631. 					{

    2632. 

  2632. 						$execution_ids[]=$info['exec_id'];

    2633. 

  2633. 					}    

    2634. 

  2634. 				}    

    2635. 

  2635. 			}

    2636. 

  2636. 			else

    2637. 

  2637. 			{

    2638. 

  2638. 				$execution_ids=$execution_set;  

    2639. 

  2639. 			}

    2640. 

  2640. 		}  

    2641. 

  2641. 		

    2642. 

  2642. 		if($status_ok)

    2643. 

  2643. 		{

    2644. 

  2644. 			$sql="SELECT SUM(CAST(value AS NUMERIC)) ";

    2645. 

  2645. 			if( DB_TYPE == 'mysql')

    2646. 

  2646. 			{

    2647. 

  2647. 				$sql="SELECT SUM(value) ";

    2648. 

  2648. 			} 

    2649. 

  2649. 			else if ( DB_TYPE == 'postgres')

    2650. 

  2650. 			{

    2651. 

  2651. 				$sql="SELECT SUM(CAST(value AS NUMERIC)) ";

    2652. 

  2652. 			}        

    2653. 

  2653. 			

    2654. 

  2654. 			$sql .= " AS SUM_VALUE FROM {$this->tables['cfield_execution_values']} CFEV " .

    2655. 

  2655. 				" WHERE CFEV.field_id={$cfield_id} " .

    2656. 

  2656. 				" AND testplan_id={$id} " .

    2657. 

  2657. 				" AND execution_id IN (" . implode(',',$execution_ids) . ")";

    2658. 

  2658. 			

    2659. 

  2659. 			$total_time=$this->db->fetchOneValue($sql);

    2660. 

  2660. 			$total_time=is_null($total_time) ? 0 :$total_time;

    2661. 

  2661. 		}

    2662. 

  2662. 		return $total_time;

    2663. 

  2663. 	}    

    2664. 

  2664. 

    2665. 

  2665. 

    2666. 

  2666. 	/*

    2667. 

  2667. 	  function: get_prev_builds() 

    2668. 

  2668. 	

    2669. 

  2669. 	  args: id: testplan id

    2670. 

  2670. 	        build_id: all builds belonging to choosen testplan,

    2671. 

  2671. 	                  with id < build_id will be retreived.

    2672. 

  2672. 	        [active]: default null  -> do not filter on active status

    2673. 

  2673. 	  

    2674. 

  2674. 	  returns: 

    2675. 

  2675. 	

    2676. 

  2676. 	*/

    2677. 

  2677. 	function get_prev_builds($id,$build_id,$active=null)

    2678. 

  2678. 	{

    2679. 

  2679. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2680. 

  2680. 

    2681. 

  2681. 		$sql = " SELECT id,testplan_id, name, notes, active, is_open " .

    2682. 

  2682. 			" FROM {$this->tables['builds']} " . 

    2683. 

  2683. 			" WHERE testplan_id = {$id} AND id < {$build_id}" ;

    2684. 

  2684. 		

    2685. 

  2685. 		if( !is_null($active) )

    2686. 

  2686. 		{

    2687. 

  2687. 			$sql .= " AND active=" . intval($active) . " ";

    2688. 

  2688. 		}

    2689. 

  2689. 		

    2690. 

  2690. 		$recordset = $this->db->fetchRowsIntoMap($sql,'id');

    2691. 

  2691. 		return $recordset;

    2692. 

  2692. 	}

    2693. 

  2693. 	

    2694. 

  2694. 

    2695. 

  2695. 	/**

    2696. 

  2696. 	 * returns set of tcversions that has same execution status

    2697. 

  2697. 	 * in every build present on buildSet.

    2698. 

  2698. 	 * ATTENTION!!!: this does not work for not_run status

    2699. 

  2699. 	 */

    2700. 

  2700. 	 /*           

    2701. 

  2701. 	  args: id: testplan id

    2702. 

  2702. 	        buildSet: builds to analise.

    2703. 

  2703. 	        status: status code

    2704. 

  2704. 	*/

    2705. 

  2705. 	function get_same_status_for_build_set($id,$buildSet,$status)

    2706. 

  2706. 	{

    2707. 

  2707. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2708. 

  2708. 

    2709. 

  2709. 		$node_types=$this->tree_manager->get_available_node_types();

    2710. 

  2710. 		$resultsCfg = config_get('results');

    2711. 

  2711. 		

    2712. 

  2712. 		$num_exec = count($buildSet);

    2713. 

  2713. 		$build_in = implode(",", $buildSet);

    2714. 

  2714. 		$status_in = implode("',", (array)$status);

    2715. 

  2715. 		

    2716. 

  2716. 		if( in_array($resultsCfg['status_code']['not_run'], (array)$status) )

    2717. 

  2717. 		{

    2718. 

  2718. 			

    2719. 

  2719. 			$sql = " SELECT distinct T.tcversion_id,E.build_id,NH.parent_id AS tcase_id " .

    2720. 

  2720. 				" FROM {$this->tables['testplan_tcversions']}  T " .

    2721. 

  2721. 				" JOIN {$this->tables['nodes_hierarchy']}  NH ON T.tcversion_id=NH.id " .

    2722. 

  2722. 				" AND NH.node_type_id={$node_types['testcase_version']} " .

    2723. 

  2723. 				" LEFT OUTER JOIN {$this->tables['executions']} E ON T.tcversion_id = E.tcversion_id " .

    2724. 

  2724. 				" AND T.testplan_id=E.testplan_id AND E.build_id IN ({$build_in}) " .

    2725. 

  2725. 				" WHERE T.testplan_id={$id} AND E.build_id IS NULL ";

    2726. 

  2726. 		}

    2727. 

  2727. 		else

    2728. 

  2728. 		{

    2729. 

  2729. 			$sql = " SELECT EE.status,SQ1.tcversion_id, NH.parent_id AS tcase_id, COUNT(EE.status) AS exec_qty " .

    2730. 

  2730. 				" FROM {$this->tables['executions']} EE, {$this->tables['nodes_hierarchy']} NH," .

    2731. 

  2731. 				" (SELECT E.tcversion_id,E.build_id,MAX(E.id) AS last_exec_id " .

    2732. 

  2732. 				" FROM {$this->tables['executions']} E " .

    2733. 

  2733. 				" WHERE E.build_id IN ({$build_in}) " .

    2734. 

  2734. 				" GROUP BY E.tcversion_id,E.build_id) AS SQ1 " .

    2735. 

  2735. 				" WHERE EE.build_id IN ({$build_in}) " .

    2736. 

  2736. 				" AND EE.status IN ('" . $status . "') AND NH.node_type_id={$node_types['testcase_version']} " .

    2737. 

  2737. 				" AND SQ1.last_exec_id=EE.id AND SQ1.tcversion_id=NH.id " .

    2738. 

  2738. 				" GROUP BY status,SQ1.tcversion_id,NH.parent_id" .

    2739. 

  2739. 				" HAVING count(EE.status)= {$num_exec} " ;

    2740. 

  2740. 		}

    2741. 

  2741. 		

    2742. 

  2742. 		$recordset = $this->db->fetchRowsIntoMap($sql,'tcase_id');

    2743. 

  2743. 		return $recordset;

    2744. 

  2744. 	}

    2745. 

  2745. 

    2746. 

  2746. 

    2747. 

  2747. 	/**

    2748. 

  2748. 	 * BUGID 2455, BUGID 3026

    2749. 

  2749. 	 * find any builds which have the wanted status in the build set

    2750. 

  2750. 	 * 

    2751. 

  2751. 	 * @author asimon

    2752. 

  2752. 	 * @param integer $id Build ID

    2753. 

  2753. 	 * @param array $buildSet build set to check

    2754. 

  2754. 	 * @param array $status status to look for

    2755. 

  2755. 	 * @return array $recordset set of builds which match the search criterium

    2756. 

  2756. 	 */

    2757. 

  2757. 	function get_status_for_any_build($id,$buildSet,$status) 

    2758. 

  2758. 	{

    2759. 

  2759. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2760. 

  2760. 

    2761. 

  2761. 		$node_types=$this->tree_manager->get_available_node_types();

    2762. 

  2762. 		$resultsCfg = config_get('results');

    2763. 

  2763. 

    2764. 

  2764. 		$build_in = implode(",", $buildSet);

    2765. 

  2765. 		$status_in = implode("','", (array)$status);

    2766. 

  2766. 

    2767. 

  2767. 		if( in_array($resultsCfg['status_code']['not_run'], (array)$status) ) {

    2768. 

  2768. 			//not run status

    2769. 

  2769. 			$sql = "/* $debugMsg */ SELECT distinct T.tcversion_id,E.build_id,NH.parent_id AS tcase_id " .

    2770. 

  2770. 				   " FROM {$this->tables['testplan_tcversions']}  T " .

    2771. 

  2771. 				   " JOIN {$this->tables['nodes_hierarchy']}  NH ON T.tcversion_id=NH.id " .

    2772. 

  2772. 				   " AND NH.node_type_id={$node_types['testcase_version']} " .

    2773. 

  2773. 				   " LEFT OUTER JOIN {$this->tables['executions']} E ON T.tcversion_id = E.tcversion_id " .

    2774. 

  2774. 				   " AND T.testplan_id=E.testplan_id AND E.build_id IN ({$build_in}) " .

    2775. 

  2775. 				   " WHERE T.testplan_id={$id} AND E.build_id IS NULL ";

    2776. 

  2776. 		} else {

    2777. 

  2777. 			//anything else

    2778. 

  2778. 			$sql = "/* $debugMsg */ SELECT EE.status,SQ1.tcversion_id, NH.parent_id AS tcase_id," .

    2779. 

  2779. 			       " COUNT(EE.status) AS exec_qty " .

    2780. 

  2780. 				   " FROM {$this->tables['executions']} EE, {$this->tables['nodes_hierarchy']} NH," .

    2781. 

  2781. 				   " (SELECT E.tcversion_id,E.build_id,MAX(E.id) AS last_exec_id " .

    2782. 

  2782. 				   "  FROM {$this->tables['executions']} E " .

    2783. 

  2783. 				   "  WHERE E.build_id IN ({$build_in}) GROUP BY E.tcversion_id,E.build_id) AS SQ1 " .

    2784. 

  2784. 				   " WHERE EE.build_id IN ({$build_in}) " .

    2785. 

  2785. 				   " AND EE.status IN ('" . $status_in . "') AND NH.node_type_id={$node_types['testcase_version']} " .

    2786. 

  2786. 				   " AND SQ1.last_exec_id=EE.id AND SQ1.tcversion_id=NH.id " .

    2787. 

  2787. 				   " GROUP BY status,SQ1.tcversion_id,NH.parent_id";

    2788. 

  2788. 		}

    2789. 

  2789. 

    2790. 

  2790. 		$recordset = $this->db->fetchRowsIntoMap($sql,'tcase_id');

    2791. 

  2791. 		return $recordset;

    2792. 

  2792. 	}

    2793. 

  2793. 

    2794. 

  2794. 	

    2795. 

  2795. 	/**

    2796. 

  2796. 	 * BUGID 2455, BUGID 3026

    2797. 

  2797. 	 * find all builds for which a testcase has not been executed

    2798. 

  2798. 	 * 

    2799. 

  2799. 	 * @author asimon

    2800. 

  2800. 	 * @param integer $id Build ID

    2801. 

  2801. 	 * @param array $buildSet build set to check

    2802. 

  2802. 	 * @return array $new_set set of builds which match the search criterium

    2803. 

  2803. 	 */

    2804. 

  2804. 	function get_not_run_for_any_build($id,$buildSet) {

    2805. 

  2805. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2806. 

  2806. 

    2807. 

  2807. 		$node_types=$this->tree_manager->get_available_node_types();

    2808. 

  2808. 		

    2809. 

  2809. 		$results = array();

    2810. 

  2810. 		

    2811. 

  2811. 		foreach ($buildSet as $build) {

    2812. 

  2812. 			$sql = "/* $debugMsg */ SELECT distinct T.tcversion_id, E.build_id, E.status, NH.parent_id AS tcase_id " .

    2813. 

  2813. 				   " FROM {$this->tables['testplan_tcversions']} T " .

    2814. 

  2814. 				   " JOIN {$this->tables['nodes_hierarchy']} NH ON T.tcversion_id=NH.id  AND NH.node_type_id=4 " .

    2815. 

  2815. 				   " LEFT OUTER JOIN {$this->tables['executions']} E ON T.tcversion_id = E.tcversion_id " .

    2816. 

  2816. 				   " AND T.testplan_id=E.testplan_id AND E.build_id=$build " .

    2817. 

  2817. 				   " WHERE T.testplan_id={$id} AND E.status IS NULL ";

    2818. 

  2818. 			

    2819. 

  2819. 			$results[] = $this->db->fetchRowsIntoMap($sql,'tcase_id');

    2820. 

  2820. 		}

    2821. 

  2821. 		

    2822. 

  2822. 		$recordset = array();

    2823. 

  2823. 		foreach ($results as $result) 

    2824. 

  2824. 		{

    2825. 

  2825. 			$recordset = array_merge_recursive($recordset, $result);

    2826. 

  2826. 		} 

    2827. 

  2827. 		

    2828. 

  2828. 		$new_set = array();

    2829. 

  2829. 		foreach ($recordset as $key => $val) {

    2830. 

  2830. 			$new_set[$val['tcase_id']] = $val;

    2831. 

  2831. 		}

    2832. 

  2832. 		

    2833. 

  2833. 		return $new_set;

    2834. 

  2834. 	}

    2835. 

  2835. 

    2836. 

  2836. 

    2837. 

  2837. 	/**

    2838. 

  2838. 	 * link platforms to a new Test Plan

    2839. 

  2839. 	 * 

    2840. 

  2840. 	 * @param int $source_id original Test Plan id

    2841. 

  2841. 	 * @param int $target_id new Test Plan id

    2842. 

  2842. 	 * @param array $mappings: key source platform id, target platform id

    2843. 

  2843. 	 *                         USED when copy is done to a test plan that BELONGS to

    2844. 

  2844. 	 *                         another Test Project.

    2845. 

  2845. 	 */

    2846. 

  2846. 	private function copy_platforms_links($source_id, $target_id, $mappings = null)

    2847. 

  2847. 	{

    2848. 

  2848.     	$sourceLinks = $this->platform_mgr->getLinkedToTestplanAsMap($source_id);

    2849. 

  2849.     	if( !is_null($sourceLinks) )

    2850. 

  2850.     	{

    2851. 

  2851.     		$sourceLinks = array_keys($sourceLinks);

    2852. 

  2852.     		if( !is_null($mappings) )

    2853. 

  2853.     		{

    2854. 

  2854.     			foreach($sourceLinks as $key => $value)

    2855. 

  2855.     			{

    2856. 

  2856.     				$sourceLinks[$key] = $mappings[$value];

    2857. 

  2857.     			}

    2858. 

  2858.     		}

    2859. 

  2859.     		$this->platform_mgr->linkToTestplan($sourceLinks,$target_id);

    2860. 

  2860.     	}

    2861. 

  2861. 	}

    2862. 

  2862. 

    2863. 

  2863.     /**

    2864. 

  2864. 	 * 

    2865. 

  2865.  	 *

    2866. 

  2866.  	 * outputFormat: 

    2867. 

  2867.  	 *				'array',

    2868. 

  2868.  	 *				'map', 

    2869. 

  2869.  	 *				'mapAccessByID' => map access key: id

    2870. 

  2870. 	 *				'mapAccessByName' => map access key: name

    2871. 

  2871. 	 *

    2872. 

  2872. 	 * 20100711 - franciscom - BUGID 3564

    2873. 

  2873.  	 */

    2874. 

  2874.     function getPlatforms($id,$options=null)

    2875. 

  2875.     {

    2876. 

  2876.         $my['options'] = array('outputFormat' => 'array', 'addIfNull' => false);

    2877. 

  2877. 	    $my['options'] = array_merge($my['options'], (array)$options);

    2878. 

  2878.         switch($my['options']['outputFormat'])

    2879. 

  2879.         {

    2880. 

  2880.         	case 'map':

    2881. 

  2881.         		$platforms = $this->platform_mgr->getLinkedToTestplanAsMap($id);

    2882. 

  2882.         	break;

    2883. 

  2883.         	

    2884. 

  2884.         	default:

    2885. 

  2885.         		$opt = array('outputFormat' => $my['options']['outputFormat']);

    2886. 

  2886.         		$platforms = $this->platform_mgr->getLinkedToTestplan($id,$opt);

    2887. 

  2887.         	break;

    2888. 

  2888.         } 	

    2889. 

  2889.     	

    2890. 

  2890.     	if( $my['options']['addIfNull'] && is_null($platforms) )

    2891. 

  2891. 		{

    2892. 

  2892. 			$platforms = array( 0 => '');

    2893. 

  2893. 		}

    2894. 

  2894.     	return $platforms; 

    2895. 

  2895.     }

    2896. 

  2896. 

    2897. 

  2897. 	/**

    2898. 

  2898. 	 * Logic to determine if platforms should be visible for a given testplan.

    2899. 

  2899. 	 * @return bool true if the testplan has one or more linked platforms;

    2900. 

  2900. 	 *              otherwise false.

    2901. 

  2901. 	 */

    2902. 

  2902.     function hasLinkedPlatforms($id)

    2903. 

  2903.     {

    2904. 

  2904.     	return $this->platform_mgr->platformsActiveForTestplan($id);

    2905. 

  2905.     }	

    2906. 

  2906. 

    2907. 

  2907. 

    2908. 

  2908. 

    2909. 

  2909.     /**

    2910. 

  2910.      * changes platform id on a test plan linked test case versions for

    2911. 

  2911.      * a target platform.

    2912. 

  2912.      * Corresponding executions information is also updated

    2913. 

  2913.      *

    2914. 

  2914. 	 * @param id: test plan id

    2915. 

  2915. 	 * @param from: plaftorm id to update (used as filter criteria).

    2916. 

  2916. 	 * @param to: new plaftorm id value

    2917. 

  2917. 	 * @param tcversionSet: default null, can be array with tcversion id

    2918. 

  2918. 	 *                      (used as filter criteria).

    2919. 

  2919. 	 *

    2920. 

  2920.  	 *

    2921. 

  2921.  	 */

    2922. 

  2922.     function changeLinkedTCVersionsPlatform($id,$from,$to,$tcversionSet=null)

    2923. 

  2923.     {

    2924. 

  2924. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2925. 

  2925.     	$sqlFilter = '';

    2926. 

  2926.     	if( !is_null($tcversionSet) )

    2927. 

  2927.     	{

    2928. 

  2928. 			$sqlFilter = " AND tcversion_id IN (" . implode(',',(array)$tcversionSet) . " ) ";

    2929. 

  2929.     	}

    2930. 

  2930.     	$whereClause = " WHERE testplan_id = {$id} AND platform_id = {$from} {$sqlFilter}";

    2931. 

  2931. 

    2932. 

  2932.         $sqlStm = array();

    2933. 

  2933. 		$sqlStm[] = "/* {$debugMsg} */ " . 

    2934. 

  2934. 		            " UPDATE {$this->tables['testplan_tcversions']} " .

    2935. 

  2935. 			        " SET platform_id = {$to} " . $whereClause;

    2936. 

  2936. 

    2937. 

  2937. 		$sqlStm[] = "/* {$debugMsg} */" .

    2938. 

  2938. 		            " UPDATE {$this->tables['executions']} " .

    2939. 

  2939. 			        " SET platform_id = {$to} " . $whereClause;

    2940. 

  2940. 

    2941. 

  2941.         foreach($sqlStm as $sql)

    2942. 

  2942.         {

    2943. 

  2943. 			$this->db->exec_query($sql);		

    2944. 

  2944. 		}

    2945. 

  2945.     }

    2946. 

  2946. 

    2947. 

  2947.     /**

    2948. 

  2948.      *

    2949. 

  2949. 	 * @param id: test plan id

    2950. 

  2950. 	 * @param platformSet: default null, used as filter criteria.

    2951. 

  2951. 	 * @return map: key platform id, values count,platform_id

    2952. 

  2952.  	 */

    2953. 

  2953. 	public function countLinkedTCVersionsByPlatform($id,$platformSet=null)

    2954. 

  2954. 	{

    2955. 

  2955. 		$sqlFilter = '';

    2956. 

  2956. 		if( !is_null($platformSet) )

    2957. 

  2957. 		{

    2958. 

  2958. 			$sqlFilter = " AND platform_id IN (" . implode(',',(array)$platformSet). ") ";

    2959. 

  2959. 		}

    2960. 

  2960. 		$sql = " SELECT COUNT(testplan_id) AS qty,platform_id " .

    2961. 

  2961. 		       " FROM {$this->tables['testplan_tcversions']} " .

    2962. 

  2962. 			   " WHERE testplan_id={$id} {$sqlFilter} " .

    2963. 

  2963. 			   " GROUP BY platform_id ";

    2964. 

  2964. 		$rs = $this->db->fetchRowsIntoMap($sql,'platform_id');

    2965. 

  2965. 		return $rs;

    2966. 

  2966. 	}

    2967. 

  2967. 

    2968. 

  2968. 

    2969. 

  2969.     /**

    2970. 

  2970.      * get detailed information of test case versions linke to test plan an NOT executed

    2971. 

  2971.      * gives detaile for each platform and build combination

    2972. 

  2972.      *

    2973. 

  2973.      * @deprecated 1.9

    2974. 

  2974.      *

    2975. 

  2975. 	 * @param id: test plan id

    2976. 

  2976. 	 * @param filters: optional, map with following keys

    2977. 

  2977. 	 *                 build_id: contains a build id (just one) to be filtered

    2978. 

  2978. 	 *                 platform_id: contains a platform id (just one) to be filtered

    2979. 

  2979. 	 *

    2980. 

  2980. 	 * @param options: optional map with following keys

    2981. 

  2981. 	 *                 group_by_platform_tcversion: true -> in this way we will get one record

    2982. 

  2982. 	 *                                              for each platform no matter on how many builds

    2983. 

  2983. 	 *                                              test case version has not been executed.

    2984. 

  2984. 	 *                                              when this option is set, filters are ignored

    2985. 

  2985. 	 * @return map: 

    2986. 

  2986.  	 */

    2987. 

  2987. 	public function getNotExecutedLinkedTCVersionsDetailed($id,$filters=null,$options=null)

    2988. 

  2988. 	{

    2989. 

  2989. 		$debugMsg = 'Class:' . __CLASS__ . ' - Method: ' . __FUNCTION__;

    2990. 

  2990. 		$resultsCfg = config_get('results');

    2991. 

  2991. 		$status_not_run=$resultsCfg['status_code']['not_run'];

    2992. 

  2992.         $executions_join = "";

    2993. 

  2993. 

    2994. 

  2994.         $my['filters'] = array('build_id' => 0,'platform_id' => null);

    2995. 

  2995. 		$my['filters'] = array_merge($my['filters'], (array)$filters);

    2996. 

  2996. 

    2997. 

  2997.         $my['options'] = array('group_by_platform_tcversion' => false);

    2998. 

  2998. 		$my['options'] = array_merge($my['options'], (array)$options);

    2999. 

  2999. 

    3000. 

  3000. 		$sqlFilter = "";

    3001. 

  3001.         foreach($my['filters'] as $key => $value)

    3002. 

  3002.         {

    3003. 

  3003.         	if( !is_null($value) && $value > 0)

    3004. 

  3004.         	{

    3005. 

  3005.         		$sqlFilter .= " AND {$key} = {$value} "; 

    3006. 

  3006.         	}	

    3007. 

  3007.         } 

    3008. 

  3008.         

    3009. 

  3009.         if($my['options']['group_by_platform_tcversion'])

    3010. 

  3010.         {

    3011. 

  3011. 			$build_fields = " ";

    3012. 

  3012.             $build_join = " ";

    3013. 

  3013. 			$executions_join = " E.tcversion_id=TPTCV.tcversion_id " .

    3014. 

  3014. 			                   " AND E.testplan_id = TPTCV.testplan_id " .

    3015. 

  3015. 			                   " AND E.platform_id = TPTCV.platform_id ";

    3016. 

  3016. 		    $sqlFilter = "";

    3017. 

  3017.         }

    3018. 

  3018.         else

    3019. 

  3019.         {

    3020. 

  3020. 			$build_fields = " B.id AS build_id, B.name AS build_name, " .

    3021. 

  3021. 			                " B.release_date AS build_release_date, " .

    3022. 

  3022. 			                " B.closed_on_date AS build_closed_on_date,";

    3023. 

  3023.             $build_join = " JOIN {$this->tables['builds']} B ON  B.testplan_id=TPTCV.testplan_id " ;

    3024. 

  3024. 			$executions_join = " E.build_id=B.id AND E.tcversion_id=TPTCV.tcversion_id " .

    3025. 

  3025. 			                   " AND E.testplan_id = TPTCV.testplan_id " .

    3026. 

  3026. 			                   " AND E.platform_id = TPTCV.platform_id ";

    3027. 

  3027.         }

    3028. 

  3028. 

    3029. 

  3029. 		$sql = "/* {$debugMsg} */ ";

    3030. 

  3030. 		$sql .= "SELECT COALESCE(E.status,'" . $status_not_run . "') AS exec_status, " .

    3031. 

  3031. 		        $build_fields .

    3032. 

  3032. 		        " PLAT.name AS platform_name," . 

    3033. 

  3033. 		        " NODE_TCASE.parent_id AS testsuite_id, NODE_TCASE.name AS name, NODE_TCASE.id AS tc_id," .

    3034. 

  3034. 		        " NODE_TCASE.node_order," .

    3035. 

  3035. 		        " TPTCV.id AS feature_id, TPTCV.testplan_id, TPTCV.tcversion_id, " .

    3036. 

  3036. 		        " TPTCV.node_order AS exec_node_order, TPTCV.author_id AS linked_by," .

    3037. 

  3037. 		        " TPTCV.creation_ts AS link_creation_ts, TPTCV.platform_id, " . 

    3038. 

  3038. 			    " TCV.version AS version, TCV.active, TCV.summary, " .

    3039. 

  3039. 			    " TCV.tc_external_id AS external_id, TCV.execution_type," .

    3040. 

  3040. 				" COALESCE(UA.user_id,0) AS assigned_to, " .

    3041. 

  3041. 				" (urgency * importance) AS priority " .

    3042. 

  3042. 				" FROM {$this->tables['testplan_tcversions']} TPTCV " .

    3043. 

  3043. 				$build_join .

    3044. 

  3044. 				" /* get test case version info */ " .

    3045. 

  3045. 				" JOIN {$this->tables['tcversions']} TCV ON TCV.id=TPTCV.tcversion_id " .

    3046. 

  3046. 				" /* get test case name */ " .

    3047. 

  3047. 				" JOIN {$this->tables['nodes_hierarchy']} NODE_TCV ON NODE_TCV.id=TPTCV.tcversion_id " .

    3048. 

  3048. 				" JOIN {$this->tables['nodes_hierarchy']} NODE_TCASE ON NODE_TCASE.id=NODE_TCV.parent_id " .

    3049. 

  3049. 				" /* get platform name */ " .

    3050. 

  3050. 				" LEFT OUTER JOIN {$this->tables['platforms']} PLAT ON " .

    3051. 

  3051. 				" PLAT.id=TPTCV.platform_id " .

    3052. 

  3052. 				" /* get assigned user id */ " .

    3053. 

  3053. 				" LEFT OUTER JOIN {$this->tables['user_assignments']} UA ON UA.feature_id = TPTCV.id " .

    3054. 

  3054. 				" LEFT OUTER JOIN {$this->tables['executions']} E ON " .

    3055. 

  3055. 				$executions_join .

    3056. 

  3056. 				" WHERE TPTCV.testplan_id={$id} {$sqlFilter} AND E.status IS NULL " .

    3057. 

  3057. 				" ORDER BY testsuite_id, node_order";

    3058. 

  3058. 

    3059. 

  3059.         $result = $this->db->get_recordset($sql);

    3060. 

  3060.  		return $result;

    3061. 

  3061. 	}

    3062. 

  3062. 

    3063. 

  3063.     /**

    3064. 

  3064.      *

    3065. 

  3065. 	 * @param tplan_id: test plan id

    3066. 

  3066. 	 * @return map: 

    3067. 

  3067. 	 *

    3068. 

  3068. 	 * @internal revisions

    3069. 

  3069. 	 * 20100610 - eloff - BUGID 3515 - take platforms into account

    3070. 

  3070.  	 */

    3071. 

  3071. 	public function getStatusTotals($tplan_id)

    3072. 

  3072. 	{

    3073. 

  3073. 		$code_verbose = $this->getStatusForReports();

    3074. 

  3074. 	

    3075. 

  3075. 		$filters=null;

    3076. 

  3076. 		$options=array('output' => 'mapOfMap');

    3077. 

  3077. 		$execResults = $this->get_linked_tcversions($tplan_id,$filters,$options);

    3078. 

  3078. 	

    3079. 

  3079. 		$totals = array('total' => 0,'not_run' => 0);

    3080. 

  3080. 		foreach($code_verbose as $status_code => $status_verbose)

    3081. 

  3081. 		{

    3082. 

  3082. 			$totals[$status_verbose]=0;

    3083. 

  3083. 		}

    3084. 

  3084. 		foreach($execResults as $key => $testcases)

    3085. 

  3085. 		{

    3086. 

  3086. 			foreach($testcases as $testcase)

    3087. 

  3087. 			{

    3088. 

  3088. 				$totals['total']++;

    3089. 

  3089. 				$totals[$code_verbose[$testcase['exec_status']]]++;

    3090. 

  3090. 			}

    3091. 

  3091. 		}

    3092. 

  3092. 		return $totals;

    3093. 

  3093. 	}

    3094. 

  3094. 

    3095. 

  3095. 

    3096. 

  3096.     /**

    3097. 

  3097. 	 * DocBlock with nested lists

    3098. 

  3098.  	 *

    3099. 

  3099.  	 */

    3100. 

  3100. 	public function getStatusForReports()

    3101. 

  3101. 	{

    3102. 

  3102. 		// This will be used to create dynamically counters if user add new status

    3103. 

  3103. 		$resultsCfg = config_get('results');

    3104. 

  3104. 		foreach( $resultsCfg['status_label_for_exec_ui'] as $tc_status_verbose => $label)

    3105. 

  3105. 		{

    3106. 

  3106. 			$code_verbose[$resultsCfg['status_code'][$tc_status_verbose]] = $tc_status_verbose;

    3107. 

  3107. 		}

    3108. 

  3108. 		if( !isset($resultsCfg['status_label_for_exec_ui']['not_run']) )

    3109. 

  3109. 		{

    3110. 

  3110. 			$code_verbose[$resultsCfg['status_code']['not_run']] = 'not_run';

    3111. 

  3111. 		}

    3112. 

  3112. 		return $code_verbose;

    3113. 

  3113. 	}

    3114. 

  3114. 

    3115. 

  3115.     /**

    3116. 

  3116.      *

    3117. 

  3117. 	 * @param tplan_id: test plan id

    3118. 

  3118. 	 * @return map:

    3119. 

  3119. 	 *

    3120. 

  3120. 	 *	'type' => 'platform'

    3121. 

  3121. 	 *	'total_tc => ZZ

    3122. 

  3122. 	 *	'details' => array ( 'passed' => array( 'qty' => X)

    3123. 

  3123. 	 *	                     'failed' => array( 'qty' => Y)

    3124. 

  3124. 	 *	                     'blocked' => array( 'qty' => U)

    3125. 

  3125. 	 *                       ....)

    3126. 

  3126. 	 *

    3127. 

  3127. 	 * @internal revision

    3128. 

  3128. 	 * 20100610 - eloff - BUGID 3515 - rewrite inspired by getStatusTotals()

    3129. 

  3129. 	 * 20100201 - franciscom - BUGID 3121

    3130. 

  3130. 	 */

    3131. 

  3131. 	public function getStatusTotalsByPlatform($tplan_id)

    3132. 

  3132. 	{

    3133. 

  3133. 		$code_verbose = $this->getStatusForReports();

    3134. 

  3134. 

    3135. 

  3135. 		$filters=null;

    3136. 

  3136. 		$options=array('output' => 'mapOfMap');

    3137. 

  3137. 		$execResults = $this->get_linked_tcversions($tplan_id,$filters,$options);

    3138. 

  3138. 

    3139. 

  3139. 		$code_verbose = $this->getStatusForReports();

    3140. 

  3140. 		$platformSet = $this->getPlatforms($tplan_id, array('outputFormat' => 'map'));

    3141. 

  3141. 		$totals = null;

    3142. 

  3142. 		$platformIDSet = is_null($platformSet) ? array(0) : array_keys($platformSet);

    3143. 

  3143. 

    3144. 

  3144. 		foreach($platformIDSet as $platformID)

    3145. 

  3145. 		{

    3146. 

  3146. 			$totals[$platformID]=array(

    3147. 

  3147. 				'type' => 'platform',

    3148. 

  3148. 				'name' => $platformSet[$platformID],

    3149. 

  3149. 				'total_tc' => 0,

    3150. 

  3150. 				'details' => array());

    3151. 

  3151. 			foreach($code_verbose as $status_code => $status_verbose)

    3152. 

  3152. 			{

    3153. 

  3153. 				$totals[$platformID]['details'][$status_verbose]['qty'] = 0;

    3154. 

  3154. 			}

    3155. 

  3155. 		}

    3156. 

  3156. 		foreach($execResults as $key => $testcases)

    3157. 

  3157. 		{

    3158. 

  3158. 			foreach($testcases as $platform_id => $testcase)

    3159. 

  3159. 			{

    3160. 

  3160. 				$totals[$platform_id]['total_tc']++;

    3161. 

  3161. 				$totals[$platform_id]['details'][$code_verbose[$testcase['exec_status']]]['qty']++;

    3162. 

  3162. 			}

    3163. 

  3163. 		}

    3164. 

  3164. 		return $totals;

    3165. 

  3165. 	}

    3166. 

  3166. 

    3167. 

  3167. 	/**

    3168. 

  3168. 	 * @param int $tplan_id test plan id

    3169. 

  3169. 	 * @return map:

    3170. 

  3170. 	 *	'type' => 'priority'

    3171. 

  3171. 	 *	'total_tc => ZZ

    3172. 

  3172. 	 *	'details' => array ( 'passed' => array( 'qty' => X)

    3173. 

  3173. 	 *	                     'failed' => array( 'qty' => Y)

    3174. 

  3174. 	 *	                     'blocked' => array( 'qty' => U)

    3175. 

  3175. 	 *	                      ....)

    3176. 

  3176. 	 *

    3177. 

  3177. 	 * @internal revision

    3178. 

  3178. 	 * 20100614 - eloff - refactor to same style as the other getStatusTotals...()

    3179. 

  3179. 	 * 20100206 - eloff - BUGID 3060

    3180. 

  3180. 	 */

    3181. 

  3181. 	public function getStatusTotalsByPriority($tplan_id)

    3182. 

  3182. 	{

    3183. 

  3183. 		$code_verbose = $this->getStatusForReports();

    3184. 

  3184. 		$urgencyCfg = config_get('urgency');

    3185. 

  3185. 		$prioSet = array(

    3186. 

  3186. 			HIGH => lang_get($urgencyCfg['code_label'][HIGH]),

    3187. 

  3187. 			MEDIUM => lang_get($urgencyCfg['code_label'][MEDIUM]),

    3188. 

  3188. 			LOW => lang_get($urgencyCfg['code_label'][LOW]));

    3189. 

  3189. 		$totals = array();

    3190. 

  3190. 

    3191. 

  3191. 		foreach($prioSet as $prioCode => $prioLabel)

    3192. 

  3192. 		{

    3193. 

  3193. 			$totals[$prioCode]=array('type' => 'priority',

    3194. 

  3194. 				'name' => $prioLabel,

    3195. 

  3195. 				'total_tc' => 0,

    3196. 

  3196. 				'details' => null);

    3197. 

  3197. 			foreach($code_verbose as $status_code => $status_verbose)

    3198. 

  3198. 			{

    3199. 

  3199. 				$totals[$prioCode]['details'][$status_verbose]['qty']=0;

    3200. 

  3200. 			}

    3201. 

  3201. 		}

    3202. 

  3202. 		$filters = null;

    3203. 

  3203. 		$options=array('output' => 'mapOfMap');

    3204. 

  3204. 		$execResults = $this->get_linked_tcversions($tplan_id,$filters,$options);

    3205. 

  3205. 

    3206. 

  3206. 		foreach($execResults as $testcases)

    3207. 

  3207. 		{

    3208. 

  3208. 			foreach($testcases as $testcase)

    3209. 

  3209. 			{

    3210. 

  3210. 				$prio_level = $this->urgencyImportanceToPriorityLevel($testcase['priority']);

    3211. 

  3211. 				$totals[$prio_level]['total_tc']++;

    3212. 

  3212. 				$totals[$prio_level]['details'][$code_verbose[$testcase['exec_status']]]['qty']++;

    3213. 

  3213. 			}

    3214. 

  3214. 		}

    3215. 

  3215. 		return $totals;

    3216. 

  3216. 	}

    3217. 

  3217. 

    3218. 

  3218. 	/**

    3219. 

  3219. 	 * get last execution status analised by keyword, used to build reports.

    3220. 

  3220. 	 *

    3221. 

  3221. 	 * @param tplan_id: test plan id

    3222. 

  3222. 	 * @return map: key: keyword id

    3223. 

  3223. 	 *              value: map with following structure

    3224. 

  3224. 	 *

    3225. 

  3225. 	 *

    3226. 

  3226.  	 */

    3227. 

  3227. 	public function getStatusTotalsByKeyword($tplan_id)

    3228. 

  3228. 	{

    3229. 

  3229. 		$code_verbose = $this->getStatusForReports();

    3230. 

  3230. 		$totals = null;

    3231. 

  3231. 		$filters=null;

    3232. 

  3232. 		$options=array('output' => 'map');

    3233. 

  3233. 		$execResults = $this->get_linked_tcversions($tplan_id,$filters,$options);

    3234. 

  3234. 

    3235. 

  3235. 		if( !is_null($execResults) )

    3236. 

  3236. 		{

    3237. 

  3237. 			$tcaseSet = array_keys($execResults);

    3238. 

  3238. 			$kw=$this->tcase_mgr->getKeywords($tcaseSet,null,'keyword_id',' ORDER BY keyword ASC ');

    3239. 

  3239. 			if( !is_null($kw) )

    3240. 

  3240. 			{

    3241. 

  3241. 				$keywordSet = array_keys($kw);

    3242. 

  3242. 				foreach($keywordSet as $keywordID)

    3243. 

  3243. 				{

    3244. 

  3244. 					$totals[$keywordID]['type'] = 'keyword';

    3245. 

  3245. 					$totals[$keywordID]['name']=$kw[$keywordID][0]['keyword'];

    3246. 

  3246. 					$totals[$keywordID]['notes']=$kw[$keywordID][0]['notes'];

    3247. 

  3247. 					$totals[$keywordID]['total_tc'] = 0;

    3248. 

  3248. 					foreach($code_verbose as $status_code => $status_verbose)

    3249. 

  3249. 					{

    3250. 

  3250. 						$totals[$keywordID]['details'][$status_verbose]['qty']=0;

    3251. 

  3251. 					}

    3252. 

  3252. 				}

    3253. 

  3253. 

    3254. 

  3254. 				foreach($keywordSet as $keywordID)

    3255. 

  3255. 				{

    3256. 

  3256. 					foreach($kw[$keywordID] as $kw_tcase)

    3257. 

  3257. 					{

    3258. 

  3258. 						$status = $execResults[$kw_tcase['testcase_id']]['exec_status'];

    3259. 

  3259. 						$totals[$keywordID]['total_tc']++;

    3260. 

  3260. 						$totals[$keywordID]['details'][$code_verbose[$status]]['qty']++;

    3261. 

  3261. 					}

    3262. 

  3262. 				}

    3263. 

  3263. 			}

    3264. 

  3264. 		}

    3265. 

  3265. 

    3266. 

  3266. 		return $totals;

    3267. 

  3267. 	}

    3268. 

  3268. 

    3269. 

  3269.     /**

    3270. 

  3270.      * 

    3271. 

  3271. 	 * @param id: test plan id

    3272. 

  3272. 	 * @return map: 

    3273. 

  3273.  	 *             key: user id

    3274. 

  3274.  	 *             value: map with key=platform id

    3275. 

  3275.  	 *                             value: map with keys: 'total' and verbose status

    3276. 

  3276.  	 *                                             values: test case count.

    3277. 

  3277.  	 *                              

    3278. 

  3278.  	 */

    3279. 

  3279. 	public function getStatusTotalsByAssignedTesterPlatform($id)

    3280. 

  3280. 	{

    3281. 

  3281. 		$code_verbose = $this->getStatusForReports();

    3282. 

  3282. 		$filters = null;

    3283. 

  3283. 		$user_platform = null;

    3284. 

  3284. 		$options = array('output' => 'mapOfMap');

    3285. 

  3285.     	$execResults = $this->get_linked_tcversions($id,$filters,$options);

    3286. 

  3286.     	

    3287. 

  3287. 	    if( !is_null($execResults) )

    3288. 

  3288. 	    {

    3289. 

  3289. 	    	$tcaseSet = array_keys($execResults);

    3290. 

  3290.             foreach($tcaseSet as $tcaseID)

    3291. 

  3291.             {

    3292. 

  3292.             	$testcaseInfo=$execResults[$tcaseID];

    3293. 

  3293.             	$platformIDSet = array_keys($execResults[$tcaseID]);

    3294. 

  3294.             	foreach($platformIDSet as $platformID)

    3295. 

  3295.             	{

    3296. 

  3296.             		

    3297. 

  3297.             		$testedBy = $testcaseInfo[$platformID]['tester_id'];

    3298. 

  3298.             		$assignedTo = $testcaseInfo[$platformID]['user_id'];

    3299. 

  3299.             		$assignedTo = !is_null($assignedTo) && $assignedTo > 0 ? $assignedTo : TL_USER_NOBODY;

    3300. 

  3300.             		$execStatus = $testcaseInfo[$platformID]['exec_status'];

    3301. 

  3301. 					

    3302. 

  3302.             		// to avoid errors due to bad or missing config

    3303. 

  3303.             		$verboseStatus = isset($code_verbose[$execStatus]) ? $code_verbose[$execStatus] : $execStatus;

    3304. 

  3304.             		

    3305. 

  3305.             		// 20100425 - francisco.mancardi@gruppotesi.com

    3306. 

  3306.             		if( $assignedTo != TL_USER_NOBODY )

    3307. 

  3307.             		{

    3308. 

  3308.             			if( !isset($user_platform[$assignedTo][$platformID]) )

    3309. 

  3309.             			{

    3310. 

  3310.             				$user_platform[$assignedTo][$platformID]['total']=0;

    3311. 

  3311.             			}

    3312. 

  3312.             			

    3313. 

  3313.             			if( !isset($user_platform[$assignedTo][$platformID][$verboseStatus]) )

    3314. 

  3314.             			{

    3315. 

  3315.             				$user_platform[$assignedTo][$platformID][$verboseStatus]=0;

    3316. 

  3316.             			}

    3317. 

  3317.             		}   

    3318. 

  3318.             		

    3319. 

  3319.             		$testerBoy = is_null($testedBy) ? $assignedTo : $testedBy; 

    3320. 

  3320.             		if( !isset($user_platform[$testerBoy][$platformID]) )

    3321. 

  3321.             		{

    3322. 

  3322.             			$user_platform[$testerBoy][$platformID]['total']=0;

    3323. 

  3323.             		}

    3324. 

  3324.             		

    3325. 

  3325.             		if( !isset($user_platform[$testerBoy][$platformID][$verboseStatus]) )

    3326. 

  3326.             		{

    3327. 

  3327.             			$user_platform[$testerBoy][$platformID][$verboseStatus]=0;

    3328. 

  3328.             		}   

    3329. 

  3329.                     

    3330. 

  3330.             		$user_platform[$testerBoy][$platformID]['total']++;

    3331. 

  3331.             		$user_platform[$testerBoy][$platformID][$verboseStatus]++;

    3332. 

  3332.                    

    3333. 

  3333. 				}

    3334. 

  3334.             } 

    3335. 

  3335.         }

    3336. 

  3336.         return $user_platform;

    3337. 

  3337.     }

    3338. 

  3338. 

    3339. 

  3339.     /**

    3340. 

  3340.      * 

    3341. 

  3341. 	 * @param id: test plan id

    3342. 

  3342. 	 * @return map: 

    3343. 

  3343.  	 *             key: user id

    3344. 

  3344.  	 *             value: map with key=platform id

    3345. 

  3345.  	 *                             value: map with keys: 'total' and verbose status

    3346. 

  3346.  	 *                                             values: test case count.

    3347. 

  3347.  	 *                              

    3348. 

  3348.  	 */

    3349. 

  3349. 	public function getStatusTotalsByAssignedTester($id)

    3350. 

  3350. 	{

    3351. 

  3351. 		$unassigned = lang_get('unassigned');

    3352. 

  3352. 		$data_set = $this->getStatusTotalsByAssignedTesterPlatform($id);

    3353. 

  3353. 	    if( !is_null($data_set) )

    3354. 

  3354. 	    {

    3355. 

  3355. 			$code_verbose = $this->getStatusForReports();

    3356. 

  3356. 

    3357. 

  3357. 	    	$userSet = array_keys($data_set);

    3358. 

  3358. 	    	// need to find a better way (with less overhead and data movement) to do this

    3359. 

  3359.             $userCol=tlUser::getByIDs($this->db,$userSet,tlUser::TLOBJ_O_GET_DETAIL_MINIMUM);

    3360. 

  3360.             foreach($userSet as $assignedTo)

    3361. 

  3361.             {

    3362. 

  3362.             	$user_platform[$assignedTo]['type'] = 'assignedTester';

    3363. 

  3363.             	$user_platform[$assignedTo]['name'] = $unassigned; 

    3364. 

  3364.             	if( $assignedTo > 0 )

    3365. 

  3365.             	{

    3366. 

  3366.             		$user_platform[$assignedTo]['name'] = $userCol[$assignedTo]->getDisplayName();;

    3367. 

  3367.             	}

    3368. 

  3368.             	$user_platform[$assignedTo]['total_tc'] = 0;

    3369. 

  3369.             	

    3370. 

  3370.    				foreach($code_verbose as $status_code => $status_verbose)

    3371. 

  3371. 			    {

    3372. 

  3372. 					$user_platform[$assignedTo]['details'][$status_verbose]['qty']=0;

    3373. 

  3373. 			    }

    3374. 

  3374.             	

    3375. 

  3375.             	// this will be removed from final result

    3376. 

  3376.             	$user_platform[$assignedTo]['details']['total']['qty'] = 0;

    3377. 

  3377.             	

    3378. 

  3378.             	$platformIDSet = array_keys($data_set[$assignedTo]);

    3379. 

  3379.             	foreach($platformIDSet as $platformID)

    3380. 

  3380.             	{

    3381. 

  3381.             		foreach( $data_set[$assignedTo][$platformID] as $verboseStatus => $counter)

    3382. 

  3382.             		{

    3383. 

  3383.             			if( !isset($user_platform[$assignedTo]['details'][$verboseStatus]) )

    3384. 

  3384.             			{

    3385. 

  3385.             				$user_platform[$assignedTo]['details'][$verboseStatus]['qty']=0;

    3386. 

  3386.             			}   

    3387. 

  3387.             		    $user_platform[$assignedTo]['details'][$verboseStatus]['qty'] += $counter;

    3388. 

  3388.             		}

    3389. 

  3389. 				}

    3390. 

  3390. 				$user_platform[$assignedTo]['total_tc']=$user_platform[$assignedTo]['details']['total']['qty'];

    3391. 

  3391. 				unset($user_platform[$assignedTo]['details']['total']);

    3392. 

  3392.             } 

    3393. 

  3393.         }

    3394. 

  3394.         return $user_platform;

    3395. 

  3395.     }

    3396. 

  3396. 

    3397. 

  3397. 

    3398. 

  3398.     /**

    3399. 

  3399.      * 

    3400. 

  3400. 	 * @param id: test plan id

    3401. 

  3401. 	 * @return map: 

    3402. 

  3402.  	 */

    3403. 

  3403. 	public function getStatusByAssignedTesterPlatform($id)

    3404. 

  3404. 	{

    3405. 

  3405. 		$filters = null;

    3406. 

  3406. 		$info = null;

    3407. 

  3407. 		$options = array('output' => 'mapOfMap');

    3408. 

  3408.     	$execResults = $this->get_linked_tcversions($id,$filters,$options);

    3409. 

  3409. 	    if( !is_null($execResults) )

    3410. 

  3410. 	    {

    3411. 

  3411. 	    	$tcaseSet = array_keys($execResults);

    3412. 

  3412.             foreach($tcaseSet as $tcaseID)

    3413. 

  3413.             {

    3414. 

  3414.             	$testcaseInfo=$execResults[$tcaseID];

    3415. 

  3415.             	$platformIDSet = array_keys($execResults[$tcaseID]);

    3416. 

  3416.             	foreach($platformIDSet as $platformID)

    3417. 

  3417.             	{

    3418. 

  3418.             		$assignedTo = $testcaseInfo[$platformID]['user_id'];

    3419. 

  3419.             		$assignedTo = !is_null($assignedTo) && $assignedTo > 0 ? $assignedTo : TL_USER_NOBODY;   

    3420. 

  3420. 					$info[$assignedTo][$tcaseID][$platformID] = $testcaseInfo[$platformID]['exec_status'];

    3421. 

  3421. 				}

    3422. 

  3422.             } 

    3423. 

  3423.         }

    3424. 

  3424. 

    3425. 

  3425.         return $info;

    3426. 

  3426.     }

    3427. 

  3427. 

    3428. 

  3428. 	/**

    3429. 

  3429. 	 * 

    3430. 

  3430.  	 *

    3431. 

  3431.      */

    3432. 

  3432. 	function tallyResultsForReport($results)

    3433. 

  3433. 	{

    3434. 

  3434. 		if ($results == null)

    3435. 

  3435. 		{

    3436. 

  3436. 			return null;

    3437. 

  3437. 		}

    3438. 

  3438. 		$na_string = lang_get('not_aplicable');

    3439. 

  3439. 		$keySet = array_keys($results);

    3440. 

  3440. 		foreach($keySet as $keyID)

    3441. 

  3441. 		{

    3442. 

  3442. 			$results[$keyID]['percentage_completed'] = 0;

    3443. 

  3443. 			$totalCases = $results[$keyID]['total_tc'];

    3444. 

  3444. 			$target = &$results[$keyID]['details']; 

    3445. 

  3445. 			if ($totalCases != 0)

    3446. 

  3446. 			{

    3447. 

  3447. 				$results[$keyID]['percentage_completed'] = 

    3448. 

  3448. 						number_format((($totalCases - $target['not_run']['qty']) / $totalCases) * 100,2);

    3449. 

  3449. 						

    3450. 

  3450. 				foreach($target as $status_verbose => $qty)

    3451. 

  3451. 				{

    3452. 

  3452. 					$target[$status_verbose]['percentage']=(($target[$status_verbose]['qty']) / $totalCases) * 100;

    3453. 

  3453. 					$target[$status_verbose]['percentage']=number_format($target[$status_verbose]['percentage'],2);

    3454. 

  3454. 				}

    3455. 

  3455. 			} else {

    3456. 

  3456. 				// 20100722 - asimon: if $target[$status_verbose]['percentage'] is not set,

    3457. 

  3457. 				// it causes warnings in the template later, so it has to be set here

    3458. 

  3458. 				// if $totalCases == 0 to avoid later undefined index warnings in the log

    3459. 

  3459. 				foreach($target as $status_verbose => $qty) {

    3460. 

  3460. 					$target[$status_verbose]['percentage'] = $na_string;

    3461. 

  3461. 				}

    3462. 

  3462. 			}

    3463. 

  3463. 		}

    3464. 

  3464. 		return $results;

    3465. 

  3465. 	} // end function

    3466. 

  3466. 

    3467. 

  3467. 

    3468. 

  3468. 	/**

    3469. 

  3469. 	 * getTestCaseSiblings()

    3470. 

  3470. 	 *

    3471. 

  3471. 	 * @internal revisions

    3472. 

  3472. 	 * 20100520 - franciscom - missed platform_id piece on join

    3473. 

  3473. 	 */

    3474. 

  3474. 	function getTestCaseSiblings($id,$tcversion_id,$platform_id)

    3475. 

  3475. 	{

    3476. 

  3476. 		$sql = 	" SELECT NHTSET.name as testcase_name,NHTSET.id AS testcase_id , NHTCVSET.id AS tcversion_id," .

    3477. 

  3477.         		" NHTC.parent_id AS testsuite_id, " .

    3478. 

  3478.         		" TPTCVX.id AS feature_id, TPTCVX.node_order " .

    3479. 

  3479. 				" from {$this->tables['testplan_tcversions']} TPTCVMAIN " .

    3480. 

  3480. 				" JOIN {$this->tables['nodes_hierarchy']} NHTCV ON NHTCV.id = TPTCVMAIN.tcversion_id " . 

    3481. 

  3481. 				" JOIN {$this->tables['nodes_hierarchy']} NHTC ON NHTC.id = NHTCV.parent_id " . 

    3482. 

  3482. 				" JOIN {$this->tables['nodes_hierarchy']} NHTSET ON NHTSET.parent_id = NHTC.parent_id " .

    3483. 

  3483. 				" JOIN {$this->tables['nodes_hierarchy']} NHTCVSET ON NHTCVSET.parent_id = NHTSET.id " .

    3484. 

  3484. 				" JOIN {$this->tables['testplan_tcversions']} TPTCVX " . 

    3485. 

  3485. 				" ON TPTCVX.tcversion_id = NHTCVSET.id " .

    3486. 

  3486. 				" AND TPTCVX.testplan_id = TPTCVMAIN.testplan_id " .

    3487. 

  3487. 				" AND TPTCVX.platform_id = TPTCVMAIN.platform_id " .

    3488. 

  3488. 				" WHERE TPTCVMAIN.testplan_id = {$id} AND TPTCVMAIN.tcversion_id = {$tcversion_id} " .

    3489. 

  3489. 				" AND TPTCVMAIN.platform_id = {$platform_id} " .

    3490. 

  3490. 				" ORDER BY node_order,testcase_name ";

    3491. 

  3491. 		$siblings = $this->db->fetchRowsIntoMap($sql,'tcversion_id');

    3492. 

  3492. 		return $siblings;

    3493. 

  3493. 	}

    3494. 

  3494. 

    3495. 

  3495. 

    3496. 

  3496. 	/**

    3497. 

  3497. 	 * getTestCaseNextSibling()

    3498. 

  3498. 	 *

    3499. 

  3499. 	 */

    3500. 

  3500. 	function getTestCaseNextSibling($id,$tcversion_id,$platform_id)

    3501. 

  3501. 	{

    3502. 

  3502. 		$sibling = null;

    3503. 

  3503.     	$brothers_and_sisters = $this->getTestCaseSiblings($id,$tcversion_id,$platform_id);

    3504. 

  3504.     	$tcversionSet = array_keys($brothers_and_sisters);

    3505. 

  3505.     	$elemQty = count($tcversionSet);

    3506. 

  3506.     	$dummy = array_flip($tcversionSet);

    3507. 

  3507.         $pos = $dummy[$tcversion_id]+1;

    3508. 

  3508.         $sibling_tcversion = $pos < $elemQty ? $tcversionSet[$pos] : 0;

    3509. 

  3509.         if( $sibling_tcversion > 0 )

    3510. 

  3510.         {

    3511. 

  3511.         	$sibling = array('tcase_id' => $brothers_and_sisters[$sibling_tcversion]['testcase_id'],

    3512. 

  3512.         	                 'tcversion_id' => $sibling_tcversion);

    3513. 

  3513.         }

    3514. 

  3514.         return $sibling;

    3515. 

  3515.     }

    3516. 

  3516. 

    3517. 

  3517.     /**

    3518. 

  3518.      * Convert a given urgency and importance to a priority level using

    3519. 

  3519.      * threshold values in $tlCfg->priority_levels.

    3520. 

  3520.      *

    3521. 

  3521.      * @param mixed $urgency Urgency of the testcase.

    3522. 

  3522.      *      If this is the only parameter given then interpret it as

    3523. 

  3523.      *      $urgency*$importance.

    3524. 

  3524.      * @param mixed $importance Importance of the testcase. (Optional)

    3525. 

  3525.      *

    3526. 

  3526.      * @return int HIGH, MEDIUM or LOW

    3527. 

  3527.      */

    3528. 

  3528.     public function urgencyImportanceToPriorityLevel($urgency, $importance=null)

    3529. 

  3529.     {

    3530. 

  3530.         static $priorityLevelsCfg;

    3531. 

  3531.         if ($priorityLevelsCfg == null) {

    3532. 

  3532.             $priorityLevelsCfg = config_get('priority_levels');

    3533. 

  3533.         }

    3534. 

  3534. 

    3535. 

  3535.         $urgencyImportance = intval($urgency) * (is_null($importance) ? 1 : intval($importance)) ;

    3536. 

  3536. 		

    3537. 

  3537.         $levels2check = array(HIGH,MEDIUM,LOW);  // order is important for algorithm

    3538. 

  3538. 		foreach($levels2check as $level)

    3539. 

  3539. 		{

    3540. 

  3540. 			if($urgencyImportance >= $priorityLevelsCfg[$level])

    3541. 

  3541. 			{

    3542. 

  3542. 				break;

    3543. 

  3543. 			}

    3544. 

  3544. 		}		

    3545. 

  3545.         return $level;

    3546. 

  3546.         

    3547. 

  3547.     }

    3548. 

  3548. 

    3549. 

  3549. 

    3550. 

  3550. 	// -------------------

    3551. 

  3551.     /**

    3552. 

  3552.      * 

    3553. 

  3553. 	 * @param id: test plan id

    3554. 

  3554. 	 * @return map: 

    3555. 

  3555.  	 *             key: user id

    3556. 

  3556.  	 *             value: map with key=platform id

    3557. 

  3557.  	 *                             value: map with keys: 'total' and verbose status

    3558. 

  3558.  	 *                                             values: test case count.

    3559. 

  3559.  	 *                              

    3560. 

  3560.  	 */

    3561. 

  3561. 	public function getStatusTotalsByTesterPlatform($id)

    3562. 

  3562. 	{

    3563. 

  3563. 		$code_verbose = $this->getStatusForReports();

    3564. 

  3564. 		$filters = null;

    3565. 

  3565. 		$user_platform = null;

    3566. 

  3566. 		$options = array('output' => 'mapOfMap');

    3567. 

  3567.     	$execResults = $this->get_linked_tcversions($id,$filters,$options);

    3568. 

  3568.     	

    3569. 

  3569. 	    if( !is_null($execResults) )

    3570. 

  3570. 	    {

    3571. 

  3571. 	    	$tcaseSet = array_keys($execResults);

    3572. 

  3572.             foreach($tcaseSet as $tcaseID)

    3573. 

  3573.             {

    3574. 

  3574.             	$testcaseInfo=$execResults[$tcaseID];

    3575. 

  3575.             	$platformIDSet = array_keys($execResults[$tcaseID]);

    3576. 

  3576.             	foreach($platformIDSet as $platformID)

    3577. 

  3577.             	{

    3578. 

  3578.             		$testedBy = $testcaseInfo[$platformID]['tester_id'];

    3579. 

  3579.             		$testedBy = !is_null($testedBy) && $testedBy > 0 ? $testedBy : TL_USER_NOBODY;

    3580. 

  3580.             		$execStatus = $testcaseInfo[$platformID]['exec_status'];

    3581. 

  3581.             		

    3582. 

  3582.             		// to avoid errors due to bad or missing config

    3583. 

  3583.             		$verboseStatus = isset($code_verbose[$execStatus]) ? $code_verbose[$execStatus] : $execStatus;

    3584. 

  3584.             		

    3585. 

  3585.             		if( !isset($user_platform[$testedBy][$platformID]) )

    3586. 

  3586.             		{

    3587. 

  3587.             			$user_platform[$testedBy][$platformID]['total']=0;

    3588. 

  3588.             		}

    3589. 

  3589.             		

    3590. 

  3590.             		if( !isset($user_platform[$testedBy][$platformID][$verboseStatus]) )

    3591. 

  3591.             		{

    3592. 

  3592.             			$user_platform[$testedBy][$platformID][$verboseStatus]=0;

    3593. 

  3593.             		}   

    3594. 

  3594.             		$user_platform[$testedBy][$platformID]['total']++;

    3595. 

  3595.             		$user_platform[$testedBy][$platformID][$verboseStatus]++;

    3596. 

  3596. 				}

    3597. 

  3597.             } 

    3598. 

  3598.         }

    3599. 

  3599. 	    

    3600. 

  3600.         return $user_platform;

    3601. 

  3601.     }

    3602. 

  3602. 

    3603. 

  3603.     /**

    3604. 

  3604.      * 

    3605. 

  3605. 	 * @param id: test plan id

    3606. 

  3606. 	 * @return map: 

    3607. 

  3607.  	 *             key: user id

    3608. 

  3608.  	 *             value: map with key=platform id

    3609. 

  3609.  	 *                             value: map with keys: 'total' and verbose status

    3610. 

  3610.  	 *                                             values: test case count.

    3611. 

  3611.  	 *                              

    3612. 

  3612.  	 */

    3613. 

  3613. 	public function getStatusTotalsByTester($id)

    3614. 

  3614. 	{

    3615. 

  3615. 		$unassigned = lang_get('unassigned');

    3616. 

  3616. 		$data_set = $this->getStatusTotalsByAssignedTesterPlatform($id);

    3617. 

  3617. 	    if( !is_null($data_set) )

    3618. 

  3618. 	    {

    3619. 

  3619. 			$code_verbose = $this->getStatusForReports();

    3620. 

  3620. 

    3621. 

  3621. 	    	$userSet = array_keys($data_set);

    3622. 

  3622. 	    	// need to find a better way (with less overhead and data movement) to do this

    3623. 

  3623.             $userCol=tlUser::getByIDs($this->db,$userSet,tlUser::TLOBJ_O_GET_DETAIL_MINIMUM);

    3624. 

  3624.             foreach($userSet as $testedBy)

    3625. 

  3625.             {

    3626. 

  3626.             	$user_platform[$testedBy]['type'] = 'tester';

    3627. 

  3627.             	$user_platform[$testedBy]['name'] = $unassigned; 

    3628. 

  3628.             	if( $testedBy > 0 )

    3629. 

  3629.             	{

    3630. 

  3630.             		$user_platform[$testedBy]['name'] = $userCol[$testedBy]->getDisplayName();;

    3631. 

  3631.             	}

    3632. 

  3632.             	$user_platform[$testedBy]['total_tc'] = 0;

    3633. 

  3633.             	

    3634. 

  3634.    				foreach($code_verbose as $status_code => $status_verbose)

    3635. 

  3635. 			    {

    3636. 

  3636. 					$user_platform[$testedBy]['details'][$status_verbose]['qty']=0;

    3637. 

  3637. 			    }

    3638. 

  3638.             	

    3639. 

  3639.             	// this will be removed from final result

    3640. 

  3640.             	$user_platform[$testedBy]['details']['total']['qty'] = 0;

    3641. 

  3641.             	

    3642. 

  3642.             	$platformIDSet = array_keys($data_set[$assignedTo]);

    3643. 

  3643.             	foreach($platformIDSet as $platformID)

    3644. 

  3644.             	{

    3645. 

  3645.             		foreach( $data_set[$testedBy][$platformID] as $verboseStatus => $counter)

    3646. 

  3646.             		{

    3647. 

  3647.             			if( !isset($user_platform[$testedBy]['details'][$verboseStatus]) )

    3648. 

  3648.             			{

    3649. 

  3649.             				$user_platform[$testedBy]['details'][$verboseStatus]['qty']=0;

    3650. 

  3650.             			}   

    3651. 

  3651.             		    $user_platform[$testedBy]['details'][$verboseStatus]['qty'] += $counter;

    3652. 

  3652.             		}

    3653. 

  3653. 				}

    3654. 

  3654. 				$user_platform[$testedBy]['total_tc']=$user_platform[$testedBy]['details']['total']['qty'];

    3655. 

  3655. 				unset($user_platform[$testedBy]['details']['total']);

    3656. 

  3656.             } 

    3657. 

  3657.         }

    3658. 

  3658.         return $user_platform;

    3659. 

  3659.     }

    3660. 

  3660. 

    3661. 

  3661. 

    3662. 

  3662. 

    3663. 

  3663. 

    3664. 

  3664. } // end class testplan

    3665. 

  3665. 

    3666. 

  3666. 

    3667. 

  3667. // ######################################################################################

    3668. 

  3668. /** 

    3669. 

  3669.  * Build Manager Class 

    3670. 

  3670.  * @package TestLink

    3671. 

  3671.  **/

    3672. 

  3672. class build_mgr extends tlObject

    3673. 

  3673. {

    3674. 

  3674. 	/** @var database handler */

    3675. 

  3675. 	var $db;

    3676. 

  3676. 

    3677. 

  3677. 	/** 

    3678. 

  3678. 	 * class constructor 

    3679. 

  3679. 	 * 

    3680. 

  3680. 	 * @param resource &$db reference to database handler

    3681. 

  3681. 	 **/

    3682. 

  3682. 	function build_mgr(&$db)

    3683. 

  3683. 	{

    3684. 

  3684.    		parent::__construct();

    3685. 

  3685. 		$this->db = &$db;

    3686. 

  3686. 	}

    3687. 

  3687. 

    3688. 

  3688. 

    3689. 

  3689.   /*

    3690. 

  3690.     function: create

    3691. 

  3691. 

    3692. 

  3692.     args :

    3693. 

  3693.           $tplan_id

    3694. 

  3694.           $name

    3695. 

  3695.           $notes

    3696. 

  3696.           [$active]: default: 1

    3697. 

  3697.           [$open]: default: 1

    3698. 

  3698.           [release_date]: YYYY-MM-DD

    3699. 

  3699. 

    3700. 

  3700. 

    3701. 

  3701.     returns:

    3702. 

  3702. 

    3703. 

  3703.     rev :

    3704. 

  3704.   */

    3705. 

  3705. 	function create($tplan_id,$name,$notes = '',$active=1,$open=1,$release_date='')

    3706. 

  3706. 	{

    3707. 

  3707. 		$targetDate=trim($release_date);

    3708. 

  3708. 		$sql = " INSERT INTO {$this->tables['builds']} " .

    3709. 

  3709. 			" (testplan_id,name,notes,release_date,active,is_open,creation_ts) " .

    3710. 

  3710. 			" VALUES ('". $tplan_id . "','" .

    3711. 

  3711. 			$this->db->prepare_string($name) . "','" .

    3712. 

  3712. 			$this->db->prepare_string($notes) . "',";

    3713. 

  3713. 		if($targetDate == '')

    3714. 

  3714. 		{

    3715. 

  3715. 			$sql .= "NULL,";

    3716. 

  3716. 		}       

    3717. 

  3717. 		else

    3718. 

  3718. 		{

    3719. 

  3719. 			$sql .= "'" . $this->db->prepare_string($targetDate) . "',";

    3720. 

  3720. 		}

    3721. 

  3721. 		

    3722. 

  3722. 		

    3723. 

  3723. 		// Important: MySQL do not support default values on datetime columns that are functions

    3724. 

  3724. 		// that's why we are using db_now().

    3725. 

  3725. 		$sql .= "{$active},{$open},{$this->db->db_now()})"; 	                     

    3726. 

  3726. 		

    3727. 

  3727. 		

    3728. 

  3728. 		$new_build_id = 0;

    3729. 

  3729. 		$result = $this->db->exec_query($sql);

    3730. 

  3730. 		if ($result)

    3731. 

  3731. 		{

    3732. 

  3732. 			$new_build_id = $this->db->insert_id($this->tables['builds']);

    3733. 

  3733. 		}

    3734. 

  3734. 		

    3735. 

  3735. 		return $new_build_id;

    3736. 

  3736. 	}

    3737. 

  3737. 

    3738. 

  3738. 

    3739. 

  3739.   /*

    3740. 

  3740.     function: update

    3741. 

  3741. 

    3742. 

  3742.     args :

    3743. 

  3743.           $id

    3744. 

  3744.           $name

    3745. 

  3745.           $notes

    3746. 

  3746.           [$active]: default: null

    3747. 

  3747.           [$open]: default: null

    3748. 

  3748.           [$release_date]=''    FORMAT YYYY-MM-DD

    3749. 

  3749.           [$closed_on_date]=''  FORMAT YYYY-MM-DD

    3750. 

  3750. 

    3751. 

  3751.     returns:

    3752. 

  3752. 

    3753. 

  3753.     rev :

    3754. 

  3754.   */

    3755. 

  3755. 	function update($id,$name,$notes,$active=null,$open=null,$release_date='',$closed_on_date='')

    3756. 

  3756. 	{

    3757. 

  3757. 		$closure_date = '';

    3758. 

  3758. 		$targetDate=trim($release_date);

    3759. 

  3759. 		$sql = " UPDATE {$this->tables['builds']} " .

    3760. 

  3760. 			" SET name='" . $this->db->prepare_string($name) . "'," .

    3761. 

  3761. 			"     notes='" . $this->db->prepare_string($notes) . "'";

    3762. 

  3762. 		

    3763. 

  3763. 		if($targetDate == '')

    3764. 

  3764. 		{

    3765. 

  3765. 			$sql .= ",release_date=NULL";

    3766. 

  3766. 		}       

    3767. 

  3767. 		else

    3768. 

  3768. 		{

    3769. 

  3769. 			$sql .= ",release_date='" . $this->db->prepare_string($targetDate) . "'";

    3770. 

  3770. 		}

    3771. 

  3771. 		if( !is_null($active) )

    3772. 

  3772. 		{

    3773. 

  3773. 			$sql .=" , active=" . intval($active);

    3774. 

  3774. 		}

    3775. 

  3775. 		

    3776. 

  3776. 		if( !is_null($open) )

    3777. 

  3777. 		{

    3778. 

  3778. 			$open_status=intval($open) ? 1 : 0; 

    3779. 

  3779. 			$sql .=" , is_open=" . $open_status;

    3780. 

  3780. 			

    3781. 

  3781. 			if($open_status == 1)

    3782. 

  3782. 			{

    3783. 

  3783. 				$closure_date = ''; 

    3784. 

  3784. 			}

    3785. 

  3785. 		}

    3786. 

  3786. 		

    3787. 

  3787. 		if($closure_date == '')

    3788. 

  3788. 		{

    3789. 

  3789. 			$sql .= ",closed_on_date=NULL";

    3790. 

  3790. 		}       

    3791. 

  3791. 		else

    3792. 

  3792. 		{

    3793. 

  3793. 			// may be will be useful validate date format

    3794. 

  3794. 			$sql .= ",closed_on_date='" . $this->db->prepare_string($closure_date) . "'";

    3795. 

  3795. 		}

    3796. 

  3796. 		

    3797. 

  3797. 		$sql .= " WHERE id={$id}";

    3798. 

  3798. 		$result = $this->db->exec_query($sql);

    3799. 

  3799. 		return $result ? 1 : 0;

    3800. 

  3800. 	}

    3801. 

  3801. 

    3802. 

  3802. 	/**

    3803. 

  3803. 	 * Delete a build

    3804. 

  3804. 	 * 

    3805. 

  3805. 	 * @param integer $id

    3806. 

  3806. 	 * @return integer status code

    3807. 

  3807. 	 * 

    3808. 

  3808. 	 * @internal revisions:

    3809. 

  3809. 	 *  20100716 - asimon - BUGID 3406: delete user assignments with build

    3810. 

  3810. 	 */

    3811. 

  3811. 	function delete($id)

    3812. 

  3812. 	{

    3813. 

  3813. 		// 20090611 - franciscom

    3814. 

  3814. 		// Need to be fixed, because execution bugs are not delete

    3815. 

  3815. 		

    3816. 

  3816. 		$sql = " DELETE FROM {$this->tables['executions']}  " .

    3817. 

  3817. 			" WHERE build_id={$id}";

    3818. 

  3818. 		

    3819. 

  3819. 		$result=$this->db->exec_query($sql);

    3820. 

  3820. 		

    3821. 

  3821. 		// 3406 - delete user assignments with build

    3822. 

  3822. 		$sql = " DELETE FROM {$this->tables['user_assignments']}  " .

    3823. 

  3823. 			" WHERE build_id={$id}";		

    3824. 

  3824. 		$result=$this->db->exec_query($sql);

    3825. 

  3825. 		

    3826. 

  3826. 		$sql = " DELETE FROM {$this->tables['builds']} " .

    3827. 

  3827. 			" WHERE id={$id}";

    3828. 

  3828. 		

    3829. 

  3829. 		$result=$this->db->exec_query($sql);

    3830. 

  3830. 		return $result ? 1 : 0;

    3831. 

  3831. 	}

    3832. 

  3832. 

    3833. 

  3833. 

    3834. 

  3834.   /*

    3835. 

  3835.     function: get_by_id

    3836. 

  3836.               get information about a build

    3837. 

  3837. 

    3838. 

  3838.     args : id: build id

    3839. 

  3839. 

    3840. 

  3840.     returns: map with following keys

    3841. 

  3841.              id: build id

    3842. 

  3842.              name: build name

    3843. 

  3843.              notes: build notes

    3844. 

  3844.              active: build active status

    3845. 

  3845.              is_open: build open status

    3846. 

  3846.              testplan_id

    3847. 

  3847. 

    3848. 

  3848.     rev :

    3849. 

  3849.   */

    3850. 

  3850. 	function get_by_id($id)

    3851. 

  3851. 	{

    3852. 

  3852. 		$sql = "SELECT * FROM {$this->tables['builds']} WHERE id = {$id}";

    3853. 

  3853. 		$result = $this->db->exec_query($sql);

    3854. 

  3854. 		$myrow = $this->db->fetch_array($result);

    3855. 

  3855. 		return $myrow;

    3856. 

  3856. 	}

    3857. 

  3857. 

    3858. 

  3858. 	/**

    3859. 

  3859. 	 * Set date of closing build

    3860. 

  3860. 	 * 

    3861. 

  3861. 	 * @param integer $id Build identifier

    3862. 

  3862. 	 * @param string $targetDate, format YYYY-MM-DD. can be null

    3863. 

  3863. 	 * 

    3864. 

  3864. 	 * @return TBD TBD

    3865. 

  3865. 	 */

    3866. 

  3866. 	function setClosedOnDate($id,$targetDate)

    3867. 

  3867. 	{

    3868. 

  3868. 		$sql = " UPDATE {$this->tables['builds']} ";

    3869. 

  3869. 		

    3870. 

  3870. 		if( is_null($targetDate) )

    3871. 

  3871. 		{

    3872. 

  3872. 			$sql .= " SET closed_on_date=NULL ";

    3873. 

  3873. 		}

    3874. 

  3874. 		else

    3875. 

  3875. 		{

    3876. 

  3876. 			$sql .= " SET closed_on_date='" . $this->db->prepare_string($targetDate) . "'";  	    

    3877. 

  3877. 		}

    3878. 

  3878. 		$sql .= " WHERE id={$id} "; 

    3879. 

  3879. 

    3880. 

  3880. 		$result = $this->db->exec_query($sql);

    3881. 

  3881. 	}

    3882. 

  3882. 

    3883. 

  3883. 

    3884. 

  3884. } // end class build_mgr

    3885. 

  3885. 

    3886. 

  3886. 

    3887. 

  3887. // ##################################################################################

    3888. 

  3888. /** 

    3889. 

  3889.  * Milestone Manager Class 

    3890. 

  3890.  * @package TestLink

    3891. 

  3891.  **/

    3892. 

  3892. class milestone_mgr extends tlObject

    3893. 

  3893. {

    3894. 

  3894. 	/** @var database handler */

    3895. 

  3895. 	var $db;

    3896. 

  3896. 

    3897. 

  3897. 	/** 

    3898. 

  3898. 	 * class constructor 

    3899. 

  3899. 	 * 

    3900. 

  3900. 	 * @param resource &$db reference to database handler

    3901. 

  3901. 	 **/

    3902. 

  3902. 	function milestone_mgr(&$db)

    3903. 

  3903. 	{

    3904. 

  3904.         parent::__construct();

    3905. 

  3905. 		$this->db = &$db;

    3906. 

  3906. 	}

    3907. 

  3907. 

    3908. 

  3908.   /*

    3909. 

  3909.     function: create()

    3910. 

  3910. 

    3911. 

  3911.     args :

    3912. 

  3912.             $tplan_id

    3913. 

  3913.             $name

    3914. 

  3914.             $target_date: string with format: 

    3915. 

  3915.             $start_date: 

    3916. 

  3916.             $low_priority: percentage

    3917. 

  3917.             $medium_priority: percentage

    3918. 

  3918.             $high_priority: percentage

    3919. 

  3919. 

    3920. 

  3920.     returns:

    3921. 

  3921. 

    3922. 

  3922.   */

    3923. 

  3923. 	function create($tplan_id,$name,$target_date,$start_date,$low_priority,$medium_priority,$high_priority)

    3924. 

  3924. 	{

    3925. 

  3925. 		$new_milestone_id=0;

    3926. 

  3926. 		$dateFields=null;

    3927. 

  3927. 		$dateValues=null;

    3928. 

  3928. 		$dateKeys=array('target_date','start_date');

    3929. 

  3929. 		

    3930. 

  3930. 		// check dates

    3931. 

  3931. 		foreach($dateKeys as $varname)

    3932. 

  3932. 		{

    3933. 

  3933. 			$value=	trim($$varname);

    3934. 

  3934. 			if($value != '') 

    3935. 

  3935. 			{

    3936. 

  3936. 				if (($time = strtotime($value)) == -1 || $time === false) 

    3937. 

  3937. 				{

    3938. 

  3938.                    die (__FUNCTION__ . ' Abort - Invalid date');

    3939. 

  3939.                 }

    3940. 

  3940. 				$dateFields[]=$varname;	

    3941. 

  3941. 		        $dateValues[]=" '{$this->db->prepare_string($value)}' ";

    3942. 

  3942. 			}

    3943. 

  3943. 		}

    3944. 

  3944. 		$additionalFields='';

    3945. 

  3945. 		if( !is_null($dateFields) )

    3946. 

  3946. 		{

    3947. 

  3947. 			$additionalFields= ',' . implode(',',$dateFields) ;

    3948. 

  3948. 			$additionalValues= ',' . implode(',',$dateValues) ;

    3949. 

  3949. 		}

    3950. 

  3950. 		$sql = "INSERT INTO {$this->tables['milestones']} " .

    3951. 

  3951. 		       " (testplan_id,name,a,b,c{$additionalFields}) " .

    3952. 

  3952. 			   " VALUES (" . $tplan_id . ",'{$this->db->prepare_string($name)}'," .

    3953. 

  3953. 			   $low_priority . "," .  $medium_priority . "," . $high_priority . 

    3954. 

  3954. 			   $additionalValues . ")";

    3955. 

  3955. 		$result = $this->db->exec_query($sql);

    3956. 

  3956. 		

    3957. 

  3957. 		if ($result)

    3958. 

  3958. 		{

    3959. 

  3959. 			$new_milestone_id = $this->db->insert_id($this->tables['milestones']);

    3960. 

  3960. 		}

    3961. 

  3961. 		

    3962. 

  3962. 		return $new_milestone_id;

    3963. 

  3963. 	}

    3964. 

  3964. 

    3965. 

  3965.   /*

    3966. 

  3966.     function: update

    3967. 

  3967. 

    3968. 

  3968.     args :

    3969. 

  3969.           $id

    3970. 

  3970.           $name

    3971. 

  3971.           $notes

    3972. 

  3972.           [$active]: default: 1

    3973. 

  3973.           [$open]: default: 1

    3974. 

  3974. 

    3975. 

  3975. 

    3976. 

  3976. 

    3977. 

  3977.     returns:

    3978. 

  3978. 

    3979. 

  3979.     rev :

    3980. 

  3980.   */

    3981. 

  3981. 	function update($id,$name,$target_date,$start_date,$low_priority,$medium_priority,$high_priority)

    3982. 

  3982. 	{

    3983. 

  3983. 		$sql = "UPDATE {$this->tables['milestones']} " . 

    3984. 

  3984. 		       " SET name='{$this->db->prepare_string($name)}', " .

    3985. 

  3985. 			   " target_date='{$this->db->prepare_string($target_date)}', " .

    3986. 

  3986. 			   " start_date='{$this->db->prepare_string($start_date)}', " .

    3987. 

  3987. 			   " a={$low_priority}, b={$medium_priority}, c={$high_priority} WHERE id={$id}";

    3988. 

  3988. 		$result = $this->db->exec_query($sql);

    3989. 

  3989. 		return $result ? 1 : 0;

    3990. 

  3990. 	}

    3991. 

  3991. 

    3992. 

  3992. 

    3993. 

  3993. 

    3994. 

  3994.   /*

    3995. 

  3995.     function: delete

    3996. 

  3996. 

    3997. 

  3997.     args :

    3998. 

  3998.           $id

    3999. 

  3999. 

    4000. 

  4000. 

    4001. 

  4001.     returns:

    4002. 

  4002. 

    4003. 

  4003.   */

    4004. 

  4004. 	function delete($id)

    4005. 

  4005. 	{

    4006. 

  4006. 		$sql = "DELETE FROM {$this->tables['milestones']} WHERE id={$id}";

    4007. 

  4007. 		$result=$this->db->exec_query($sql);

    4008. 

  4008. 		return $result ? 1 : 0;

    4009. 

  4009. 	}

    4010. 

  4010. 

    4011. 

  4011. 

    4012. 

  4012.   /*

    4013. 

  4013.     function: get_by_id

    4014. 

  4014. 

    4015. 

  4015.     args :

    4016. 

  4016.           $id

    4017. 

  4017.     returns:

    4018. 

  4018. 

    4019. 

  4019.     rev: 20090103 - franciscom - get test plan name.

    4020. 

  4020.   */

    4021. 

  4021. 	function get_by_id($id)

    4022. 

  4022. 	{

    4023. 

  4023. 		$sql=" SELECT M.id, M.name, M.a AS high_percentage, M.b AS medium_percentage, M.c AS low_percentage, " .

    4024. 

  4024. 			 " M.target_date, M.start_date, M.testplan_id, NH.name as testplan_name " .   

    4025. 

  4025. 			 " FROM {$this->tables['milestones']} M, {$this->tables['nodes_hierarchy']} NH " .

    4026. 

  4026. 			 " WHERE M.id = {$id} AND NH.id=M.testplan_id";

    4027. 

  4027. 		$myrow = $this->db->fetchRowsIntoMap($sql,'id');

    4028. 

  4028. 		return $myrow;

    4029. 

  4029. 	}

    4030. 

  4030. 

    4031. 

  4031. 	/**

    4032. 

  4032. 	 * check existence of milestone name in Test Plan

    4033. 

  4033. 	 * 

    4034. 

  4034. 	 * @param integer $tplan_id  test plan id.

    4035. 

  4035. 	 * @param string $milestone_name milestone name

    4036. 

  4036. 	 * @param integer $milestone_id default: null

    4037. 

  4037. 	 *                when is not null we add milestone_id as filter, this is useful

    4038. 

  4038. 	 *                to understand if is really a duplicate when using this method

    4039. 

  4039. 	 *                while managing update operations via GUI

    4040. 

  4040. 	 * 

    4041. 

  4041. 	 * @return integer 1 => name exists

    4042. 

  4042. 	 */

    4043. 

  4043. 	function check_name_existence($tplan_id,$milestone_name,$milestone_id=null,$case_sensitive=0)

    4044. 

  4044. 	{

    4045. 

  4045. 		$sql = " SELECT id, name FROM {$this->tables['milestones']} " .

    4046. 

  4046. 			   " WHERE testplan_id = {$tplan_id} ";

    4047. 

  4047. 		

    4048. 

  4048. 		if($case_sensitive)

    4049. 

  4049. 		{

    4050. 

  4050. 			$sql .= " AND name=";

    4051. 

  4051. 		}

    4052. 

  4052. 		else

    4053. 

  4053. 		{

    4054. 

  4054. 			$milestone_name=strtoupper($milestone_name);

    4055. 

  4055. 			$sql .= " AND UPPER(name)=";

    4056. 

  4056. 		}

    4057. 

  4057. 		$sql .= "'{$this->db->prepare_string($milestone_name)}'";

    4058. 

  4058. 		

    4059. 

  4059. 		if( !is_null($milestone_id) )

    4060. 

  4060. 		{

    4061. 

  4061. 			$sql .= " AND id <> " . $this->db->prepare_int($milestone_id);

    4062. 

  4062. 		}

    4063. 

  4063. 		

    4064. 

  4064. 		$result = $this->db->exec_query($sql);

    4065. 

  4065. 		$status= $this->db->num_rows($result) ? 1 : 0;

    4066. 

  4066. 		

    4067. 

  4067. 		return $status;

    4068. 

  4068. 	}

    4069. 

  4069. 

    4070. 

  4070. 

    4071. 

  4071.   /*

    4072. 

  4072.     function: get_all_by_testplan

    4073. 

  4073.               get info about all milestones defined for a testlan

    4074. 

  4074.     args :

    4075. 

  4075.           tplan_id

    4076. 

  4076. 

    4077. 

  4077. 

    4078. 

  4078.     returns:

    4079. 

  4079. 

    4080. 

  4080.     rev :

    4081. 

  4081.   */

    4082. 

  4082. 	function get_all_by_testplan($tplan_id)

    4083. 

  4083. 	{

    4084. 

  4084. 		$sql=" SELECT M.id, M.name, M.a AS high_percentage, M.b AS medium_percentage, M.c AS low_percentage, " .

    4085. 

  4085. 			 " M.target_date, M.start_date, M.testplan_id, NH.name as testplan_name " .   

    4086. 

  4086. 			 " FROM {$this->tables['milestones']} M, {$this->tables['nodes_hierarchy']} NH " .

    4087. 

  4087. 			 " WHERE testplan_id={$tplan_id} AND NH.id = testplan_id " .

    4088. 

  4088. 			 " ORDER BY M.target_date,M.name";

    4089. 

  4089. 		$rs=$this->db->get_recordset($sql);

    4090. 

  4090. 		return $rs;

    4091. 

  4091. 	}

    4092. 

  4092. 

    4093. 

  4093. 

    4094. 

  4094. } // end class milestone_mgr

    4095. 

  4095. ?>

    4096. 

  4096.