# Mantis - a php based bugtracking system

# Copyright (C) 2000 - 2002  Kenzaburo Ito - kenito@300baud.org

# Copyright (C) 2002 - 2007  Mantis Team   - mantisbt-dev@lists.sourceforge.net

# Mantis 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, either version 2 of the License, or

# (at your option) any later version.

#

# Mantis 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 Mantis.  If not, see <http://www.gnu.org/licenses/>.

	#------------------------------

	#   $Revision: 2643 $

	#     $Author: al $    

	#       $Date: 2009-06-18 19:06:27 -0400 (Thu, 18 Jun 2009) $  

	#------------------------------

	$t_core_dir = dirname( __FILE__ ).DIRECTORY_SEPARATOR;

	require_once( $t_core_dir . 'history_api.php' );

	require_once( $t_core_dir . 'email_api.php' );

	require_once( $t_core_dir . 'bugnote_api.php' );

	require_once( $t_core_dir . 'file_api.php' );

	require_once( $t_core_dir . 'string_api.php' );

	require_once( $t_core_dir . 'sponsorship_api.php' );

	require_once( $t_core_dir . 'twitter_api.php' );

	require_once( $t_core_dir . 'tag_api.php' );

	# MASC RELATIONSHIP

	require_once( $t_core_dir.'relationship_api.php' );

	# MASC RELATIONSHIP

	### Bug API ###

	#===================================

	# Bug Data Structure Definition

	#===================================

	class BugData {

		var $project_id = null;

		var $reporter_id = 0;

		var $handler_id = 0;

		var $duplicate_id = 0;

		var $priority = NORMAL;

		var $severity = MINOR;

		var $reproducibility = 10;

		var $status = NEW_;

		var $resolution = OPEN;

		var $projection = 10;

		var $category = '';

		var $date_submitted = '';

		var $last_updated = '';

		var $eta = 10;

		var $os = '';

		var $os_build = '';

		var $platform = '';

		var $version = '';

		var $fixed_in_version = '';

		var $target_version = '';

		var $build = '';

		var $view_state = VS_PUBLIC;

		var $summary = '';

		var $sponsorship_total = 0;

		var $sticky = 0;

		# omitted:

		# var $bug_text_id

		var $profile_id;

		# extended info

		var $description = '';

		var $steps_to_reproduce = '';

		var $additional_information = '';

		#internal helper objects

		var $_stats = null;

	}

	#===================================

	# Caching

	#===================================

	#########################################

	# SECURITY NOTE: cache globals are initialized here to prevent them

	#   being spoofed if register_globals is turned on

	$g_cache_bug = array();

	$g_cache_bug_text = array();

	# --------------------

	# Cache an object as a bug.

	function bug_cache_database_result( $p_bug_datebase_result, $p_stats = null ) {

		global $g_cache_bug;

		if ( isset( $g_cache_bug[ $p_bug_datebase_result['id'] ] ) ) {

			return $g_cache_bug[ $p_bug_datebase_result['id'] ];

		}	

		if( !is_int( $p_bug_datebase_result['date_submitted'] ) )

			$p_bug_datebase_result['date_submitted']	= db_unixtimestamp( $p_bug_datebase_result['date_submitted']['date_submitted'] );

		if( !is_int( $p_bug_datebase_result['last_updated'] ) )

			$p_bug_datebase_result['last_updated']	= db_unixtimestamp( $p_bug_datebase_result['last_updated'] );

		$g_cache_bug[ $p_bug_datebase_result['id'] ] = $p_bug_datebase_result;

		if( !is_null( $p_stats ) ) {

			$g_cache_bug[ $p_bug_datebase_result['id'] ]['_stats'] = $p_stats;

		}

	}

	# --------------------

	# Cache a bug row if necessary and return the cached copy

	#  If the second parameter is true (default), trigger an error

	#  if the bug can't be found.  If the second parameter is

	#  false, return false if the bug can't be found.

	function bug_cache_row( $p_bug_id, $p_trigger_errors=true ) {

		global $g_cache_bug;

		if ( isset( $g_cache_bug[$p_bug_id] ) ) {

			return $g_cache_bug[$p_bug_id];

		}

		$c_bug_id		= db_prepare_int( $p_bug_id );

		$t_bug_table	= config_get( 'mantis_bug_table' );

		$query = "SELECT *

				  FROM $t_bug_table

				  WHERE id='$c_bug_id'";

		$result = db_query( $query );

		if ( 0 == db_num_rows( $result ) ) {

			$g_cache_bug[$c_bug_id] = false;

			if ( $p_trigger_errors ) {

				error_parameters( $p_bug_id );

				trigger_error( ERROR_BUG_NOT_FOUND, ERROR );

			} else {

				return false;

			}

		}

		$row = db_fetch_array( $result );

		$row['date_submitted']	= db_unixtimestamp( $row['date_submitted'] );

		$row['last_updated']	= db_unixtimestamp( $row['last_updated'] );

		$g_cache_bug[$c_bug_id] = $row;

		return $row;

	}

	# --------------------

	# Inject a bug into the bug cache

	function bug_add_to_cache( $p_bug_row ) {

		global $g_cache_bug;

		if ( !is_array( $p_bug_row ) )

			return false;

		$c_bug_id = db_prepare_int( $p_bug_row['id'] );

		$g_cache_bug[ $c_bug_id ] = $p_bug_row;

		return true;

	}

	# --------------------

	# Clear the bug cache (or just the given id if specified)

	function bug_clear_cache( $p_bug_id = null ) {

		global $g_cache_bug;

		if ( null === $p_bug_id ) {

			$g_cache_bug = array();

		} else {

			$c_bug_id = db_prepare_int( $p_bug_id );

			unset( $g_cache_bug[$c_bug_id] );

		}

		return true;

	}

	# --------------------

	# Cache a bug text row if necessary and return the cached copy

	#  If the second parameter is true (default), trigger an error

	#  if the bug text can't be found.  If the second parameter is

	#  false, return false if the bug text can't be found.

	function bug_text_cache_row( $p_bug_id, $p_trigger_errors=true ) {

		global $g_cache_bug_text;

		$c_bug_id			= db_prepare_int( $p_bug_id );

		$t_bug_table		= config_get( 'mantis_bug_table' );

		$t_bug_text_table	= config_get( 'mantis_bug_text_table' );

		if ( isset ( $g_cache_bug_text[$c_bug_id] ) ) {

			return $g_cache_bug_text[$c_bug_id];

		}

		$query = "SELECT bt.*

				  FROM $t_bug_text_table bt, $t_bug_table b

				  WHERE b.id='$c_bug_id' AND

				  		b.bug_text_id = bt.id";

		$result = db_query( $query );

		if ( 0 == db_num_rows( $result ) ) {

			$g_cache_bug_text[$c_bug_id] = false;

			if ( $p_trigger_errors ) {

				error_parameters( $p_bug_id );

				trigger_error( ERROR_BUG_NOT_FOUND, ERROR );

			} else {

				return false;

			}

		}

		$row = db_fetch_array( $result );

		$g_cache_bug_text[$c_bug_id] = $row;

		return $row;

	}

	# --------------------

	# Clear the bug text cache (or just the given id if specified)

	function bug_text_clear_cache( $p_bug_id = null ) {

		global $g_cache_bug_text;

		if ( null === $p_bug_id ) {

			$g_cache_bug_text = array();

		} else {

			$c_bug_id = db_prepare_int( $p_bug_id );

			unset( $g_cache_bug_text[$c_bug_id] );

		}

		return true;

	}

	#===================================

	# Boolean queries and ensures

	#===================================

	# --------------------

	# check to see if bug exists by id

	# return true if it does, false otherwise

	function bug_exists( $p_bug_id ) {

		if ( false == bug_cache_row( $p_bug_id, false ) ) {

			return false;

		} else {

			return true;

		}

	}

	# --------------------

	# check to see if bug exists by id

	# if it doesn't exist then error

	#  otherwise let execution continue undisturbed

	function bug_ensure_exists( $p_bug_id ) {

		if ( !bug_exists( $p_bug_id ) ) {

			error_parameters( $p_bug_id );

			trigger_error( ERROR_BUG_NOT_FOUND, ERROR );

		}

	}

	# --------------------

	# check if the given user is the reporter of the bug

	# return true if the user is the reporter, false otherwise

	function bug_is_user_reporter( $p_bug_id, $p_user_id ) {

		if ( bug_get_field( $p_bug_id, 'reporter_id' ) == $p_user_id ) {

			return true;

		} else {

			return false;

		}

	}

	# --------------------

	# check if the given user is the handler of the bug

	# return true if the user is the handler, false otherwise

	function bug_is_user_handler( $p_bug_id, $p_user_id ) {

		if ( bug_get_field( $p_bug_id, 'handler_id' ) == $p_user_id ) {

			return true;

		} else {

			return false;

		}

	}

	# --------------------

	# Check if the bug is readonly and shouldn't be modified

	# For a bug to be readonly the status has to be >= bug_readonly_status_threshold and

	# current user access level < update_readonly_bug_threshold.

	function bug_is_readonly( $p_bug_id ) {

		$t_status = bug_get_field( $p_bug_id, 'status' );

		if ( $t_status < config_get( 'bug_readonly_status_threshold' ) ) {

			return false;

		}

		if ( access_has_bug_level( config_get( 'update_readonly_bug_threshold' ), $p_bug_id ) ) {

			return false;

		}

		return true;

	}

	# --------------------

	# Check if the bug is resolved

	function bug_is_resolved( $p_bug_id ) {

		$t_status = bug_get_field( $p_bug_id, 'status' );

		return ( $t_status >= config_get( 'bug_resolved_status_threshold' ) );

	}

	# --------------------

	# Validate workflow state to see if bug can be moved to requested state

	function bug_check_workflow( $p_bug_status, $p_wanted_status ) {

		$t_status_enum_workflow = config_get( 'status_enum_workflow' );

		if ( count( $t_status_enum_workflow ) < 1) {

			# workflow not defined, use default enum

			return true;

		} else if ( $p_bug_status == $p_wanted_status ) {

			# no change in state, allow the transition

			return true;

		} else {

			# workflow defined - find allowed states

			$t_allowed_states = $t_status_enum_workflow[$p_bug_status];

			$t_arr = explode_enum_string( $t_allowed_states );

			$t_enum_count = count( $t_arr );

			for ( $i = 0; $i < $t_enum_count; $i++ ) {

				# check if wanted status is allowed

				$t_elem  = explode_enum_arr( $t_arr[$i] );

				if ( $p_wanted_status == $t_elem[0] ) {

					return true;

				}

			} # end for

		}

		return false;

	}

	#===================================

	# Creation / Deletion / Updating

	#===================================

	# --------------------

	# Create a new bug and return the bug id

	#

	function bug_create( $p_bug_data ) {

		$c_summary				= db_prepare_string( $p_bug_data->summary );

		$c_description			= db_prepare_string( $p_bug_data->description );

		$c_project_id			= db_prepare_int( $p_bug_data->project_id );

		$c_reporter_id			= db_prepare_int( $p_bug_data->reporter_id );

		$c_handler_id			= db_prepare_int( $p_bug_data->handler_id );

		$c_priority				= db_prepare_int( $p_bug_data->priority );

		$c_severity				= db_prepare_int( $p_bug_data->severity );

		$c_reproducibility		= db_prepare_int( $p_bug_data->reproducibility );

		$c_category				= db_prepare_string( $p_bug_data->category );

		$c_os					= db_prepare_string( $p_bug_data->os );

		$c_os_build				= db_prepare_string( $p_bug_data->os_build );

		$c_platform				= db_prepare_string( $p_bug_data->platform );

		$c_version				= db_prepare_string( $p_bug_data->version );

		$c_build				= db_prepare_string( $p_bug_data->build );

		$c_profile_id			= db_prepare_int( $p_bug_data->profile_id );

		$c_view_state			= db_prepare_int( $p_bug_data->view_state );

		$c_steps_to_reproduce	= db_prepare_string( $p_bug_data->steps_to_reproduce );

		$c_additional_info		= db_prepare_string( $p_bug_data->additional_information );

		$c_sponsorship_total 	= 0;

		$c_sticky 				= 0;

		# Summary cannot be blank

		if ( is_blank( $c_summary ) ) {

			error_parameters( lang_get( 'summary' ) );

			trigger_error( ERROR_EMPTY_FIELD, ERROR );

		}

		# Description cannot be blank

		if ( is_blank( $c_description ) ) {

			error_parameters( lang_get( 'description' ) );

			trigger_error( ERROR_EMPTY_FIELD, ERROR );

		}

		# If category is not specified and not defaulted + project has categories defined, then error.

		if ( is_blank( $c_category ) && ( category_get_count( $c_project_id ) > 0 ) ) {

			error_parameters( lang_get( 'category' ) );

			trigger_error( ERROR_EMPTY_FIELD, ERROR );

		}

		# Only set target_version if user has access to do so

		if ( access_has_project_level( config_get( 'roadmap_update_threshold' ) ) ) {

			$c_target_version	= db_prepare_string( $p_bug_data->target_version );

		} else { 

			$c_target_version	= '';

		}

		$t_bug_table				= config_get( 'mantis_bug_table' );

		$t_bug_text_table			= config_get( 'mantis_bug_text_table' );

		$t_project_category_table	= config_get( 'mantis_project_category_table' );

		# Insert text information

		$query = "INSERT INTO $t_bug_text_table

				    ( description, steps_to_reproduce, additional_information )

				  VALUES

				    ( '$c_description', '$c_steps_to_reproduce',

				      '$c_additional_info' )";

		db_query( $query );

		# Get the id of the text information we just inserted

		# NOTE: this is guarranteed to be the correct one.

		# The value LAST_INSERT_ID is stored on a per connection basis.

		$t_text_id = db_insert_id($t_bug_text_table);

		# check to see if we want to assign this right off

		$t_status = config_get( 'bug_submit_status' );

		# if not assigned, check if it should auto-assigned.

		if ( 0 == $c_handler_id ) {

			# if a default user is associated with the category and we know at this point

			# that that the bug was not assigned to somebody, then assign it automatically.

			$query = "SELECT user_id

					  FROM $t_project_category_table

					  WHERE project_id='$c_project_id' AND category='$c_category'";

			$result = db_query( $query );

			if ( db_num_rows( $result ) > 0 ) {

				$c_handler_id = $p_handler_id = db_result( $result );

			}

		}

		# Check if bug was pre-assigned or auto-assigned.

		if ( ( $c_handler_id != 0 ) && ( ON == config_get( 'auto_set_status_to_assigned' ) ) ) {

			$t_status = config_get( 'bug_assigned_status' );

		}

		# Insert the rest of the data

		$t_resolution = OPEN;

		$query = "INSERT INTO $t_bug_table

				    ( project_id,

				      reporter_id, handler_id,

				      duplicate_id, priority,

				      severity, reproducibility,

				      status, resolution,

				      projection, category,

				      date_submitted, last_updated,

				      eta, bug_text_id,

				      os, os_build,

				      platform, version,

				      build,

				      profile_id, summary, view_state, sponsorship_total, sticky, fixed_in_version,

				      target_version 

				    )

				  VALUES

				    ( '$c_project_id',

				      '$c_reporter_id', '$c_handler_id',

				      '0', '$c_priority',

				      '$c_severity', '$c_reproducibility',

				      '$t_status', '$t_resolution',

				      10, '$c_category',

				      " . db_now() . "," . db_now() . ",

				      10, '$t_text_id',

				      '$c_os', '$c_os_build',

				      '$c_platform', '$c_version',

				      '$c_build',

				      '$c_profile_id', '$c_summary', '$c_view_state', '$c_sponsorship_total', '$c_sticky', '',

				      '$c_target_version'

				    )";

		db_query( $query );

		$t_bug_id = db_insert_id($t_bug_table);

		# log new bug

		history_log_event_special( $t_bug_id, NEW_BUG );

		# log changes, if any (compare happens in history_log_event_direct)

		history_log_event_direct( $t_bug_id, 'status', config_get( 'bug_submit_status' ), $t_status );

		history_log_event_direct( $t_bug_id, 'handler_id', 0, $c_handler_id );

		return $t_bug_id;

	}

	# --------------------

	# Copy a bug from one project to another. Also make copies of issue notes, attachments, history,

	# email notifications etc.

	# @@@ Not managed FTP file upload

	# MASC RELATIONSHIP

	function bug_copy( $p_bug_id, $p_target_project_id = null, $p_copy_custom_fields = false, $p_copy_relationships = false,

		$p_copy_history = false, $p_copy_attachments = false, $p_copy_bugnotes = false, $p_copy_monitoring_users = false ) {

		global $g_db;

		$t_mantis_custom_field_string_table	= config_get( 'mantis_custom_field_string_table' );

		$t_mantis_bug_file_table			= config_get( 'mantis_bug_file_table' );

		$t_mantis_bugnote_table				= config_get( 'mantis_bugnote_table' );

		$t_mantis_bugnote_text_table		= config_get( 'mantis_bugnote_text_table' );

		$t_mantis_bug_monitor_table			= config_get( 'mantis_bug_monitor_table' );

		$t_mantis_bug_history_table			= config_get( 'mantis_bug_history_table' );

		$t_mantis_db = $g_db;

		$t_bug_id = db_prepare_int( $p_bug_id );

		$t_target_project_id = db_prepare_int( $p_target_project_id );

		$t_bug_data = new BugData;

		$t_bug_data = bug_get( $t_bug_id, true );

		# retrieve the project id associated with the bug

		if ( ( $p_target_project_id == null ) || is_blank( $p_target_project_id ) ) {

			$t_target_project_id = $t_bug_data->project_id;

		}

		$t_bug_data->project_id = $t_target_project_id;

		$t_new_bug_id = bug_create( $t_bug_data );

		# MASC ATTENTION: IF THE SOURCE BUG HAS TO HANDLER THE bug_create FUNCTION CAN TRY TO AUTO-ASSIGN THE BUG

		# WE FORCE HERE TO DUPLICATE THE SAME HANDLER OF THE SOURCE BUG

		# @@@ VB: Shouldn't we check if the handler in the source project is also a handler in the destination project?

		bug_set_field( $t_new_bug_id, 'handler_id', $t_bug_data->handler_id );

		bug_set_field( $t_new_bug_id, 'duplicate_id', $t_bug_data->duplicate_id );

		bug_set_field( $t_new_bug_id, 'status', $t_bug_data->status );

		bug_set_field( $t_new_bug_id, 'resolution', $t_bug_data->resolution );

		bug_set_field( $t_new_bug_id, 'projection', $t_bug_data->projection );

		bug_set_field( $t_new_bug_id, 'date_submitted', $t_mantis_db->DBTimeStamp( $t_bug_data->date_submitted ), false );

		bug_set_field( $t_new_bug_id, 'last_updated', $t_mantis_db->DBTimeStamp( $t_bug_data->last_updated ), false );

		bug_set_field( $t_new_bug_id, 'eta', $t_bug_data->eta );

		bug_set_field( $t_new_bug_id, 'fixed_in_version', $t_bug_data->fixed_in_version );

		bug_set_field( $t_new_bug_id, 'target_version', $t_bug_data->target_version );

		bug_set_field( $t_new_bug_id, 'sponsorship_total', 0 );

		bug_set_field( $t_new_bug_id, 'sticky', 0 );

		# COPY CUSTOM FIELDS

		if ( $p_copy_custom_fields ) {

			$query = "SELECT field_id, bug_id, value

					   FROM $t_mantis_custom_field_string_table

					   WHERE bug_id = '$t_bug_id';";

			$result = db_query( $query );

			$t_count = db_num_rows( $result );

			for ( $i = 0 ; $i < $t_count ; $i++ ) {

				$t_bug_custom = db_fetch_array( $result );

				$c_field_id = db_prepare_int( $t_bug_custom['field_id'] );

				$c_new_bug_id = db_prepare_int( $t_new_bug_id );

				$c_value = db_prepare_string( $t_bug_custom['value'] );

				$query = "INSERT INTO $t_mantis_custom_field_string_table

						   ( field_id, bug_id, value )

						   VALUES ('$c_field_id', '$c_new_bug_id', '$c_value')";

				db_query( $query );

			}

		}

		# COPY RELATIONSHIPS

		if ( $p_copy_relationships ) {

			if ( ON == config_get( 'enable_relationship' ) ) {

				relationship_copy_all( $t_bug_id,$t_new_bug_id );

			}

		}

		# Copy bugnotes

		if ( $p_copy_bugnotes ) {

			$query = "SELECT *

					  FROM $t_mantis_bugnote_table

					  WHERE bug_id = '$t_bug_id';";

			$result = db_query( $query );

			$t_count = db_num_rows( $result );

			for ( $i = 0; $i < $t_count; $i++ ) {

				$t_bug_note = db_fetch_array( $result );

				$t_bugnote_text_id = $t_bug_note['bugnote_text_id'];

				$query2 = "SELECT *

						   FROM $t_mantis_bugnote_text_table

						   WHERE id = '$t_bugnote_text_id';";

				$result2 = db_query( $query2 );

				$t_count2 = db_num_rows( $result2 );

				$t_bugnote_text_insert_id = -1;

				if ( $t_count2 > 0 ) {

					$t_bugnote_text = db_fetch_array( $result2 );

					$t_bugnote_text['note'] = db_prepare_string( $t_bugnote_text['note'] );

					$query2 = "INSERT INTO $t_mantis_bugnote_text_table

							   ( note )

							   VALUES ( '" . $t_bugnote_text['note'] . "' );";

					db_query( $query2 );

					$t_bugnote_text_insert_id = db_insert_id( $t_mantis_bugnote_text_table );

				}

				$query2 = "INSERT INTO $t_mantis_bugnote_table

						   ( bug_id, reporter_id, bugnote_text_id, view_state, date_submitted, last_modified )

						   VALUES ( '$t_new_bug_id',

						   			'" . $t_bug_note['reporter_id'] . "',

						   			'$t_bugnote_text_insert_id',

						   			'" . $t_bug_note['view_state'] . "',

						   			'" . $t_bug_note['date_submitted'] . "',

						   			'" . $t_bug_note['last_modified'] . "' );";

				db_query( $query2 );

			}

		}

		# Copy attachments

		if ( $p_copy_attachments ) {

			$query = "SELECT *

					  FROM $t_mantis_bug_file_table

					  WHERE bug_id = '$t_bug_id';";

			$result = db_query( $query );

			$t_count = db_num_rows( $result );

			$t_bug_file = array();

			for ( $i = 0; $i < $t_count; $i++ ) {

				$t_bug_file = db_fetch_array( $result );

				# prepare the new diskfile name and then copy the file

				$t_file_path = dirname( $t_bug_file['folder'] );

				$t_new_diskfile_name = $t_file_path . file_generate_unique_name( 'bug-' . $p_file_name, $t_file_path );

				$t_new_file_name = file_get_display_name( $t_bug_file['filename'] );

				if ( ( config_get( 'file_upload_method' ) == DISK ) ) {

					copy( $t_bug_file['diskfile'], $t_new_diskfile_name );

					chmod( $t_new_diskfile_name, config_get( 'attachments_file_permissions' ) );

				}

				$query = "INSERT INTO $t_mantis_bug_file_table

						( bug_id, title, description, diskfile, filename, folder, filesize, file_type, date_added, content )

						VALUES ( '$t_new_bug_id',

								 '" . db_prepare_string( $t_bug_file['title'] ) . "',

								 '" . db_prepare_string( $t_bug_file['description'] ) . "',

								 '" . db_prepare_string( $t_new_diskfile_name ) . "',

								 '" . db_prepare_string( $t_new_file_name ) . "',

								 '" . db_prepare_string( $t_bug_file['folder'] ) . "',

								 '" . db_prepare_int( $t_bug_file['filesize'] ) . "',

								 '" . db_prepare_string( $t_bug_file['file_type'] ) . "',

								 '" . db_prepare_string( $t_bug_file['date_added'] ) . "',

								 '" . db_prepare_string( $t_bug_file['content'] ) . "');";

				db_query( $query );

			}

		}

		# Copy users monitoring bug

		if ( $p_copy_monitoring_users ) {

			$query = "SELECT *

					  FROM $t_mantis_bug_monitor_table

					  WHERE bug_id = '$t_bug_id';";

			$result = db_query( $query );

			$t_count = db_num_rows( $result );

			for ( $i = 0; $i < $t_count; $i++ ) {

				$t_bug_monitor = db_fetch_array( $result );

				$query = "INSERT INTO $t_mantis_bug_monitor_table

						 ( user_id, bug_id )

						 VALUES ( '" . $t_bug_monitor['user_id'] . "', '$t_new_bug_id' );";

				db_query( $query );

			}

		}

		# COPY HISTORY

		history_delete( $t_new_bug_id );	# should history only be deleted inside the if statement below?

		if ( $p_copy_history ) {

			$query = "SELECT *

					  FROM $t_mantis_bug_history_table

					  WHERE bug_id = '$t_bug_id';";

			$result = db_query( $query );

			$t_count = db_num_rows( $result );

			for ( $i = 0; $i < $t_count; $i++ ) {

				$t_bug_history = db_fetch_array( $result );

				$query = "INSERT INTO $t_mantis_bug_history_table

						  ( user_id, bug_id, date_modified, field_name, old_value, new_value, type )

						  VALUES ( '" . db_prepare_int( $t_bug_history['user_id'] ) . "',

						  		   '$t_new_bug_id',

						  		   '" . db_prepare_string( $t_bug_history['date_modified'] ) . "',

						  		   '" . db_prepare_string( $t_bug_history['field_name'] ) . "',

						  		   '" . db_prepare_string( $t_bug_history['old_value'] ) . "',

						  		   '" . db_prepare_string( $t_bug_history['new_value'] ) . "',

						  		   '" . db_prepare_int( $t_bug_history['type'] ) . "' );";

				db_query( $query );

			}

		}

		return $t_new_bug_id;

	}

	# --------------------

	# allows bug deletion :

	# delete the bug, bugtext, bugnote, and bugtexts selected

	# used in bug_delete.php & mass treatments

	function bug_delete( $p_bug_id ) {

		$c_bug_id			= db_prepare_int( $p_bug_id );

		$t_bug_table		= config_get( 'mantis_bug_table' );

		$t_bug_text_table	= config_get( 'mantis_bug_text_table' );

		# call pre-deletion custom function

		helper_call_custom_function( 'issue_delete_validate', array( $p_bug_id ) );

		# log deletion of bug

		history_log_event_special( $p_bug_id, BUG_DELETED, bug_format_id( $p_bug_id ) );

		email_bug_deleted( $p_bug_id );

		# call post-deletion custom function.  We call this here to allow the custom function to access the details of the bug before 

		# they are deleted from the database given it's id.  The other option would be to move this to the end of the function and

		# provide it with bug data rather than an id, but this will break backward compatibility.

		helper_call_custom_function( 'issue_delete_notify', array( $p_bug_id ) );

		# Unmonitor bug for all users

		bug_unmonitor( $p_bug_id, null );

		# Delete custom fields

		custom_field_delete_all_values( $p_bug_id );

		# Delete bugnotes

		bugnote_delete_all( $p_bug_id );

		# Delete all sponsorships

		sponsorship_delete( sponsorship_get_all_ids( $p_bug_id ) );