<?php
/*=====================================================================*\
|| ###################################################################
|| # Bugdar
|| # Copyright (c)2004-2009 Blue Static
|| #
|| # This program is free software; you can redistribute it and/or modify
|| # it under the terms of the GNU General Public License as published by
|| # the Free Software Foundation; version 2 of the License.
|| #
|| # This program is distributed in the hope that it will be useful, but
|| # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|| # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|| # more details.
|| #
|| # You should have received a copy of the GNU General Public License along
|| # with this program; if not, write to the Free Software Foundation, Inc.,
|| # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|| ###################################################################
\*=====================================================================*/

// ###################################################################
/**
* Constructs HTML code <select>s from an array. You use they keys when
* you need to access a multi-dimensional array of data.
*
* @access	public
*
* @param	string	HTML name of the select
* @param	array	Array of <option>s
* @param	integer	ID of the selected item, 0 for none
* @param	string	Name of the index where values are stored in the $array
* @param	string	Name of the iddex where the labels are stored in $array
* @param	bool	Value of the blank option, FALSE turns it off
* @param	bool	Construct a multiple-selection <select> menu and append "[]" to the end of the name
*
* @return	string	Constructed HTML output
*/
function construct_option_select($name, $array, $selected = 0, $valuekey = '', $labelkey = '', $includenil = false, $multiple = false)
{
	if ($multiple)
	{
		$selected = explode(',', $selected);
	}
	
	// if we're not working on a boolean false, we use it for the value (allows -1 and 0)
	if ($includenil !== false)
	{
		$opts[] = '<option value="' . $includenil . '"' . ((!$selected OR (is_array($selected) AND in_array($includenil, $selected))) ? ' selected="selected"' : '') . '> ---------</option>';
	}
	foreach ($array AS $value => $label)
	{
		$newval = ($valuekey ? $label["$valuekey"] : $value);
		$newlab = ($labelkey ? $label["$labelkey"] : $label);
		$opts[] = '<option value="' . $newval . '"' . (($selected == $newval OR (is_array($selected) AND in_array($newval, $selected))) ? ' selected="selected"' : '') . '>' . $newlab . '</option>';
	}
	return '<select class="input" id="' . $name . '" name="' . $name . ($multiple ? '[]' : '') . '"' . ($multiple ? ' multiple="multiple" size="' . (sizeof($array) < 8 ? sizeof($array) + 1 : 8) . '"' : '') . '>' . implode("\n\t", $opts) . "\r</select>";
}

/**
 * Constructs the user information link
 * 
 * @param	array	Userinfo array - requires userid, email, displayname, and showemail values
 * @param	bool	Return HTML or just a string?
 * @return	string
 */
function construct_user_display($userinfo, $html = true)
{
	if (!$userinfo['userid'])
	{
		$userinfo['displayname'] = T('Guest');
		$userinfo['showemail'] = false;
	}
	
	if ($html)
	{
		$tpl = new BSTemplate('username_display');
		$tpl->vars = array('userinfo' => $userinfo);
		$username = $tpl->evaluate()->getTemplate();
	}
	else
	{
		if ($userinfo['showemail'])
		{
			$username = sprintf(T('%1$s &lt;%2$s&gt;'), $userinfo['displayname'], $userinfo['email']);
		}
		else
		{
			$username = $userinfo['displayname'];
		}
	}
	
	return $username;
}

// ######################## Start can_perform ########################
// short-hand for bitwise &
function can_perform($bitmask, $productid = 0, $userinfo = null)
{
	// masks that aren't product-specific
	static $inspecific = array(
		'cansearch',
		'canbeassignedto',
		'canadminpanel',
		'canadminbugs',
		'canadminfields',
		'canadminversions',
		'canadminusers',
		'canadmingroups',
		'canadmintools'
	);
	
	if ($userinfo == null)
	{
		$userinfo =& bugdar::$userinfo;
	}
	
	$permissions =& bugdar::$datastore['permission'];
	
	if (!isset(bugdar::$permissions["$bitmask"]))
	{
		trigger_error('Invalid bitmask "' . $bitmask . '" specified for can_perform() [includes/functions.php]', E_USER_WARNING);
	}
	
	if (!$userinfo['permissions'])
	{
		$userinfo['permissions'] = FetchUserPermissions($userinfo);
	}
	
	if ($productid AND !in_array($bitmask, $inspecific))
	{
		$verdict = (isset($permissions["$userinfo[usergroupid]"]["$productid"]) ? ($permissions["$userinfo[usergroupid]"]["$productid"] & bugdar::$permissions["$bitmask"]) : ($userinfo['permissions'] & bugdar::$permissions["$bitmask"]));
		
		foreach ($userinfo['groupids'] AS $group)
		{
			if (isset($permissions["$group"]["$productid"]))
			{
				$verdict |= ($permissions["$group"]["$productid"] & bugdar::$permissions["$bitmask"]);
			}
		}
		BSApp::debug("verdict* on can_perform($bitmask, $productid, $userinfo[userid]) = $verdict");
		return $verdict;
	}
	
	BSApp::debug("verdict on can_perform($bitmask, $productid, $userinfo[userid]) = " . ($userinfo['permissions'] & bugdar::$permissions["$bitmask"]));
	return ($userinfo['permissions'] & bugdar::$permissions["$bitmask"]);
}

/**
 * Runs through a given datastore item and creates a series of <select>
 * options.
 *
 * @access	public
 *
 * @param	string	Datastore name
 * @param	string	Array index for the label
 * @param	string	Array index for the value
 * @param	mixed	The selected value(s)
 * @param	bool	Include a blank option? TRUE will set a null value, FALSE turns it off, anything else is used as the value for the blank option
 * @param	bool	Generate it using admin printers?
 *
 * @return	string	Unelss in admin mode, returns the constructed options
 */
function construct_datastore_select($datastore, $labelname, $valuename, $selectedvalue = 0, $includeblank = false, $adminmode = false)
{
	if ($adminmode)
	{
		global $admin;
	}
	
	$select = '';
	
	if ($includeblank === true OR $includeblank !== false)
	{
		$newval = ($inclueblank === true ? '' : $includeblank);
		if ($adminmode)
		{
			$admin->list_item('', '', ((!$selectedvalue OR (is_array($selectedvalue) AND in_array($newval, $selectedvalue))) ? true : false));
		}
		else
		{
			$tpl = new BSTemplate('selectoption');
			$tpl->vars = array(
				'label'		=> '',
				'value'		=> $newval,
				'selected'	=> (!$selectedvalue || (is_array($selectedvalue) && in_array($newval, $selectedvalue)))
			);
			$select .= $tpl->evaluate()->getTemplate();
		}
	}
	
	foreach (bugdar::$datastore["$datastore"] AS $item)
	{
		$label = $item["$labelname"];
		$value = $item["$valuename"];
		$selected = (($value == $selectedvalue OR (is_array($selectedvalue) AND in_array($value, $selectedvalue))) ? true : false);
		
		if ($adminmode)
		{
			$admin->list_item($label, $value, $selected);
		}
		else
		{
			$tpl = new BSTemplate('selectoption');
			$tpl->vars = array(
				'label'		=> $label,
				'value'		=> $value,
				'selected'	=> $selected
			);
			$select .= $tpl->evaluate()->getTemplate();
		}
	}
	
	if (!$adminmode)
	{
		return $select;
	}
}

// ################## Start construct_custom_fields ##################
function construct_custom_fields($bug = array(), $ignore21mask = false, $nodefault = false, $searchMode = false)
{
	static $fields;
	
	if (!is_array($fields))
	{
		$fields = array();
		$fields_fetch = BSApp::$db->query("
			SELECT bugfield.*, MAX(permission.mask) AS mask
			FROM " . TABLE_PREFIX . "bugfield AS bugfield
			LEFT JOIN " . TABLE_PREFIX . "bugfieldpermission AS permission
				ON (bugfield.fieldid = permission.fieldid)
			WHERE (permission.mask = 2 OR permission.mask = 1)
			AND permission.usergroupid IN (" . bugdar::$userinfo['usergroupid'] . (sizeof(bugdar::$userinfo['groupids']) != 0 ? ',' . implode(',', bugdar::$userinfo['groupids']) : '') . ")
			GROUP BY (bugfield.fieldid)
		");
		foreach ($fields_fetch as $field)
		{
			$fields["$field[fieldid]"] = $field;
		}
	}
	
	$fieldbits = array();
	
	foreach ($fields AS $field)
	{
		if ($nodefault)
		{
			$field['defaultvalue'] = '';
		}
		
		if (!is_null($bug["custom$field[fieldid]"]))
		{
			BSApp::debug("not null: $field[fieldid]");
			$value = $bug["custom$field[fieldid]"];
		}
		else
		{
			$value = $field['defaultvalue'];
		}
		
		if ($ignore21mask AND $field['mask'] != 0)
		{
			$field['mask'] = 2;
		}
		
		if ($field['mask'] == 2)
		{
			switch ($field['type'])
			{
				case 'input_text':
					$tpl = new BSTemplate('bugfield_input_text');
					$tpl->vars = array(
						'field'	=> $field,
						'value'	=> $value
					);
					$tempfield = $tpl->evaluate()->getTemplate();
				break;
				
				case 'input_checkbox':
					$tpl = new BSTemplate('bugfield_input_checkbox');
					$tpl->vars = array(
						'field'			=> $field,
						'searchMode'	=> $searchMode,
						'selected'		=> ($value ? ' checked="checked"' : '')
					);
					$tempfield = $tpl->evaluate()->getTemplate();
				break;
				
				case 'select_single':
					$selects = unserialize($field['selects']);
					$value = trim($value);
					$options = '';
					
					// this overrides $field['usedefault'] because required fields will no longer have
					// blank values as options
					// TODO document above comment in the ACP
					if (!$field['required'])
					{
						$tpl = new BSTemplate('bugfield_select_single_option');
						$tpl->vars = array(
							'id'		=> -1,
							'select'	=> '',
							'selected'	=> ((!$field['usedefault'] && !trim($value)) ? ' selected="selected"' : '')
						);
						$options = $tpl->evaluate()->getTemplate();
					}
					
					foreach ($selects as $id => $select)
					{
						$tpl = new BSTemplate('bugfield_select_single_option');
						$tpl->vars = array(
							'id'		=> $id,
							'select'	=> stripslashes(trim($select)),
							'selected'	=> (($select == $value || ($field['usedefault'] && $id == 0)) ? ' selected="selected"' : '')
						);
						$options .= $tpl->evaluate()->getTemplate();
					}
					
					$tpl = new BSTemplate('bugfield_select_single');
					$tpl->vars = array(
						'field'		=> $field,
						'options'	=> $options
					);
					$tempfield = $tpl->evaluate()->getTemplate();
				break;
			}
		}
		else
		{
			BSApp::debug('mask 1 processing');
			if (is_null($bug["custom$field[fieldid]"]))
			{
				BSApp::debug("is null: $field[fieldid]");
				if ($field['type'] == 'select_single')
				{
					if ($field['usedefault'])
					{
						$temp = unserialize($field['selects']);
						$value = trim($temp[0]);
					}
					else
					{
						$value = $bug["custom$field[fieldid]"];
					}
				}
				else
				{
					$value = $field['defaultvalue'];
				}
			}
			else
			{
				$value = $bug["custom$field[fieldid]"];
			}
					
			if ($field['type'] == 'input_checkbox')
			{
				$value = ($value ? 'True' : 'False');
			}
			$field['value'] = $value;
			
			$tpl = new BSTemplate('bugfield_static_text');
			$tpl->vars = array('field' => $field);
			$tempfield = $tpl->evaluate()->getTemplate();
		}
		$fieldbits[] = $tempfield;
	}
	
	return $fieldbits;
}

// ###################################################################
/**
* This takes the bug API object and input data and then sanitizes, verifies,
* and processes the data for custom fields. If there are any errors,
* they are passed to the message reporter.
*
* @param	object	A BugAPI object
* @param	object	MessageReporter object
* @param	bool	If there are errors, add them to an errorbox format? If not, then display-on-encounter
* @param	bool	Search mode: don't change certain fields when they're 0 or empty
*
* @return	mixed	NULL if an ID is passed, string if bugid is NULL
*/
function process_custom_fields(&$bugapi, &$msg, $errorbox = false, $searchMode = false)
{
	if (!$inputdata)
	{
		$inputdata = &BSApp::$input->in;
	}
	
	$fields = BSApp::$db->query("
		SELECT bugfield.*, MAX(permission.mask) AS mask
		FROM " . TABLE_PREFIX . "bugfield AS bugfield
		LEFT JOIN " . TABLE_PREFIX . "bugfieldpermission AS permission
			ON (bugfield.fieldid = permission.fieldid)
		WHERE permission.mask = 2
		AND permission.usergroupid IN (" . bugdar::$userinfo['usergroupid'] . (sizeof(bugdar::$userinfo['groupids']) != 0 ? ',' . implode(',', bugdar::$userinfo['groupids']) : '') . ")
		GROUP BY (bugfield.fieldid)
	");
	foreach ($fields as $field)
	{
		$fieldname = "custom$field[fieldid]";
		
		if ($field['type'] == 'input_checkbox')
		{
			if ($searchMode AND intval($inputdata["$fieldname"]) == 0)
			{
				continue;
			}
			$bugapi->set($fieldname, intval($inputdata["$fieldname"]));
			continue;
		}
		else if ($field['type'] == 'select_single')
		{
			$temp = unserialize($field['selects']);
			$inputdata[$fieldname] = $temp[intval($inputdata["$fieldname"])] . ''; // make it a string so isset() doesn't catch
		}
		
		// field data wasn't passed, so skip it
		if (!isset($inputdata["$fieldname"]))
		{
			continue;
		}
				
		if ($field['required'] AND empty($inputdata["$fieldname"]) AND !$searchMode)
		{
			$errorlist[] = sprintf(T('The field "%1$s" is a required.'), $field['name']);
			continue;
		}
		
		if (!empty($field['regexmatch']))
		{
			if (!preg_match('#' . str_replace('#', '\#', $field['regexmatch']) . '#si', $inputdata["$fieldname"]))
			{
				$errorlist[] = sprintf(T('%1$s does not match the specified format'), $field['name']);
				continue;
			}
		}
		
		if (isset($inputdata["$fieldname"]))
		{
			if ($field['type'] == 'input_text')
			{
				if (empty($inputdata["$fieldname"]) AND $searchMode)
				{
					continue;
				}
				$bugapi->set($fieldname, $inputdata["$fieldname"]);
			}
			else
			{
				if (empty($inputdata["$fieldname"]))
				{
					if (!$searchMode)
					{
						$bugapi->set($fieldname, '');
					}
					continue;
				}
				
				$bugapi->set($fieldname, trim($inputdata["$fieldname"]));
			}
		}
	}
	
	if ($errorlist)
	{
		if ($errorbox)
		{
			foreach ($errorlist AS $err)
			{
				$msg->addError($err);
			}
		}
		else
		{
			$msg->error($errorlist[0]);
		}
	}
}

// ####################### Start fetch_on_bits #######################
function fetch_on_bits($mask, $userinfo = null)
{
	if ($userinfo == null)
	{
		$userinfo =& bugdar::$userinfo;
	}
	
	$onbits = array();
	
	$usergroupid = $userinfo['usergroupid'];
	FetchUserPermissions($userinfo); // get the groups
	$groups = $userinfo['groupids'];
	$groups[] = $usergroupid;
	
	// product-inspecific work
	if (is_array(bugdar::$datastore['product']))
	{
		foreach ($groups AS $groupid)
		{
			// we only need to do this so long as there's no onbits array because this isn't product specific
			if (sizeof($onbits) == 0 AND bugdar::$datastore['usergroup']["$groupid"]['permissions'] & bugdar::$permissions["$mask"])
			{
				foreach (bugdar::$datastore['product'] AS $id => $product)
				{
					$onbits["$id"] = $id;
				}
			}
		}
	}
	
	// bits set explicitly by products
	$explicit = array();
	
	// product specific work
	foreach ($groups AS $groupid)
	{
		if (is_array(bugdar::$datastore['permission']["$groupid"]))
		{
			foreach (bugdar::$datastore['permission']["$groupid"] AS $productid => $bit)
			{
				if ($bit & bugdar::$permissions["$mask"])
				{
					$explicit["$productid"] = $productid;
					$onbits["$productid"] = $productid;
				}
				else
				{
					// only unset if the bit was set in the first place by blanket and not product-specific permissions
					// if it was set by product permissions then the highest level takes precedence
					if ($onbits["$productid"] AND !isset($explicit["$productid"]))
					{
						unset($onbits["$productid"]);
					}
				}
			}
		}
	}
	
	// SQL queries would become very unhappy if we didn't do this
	if (sizeof($onbits) < 1)
	{
		$onbits = array(0);
	}
	
	return implode(',', $onbits);
}

/**
 * Pre-parse hook for BSTemplate class. This merely substitutes help links
 * 
 * @param	string	Template
 * @return	string
 */
function isso_pre_parse_hook($template)
{
	$template = preg_replace('#\$help\[(.*)\]#', '<?php echo fetch_help_link("\1") ?>', $template);
	return $template;
}

/**
 * Returns the HTML used to generate a help link for a given topic
 * 
 * @param	string	Topic name
 * @return	string
 */
function fetch_help_link($topic)
{
	$tpl = new BSTemplate('help_link');
	$tpl->vars = array('topic' => $topic);
	
	if (isset(bugdar::$datastore['help']["$topic"]))
	{
		return $tpl->evaluate()->getTemplate();
	}
	else
	{
		if (BSApp::get_debug())
		{
			return "[[INVALID TOPIC: $topic]]";
		}
		// do we want this?
		else if (null == 1)
		{
			return $tpl->evaluate()->getTemplate();
		}
	}
}

// ###################################################################
/**
* Returns a user array of information that is specific to all visiting
* users (guests). This can then be passed to any function that requires
* user information.
*
* @access	public
*
* @return	array	User information array
*/
function fetch_guest_user()
{
	return array(
		'usergroupid' => 1,
		'groupids' => array(),
		'userid' => 0,
		'email' => '',
		'displayname' => '',
		'showcolors' => 1,
		'permissions' => bugdar::$datastore['usergroup'][1]['permissions'],
		'displaytitle' => bugdar::$datastore['usergroup'][1]['displaytitle'],
		'timezone' => bugdar::$options['defaulttimezone']
	);
}

// ###################################################################
/**
* Does an exhaustive permissions check on the bug. It checks for hidden
* bug status and ability to view hidden bugs. This normally was done
* at the top of each page, but it got so big, it was moved to a function.
*
* @access	public
*
* @param	array	Bug array
* @param	array	Alternate user array
*
* @return	bool	Does the user have permission
*/
function check_bug_permissions($bug, $userinfo = null)
{
	if ($userinfo == null)
	{
		$userinfo = bugdar::$userinfo;
	}
	
	BSApp::debug("checking permissions for $userinfo[userid] on bug $bug[bugid]");
	
	BSApp::debug('*** START VERBOSE CHECK ***');
	
	BSApp::debug('* !can_perform(canviewbugs, $bug[product], $userinfo) = ' . (int)(!can_perform('canviewbugs', $bug['product'], $userinfo)));
	BSApp::debug('* $bug[hidden] = ' . (int)$bug['hidden']);
	BSApp::debug('* $userinfo[userid] (' . $userinfo['userid'] . ') == $bug[userid] (' . $bug['userid'] . ') = ' . (int)($userinfo['userid'] == $bug['userid']));
	BSApp::debug('* can_perform(canviewownhidden, $bug[product], $userinfo) = ' . (int)(!!can_perform('canviewownhidden', $bug['product'], $userinfo)));
	BSApp::debug('* can_perform(canviewhidden, $bug[product], $userinfo) = ' . (int)(!!can_perform('canviewhidden', $bug['product'], $userinfo)));
	BSApp::debug('* !$bug[hidden] = ' . (int)(!$bug['hidden']));
	
	BSApp::debug('*** END PERMISSIONS CHECK ***');
	
	if
	(
		!can_perform('canviewbugs', $bug['product'], $userinfo)
			OR
		!(
			(
				$bug['hidden']
					AND
				(
					($userinfo['userid'] == $bug['userid'] AND can_perform('canviewownhidden', $bug['product'], $userinfo))
						OR
					can_perform('canviewhidden', $bug['product'], $userinfo)
				)
			)
				OR
			!$bug['hidden']
		)
	)
	{
		BSApp::debug('*** DONE WITH REAL CALLS ***');
		return false;
	}
	
	BSApp::debug('*** DONE WITH REAL CALLS ***');
	
	return true;
}

// ###################################################################
/**
* Takes an array of bug information and returns another array with
* information that is suitable for display as all the IDs have been
* replaced by their string equivalents
*
* @param	array	Unprocessed bug data
* @param	string	Color to display if the user has opted to not show status colours
*
* @param	array	Bug array with data fit for display
*/
function ProcessBugDataForDisplay($bug, $color = '')
{	
	$bug['hiddendisplay'] = ($bug['hidden'] AND (can_perform('canviewhidden', $bug['product']) OR (can_perform('canviewownhidden') AND $bug['userid'] == bugdar::$userinfo['userid'])));
	
	$bug['bgcolor'] = (bugdar::$userinfo['showcolors'] ? bugdar::$datastore['status']["$bug[status]"]['color'] : $color);
	$bug['product'] = bugdar::$datastore['product']["$bug[product]"]['title'];
	$bug['version'] = bugdar::$datastore['version']["$bug[version]"]['version'];
	$bug['component'] = bugdar::$datastore['component']["$bug[component]"]['title'];
	$bug['status'] = bugdar::$datastore['status']["$bug[status]"]['status'];
	$bug['resolution'] = bugdar::$datastore['resolution']["$bug[resolution]"]['resolution'];
	$bug['priority'] = bugdar::$datastore['priority']["$bug[priority]"]['priority'];
	$bug['severity'] = bugdar::$datastore['severity']["$bug[severity]"]['severity'];
	$bug['assignedto'] = ((empty($bug['assignedto']) OR !isset(bugdar::$datastore['assignto']["$bug[assignedto]"])) ? '' : construct_user_display(bugdar::$datastore['assignto']["$bug[assignedto]"]));
	
	$bug['lastposttime'] = ($bug['hiddendisplay'] ? $bug['hiddenlastposttime'] : $bug['lastposttime']);
	$bug['lastpost'] = ($bug['hiddendisplay'] ? $bug['hiddenlastpostbyname'] : $bug['lastpostbyname']);
	
	$bug['lastposttime'] = BSApp::$date->format(bugdar::$options['dateformat'], $bug['lastposttime']);
	
	return $bug;
}

// ###################################################################
/**
* Determines the correct permissions of the user. This is especially
* important for working with multiple-usergroup permission schemes.
* If a user is assigned to more than one usergroup, the highest level
* will always override (so a YES will always override a NO); this is
* because permissions are calculated with bitwise OR.
*
* @param	array	The user array with usergroups already exploded
*
* @return	integer	Permissions value
*/
function FetchUserPermissions(&$user)
{
	$perms = (int)bugdar::$datastore['usergroup']["$user[usergroupid]"]['permissions'];
	if (!is_array($user['groupids']))
	{
		$user['groupids'] = explode(',', bugdar::$userinfo['groupids']);
	}
	$user['groupids'] = BSFunctions::array_strip_empty($user['groupids']);
	
	foreach ($user['groupids'] AS $group)
	{
		$perms |= (int)bugdar::$datastore['usergroup']["$group"]['permissions'];
	}
	
	return $perms;
}

// ###################################################################
/**
* Fetches the path for an email template, given the name of the
* template and the locale to use
*
* @param	string	The template name
* @param	string	Language locale code
*
* @return	string	Template path
*/
function FetchEmailPath($name, $locale)
{
	return '../locale/' . $locale . '/emails/' . $name;
}

?>