EE_Question

Complexity

Total Complexity

45

Size/Duplication

Total Lines	452
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

36 Methods

Rating	Name	Duplication	Size	Complexity
A	new_instance()	0	4	2
A	new_instance_from_db()	0	3	1
A	set_display_text()	0	3	1
A	set_admin_label()	0	3	1
A	set_system_ID()	0	3	1
A	set_question_type()	0	3	1
A	set_required()	0	3	1
A	set_required_text()	0	3	1
A	set_order()	0	3	1
A	set_admin_only()	0	3	1
A	set_wp_user()	0	3	1
A	set_deleted()	0	3	1
A	display_text()	0	3	1
A	admin_label()	0	3	1
A	system_ID()	0	3	1
A	required()	0	3	1
A	required_text()	0	3	1
A	type()	0	3	1
A	order()	0	3	1
A	admin_only()	0	3	1
A	wp_user()	0	3	1
A	deleted()	0	3	1
A	answers()	0	3	1
A	has_answers()	0	3	2
A	question_groups()	0	3	1
B	options()	0	19	5
A	temp_options()	0	3	1
A	add_option()	0	3	1
A	add_temp_option()	0	4	1
A	remove_option()	0	3	1
A	is_system_question()	0	4	2
A	set_order_to_latest()	0	5	1
A	_allowed_question_types()	0	5	1
A	duplicate()	0	20	3
A	max()	0	3	1
A	set_max()	0	3	1

<?php if ( !defined( 'EVENT_ESPRESSO_VERSION' ) ) {
	exit( 'No direct script access allowed' );
}
/**
 * Event Espresso
 *
 * Event Registration and Management Plugin for WordPress
 *
 * @ package 		Event Espresso
 * @ author 		Event Espresso
 * @ copyright 	(c) 2008-2011 Event Espresso  All Rights Reserved.
 * @ license 		{@link http://eventespresso.com/support/terms-conditions/}   * see Plugin Licensing *
 * @ link 				{@link http://www.eventespresso.com}
 * @ since 			4.0
 *
 */



/**
 * EE_Question class
 *
 * @package 			Event Espresso
 * @subpackage 	includes/classes/EE_Answer.class.php
 * @author 				Mike Nelson
 *
 * ------------------------------------------------------------------------
 */
class EE_Question extends EE_Soft_Delete_Base_Class implements EEI_Duplicatable {

	/**
	 *
	 * @param array $props_n_values  incoming values
	 * @param string $timezone  incoming timezone (if not set the timezone set for the website will be
	 *                          		used.)
	 * @param array $date_formats  incoming date_formats in an array where the first value is the
	 *                             		    date_format and the second value is the time format
	 * @return EE_Question
	 */
	public static function new_instance( $props_n_values = array(), $timezone = null, $date_formats = array() ) {
		$has_object = parent::_check_for_object( $props_n_values, __CLASS__ );

It seems like you call parent on a different method (_check_for_object() instead of new_instance()). Are you sure this is correct? If so, you might want to change this to $this->_check_for_object().

		return $has_object ? $has_object : new self( $props_n_values, false, $timezone, $date_formats );
	}



	/**
	 * @param array $props_n_values  incoming values from the database
	 * @param string $timezone  incoming timezone as set by the model.  If not set the timezone for
	 *                          		the website will be used.
	 * @return EE_Question
	 */
	public static function new_instance_from_db( $props_n_values = array(), $timezone = null ) {
		return new self( $props_n_values, TRUE, $timezone );
	}



	/**
	 *        Set    Question display text
	 *
	 * @access        public
	 * @param string $QST_display_text
	 */
	public function set_display_text( $QST_display_text = '' ) {
		$this->set( 'QST_display_text', $QST_display_text );
	}



	/**
	 *        Set    Question admin text
	 *
	 * @access        public
	 * @param        string $QST_admin_label
	 */
	public function set_admin_label( $QST_admin_label = '' ) {
		$this->set( 'QST_admin_label', $QST_admin_label );
	}



	/**
	 *        Set    system name
	 *
	 * @access        public
	 * @param        mixed $QST_system
	 */
	public function set_system_ID( $QST_system = '' ) {
		$this->set( 'QST_system', $QST_system );
	}



	/**
	 *        Set    question's type
	 *
	 * @access        public
	 * @param        string $QST_type
	 */
	public function set_question_type( $QST_type = '' ) {
		$this->set( 'QST_type', $QST_type );
	}



	/**
	 *        Sets whether this question must be answered when presented in a form
	 *
	 * @access        public
	 * @param        bool $QST_required
	 */
	public function set_required( $QST_required = FALSE ) {
		$this->set( 'QST_required', $QST_required );
	}



	/**
	 *        Set    Question display text
	 *
	 * @access        public
	 * @param        string $QST_required_text
	 */
	public function set_required_text( $QST_required_text = '' ) {
		$this->set( 'QST_required_text', $QST_required_text );
	}



	/**
	 *        Sets the order of this question when placed in a sequence of questions
	 *
	 * @access        public
	 * @param        int $QST_order
	 */
	public function set_order( $QST_order = 0 ) {
		$this->set( 'QST_order', $QST_order );
	}



	/**
	 *        Sets whether the question is admin-only
	 *
	 * @access        public
	 * @param        bool $QST_admin_only
	 */
	public function set_admin_only( $QST_admin_only = FALSE ) {
		$this->set( 'QST_admin_only', $QST_admin_only );
	}



	/**
	 *        Sets the wordpress user ID on the question
	 *
	 * @access        public
	 * @param        int $QST_wp_user
	 */
	public function set_wp_user( $QST_wp_user = 1 ) {
		$this->set( 'QST_wp_user', $QST_wp_user );
	}



	/**
	 *        Sets whether the question has been deleted
	 *        (we use this boolean instead of actually
	 *        deleting it because when users delete this question
	 *        they really want to remove the question from future
	 *        forms, BUT keep their old answers which depend
	 *        on this record actually existing.
	 *
	 * @access        public
	 * @param 	bool $QST_deleted
	 */
	public function set_deleted( $QST_deleted = FALSE ) {
		$this->set( 'QST_deleted', $QST_deleted );
	}



	/**
	 * returns the text for displaying the question to users
	 * @access public
	 * @return string
	 */
	public function display_text() {
		return $this->get( 'QST_display_text' );
	}



	/**
	 * returns the text for the administrative label
	 * @access public
	 * @return string
	 */
	public function admin_label() {
		return $this->get( 'QST_admin_label' );
	}



	/**
	 * returns the attendee column name for this question
	 * @access public
	 * @return string
	 */
	public function system_ID() {
		return $this->get( 'QST_system' );
	}



	/**
	 * returns either a string of 'text', 'textfield', etc.
	 * @access public
	 * @return boolean
	 */
	public function required() {
		return $this->get( 'QST_required' );
	}



	/**
	 * returns the text which should be displayed when a user
	 * doesn't answer this question in a form
	 * @access public
	 * @return string
	 */
	public function required_text() {
		return $this->get( 'QST_required_text' );
	}



	/**
	 * returns the type of this question
	 * @access public
	 * @return string
	 */
	public function type() {
		return $this->get( 'QST_type' );
	}



	/**
	 * returns an integer showing where this question should
	 * be placed in a sequence of questions
	 * @access public
	 * @return int
	 */
	public function order() {
		return $this->get( 'QST_order' );
	}



	/**
	 * returns whether this question should only appears to admins,
	 * or to everyone
	 * @access public
	 * @return boolean
	 */
	public function admin_only() {
		return $this->get( 'QST_admin_only' );
	}



	/**
	 * returns the id the wordpress user who created this question
	 * @access public
	 * @return int
	 */
	public function wp_user() {
		return $this->get( 'QST_wp_user' );
	}



	/**
	 * returns whether this question has been marked as 'deleted'
	 * @access public
	 * @return boolean
	 */
	public function deleted() {
		return $this->get( 'QST_deleted' );
	}



	/**
	 * Gets an array of related EE_Answer  to this EE_Question
	 * @return EE_Answer[]
	 */
	public function answers() {
		return $this->get_many_related( 'Answer' );
	}



	/**
	 * Boolean check for if there are answers on this question in th db
	 * @return boolean true = has answers, false = no answers.
	 */
	public function has_answers() {
		return $this->count_related( 'Answer' ) > 0 ? TRUE : FALSE;
	}



	/**
	 * gets an array of EE_Question_Group which relate to this question
	 * @return EE_Question_Group[]
	 */
	public function question_groups() {
		return $this->get_many_related( 'Question_Group' );
	}



	/**
	 * Returns all the options for this question. By default, it returns only the not-yet-deleted ones.
	 * @param boolean      $notDeletedOptionsOnly            1
	 *                                                       whether to return ALL options, or only the ones which have not yet been deleleted
	 * @param string|array $selected_value_to_always_include , when retrieving options to an ANSWERED question,
	 *                                                       we want to usually only show non-deleted options AND the value that was selected for the answer,
	 *                                                       whether it was trashed or not.
	 * @return EE_Question_Option[]
	 */
	public function options( $notDeletedOptionsOnly = TRUE, $selected_value_to_always_include = NULL ) {
		if ( ! $this->ID() ) {
			return array();
		}
		$query_params = array();
		if ( $selected_value_to_always_include ) {
			if ( is_array( $selected_value_to_always_include ) ) {
				$query_params[ 0 ][ 'OR*options-query' ][ 'QSO_value' ] = array( 'IN', $selected_value_to_always_include );
			} else {
				$query_params[ 0 ][ 'OR*options-query' ][ 'QSO_value' ] = $selected_value_to_always_include;
			}
		}
		if ( $notDeletedOptionsOnly ) {
			$query_params[ 0 ][ 'OR*options-query' ][ 'QSO_deleted' ] = FALSE;
		}
		//order by QSO_order
		$query_params[ 'order_by' ] = array( 'QSO_order' => 'ASC' );
		return $this->get_many_related( 'Question_Option', $query_params );
	}



	/**
	 * returns an array of EE_Question_Options which relate to this question
	 * @return \EE_Question_Option[]
	 */
	public function temp_options() {
		return $this->_model_relations[ 'Question_Option' ];
	}



	/**
	 * Adds an option for this question. Note: if the option were previously associated with a different
	 * Question, that relationship will be overwritten.
	 * @param EE_Question_Option $option
	 * @return boolean success
	 */
	public function add_option( EE_Question_Option $option ) {
		return $this->_add_relation_to( $option, 'Question_Option' );
	}



	/**
	 * Adds an option directly to this question without saving to the db
	 * @param EE_Question_Option $option
	 * @return boolean success
	 */
	public function add_temp_option( EE_Question_Option $option ) {
		$this->_model_relations[ 'Question_Option' ][ ] = $option;
		return TRUE;
	}



	/**
	 * Marks the option as deleted.
	 * @param EE_Question_Option $option
	 * @return boolean success
	 */
	public function remove_option( EE_Question_Option $option ) {
		return $this->_remove_relation_to( $option, 'Question_Option' );
	}



	/**
	 * @return bool
	 */
	public function is_system_question() {
		$system_ID = $this->get( 'QST_system' );
		return ! empty( $system_ID ) ? TRUE : FALSE;
	}



	/**
	 * The purpose of this method is set the question order this question order to be the max out of all questions
	 *
	 * @access public
	 * @return void
	 */
	public function set_order_to_latest() {
		$latest_order = $this->get_model()->get_latest_question_order();

The method get_latest_question_order cannot be called on $this->get_model() (of type boolean).

		$latest_order ++;
		$this->set( 'QST_order', $latest_order );
	}



	/**
	 * Retrieves the list of allowed question types from the model.
	 * @return string[]
	 */
	private function _allowed_question_types() {
		$questionModel = $this->get_model();
		/* @var $questionModel EEM_Question */
		return $questionModel->allowed_question_types();
	}

	/**
	 * Duplicates this question and its question options
	 * @return \EE_Question
	 */
	public function duplicate( $options = array() ) {
		$new_question = clone $this;
		$new_question->set( 'QST_ID', null );
		$new_question->set_display_text( sprintf( __( '%s **Duplicate**', 'event_espresso' ), $this->display_text() ) );
		$new_question->set_admin_label( sprintf( __( '%s **Duplicate**', 'event_espresso' ), $this->admin_label() ) );
		$new_question->set_system_ID( null );
		$new_question->set_wp_user( get_current_user_id() );
                //if we're duplicating a trashed question, assume we don't want the new one to be trashed
                $new_question->set_deleted( false );
		$success = $new_question->save();
		if( $success ) {
			//we don't totally want to duplicate the question options, because we want them to be for the NEW question
			foreach( $this->options() as $question_option ) {
				$question_option->duplicate( array( 'QST_ID' => $new_question->ID() ) );
			}
			return $new_question;
		} else {
			return null;
		}
	}
	
	/**
	 * Returns the question's maximum allowed response size
	 * @return int|float
	 */
	public function max() {
		return $this->get( 'QST_max' );
	}
	
	/**
	 * Sets the question's maximum allowed response size
	 * @param int|float $new_max
	 * @return int|float
	 */
	public function set_max( $new_max ) {
		return $this->set( 'QST_max', $new_max );
	}


}