/php/lib/export_manager/component/survey_ods_exporter.class.php

<?php

namespace application\survey;


use group\GroupDataManager;



use repository\content_object\survey_multiple_choice_question\SurveyMultipleChoiceQuestion;

use repository\content_object\survey_matrix_question\SurveyMatrixQuestion;



use tracking\Tracker;



use common\libraries\AndCondition;

use common\libraries\EqualityCondition;

use common\libraries\InCondition;

use common\libraries\Translation;

use common\libraries\Utilities;

use common\libraries\Request;

use common\libraries\path;



use reporting\ReportingData;



use Ods\Ods;

require_once Path :: get_plugin_path() . '/odsPHP/ods.php';



class SurveyExportManagerSurveyOdsExporterComponent extends SurveyExportManager

{



    const COUNT = 'count';

    const TOTAL = 'total';

    const NOT_STARTED_PARTICIPANTS = 'not_started_participants';

    const STARTED_PARTICIPANTS = 'started_participants';

    const ALL_PARTICIPANTS = 'all_participants';

    const NOT_STARTED_PARTICIPANT_COUNT = 'not_started_participant_count';

    const STARTED_PARTICIPANT_COUNT = 'started_participant_count';

    const ALL_PARTICIPANT_COUNT = 'all_participant_count';

    const CONTEXTS = 'groups';

    const CONTEXT_NAME = 'group_name';

    const CONTEXT_DESCRIPTION = 'group_description';

    const INDIVIDUAL_USERS = 'individual_users';

    const USERS = 'users';

    const PARTICIPATION_GRADE = 'participation_grade';

    const SURVEYS = 'surveys';

    const SURVEY_NAME = 'survey_name';

    const SURVEY_DESCRIPTION = 'survey_description';

    const SURVEY_COUNT = 'survey_count';

    const REPORTING_DATA = 'reporting_data';

    const DATA_NAME = 'data_name';

    const DATA_DESCRIPTION = 'data_description';

    const DATA_GROUP = 'data_group';



    private $participants;

    private $surveys;



    /**
     * Runs this component and displays its output.
     */



    function run()

    {

        $ids = Request :: get(SurveyExportManager :: PARAM_PUBLICATION_ID);



        if (! is_array($ids))

        {

            $ids = array($ids);

        }

        $this->create_participants($ids);



        $this->render_data();



    }



    public function render_data()

    {

        $ods = new Ods();



   



        $questions = $this->get_questions();

       



        header('Content-Type: application/vnd.oasis.opendocument.spreadsheet');

        header('Content-Disposition: attachment;filename="' . 'survey_export' . '.ods"');

        header('Cache-Control: max-age=0');

        $objWriter = $ods->array2Ods();

        return $objWriter->save('php://output');

    }



    private function get_questions()

    {



        $page_questions = array();

        $surveys = $this->surveys;



        foreach ($surveys as $survey)

        {

            $pages = $survey->get_pages();

            foreach ($pages as $page)

            {

                if ($page->count_questions() != 0)

                {

                    $questions = $page->get_questions();



                    foreach ($questions as $question)

                    {



                        $page_questions[$question->get_id()] = $question;

                    }

                }

            }

        }



        return $page_questions;



    }



    private function create_page_reporting_data($question)

    {

        $page_reporting_data = array();



        $all_participants_ids = $this->participants[self :: ALL_PARTICIPANTS];

        $reporting_data = $this->create_reporting_data($question, $all_participants_ids);



        $reporting_data_question = array();

        $reporting_data_question[self :: DATA_GROUP] = Translation :: get(AllGroups);

        $reporting_data_question[self :: DATA_NAME] = $question->get_title();

        $reporting_data_question[self :: DATA_DESCRIPTION] = $question->get_description();

        $reporting_data_question[self :: STARTED_PARTICIPANT_COUNT] = $this->participants[self :: STARTED_PARTICIPANT_COUNT];

        $reporting_data_question[self :: REPORTING_DATA] = $reporting_data;

        $page_reporting_data[] = $reporting_data_question;



        $groups = $this->participants[self :: GROUPS];

        foreach ($groups as $group)

        {

            $reporting_data_question = array();

            $reporting_data_question[self :: DATA_GROUP] = $group[self :: GROUP_DESCRIPTION];

            $reporting_data_question[self :: DATA_NAME] = $question->get_title();

            $reporting_data_question[self :: DATA_DESCRIPTION] = $question->get_description();

            $reporting_data_question[self :: STARTED_PARTICIPANT_COUNT] = $group[self :: STARTED_PARTICIPANT_COUNT];

            $all_participants_ids = $group[self :: ALL_PARTICIPANTS];

            $reporting_data = $this->create_reporting_data($question, $all_participants_ids);

            $reporting_data_question[self :: REPORTING_DATA] = $reporting_data;

            $page_reporting_data[] = $reporting_data_question;

        }



        return $page_reporting_data;

    }



    private function create_reporting_data($question, $participant_ids)

    {



        //retrieve the answer trackers
        $conditions = array();

        $conditions[] = new InCondition(SurveyQuestionAnswerTracker :: PROPERTY_SURVEY_PARTICIPANT_ID, $participant_ids);

        $conditions[] = new EqualityCondition(SurveyQuestionAnswerTracker :: PROPERTY_COMPLEX_QUESTION_ID, $question->get_id());

        $condition = new AndCondition($conditions);

        $trackers = Tracker :: get_data('survey_question_answer_tracker', SurveyExportManager :: APPLICATION_NAME, $condition);



        //option and matches of question
        $options = array();

        $matches = array();



        //matrix to store the answer count
        $answer_count = array();



        //reporting data and type of question
        $reporting_data = new ReportingData();

        $type = $question->get_type();



        switch ($type)

        {

            case SurveyMatrixQuestion :: get_type_name() :



                //get options and matches
                $opts = $question->get_options();

                foreach ($opts as $option)

                {

                    $options[] = $option->get_value();

                }



                $matchs = $question->get_matches();

                foreach ($matchs as $match)

                {

                    $matches[] = $match;

                }

                $total_key = count($matches);

                $matches[] = Translation :: get(self :: COUNT);



                //create answer matrix for answer counting




                $option_count = count($options) - 1;



                while ($option_count >= 0)

                {

                    $match_count = count($matches) - 1;

                    while ($match_count >= 0)

                    {

                        $answer_count[$option_count][$match_count] = 0;

                        $match_count --;

                    }

                    //                    $answer_count[$option_count][$total_key] = 0;
                    $option_count --;

                }



                //count answers from all answer trackers




                while ($tracker = $trackers->next_result())

                {

                    $answer = $tracker->get_answer();

                    $options_answered = array();

                    foreach ($answer as $key => $option)

                    {

                        $options_answered[] = $key;

                        $totals = array();

                        foreach ($option as $match_key => $match)

                        {

                            if ($question->get_matrix_type() == SurveyMatrixQuestion :: MATRIX_TYPE_CHECKBOX)

                            {

                                $answer_count[$key][$match_key] ++;

                            }

                            else

                            {

                                $answer_count[$key][$match] ++;

                            }

                            $answer_count[$key][$total_key] ++;

                        }

                    }

                }



                //creating actual reporing data




                foreach ($matches as $match)

                {

                    $reporting_data->add_row(strip_tags($match));

                }



                $totals = array();



                foreach ($options as $option_key => $option)

                {

                    $reporting_data->add_category($option);

                    //                    dump('op key: '.$option_key);
                    //                    dump('option: '.$option);
                    foreach ($matches as $match_key => $match)

                    {

                        //                        dump('match key: '.$match_key);
                        //                    	dump('match: '.$match);
                        //                    	dump('answer_count: '.$answer_count[$option_key][$match_key]);
                        $totals[$match_key] = $totals[$match_key] + $answer_count[$option_key][$match_key];

                        //                        dump('total: '.$totals[$match_key]);
                        $reporting_data->add_data_category_row($option, strip_tags($match), $answer_count[$option_key][$match_key]);

                    }



                }



                //                dump($totals);
                //
                //                dump($answer_count);




                //                dump($totals);




                //                exit;




                if (count($options) > 1)

                {

                    $reporting_data->add_category(Translation :: get(self :: TOTAL));



                    //                    foreach ($options as $option)
                    //                    {
                    foreach ($matches as $match_key => $match)

                    {

                        $reporting_data->add_data_category_row(Translation :: get(self :: TOTAL), strip_tags($match), $totals[$match_key]);

                    }



     //                    }




                }



                break;

            case SurveyMultipleChoiceQuestion :: get_type_name() :



                //get options and matches
                $opts = $question->get_options();

                foreach ($opts as $option)

                {

                    $options[] = $option->get_value();

                }

                //                $options[] = self :: NO_ANSWER;




                $matches[] = Translation :: get(self :: COUNT);



                //create answer matrix for answer counting




                $option_count = count($options) - 1;

                while ($option_count >= 0)

                {

                    $answer_count[$option_count] = 0;

                    $option_count --;

                }

                //                $answer_count[self :: NO_ANSWER] = 0;




                //count answers from all answer trackers




                while ($tracker = $trackers->next_result())

                {

                    $answer = $tracker->get_answer();

                    foreach ($answer as $key => $option)

                    {

                        if ($question->get_answer_type() == SurveyMultipleChoiceQuestion :: ANSWER_TYPE_CHECKBOX)

                        {

                            $answer_count[$key] ++;

                        }

                        else

                        {

                            $answer_count[$option] ++;

                        }

                    }

                }



                //creating actual reporing data




                foreach ($matches as $match)

                {

                    $reporting_data->add_row(strip_tags($match));

                }



                $total = 0;

                foreach ($options as $option_key => $option)

                {



                    $reporting_data->add_category($option);

                    foreach ($matches as $match)

                    {

                        $total = $total + $answer_count[$option_key];

                        $reporting_data->add_data_category_row($option, strip_tags($match), $answer_count[$option_key]);

                    }



                }

                if (count($options) > 1)

                {

                    $reporting_data->add_category(Translation :: get(self :: TOTAL));

                    foreach ($matches as $match)

                    {

                        $reporting_data->add_data_category_row(Translation :: get(self :: TOTAL), strip_tags($match), $total);

                    }

                }



                break;

            default :

                ;

                break;

        }



        return $reporting_data;

    }



    private function create_participants($ids)

    {



        $this->participants = array();

        $this->surveys = array();



        $surveys = array();

        foreach ($ids as $id)

        {

            $sv = array();

            $survey_publication = SurveyDataManager :: get_instance()->retrieve_survey_publication($id);

            $survey = $survey_publication->get_publication_object();

            $this->surveys[] = $survey;

            $survey_title = $survey->get_title();

            $survey_description = $survey->get_description();

            $sv[self :: SURVEY_NAME] = Utilities :: truncate_string(trim(strip_tags($survey_title)), 20, true, '');

            $sv[self :: SURVEY_DESCRIPTION] = Utilities :: truncate_string(trim(strip_tags($survey_description)), 20, true, '');

            $surveys[$id] = $sv;

        }



        $this->participants[self :: SURVEYS] = $surveys;

        $this->participants[self :: SURVEY_COUNT] = count($surveys);



//        $condition = new InCondition(SurveyPublicationGroup :: PROPERTY_SURVEY_PUBLICATION, $ids);

//        $publication_rel_groups = SurveyDataManager :: get_instance()->retrieve_survey_publication_groups($condition);

//

//        $groups = array();

//        $group_user_ids = array();

//        $total_user_ids = array();

//        while ($publication_rel_group = $publication_rel_groups->next_result())

//        {

//            $group = GroupDataManager :: get_instance()->retrieve_group($publication_rel_group->get_group_id());

//            $groups[] = $group;

//            $group_user_ids[$group->get_id()] = $group->get_users(true, true);

//            $total_user_ids = array_merge($total_user_ids, $group_user_ids[$group->get_id()]);

//        }

//

//        $user_ids = array();

//

//        $condition = new InCondition(SurveyPublicationUser :: PROPERTY_SURVEY_PUBLICATION, $ids);

//        $publication_rel_users = SurveyDataManager :: get_instance()->retrieve_survey_publication_users($condition);



        while ($publication_rel_user = $publication_rel_users->next_result())

        {

            $user_ids[] = $publication_rel_user->get_user_id();

        }



        $total_user_ids = array_merge($total_user_ids, $user_ids);

        $total_user_ids = array_unique($total_user_ids);



        $conditions = array();

        $conditions[] = new InCondition(SurveyParticipantTracker :: PROPERTY_SURVEY_PUBLICATION_ID, $ids);

        $conditions[] = new InCondition(SurveyParticipantTracker :: PROPERTY_USER_ID, $total_user_ids);

        $condition = new AndCondition($conditions);

        $trackers = Tracker :: get_data('survey_participant_tracker', SurveyExportManager :: APPLICATION_NAME, $condition);



        $all_participants = array();

        $started_participants = array();

        $not_started_participants = array();



        $started_users = array();

        $not_started_users = array();



        while ($tracker = $trackers->next_result())

        {



            $all_participants[] = $tracker->get_id();



            switch ($tracker->get_status())

            {

                case SurveyParticipantTracker :: STATUS_NOTSTARTED :

                    $not_started_participants[] = $tracker->get_id();

                    $not_started_users[] = $tracker->get_user_id();

                    break;

                case SurveyParticipantTracker :: STATUS_STARTED :

                    $started_participants[] = $tracker->get_id();

                    $started_users[] = $tracker->get_user_id();

                    break;

                case SurveyParticipantTracker :: STATUS_FINISHED :

                    $started_participants[] = $tracker->get_id();

                    $started_users[] = $tracker->get_user_id();

                    break;

            }

        }



        $this->participants[self :: ALL_PARTICIPANTS] = $all_participants;

        $all_participant_count = count($all_participants);

        $this->participants[self :: ALL_PARTICIPANT_COUNT] = $all_participant_count;

        $this->participants[self :: NOT_STARTED_PARTICIPANTS] = $not_started_participants;

        $not_started_particpant_count = count($not_started_participants);

        $this->participants[self :: NOT_STARTED_PARTICIPANT_COUNT] = $not_started_particpant_count;

        $this->participants[self :: STARTED_PARTICIPANTS] = $started_participants;

        $started_participant_count = count($started_participants);

        $this->participants[self :: STARTED_PARTICIPANT_COUNT] = $started_participant_count;



        $participatie = $started_participant_count / $all_participant_count * 100;

        $participatie = number_format($participatie, 2);

        $this->participants[self :: PARTICIPATION_GRADE] = $participatie;



        foreach ($groups as $group)

        {



            $this->participants[self :: GROUPS][$group->get_id()][self :: GROUP_NAME] = $group->get_name();

            $this->participants[self :: GROUPS][$group->get_id()][self :: GROUP_DESCRIPTION] = $group->get_description();



            $group_users = $group_user_ids[$group->get_id()];



            $condition = new InCondition(SurveyParticipantTracker :: PROPERTY_USER_ID, $group_users);

            $trackers = Tracker :: get_data('survey_participant_tracker', SurveyExportManager :: APPLICATION_NAME, $condition);



            $all_trackers = array();



            while ($tracker = $trackers->next_result())

            {

                $all_trackers[] = $tracker->get_id();

            }



            $all_tracker_count = count($all_trackers);

            $this->participants[self :: GROUPS][$group->get_id()][self :: ALL_PARTICIPANT_COUNT] = $all_tracker_count;

            $this->participants[self :: GROUPS][$group->get_id()][self :: ALL_PARTICIPANTS] = $all_trackers;



            $started = array_intersect($group_users, $started_users);



            $condition = new InCondition(SurveyParticipantTracker :: PROPERTY_USER_ID, $started);

            $trackers = Tracker :: get_data('survey_participant_tracker', SurveyExportManager :: APPLICATION_NAME, $condition);



            $started_trackers = array();



            while ($tracker = $trackers->next_result())

            {

                $started_trackers[] = $tracker->get_id();

            }



            $started_tracker_count = count($started_trackers);

            $this->participants[self :: GROUPS][$group->get_id()][self :: STARTED_PARTICIPANT_COUNT] = $started_tracker_count;

            $this->participants[self :: GROUPS][$group->get_id()][self :: STARTED_PARTICIPANTS] = $started_trackers;



            $not_started = array_intersect($group_users, $not_started_users);



            $condition = new InCondition(SurveyParticipantTracker :: PROPERTY_USER_ID, $not_started);

            $trackers = Tracker :: get_data('survey_participant_tracker', SurveyExportManager :: APPLICATION_NAME, $condition);



            $not_started_trackers = array();



            while ($tracker = $trackers->next_result())

            {

                $not_started_trackers[] = $tracker->get_id();

            }



            $this->participants[self :: GROUPS][$group->get_id()][self :: NOT_STARTED_PARTICIPANT_COUNT] = count($not_started_trackers);

            $this->participants[self :: GROUPS][$group->get_id()][self :: NOT_STARTED_PARTICIPANTS] = $not_started_trackers;



            $participatie = $started_tracker_count / $all_tracker_count * 100;

            $participatie = number_format($participatie, 2);

            $this->participants[self :: GROUPS][$group->get_id()][self :: PARTICIPATION_GRADE] = $participatie;



        }



    }

}



?>